src/gallium/drivers/zink/nir_to_spirv/spirv_builder.h

   1 /*
   2  * Copyright 2018 Collabora Ltd.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #ifndef SPIRV_BUILDER_H
  25 #define SPIRV_BUILDER_H
  26
  27 #include "compiler/spirv/spirv.h"
  28 #include "compiler/spirv/GLSL.std.450.h"
  29
  30 #include <stdbool.h>
  31 #include <stdint.h>
  32 #include <stdlib.h>
  33
  34 struct hash_table;
  35
  36 struct spirv_buffer {
  37    uint32_t *words;
  38    size_t num_words, room;
  39 };
  40
  41 struct spirv_builder {
  42    struct spirv_buffer capabilities;
  43    struct spirv_buffer imports;
  44    struct spirv_buffer memory_model;
  45    struct spirv_buffer entry_points;
  46    struct spirv_buffer exec_modes;
  47    struct spirv_buffer debug_names;
  48    struct spirv_buffer decorations;
  49
  50    struct spirv_buffer types_const_defs;
  51    struct hash_table *types;
  52    struct hash_table *consts;
  53
  54    struct spirv_buffer instructions;
  55    SpvId prev_id;
  56 };
  57
  58 static inline SpvId
  59 spirv_builder_new_id(struct spirv_builder *b)
  60 {
  61    return ++b->prev_id;
  62 }
  63
  64 void
  65 spirv_builder_emit_cap(struct spirv_builder *b, SpvCapability cap);
  66
  67 void
  68 spirv_builder_emit_source(struct spirv_builder *b, SpvSourceLanguage lang,
  69                           uint32_t version);
  70
  71 void
  72 spirv_builder_emit_mem_model(struct spirv_builder *b,
  73                              SpvAddressingModel addr_model,
  74                              SpvMemoryModel mem_model);
  75
  76 void
  77 spirv_builder_emit_name(struct spirv_builder *b, SpvId target,
  78                         const char *name);
  79
  80 void
  81 spirv_builder_emit_decoration(struct spirv_builder *b, SpvId target,
  82                               SpvDecoration decoration);
  83
  84 void
  85 spirv_builder_emit_location(struct spirv_builder *b, SpvId target,
  86                             uint32_t location);
  87
  88 void
  89 spirv_builder_emit_component(struct spirv_builder *b, SpvId target,
  90                              uint32_t component);
  91
  92 void
  93 spirv_builder_emit_builtin(struct spirv_builder *b, SpvId target,
  94                            SpvBuiltIn builtin);
  95
  96 void
  97 spirv_builder_emit_descriptor_set(struct spirv_builder *b, SpvId target,
  98                                   uint32_t descriptor_set);
  99
 100 void
 101 spirv_builder_emit_binding(struct spirv_builder *b, SpvId target,
 102                            uint32_t binding);
 103
 104 void
 105 spirv_builder_emit_array_stride(struct spirv_builder *b, SpvId target,
 106                                 uint32_t stride);
 107
 108 void
 109 spirv_builder_emit_member_offset(struct spirv_builder *b, SpvId target,
 110                                  uint32_t member, uint32_t offset);
 111
 112 void
 113 spirv_builder_emit_entry_point(struct spirv_builder *b,
 114                                SpvExecutionModel exec_model, SpvId entry_point,
 115                                const char *name, const SpvId interfaces[],
 116                                size_t num_interfaces);
 117
 118 void
 119 spirv_builder_emit_exec_mode(struct spirv_builder *b, SpvId entry_point,
 120                              SpvExecutionMode exec_mode);
 121
 122 void
 123 spirv_builder_function(struct spirv_builder *b, SpvId result,
 124                        SpvId return_type,
 125                        SpvFunctionControlMask function_control,
 126                        SpvId function_type);
 127
 128 void
 129 spirv_builder_function_end(struct spirv_builder *b);
 130
 131 void
 132 spirv_builder_label(struct spirv_builder *b, SpvId label);
 133
 134 void
 135 spirv_builder_return(struct spirv_builder *b);
 136
 137 SpvId
 138 spirv_builder_emit_undef(struct spirv_builder *b, SpvId result_type);
 139
 140 SpvId
 141 spirv_builder_emit_load(struct spirv_builder *b, SpvId result_type,
 142                         SpvId pointer);
 143
 144 void
 145 spirv_builder_emit_store(struct spirv_builder *b, SpvId pointer, SpvId object);
 146
 147 SpvId
 148 spirv_builder_emit_access_chain(struct spirv_builder *b, SpvId result_type,
 149                                 SpvId base, const SpvId indexes[],
 150                                 size_t num_indexes);
 151
 152 SpvId
 153 spirv_builder_emit_unop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 154                         SpvId operand);
 155
 156 SpvId
 157 spirv_builder_emit_binop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 158                          SpvId operand0, SpvId operand1);
 159
 160 SpvId
 161 spirv_builder_emit_triop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 162                          SpvId operand0, SpvId operand1, SpvId operand2);
 163
 164 SpvId
 165 spirv_builder_emit_composite_extract(struct spirv_builder *b, SpvId result_type,
 166                                      SpvId composite, const uint32_t indexes[],
 167                                      size_t num_indexes);
 168
 169 SpvId
 170 spirv_builder_emit_composite_construct(struct spirv_builder *b,
 171                                        SpvId result_type,
 172                                        const SpvId constituents[],
 173                                        size_t num_constituents);
 174
 175 SpvId
 176 spirv_builder_emit_vector_shuffle(struct spirv_builder *b, SpvId result_type,
 177                                   SpvId vector_1, SpvId vector_2,
 178                                   const uint32_t components[],
 179                                   size_t num_components);
 180
 181 void
 182 spirv_builder_emit_branch(struct spirv_builder *b, SpvId label);
 183
 184 void
 185 spirv_builder_emit_selection_merge(struct spirv_builder *b, SpvId merge_block,
 186                                    SpvSelectionControlMask selection_control);
 187
 188 void
 189 spirv_builder_loop_merge(struct spirv_builder *b, SpvId merge_block,
 190                          SpvId cont_target, SpvLoopControlMask loop_control);
 191
 192 void
 193 spirv_builder_emit_branch_conditional(struct spirv_builder *b, SpvId condition,
 194                                       SpvId true_label, SpvId false_label);
 195
 196 SpvId
 197 spirv_builder_emit_phi(struct spirv_builder *b, SpvId result_type,
 198                        size_t num_vars, size_t *position);
 199
 200 void
 201 spirv_builder_set_phi_operand(struct spirv_builder *b, size_t position,
 202                               size_t index, SpvId variable, SpvId parent);
 203
 204 void
 205 spirv_builder_emit_kill(struct spirv_builder *b);
 206
 207
 208 SpvId
 209 spirv_builder_emit_image_sample(struct spirv_builder *b,
 210                                 SpvId result_type,
 211                                 SpvId sampled_image,
 212                                 SpvId coordinate,
 213                                 bool proj,
 214                                 SpvId lod,
 215                                 SpvId bias,
 216                                 SpvId dref,
 217                                 SpvId dx,
 218                                 SpvId dy);
 219
 220 SpvId
 221 spirv_builder_emit_image(struct spirv_builder *b, SpvId result_type,
 222                          SpvId sampled_image);
 223
 224 SpvId
 225 spirv_builder_emit_image_fetch(struct spirv_builder *b,
 226                                SpvId result_type,
 227                                SpvId image,
 228                                SpvId coordinate,
 229                                SpvId lod);
 230
 231 SpvId
 232 spirv_builder_emit_ext_inst(struct spirv_builder *b, SpvId result_type,
 233                             SpvId set, uint32_t instruction,
 234                             const SpvId args[], size_t num_args);
 235
 236 SpvId
 237 spirv_builder_type_void(struct spirv_builder *b);
 238
 239 SpvId
 240 spirv_builder_type_bool(struct spirv_builder *b);
 241
 242 SpvId
 243 spirv_builder_type_int(struct spirv_builder *b, unsigned width);
 244
 245 SpvId
 246 spirv_builder_type_uint(struct spirv_builder *b, unsigned width);
 247
 248 SpvId
 249 spirv_builder_type_float(struct spirv_builder *b, unsigned width);
 250
 251 SpvId
 252 spirv_builder_type_image(struct spirv_builder *b, SpvId sampled_type,
 253                          SpvDim dim, bool depth, bool arrayed, bool ms,
 254                          unsigned sampled, SpvImageFormat image_format);
 255
 256 SpvId
 257 spirv_builder_type_sampled_image(struct spirv_builder *b, SpvId image_type);
 258
 259 SpvId
 260 spirv_builder_type_pointer(struct spirv_builder *b,
 261                            SpvStorageClass storage_class, SpvId type);
 262
 263 SpvId
 264 spirv_builder_type_vector(struct spirv_builder *b, SpvId component_type,
 265                           unsigned component_count);
 266
 267 SpvId
 268 spirv_builder_type_array(struct spirv_builder *b, SpvId component_type,
 269                          SpvId length);
 270
 271 SpvId
 272 spirv_builder_type_struct(struct spirv_builder *b, const SpvId member_types[],
 273                           size_t num_member_types);
 274
 275 SpvId
 276 spirv_builder_type_function(struct spirv_builder *b, SpvId return_type,
 277                             const SpvId parameter_types[],
 278                             size_t num_parameter_types);
 279
 280 SpvId
 281 spirv_builder_const_bool(struct spirv_builder *b, bool val);
 282
 283 SpvId
 284 spirv_builder_const_int(struct spirv_builder *b, int width, int32_t val);
 285
 286 SpvId
 287 spirv_builder_const_uint(struct spirv_builder *b, int width, uint32_t val);
 288
 289 SpvId
 290 spirv_builder_const_float(struct spirv_builder *b, int width, float val);
 291
 292 SpvId
 293 spirv_builder_const_composite(struct spirv_builder *b, SpvId result_type,
 294                               const SpvId constituents[],
 295                               size_t num_constituents);
 296
 297 SpvId
 298 spirv_builder_emit_var(struct spirv_builder *b, SpvId type,
 299                        SpvStorageClass storage_class);
 300
 301 SpvId
 302 spirv_builder_import(struct spirv_builder *b, const char *name);
 303
 304 size_t
 305 spirv_builder_get_num_words(struct spirv_builder *b);
 306
 307 size_t
 308 spirv_builder_get_words(struct spirv_builder *b, uint32_t *words,
 309                         size_t num_words);
 310
 311 #endif