1 /* 2 * Copyright 2015 Intel Corporation 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 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * 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 NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 * 23 * Authors: 24 * Jason Ekstrand (jason (at) jlekstrand.net) 25 * 26 */ 27 28 #include "nir/nir.h" 29 #include "nir/nir_builder.h" 30 #include "nir/nir_array.h" 31 #include "nir_spirv.h" 32 #include "spirv.h" 33 34 struct vtn_builder; 35 struct vtn_decoration; 36 37 enum vtn_value_type { 38 vtn_value_type_invalid = 0, 39 vtn_value_type_undef, 40 vtn_value_type_string, 41 vtn_value_type_decoration_group, 42 vtn_value_type_type, 43 vtn_value_type_constant, 44 vtn_value_type_access_chain, 45 vtn_value_type_function, 46 vtn_value_type_block, 47 vtn_value_type_ssa, 48 vtn_value_type_extension, 49 vtn_value_type_image_pointer, 50 vtn_value_type_sampled_image, 51 }; 52 53 enum vtn_branch_type { 54 vtn_branch_type_none, 55 vtn_branch_type_switch_break, 56 vtn_branch_type_switch_fallthrough, 57 vtn_branch_type_loop_break, 58 vtn_branch_type_loop_continue, 59 vtn_branch_type_discard, 60 vtn_branch_type_return, 61 }; 62 63 enum vtn_cf_node_type { 64 vtn_cf_node_type_block, 65 vtn_cf_node_type_if, 66 vtn_cf_node_type_loop, 67 vtn_cf_node_type_switch, 68 }; 69 70 struct vtn_cf_node { 71 struct list_head link; 72 enum vtn_cf_node_type type; 73 }; 74 75 struct vtn_loop { 76 struct vtn_cf_node node; 77 78 /* The main body of the loop */ 79 struct list_head body; 80 81 /* The "continue" part of the loop. This gets executed after the body 82 * and is where you go when you hit a continue. 83 */ 84 struct list_head cont_body; 85 86 SpvLoopControlMask control; 87 }; 88 89 struct vtn_if { 90 struct vtn_cf_node node; 91 92 uint32_t condition; 93 94 enum vtn_branch_type then_type; 95 struct list_head then_body; 96 97 enum vtn_branch_type else_type; 98 struct list_head else_body; 99 100 SpvSelectionControlMask control; 101 }; 102 103 struct vtn_case { 104 struct list_head link; 105 106 struct list_head body; 107 108 /* The block that starts this case */ 109 struct vtn_block *start_block; 110 111 /* The fallthrough case, if any */ 112 struct vtn_case *fallthrough; 113 114 /* The uint32_t values that map to this case */ 115 nir_array values; 116 117 /* True if this is the default case */ 118 bool is_default; 119 120 /* Initialized to false; used when sorting the list of cases */ 121 bool visited; 122 }; 123 124 struct vtn_switch { 125 struct vtn_cf_node node; 126 127 uint32_t selector; 128 129 struct list_head cases; 130 }; 131 132 struct vtn_block { 133 struct vtn_cf_node node; 134 135 /** A pointer to the label instruction */ 136 const uint32_t *label; 137 138 /** A pointer to the merge instruction (or NULL if non exists) */ 139 const uint32_t *merge; 140 141 /** A pointer to the branch instruction that ends this block */ 142 const uint32_t *branch; 143 144 enum vtn_branch_type branch_type; 145 146 /** Points to the loop that this block starts (if it starts a loop) */ 147 struct vtn_loop *loop; 148 149 /** Points to the switch case started by this block (if any) */ 150 struct vtn_case *switch_case; 151 152 /** Every block ends in a nop intrinsic so that we can find it again */ 153 nir_intrinsic_instr *end_nop; 154 }; 155 156 struct vtn_function { 157 struct exec_node node; 158 159 nir_function_impl *impl; 160 struct vtn_block *start_block; 161 162 struct list_head body; 163 164 const uint32_t *end; 165 166 SpvFunctionControlMask control; 167 }; 168 169 typedef bool (*vtn_instruction_handler)(struct vtn_builder *, uint32_t, 170 const uint32_t *, unsigned); 171 172 void vtn_build_cfg(struct vtn_builder *b, const uint32_t *words, 173 const uint32_t *end); 174 void vtn_function_emit(struct vtn_builder *b, struct vtn_function *func, 175 vtn_instruction_handler instruction_handler); 176 177 const uint32_t * 178 vtn_foreach_instruction(struct vtn_builder *b, const uint32_t *start, 179 const uint32_t *end, vtn_instruction_handler handler); 180 181 struct vtn_ssa_value { 182 union { 183 nir_ssa_def *def; 184 struct vtn_ssa_value **elems; 185 }; 186 187 /* For matrices, if this is non-NULL, then this value is actually the 188 * transpose of some other value. The value that `transposed` points to 189 * always dominates this value. 190 */ 191 struct vtn_ssa_value *transposed; 192 193 const struct glsl_type *type; 194 }; 195 196 struct vtn_type { 197 const struct glsl_type *type; 198 199 /* The value that declares this type. Used for finding decorations */ 200 struct vtn_value *val; 201 202 /* for matrices, whether the matrix is stored row-major */ 203 bool row_major; 204 205 /* for structs, the offset of each member */ 206 unsigned *offsets; 207 208 /* for structs, whether it was decorated as a "non-SSBO-like" block */ 209 bool block; 210 211 /* for structs, whether it was decorated as an "SSBO-like" block */ 212 bool buffer_block; 213 214 /* for structs with block == true, whether this is a builtin block (i.e. a 215 * block that contains only builtins). 216 */ 217 bool builtin_block; 218 219 /* Image format for image_load_store type images */ 220 unsigned image_format; 221 222 /* Access qualifier for storage images */ 223 SpvAccessQualifier access_qualifier; 224 225 /* for arrays and matrices, the array stride */ 226 unsigned stride; 227 228 /* for arrays, the vtn_type for the elements of the array */ 229 struct vtn_type *array_element; 230 231 /* for structures, the vtn_type for each member */ 232 struct vtn_type **members; 233 234 /* Whether this type, or a parent type, has been decorated as a builtin */ 235 bool is_builtin; 236 237 SpvBuiltIn builtin; 238 }; 239 240 struct vtn_variable; 241 242 enum vtn_access_mode { 243 vtn_access_mode_id, 244 vtn_access_mode_literal, 245 }; 246 247 struct vtn_access_link { 248 enum vtn_access_mode mode; 249 uint32_t id; 250 }; 251 252 struct vtn_access_chain { 253 struct vtn_variable *var; 254 255 uint32_t length; 256 257 /* Struct elements and array offsets */ 258 struct vtn_access_link link[0]; 259 }; 260 261 enum vtn_variable_mode { 262 vtn_variable_mode_local, 263 vtn_variable_mode_global, 264 vtn_variable_mode_param, 265 vtn_variable_mode_ubo, 266 vtn_variable_mode_ssbo, 267 vtn_variable_mode_push_constant, 268 vtn_variable_mode_image, 269 vtn_variable_mode_sampler, 270 vtn_variable_mode_workgroup, 271 vtn_variable_mode_input, 272 vtn_variable_mode_output, 273 }; 274 275 struct vtn_variable { 276 enum vtn_variable_mode mode; 277 278 struct vtn_type *type; 279 280 unsigned descriptor_set; 281 unsigned binding; 282 unsigned input_attachment_index; 283 bool patch; 284 285 nir_variable *var; 286 nir_variable **members; 287 288 struct vtn_access_chain chain; 289 }; 290 291 struct vtn_image_pointer { 292 struct vtn_access_chain *image; 293 nir_ssa_def *coord; 294 nir_ssa_def *sample; 295 }; 296 297 struct vtn_sampled_image { 298 struct vtn_access_chain *image; /* Image or array of images */ 299 struct vtn_access_chain *sampler; /* Sampler */ 300 }; 301 302 struct vtn_value { 303 enum vtn_value_type value_type; 304 const char *name; 305 struct vtn_decoration *decoration; 306 union { 307 void *ptr; 308 char *str; 309 struct vtn_type *type; 310 struct { 311 nir_constant *constant; 312 const struct glsl_type *const_type; 313 }; 314 struct vtn_access_chain *access_chain; 315 struct vtn_image_pointer *image; 316 struct vtn_sampled_image *sampled_image; 317 struct vtn_function *func; 318 struct vtn_block *block; 319 struct vtn_ssa_value *ssa; 320 vtn_instruction_handler ext_handler; 321 }; 322 }; 323 324 #define VTN_DEC_DECORATION -1 325 #define VTN_DEC_EXECUTION_MODE -2 326 #define VTN_DEC_STRUCT_MEMBER0 0 327 328 struct vtn_decoration { 329 struct vtn_decoration *next; 330 331 /* Specifies how to apply this decoration. Negative values represent a 332 * decoration or execution mode. (See the VTN_DEC_ #defines above.) 333 * Non-negative values specify that it applies to a structure member. 334 */ 335 int scope; 336 337 const uint32_t *literals; 338 struct vtn_value *group; 339 340 union { 341 SpvDecoration decoration; 342 SpvExecutionMode exec_mode; 343 }; 344 }; 345 346 struct vtn_builder { 347 nir_builder nb; 348 349 nir_shader *shader; 350 nir_function_impl *impl; 351 const struct nir_spirv_supported_extensions *ext; 352 struct vtn_block *block; 353 354 /* Current file, line, and column. Useful for debugging. Set 355 * automatically by vtn_foreach_instruction. 356 */ 357 char *file; 358 int line, col; 359 360 /* 361 * In SPIR-V, constants are global, whereas in NIR, the load_const 362 * instruction we use is per-function. So while we parse each function, we 363 * keep a hash table of constants we've resolved to nir_ssa_value's so 364 * far, and we lazily resolve them when we see them used in a function. 365 */ 366 struct hash_table *const_table; 367 368 /* 369 * Map from phi instructions (pointer to the start of the instruction) 370 * to the variable corresponding to it. 371 */ 372 struct hash_table *phi_table; 373 374 unsigned num_specializations; 375 struct nir_spirv_specialization *specializations; 376 377 unsigned value_id_bound; 378 struct vtn_value *values; 379 380 gl_shader_stage entry_point_stage; 381 const char *entry_point_name; 382 struct vtn_value *entry_point; 383 bool origin_upper_left; 384 bool pixel_center_integer; 385 386 struct vtn_function *func; 387 struct exec_list functions; 388 389 /* Current function parameter index */ 390 unsigned func_param_idx; 391 392 bool has_loop_continue; 393 }; 394 395 static inline struct vtn_value * 396 vtn_push_value(struct vtn_builder *b, uint32_t value_id, 397 enum vtn_value_type value_type) 398 { 399 assert(value_id < b->value_id_bound); 400 assert(b->values[value_id].value_type == vtn_value_type_invalid); 401 402 b->values[value_id].value_type = value_type; 403 404 return &b->values[value_id]; 405 } 406 407 static inline struct vtn_value * 408 vtn_untyped_value(struct vtn_builder *b, uint32_t value_id) 409 { 410 assert(value_id < b->value_id_bound); 411 return &b->values[value_id]; 412 } 413 414 static inline struct vtn_value * 415 vtn_value(struct vtn_builder *b, uint32_t value_id, 416 enum vtn_value_type value_type) 417 { 418 struct vtn_value *val = vtn_untyped_value(b, value_id); 419 assert(val->value_type == value_type); 420 return val; 421 } 422 423 void _vtn_warn(const char *file, int line, const char *msg, ...); 424 #define vtn_warn(...) _vtn_warn(__FILE__, __LINE__, __VA_ARGS__) 425 426 struct vtn_ssa_value *vtn_ssa_value(struct vtn_builder *b, uint32_t value_id); 427 428 struct vtn_ssa_value *vtn_create_ssa_value(struct vtn_builder *b, 429 const struct glsl_type *type); 430 431 struct vtn_ssa_value *vtn_ssa_transpose(struct vtn_builder *b, 432 struct vtn_ssa_value *src); 433 434 nir_ssa_def *vtn_vector_extract(struct vtn_builder *b, nir_ssa_def *src, 435 unsigned index); 436 nir_ssa_def *vtn_vector_extract_dynamic(struct vtn_builder *b, nir_ssa_def *src, 437 nir_ssa_def *index); 438 nir_ssa_def *vtn_vector_insert(struct vtn_builder *b, nir_ssa_def *src, 439 nir_ssa_def *insert, unsigned index); 440 nir_ssa_def *vtn_vector_insert_dynamic(struct vtn_builder *b, nir_ssa_def *src, 441 nir_ssa_def *insert, nir_ssa_def *index); 442 443 nir_deref_var *vtn_nir_deref(struct vtn_builder *b, uint32_t id); 444 445 nir_deref_var *vtn_access_chain_to_deref(struct vtn_builder *b, 446 struct vtn_access_chain *chain); 447 nir_ssa_def * 448 vtn_access_chain_to_offset(struct vtn_builder *b, 449 struct vtn_access_chain *chain, 450 nir_ssa_def **index_out, struct vtn_type **type_out, 451 unsigned *end_idx_out, bool stop_at_matrix); 452 453 struct vtn_ssa_value *vtn_local_load(struct vtn_builder *b, nir_deref_var *src); 454 455 void vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src, 456 nir_deref_var *dest); 457 458 struct vtn_ssa_value * 459 vtn_variable_load(struct vtn_builder *b, struct vtn_access_chain *src); 460 461 void vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src, 462 struct vtn_access_chain *dest); 463 464 void vtn_handle_variables(struct vtn_builder *b, SpvOp opcode, 465 const uint32_t *w, unsigned count); 466 467 468 typedef void (*vtn_decoration_foreach_cb)(struct vtn_builder *, 469 struct vtn_value *, 470 int member, 471 const struct vtn_decoration *, 472 void *); 473 474 void vtn_foreach_decoration(struct vtn_builder *b, struct vtn_value *value, 475 vtn_decoration_foreach_cb cb, void *data); 476 477 typedef void (*vtn_execution_mode_foreach_cb)(struct vtn_builder *, 478 struct vtn_value *, 479 const struct vtn_decoration *, 480 void *); 481 482 void vtn_foreach_execution_mode(struct vtn_builder *b, struct vtn_value *value, 483 vtn_execution_mode_foreach_cb cb, void *data); 484 485 nir_op vtn_nir_alu_op_for_spirv_opcode(SpvOp opcode, bool *swap, 486 nir_alu_type src, nir_alu_type dst); 487 488 void vtn_handle_alu(struct vtn_builder *b, SpvOp opcode, 489 const uint32_t *w, unsigned count); 490 491 bool vtn_handle_glsl450_instruction(struct vtn_builder *b, uint32_t ext_opcode, 492 const uint32_t *words, unsigned count); 493 494 static inline uint64_t 495 vtn_u64_literal(const uint32_t *w) 496 { 497 return (uint64_t)w[1] << 32 | w[0]; 498 } 499
