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    void *mem_ctx;
  43
  44    struct spirv_buffer capabilities;
  45    struct spirv_buffer extensions;
  46    struct spirv_buffer imports;
  47    struct spirv_buffer memory_model;
  48    struct spirv_buffer entry_points;
  49    struct spirv_buffer exec_modes;
  50    struct spirv_buffer debug_names;
  51    struct spirv_buffer decorations;
  52
  53    struct spirv_buffer types_const_defs;
  54    struct hash_table *types;
  55    struct hash_table *consts;
  56
  57    struct spirv_buffer instructions;
  58    SpvId prev_id;
  59 };
  60
  61 static inline SpvId
  62 spirv_builder_new_id(struct spirv_builder *b)
  63 {
  64    return ++b->prev_id;
  65 }
  66
  67 void
  68 spirv_builder_emit_cap(struct spirv_builder *b, SpvCapability cap);
  69
  70 void
  71 spirv_builder_emit_extension(struct spirv_builder *b, const char *ext);
  72
  73 void
  74 spirv_builder_emit_source(struct spirv_builder *b, SpvSourceLanguage lang,
  75                           uint32_t version);
  76
  77 void
  78 spirv_builder_emit_mem_model(struct spirv_builder *b,
  79                              SpvAddressingModel addr_model,
  80                              SpvMemoryModel mem_model);
  81
  82 void
  83 spirv_builder_emit_name(struct spirv_builder *b, SpvId target,
  84                         const char *name);
  85
  86 void
  87 spirv_builder_emit_decoration(struct spirv_builder *b, SpvId target,
  88                               SpvDecoration decoration);
  89
  90 void
  91 spirv_builder_emit_location(struct spirv_builder *b, SpvId target,
  92                             uint32_t location);
  93
  94 void
  95 spirv_builder_emit_component(struct spirv_builder *b, SpvId target,
  96                              uint32_t component);
  97
  98 void
  99 spirv_builder_emit_builtin(struct spirv_builder *b, SpvId target,
 100                            SpvBuiltIn builtin);
 101
 102 void
 103 spirv_builder_emit_index(struct spirv_builder *b, SpvId target, int index);
 104
 105 void
 106 spirv_builder_emit_descriptor_set(struct spirv_builder *b, SpvId target,
 107                                   uint32_t descriptor_set);
 108
 109 void
 110 spirv_builder_emit_binding(struct spirv_builder *b, SpvId target,
 111                            uint32_t binding);
 112
 113 void
 114 spirv_builder_emit_array_stride(struct spirv_builder *b, SpvId target,
 115                                 uint32_t stride);
 116
 117 void
 118 spirv_builder_emit_offset(struct spirv_builder *b, SpvId target,
 119                           uint32_t offset);
 120
 121 void
 122 spirv_builder_emit_xfb_buffer(struct spirv_builder *b, SpvId target,
 123                               uint32_t buffer);
 124
 125 void
 126 spirv_builder_emit_xfb_stride(struct spirv_builder *b, SpvId target,
 127                               uint32_t stride);
 128
 129 void
 130 spirv_builder_emit_member_offset(struct spirv_builder *b, SpvId target,
 131                                  uint32_t member, uint32_t offset);
 132
 133 void
 134 spirv_builder_emit_entry_point(struct spirv_builder *b,
 135                                SpvExecutionModel exec_model, SpvId entry_point,
 136                                const char *name, const SpvId interfaces[],
 137                                size_t num_interfaces);
 138
 139 void
 140 spirv_builder_emit_exec_mode(struct spirv_builder *b, SpvId entry_point,
 141                              SpvExecutionMode exec_mode);
 142
 143 void
 144 spirv_builder_function(struct spirv_builder *b, SpvId result,
 145                        SpvId return_type,
 146                        SpvFunctionControlMask function_control,
 147                        SpvId function_type);
 148
 149 void
 150 spirv_builder_function_end(struct spirv_builder *b);
 151
 152 void
 153 spirv_builder_label(struct spirv_builder *b, SpvId label);
 154
 155 void
 156 spirv_builder_return(struct spirv_builder *b);
 157
 158 SpvId
 159 spirv_builder_emit_undef(struct spirv_builder *b, SpvId result_type);
 160
 161 SpvId
 162 spirv_builder_emit_load(struct spirv_builder *b, SpvId result_type,
 163                         SpvId pointer);
 164
 165 void
 166 spirv_builder_emit_store(struct spirv_builder *b, SpvId pointer, SpvId object);
 167
 168 SpvId
 169 spirv_builder_emit_access_chain(struct spirv_builder *b, SpvId result_type,
 170                                 SpvId base, const SpvId indexes[],
 171                                 size_t num_indexes);
 172
 173 SpvId
 174 spirv_builder_emit_unop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 175                         SpvId operand);
 176
 177 SpvId
 178 spirv_builder_emit_binop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 179                          SpvId operand0, SpvId operand1);
 180
 181 SpvId
 182 spirv_builder_emit_triop(struct spirv_builder *b, SpvOp op, SpvId result_type,
 183                          SpvId operand0, SpvId operand1, SpvId operand2);
 184
 185 SpvId
 186 spirv_builder_emit_composite_extract(struct spirv_builder *b, SpvId result_type,
 187                                      SpvId composite, const uint32_t indexes[],
 188                                      size_t num_indexes);
 189
 190 SpvId
 191 spirv_builder_emit_composite_construct(struct spirv_builder *b,
 192                                        SpvId result_type,
 193                                        const SpvId constituents[],
 194                                        size_t num_constituents);
 195
 196 SpvId
 197 spirv_builder_emit_vector_shuffle(struct spirv_builder *b, SpvId result_type,
 198                                   SpvId vector_1, SpvId vector_2,
 199                                   const uint32_t components[],
 200                                   size_t num_components);
 201 SpvId
 202 spirv_builder_emit_vector_extract(struct spirv_builder *b, SpvId result_type,
 203                                   SpvId vector_1,
 204                                   uint32_t component);
 205 SpvId
 206 spirv_builder_emit_vector_insert(struct spirv_builder *b, SpvId result_type,
 207                                   SpvId vector_1,
 208                                   SpvId component,
 209                                   uint32_t index);
 210 void
 211 spirv_builder_emit_branch(struct spirv_builder *b, SpvId label);
 212
 213 void
 214 spirv_builder_emit_selection_merge(struct spirv_builder *b, SpvId merge_block,
 215                                    SpvSelectionControlMask selection_control);
 216
 217 void
 218 spirv_builder_loop_merge(struct spirv_builder *b, SpvId merge_block,
 219                          SpvId cont_target, SpvLoopControlMask loop_control);
 220
 221 void
 222 spirv_builder_emit_branch_conditional(struct spirv_builder *b, SpvId condition,
 223                                       SpvId true_label, SpvId false_label);
 224
 225 SpvId
 226 spirv_builder_emit_phi(struct spirv_builder *b, SpvId result_type,
 227                        size_t num_vars, size_t *position);
 228
 229 void
 230 spirv_builder_set_phi_operand(struct spirv_builder *b, size_t position,
 231                               size_t index, SpvId variable, SpvId parent);
 232
 233 void
 234 spirv_builder_emit_kill(struct spirv_builder *b);
 235
 236
 237 SpvId
 238 spirv_builder_emit_image_sample(struct spirv_builder *b,
 239                                 SpvId result_type,
 240                                 SpvId sampled_image,
 241                                 SpvId coordinate,
 242                                 bool proj,
 243                                 SpvId lod,
 244                                 SpvId bias,
 245                                 SpvId dref,
 246                                 SpvId dx,
 247                                 SpvId dy,
 248                                 SpvId offset);
 249
 250 SpvId
 251 spirv_builder_emit_image(struct spirv_builder *b, SpvId result_type,
 252                          SpvId sampled_image);
 253
 254 SpvId
 255 spirv_builder_emit_image_fetch(struct spirv_builder *b,
 256                                SpvId result_type,
 257                                SpvId image,
 258                                SpvId coordinate,
 259                                SpvId lod,
 260                                SpvId sample);
 261
 262 SpvId
 263 spirv_builder_emit_image_query_size(struct spirv_builder *b,
 264                                     SpvId result_type,
 265                                     SpvId image,
 266                                     SpvId lod);
 267
 268 SpvId
 269 spirv_builder_emit_ext_inst(struct spirv_builder *b, SpvId result_type,
 270                             SpvId set, uint32_t instruction,
 271                             const SpvId args[], size_t num_args);
 272
 273 SpvId
 274 spirv_builder_type_void(struct spirv_builder *b);
 275
 276 SpvId
 277 spirv_builder_type_bool(struct spirv_builder *b);
 278
 279 SpvId
 280 spirv_builder_type_int(struct spirv_builder *b, unsigned width);
 281
 282 SpvId
 283 spirv_builder_type_uint(struct spirv_builder *b, unsigned width);
 284
 285 SpvId
 286 spirv_builder_type_float(struct spirv_builder *b, unsigned width);
 287
 288 SpvId
 289 spirv_builder_type_image(struct spirv_builder *b, SpvId sampled_type,
 290                          SpvDim dim, bool depth, bool arrayed, bool ms,
 291                          unsigned sampled, SpvImageFormat image_format);
 292
 293 SpvId
 294 spirv_builder_type_sampled_image(struct spirv_builder *b, SpvId image_type);
 295
 296 SpvId
 297 spirv_builder_type_pointer(struct spirv_builder *b,
 298                            SpvStorageClass storage_class, SpvId type);
 299
 300 SpvId
 301 spirv_builder_type_vector(struct spirv_builder *b, SpvId component_type,
 302                           unsigned component_count);
 303
 304 SpvId
 305 spirv_builder_type_array(struct spirv_builder *b, SpvId component_type,
 306                          SpvId length);
 307
 308 SpvId
 309 spirv_builder_type_struct(struct spirv_builder *b, const SpvId member_types[],
 310                           size_t num_member_types);
 311
 312 SpvId
 313 spirv_builder_type_function(struct spirv_builder *b, SpvId return_type,
 314                             const SpvId parameter_types[],
 315                             size_t num_parameter_types);
 316
 317 SpvId
 318 spirv_builder_const_bool(struct spirv_builder *b, bool val);
 319
 320 SpvId
 321 spirv_builder_const_int(struct spirv_builder *b, int width, int32_t val);
 322
 323 SpvId
 324 spirv_builder_const_uint(struct spirv_builder *b, int width, uint32_t val);
 325
 326 SpvId
 327 spirv_builder_const_float(struct spirv_builder *b, int width, float val);
 328
 329 SpvId
 330 spirv_builder_const_composite(struct spirv_builder *b, SpvId result_type,
 331                               const SpvId constituents[],
 332                               size_t num_constituents);
 333
 334 SpvId
 335 spirv_builder_emit_var(struct spirv_builder *b, SpvId type,
 336                        SpvStorageClass storage_class);
 337
 338 SpvId
 339 spirv_builder_import(struct spirv_builder *b, const char *name);
 340
 341 size_t
 342 spirv_builder_get_num_words(struct spirv_builder *b);
 343
 344 size_t
 345 spirv_builder_get_words(struct spirv_builder *b, uint32_t *words,
 346                         size_t num_words);
 347
 348 #endif