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_index(struct spirv_builder *b, SpvId target, int index);
  98
  99 void
 100 spirv_builder_emit_descriptor_set(struct spirv_builder *b, SpvId target,
 101                                   uint32_t descriptor_set);
 102
 103 void
 104 spirv_builder_emit_binding(struct spirv_builder *b, SpvId target,
 105                            uint32_t binding);
 106
 107 void
 108 spirv_builder_emit_array_stride(struct spirv_builder *b, SpvId target,
 109                                 uint32_t stride);
 110
 111 void
 112 spirv_builder_emit_offset(struct spirv_builder *b, SpvId target,
 113                           uint32_t offset);
 114
 115 void
 116 spirv_builder_emit_xfb_buffer(struct spirv_builder *b, SpvId target,
 117                               uint32_t buffer);
 118
 119 void
 120 spirv_builder_emit_xfb_stride(struct spirv_builder *b, SpvId target,
 121                               uint32_t stride);
 122
 123 void
 124 spirv_builder_emit_member_offset(struct spirv_builder *b, SpvId target,
 125                                  uint32_t member, uint32_t offset);
 126
 127 void
 128 spirv_builder_emit_entry_point(struct spirv_builder *b,
 129                                SpvExecutionModel exec_model, SpvId entry_point,
 130                                const char *name, const SpvId interfaces[],
 131                                size_t num_interfaces);
 132
 133 void
 134 spirv_builder_emit_exec_mode(struct spirv_builder *b, SpvId entry_point,
 135                              SpvExecutionMode exec_mode);
 136
 137 void
 138 spirv_builder_function(struct spirv_builder *b, SpvId result,
 139                        SpvId return_type,
 140                        SpvFunctionControlMask function_control,
 141                        SpvId function_type);
 142
 143 void
 144 spirv_builder_function_end(struct spirv_builder *b);
 145
 146 void
 147 spirv_builder_label(struct spirv_builder *b, SpvId label);
 148
 149 void
 150 spirv_builder_return(struct spirv_builder *b);
 151
 152 SpvId
 153 spirv_builder_emit_undef(struct spirv_builder *b, SpvId result_type);
 154
 155 SpvId
 156 spirv_builder_emit_load(struct spirv_builder *b, SpvId result_type,
 157                         SpvId pointer);
 158
 159 void
 160 spirv_builder_emit_store(struct spirv_builder *b, SpvId pointer, SpvId object);
 161
 162 SpvId
 163 spirv_builder_emit_access_chain(struct spirv_builder *b, SpvId result_type,
 164                                 SpvId base, const SpvId indexes[],
 165                                 size_t num_indexes);
 166
 167 SpvId
 168 spirv_builder_emit_unop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 169                         SpvId operand);
 170
 171 SpvId
 172 spirv_builder_emit_binop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 173                          SpvId operand0, SpvId operand1);
 174
 175 SpvId
 176 spirv_builder_emit_triop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 177                          SpvId operand0, SpvId operand1, SpvId operand2);
 178
 179 SpvId
 180 spirv_builder_emit_composite_extract(struct spirv_builder *b, SpvId result_type,
 181                                      SpvId composite, const uint32_t indexes[],
 182                                      size_t num_indexes);
 183
 184 SpvId
 185 spirv_builder_emit_composite_construct(struct spirv_builder *b,
 186                                        SpvId result_type,
 187                                        const SpvId constituents[],
 188                                        size_t num_constituents);
 189
 190 SpvId
 191 spirv_builder_emit_vector_shuffle(struct spirv_builder *b, SpvId result_type,
 192                                   SpvId vector_1, SpvId vector_2,
 193                                   const uint32_t components[],
 194                                   size_t num_components);
 195 SpvId
 196 spirv_builder_emit_vector_extract(struct spirv_builder *b, SpvId result_type,
 197                                   SpvId vector_1,
 198                                   uint32_t component);
 199 SpvId
 200 spirv_builder_emit_vector_insert(struct spirv_builder *b, SpvId result_type,
 201                                   SpvId vector_1,
 202                                   SpvId component,
 203                                   uint32_t index);
 204 void
 205 spirv_builder_emit_branch(struct spirv_builder *b, SpvId label);
 206
 207 void
 208 spirv_builder_emit_selection_merge(struct spirv_builder *b, SpvId merge_block,
 209                                    SpvSelectionControlMask selection_control);
 210
 211 void
 212 spirv_builder_loop_merge(struct spirv_builder *b, SpvId merge_block,
 213                          SpvId cont_target, SpvLoopControlMask loop_control);
 214
 215 void
 216 spirv_builder_emit_branch_conditional(struct spirv_builder *b, SpvId condition,
 217                                       SpvId true_label, SpvId false_label);
 218
 219 SpvId
 220 spirv_builder_emit_phi(struct spirv_builder *b, SpvId result_type,
 221                        size_t num_vars, size_t *position);
 222
 223 void
 224 spirv_builder_set_phi_operand(struct spirv_builder *b, size_t position,
 225                               size_t index, SpvId variable, SpvId parent);
 226
 227 void
 228 spirv_builder_emit_kill(struct spirv_builder *b);
 229
 230
 231 SpvId
 232 spirv_builder_emit_image_sample(struct spirv_builder *b,
 233                                 SpvId result_type,
 234                                 SpvId sampled_image,
 235                                 SpvId coordinate,
 236                                 bool proj,
 237                                 SpvId lod,
 238                                 SpvId bias,
 239                                 SpvId dref,
 240                                 SpvId dx,
 241                                 SpvId dy,
 242                                 SpvId offset);
 243
 244 SpvId
 245 spirv_builder_emit_image(struct spirv_builder *b, SpvId result_type,
 246                          SpvId sampled_image);
 247
 248 SpvId
 249 spirv_builder_emit_image_fetch(struct spirv_builder *b,
 250                                SpvId result_type,
 251                                SpvId image,
 252                                SpvId coordinate,
 253                                SpvId lod,
 254                                SpvId sample);
 255
 256 SpvId
 257 spirv_builder_emit_image_query_size(struct spirv_builder *b,
 258                                     SpvId result_type,
 259                                     SpvId image,
 260                                     SpvId lod);
 261
 262 SpvId
 263 spirv_builder_emit_ext_inst(struct spirv_builder *b, SpvId result_type,
 264                             SpvId set, uint32_t instruction,
 265                             const SpvId args[], size_t num_args);
 266
 267 SpvId
 268 spirv_builder_type_void(struct spirv_builder *b);
 269
 270 SpvId
 271 spirv_builder_type_bool(struct spirv_builder *b);
 272
 273 SpvId
 274 spirv_builder_type_int(struct spirv_builder *b, unsigned width);
 275
 276 SpvId
 277 spirv_builder_type_uint(struct spirv_builder *b, unsigned width);
 278
 279 SpvId
 280 spirv_builder_type_float(struct spirv_builder *b, unsigned width);
 281
 282 SpvId
 283 spirv_builder_type_image(struct spirv_builder *b, SpvId sampled_type,
 284                          SpvDim dim, bool depth, bool arrayed, bool ms,
 285                          unsigned sampled, SpvImageFormat image_format);
 286
 287 SpvId
 288 spirv_builder_type_sampled_image(struct spirv_builder *b, SpvId image_type);
 289
 290 SpvId
 291 spirv_builder_type_pointer(struct spirv_builder *b,
 292                            SpvStorageClass storage_class, SpvId type);
 293
 294 SpvId
 295 spirv_builder_type_vector(struct spirv_builder *b, SpvId component_type,
 296                           unsigned component_count);
 297
 298 SpvId
 299 spirv_builder_type_array(struct spirv_builder *b, SpvId component_type,
 300                          SpvId length);
 301
 302 SpvId
 303 spirv_builder_type_struct(struct spirv_builder *b, const SpvId member_types[],
 304                           size_t num_member_types);
 305
 306 SpvId
 307 spirv_builder_type_function(struct spirv_builder *b, SpvId return_type,
 308                             const SpvId parameter_types[],
 309                             size_t num_parameter_types);
 310
 311 SpvId
 312 spirv_builder_const_bool(struct spirv_builder *b, bool val);
 313
 314 SpvId
 315 spirv_builder_const_int(struct spirv_builder *b, int width, int32_t val);
 316
 317 SpvId
 318 spirv_builder_const_uint(struct spirv_builder *b, int width, uint32_t val);
 319
 320 SpvId
 321 spirv_builder_const_float(struct spirv_builder *b, int width, float val);
 322
 323 SpvId
 324 spirv_builder_const_composite(struct spirv_builder *b, SpvId result_type,
 325                               const SpvId constituents[],
 326                               size_t num_constituents);
 327
 328 SpvId
 329 spirv_builder_emit_var(struct spirv_builder *b, SpvId type,
 330                        SpvStorageClass storage_class);
 331
 332 SpvId
 333 spirv_builder_import(struct spirv_builder *b, const char *name);
 334
 335 size_t
 336 spirv_builder_get_num_words(struct spirv_builder *b);
 337
 338 size_t
 339 spirv_builder_get_words(struct spirv_builder *b, uint32_t *words,
 340                         size_t num_words);
 341
 342 #endif