1/* 2 * Copyright © 2014 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 * Connor Abbott (cwabbott0@gmail.com) 25 * 26 */ 27 28#include "glsl_to_nir.h" 29#include "ir_visitor.h" 30#include "ir_hierarchical_visitor.h" 31#include "ir.h" 32#include "compiler/nir/nir_control_flow.h" 33#include "compiler/nir/nir_builder.h" 34#include "main/imports.h" 35 36/* 37 * pass to lower GLSL IR to NIR 38 * 39 * This will lower variable dereferences to loads/stores of corresponding 40 * variables in NIR - the variables will be converted to registers in a later 41 * pass. 42 */ 43 44namespace { 45 46class nir_visitor : public ir_visitor 47{ 48public: 49 nir_visitor(nir_shader *shader); 50 ~nir_visitor(); 51 52 virtual void visit(ir_variable *); 53 virtual void visit(ir_function *); 54 virtual void visit(ir_function_signature *); 55 virtual void visit(ir_loop *); 56 virtual void visit(ir_if *); 57 virtual void visit(ir_discard *); 58 virtual void visit(ir_loop_jump *); 59 virtual void visit(ir_return *); 60 virtual void visit(ir_call *); 61 virtual void visit(ir_assignment *); 62 virtual void visit(ir_emit_vertex *); 63 virtual void visit(ir_end_primitive *); 64 virtual void visit(ir_expression *); 65 virtual void visit(ir_swizzle *); 66 virtual void visit(ir_texture *); 67 virtual void visit(ir_constant *); 68 virtual void visit(ir_dereference_variable *); 69 virtual void visit(ir_dereference_record *); 70 virtual void visit(ir_dereference_array *); 71 virtual void visit(ir_barrier *); 72 73 void create_function(ir_function_signature *ir); 74 75private: 76 void add_instr(nir_instr *instr, unsigned num_components, unsigned bit_size); 77 nir_ssa_def *evaluate_rvalue(ir_rvalue *ir); 78 79 nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def **srcs); 80 nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def *src1); 81 nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def *src1, 82 nir_ssa_def *src2); 83 nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def *src1, 84 nir_ssa_def *src2, nir_ssa_def *src3); 85 86 bool supports_ints; 87 88 nir_shader *shader; 89 nir_function_impl *impl; 90 nir_builder b; 91 nir_ssa_def *result; /* result of the expression tree last visited */ 92 93 nir_deref_var *evaluate_deref(nir_instr *mem_ctx, ir_instruction *ir); 94 95 /* the head of the dereference chain we're creating */ 96 nir_deref_var *deref_head; 97 /* the tail of the dereference chain we're creating */ 98 nir_deref *deref_tail; 99 100 nir_variable *var; /* variable created by ir_variable visitor */ 101 102 /* whether the IR we're operating on is per-function or global */ 103 bool is_global; 104 105 /* map of ir_variable -> nir_variable */ 106 struct hash_table *var_table; 107 108 /* map of ir_function_signature -> nir_function_overload */ 109 struct hash_table *overload_table; 110}; 111 112/* 113 * This visitor runs before the main visitor, calling create_function() for 114 * each function so that the main visitor can resolve forward references in 115 * calls. 116 */ 117 118class nir_function_visitor : public ir_hierarchical_visitor 119{ 120public: 121 nir_function_visitor(nir_visitor *v) : visitor(v) 122 { 123 } 124 virtual ir_visitor_status visit_enter(ir_function *); 125 126private: 127 nir_visitor *visitor; 128}; 129 130} /* end of anonymous namespace */ 131 132static void 133nir_remap_attributes(nir_shader *shader) 134{ 135 nir_foreach_variable(var, &shader->inputs) { 136 var->data.location += _mesa_bitcount_64(shader->info->double_inputs_read & 137 BITFIELD64_MASK(var->data.location)); 138 } 139 140 /* Once the remap is done, reset double_inputs_read, so later it will have 141 * which location/slots are doubles */ 142 shader->info->double_inputs_read = 0; 143} 144 145nir_shader * 146glsl_to_nir(const struct gl_shader_program *shader_prog, 147 gl_shader_stage stage, 148 const nir_shader_compiler_options *options) 149{ 150 struct gl_linked_shader *sh = shader_prog->_LinkedShaders[stage]; 151 152 nir_shader *shader = nir_shader_create(NULL, stage, options, 153 &sh->Program->info); 154 155 nir_visitor v1(shader); 156 nir_function_visitor v2(&v1); 157 v2.run(sh->ir); 158 visit_exec_list(sh->ir, &v1); 159 160 nir_lower_constant_initializers(shader, (nir_variable_mode)~0); 161 162 /* Remap the locations to slots so those requiring two slots will occupy 163 * two locations. For instance, if we have in the IR code a dvec3 attr0 in 164 * location 0 and vec4 attr1 in location 1, in NIR attr0 will use 165 * locations/slots 0 and 1, and attr1 will use location/slot 2 */ 166 if (shader->stage == MESA_SHADER_VERTEX) 167 nir_remap_attributes(shader); 168 169 shader->info->name = ralloc_asprintf(shader, "GLSL%d", shader_prog->Name); 170 if (shader_prog->Label) 171 shader->info->label = ralloc_strdup(shader, shader_prog->Label); 172 shader->info->clip_distance_array_size = sh->Program->ClipDistanceArraySize; 173 shader->info->cull_distance_array_size = sh->Program->CullDistanceArraySize; 174 shader->info->has_transform_feedback_varyings = 175 shader_prog->TransformFeedback.NumVarying > 0; 176 177 return shader; 178} 179 180nir_visitor::nir_visitor(nir_shader *shader) 181{ 182 this->supports_ints = shader->options->native_integers; 183 this->shader = shader; 184 this->is_global = true; 185 this->var_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer, 186 _mesa_key_pointer_equal); 187 this->overload_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer, 188 _mesa_key_pointer_equal); 189 this->result = NULL; 190 this->impl = NULL; 191 this->var = NULL; 192 this->deref_head = NULL; 193 this->deref_tail = NULL; 194 memset(&this->b, 0, sizeof(this->b)); 195} 196 197nir_visitor::~nir_visitor() 198{ 199 _mesa_hash_table_destroy(this->var_table, NULL); 200 _mesa_hash_table_destroy(this->overload_table, NULL); 201} 202 203nir_deref_var * 204nir_visitor::evaluate_deref(nir_instr *mem_ctx, ir_instruction *ir) 205{ 206 ir->accept(this); 207 ralloc_steal(mem_ctx, this->deref_head); 208 return this->deref_head; 209} 210 211static nir_constant * 212constant_copy(ir_constant *ir, void *mem_ctx) 213{ 214 if (ir == NULL) 215 return NULL; 216 217 nir_constant *ret = ralloc(mem_ctx, nir_constant); 218 219 const unsigned rows = ir->type->vector_elements; 220 const unsigned cols = ir->type->matrix_columns; 221 unsigned i; 222 223 ret->num_elements = 0; 224 switch (ir->type->base_type) { 225 case GLSL_TYPE_UINT: 226 /* Only float base types can be matrices. */ 227 assert(cols == 1); 228 229 for (unsigned r = 0; r < rows; r++) 230 ret->values[0].u32[r] = ir->value.u[r]; 231 232 break; 233 234 case GLSL_TYPE_INT: 235 /* Only float base types can be matrices. */ 236 assert(cols == 1); 237 238 for (unsigned r = 0; r < rows; r++) 239 ret->values[0].i32[r] = ir->value.i[r]; 240 241 break; 242 243 case GLSL_TYPE_FLOAT: 244 for (unsigned c = 0; c < cols; c++) { 245 for (unsigned r = 0; r < rows; r++) 246 ret->values[c].f32[r] = ir->value.f[c * rows + r]; 247 } 248 break; 249 250 case GLSL_TYPE_DOUBLE: 251 for (unsigned c = 0; c < cols; c++) { 252 for (unsigned r = 0; r < rows; r++) 253 ret->values[c].f64[r] = ir->value.d[c * rows + r]; 254 } 255 break; 256 257 case GLSL_TYPE_BOOL: 258 /* Only float base types can be matrices. */ 259 assert(cols == 1); 260 261 for (unsigned r = 0; r < rows; r++) 262 ret->values[0].u32[r] = ir->value.b[r] ? NIR_TRUE : NIR_FALSE; 263 264 break; 265 266 case GLSL_TYPE_STRUCT: 267 ret->elements = ralloc_array(mem_ctx, nir_constant *, 268 ir->type->length); 269 ret->num_elements = ir->type->length; 270 271 i = 0; 272 foreach_in_list(ir_constant, field, &ir->components) { 273 ret->elements[i] = constant_copy(field, mem_ctx); 274 i++; 275 } 276 break; 277 278 case GLSL_TYPE_ARRAY: 279 ret->elements = ralloc_array(mem_ctx, nir_constant *, 280 ir->type->length); 281 ret->num_elements = ir->type->length; 282 283 for (i = 0; i < ir->type->length; i++) 284 ret->elements[i] = constant_copy(ir->array_elements[i], mem_ctx); 285 break; 286 287 default: 288 unreachable("not reached"); 289 } 290 291 return ret; 292} 293 294void 295nir_visitor::visit(ir_variable *ir) 296{ 297 nir_variable *var = ralloc(shader, nir_variable); 298 var->type = ir->type; 299 var->name = ralloc_strdup(var, ir->name); 300 301 var->data.read_only = ir->data.read_only; 302 var->data.centroid = ir->data.centroid; 303 var->data.sample = ir->data.sample; 304 var->data.patch = ir->data.patch; 305 var->data.invariant = ir->data.invariant; 306 var->data.location = ir->data.location; 307 var->data.compact = false; 308 309 switch(ir->data.mode) { 310 case ir_var_auto: 311 case ir_var_temporary: 312 if (is_global) 313 var->data.mode = nir_var_global; 314 else 315 var->data.mode = nir_var_local; 316 break; 317 318 case ir_var_function_in: 319 case ir_var_function_out: 320 case ir_var_function_inout: 321 case ir_var_const_in: 322 var->data.mode = nir_var_local; 323 break; 324 325 case ir_var_shader_in: 326 if (shader->stage == MESA_SHADER_FRAGMENT && 327 ir->data.location == VARYING_SLOT_FACE) { 328 /* For whatever reason, GLSL IR makes gl_FrontFacing an input */ 329 var->data.location = SYSTEM_VALUE_FRONT_FACE; 330 var->data.mode = nir_var_system_value; 331 } else if (shader->stage == MESA_SHADER_GEOMETRY && 332 ir->data.location == VARYING_SLOT_PRIMITIVE_ID) { 333 /* For whatever reason, GLSL IR makes gl_PrimitiveIDIn an input */ 334 var->data.location = SYSTEM_VALUE_PRIMITIVE_ID; 335 var->data.mode = nir_var_system_value; 336 } else { 337 var->data.mode = nir_var_shader_in; 338 339 if (shader->stage == MESA_SHADER_TESS_EVAL && 340 (ir->data.location == VARYING_SLOT_TESS_LEVEL_INNER || 341 ir->data.location == VARYING_SLOT_TESS_LEVEL_OUTER)) { 342 var->data.compact = ir->type->without_array()->is_scalar(); 343 } 344 } 345 346 /* Mark all the locations that require two slots */ 347 if (glsl_type_is_dual_slot(glsl_without_array(var->type))) { 348 for (uint i = 0; i < glsl_count_attribute_slots(var->type, true); i++) { 349 uint64_t bitfield = BITFIELD64_BIT(var->data.location + i); 350 shader->info->double_inputs_read |= bitfield; 351 } 352 } 353 break; 354 355 case ir_var_shader_out: 356 var->data.mode = nir_var_shader_out; 357 if (shader->stage == MESA_SHADER_TESS_CTRL && 358 (ir->data.location == VARYING_SLOT_TESS_LEVEL_INNER || 359 ir->data.location == VARYING_SLOT_TESS_LEVEL_OUTER)) { 360 var->data.compact = ir->type->without_array()->is_scalar(); 361 } 362 break; 363 364 case ir_var_uniform: 365 var->data.mode = nir_var_uniform; 366 break; 367 368 case ir_var_shader_storage: 369 var->data.mode = nir_var_shader_storage; 370 break; 371 372 case ir_var_system_value: 373 var->data.mode = nir_var_system_value; 374 break; 375 376 default: 377 unreachable("not reached"); 378 } 379 380 var->data.interpolation = ir->data.interpolation; 381 var->data.origin_upper_left = ir->data.origin_upper_left; 382 var->data.pixel_center_integer = ir->data.pixel_center_integer; 383 var->data.location_frac = ir->data.location_frac; 384 385 switch (ir->data.depth_layout) { 386 case ir_depth_layout_none: 387 var->data.depth_layout = nir_depth_layout_none; 388 break; 389 case ir_depth_layout_any: 390 var->data.depth_layout = nir_depth_layout_any; 391 break; 392 case ir_depth_layout_greater: 393 var->data.depth_layout = nir_depth_layout_greater; 394 break; 395 case ir_depth_layout_less: 396 var->data.depth_layout = nir_depth_layout_less; 397 break; 398 case ir_depth_layout_unchanged: 399 var->data.depth_layout = nir_depth_layout_unchanged; 400 break; 401 default: 402 unreachable("not reached"); 403 } 404 405 var->data.index = ir->data.index; 406 var->data.binding = ir->data.binding; 407 var->data.offset = ir->data.offset; 408 var->data.image.read_only = ir->data.image_read_only; 409 var->data.image.write_only = ir->data.image_write_only; 410 var->data.image.coherent = ir->data.image_coherent; 411 var->data.image._volatile = ir->data.image_volatile; 412 var->data.image.restrict_flag = ir->data.image_restrict; 413 var->data.image.format = ir->data.image_format; 414 var->data.fb_fetch_output = ir->data.fb_fetch_output; 415 416 var->num_state_slots = ir->get_num_state_slots(); 417 if (var->num_state_slots > 0) { 418 var->state_slots = ralloc_array(var, nir_state_slot, 419 var->num_state_slots); 420 421 ir_state_slot *state_slots = ir->get_state_slots(); 422 for (unsigned i = 0; i < var->num_state_slots; i++) { 423 for (unsigned j = 0; j < 5; j++) 424 var->state_slots[i].tokens[j] = state_slots[i].tokens[j]; 425 var->state_slots[i].swizzle = state_slots[i].swizzle; 426 } 427 } else { 428 var->state_slots = NULL; 429 } 430 431 var->constant_initializer = constant_copy(ir->constant_initializer, var); 432 433 var->interface_type = ir->get_interface_type(); 434 435 if (var->data.mode == nir_var_local) 436 nir_function_impl_add_variable(impl, var); 437 else 438 nir_shader_add_variable(shader, var); 439 440 _mesa_hash_table_insert(var_table, ir, var); 441 this->var = var; 442} 443 444ir_visitor_status 445nir_function_visitor::visit_enter(ir_function *ir) 446{ 447 foreach_in_list(ir_function_signature, sig, &ir->signatures) { 448 visitor->create_function(sig); 449 } 450 return visit_continue_with_parent; 451} 452 453void 454nir_visitor::create_function(ir_function_signature *ir) 455{ 456 if (ir->is_intrinsic()) 457 return; 458 459 nir_function *func = nir_function_create(shader, ir->function_name()); 460 461 assert(ir->parameters.is_empty()); 462 assert(ir->return_type == glsl_type::void_type); 463 464 _mesa_hash_table_insert(this->overload_table, ir, func); 465} 466 467void 468nir_visitor::visit(ir_function *ir) 469{ 470 foreach_in_list(ir_function_signature, sig, &ir->signatures) 471 sig->accept(this); 472} 473 474void 475nir_visitor::visit(ir_function_signature *ir) 476{ 477 if (ir->is_intrinsic()) 478 return; 479 480 struct hash_entry *entry = 481 _mesa_hash_table_search(this->overload_table, ir); 482 483 assert(entry); 484 nir_function *func = (nir_function *) entry->data; 485 486 if (ir->is_defined) { 487 nir_function_impl *impl = nir_function_impl_create(func); 488 this->impl = impl; 489 490 assert(strcmp(func->name, "main") == 0); 491 assert(ir->parameters.is_empty()); 492 assert(func->return_type == glsl_type::void_type); 493 494 this->is_global = false; 495 496 nir_builder_init(&b, impl); 497 b.cursor = nir_after_cf_list(&impl->body); 498 visit_exec_list(&ir->body, this); 499 500 this->is_global = true; 501 } else { 502 func->impl = NULL; 503 } 504} 505 506void 507nir_visitor::visit(ir_loop *ir) 508{ 509 nir_loop *loop = nir_loop_create(this->shader); 510 nir_builder_cf_insert(&b, &loop->cf_node); 511 512 b.cursor = nir_after_cf_list(&loop->body); 513 visit_exec_list(&ir->body_instructions, this); 514 b.cursor = nir_after_cf_node(&loop->cf_node); 515} 516 517void 518nir_visitor::visit(ir_if *ir) 519{ 520 nir_src condition = 521 nir_src_for_ssa(evaluate_rvalue(ir->condition)); 522 523 nir_if *if_stmt = nir_if_create(this->shader); 524 if_stmt->condition = condition; 525 nir_builder_cf_insert(&b, &if_stmt->cf_node); 526 527 b.cursor = nir_after_cf_list(&if_stmt->then_list); 528 visit_exec_list(&ir->then_instructions, this); 529 530 b.cursor = nir_after_cf_list(&if_stmt->else_list); 531 visit_exec_list(&ir->else_instructions, this); 532 533 b.cursor = nir_after_cf_node(&if_stmt->cf_node); 534} 535 536void 537nir_visitor::visit(ir_discard *ir) 538{ 539 /* 540 * discards aren't treated as control flow, because before we lower them 541 * they can appear anywhere in the shader and the stuff after them may still 542 * be executed (yay, crazy GLSL rules!). However, after lowering, all the 543 * discards will be immediately followed by a return. 544 */ 545 546 nir_intrinsic_instr *discard; 547 if (ir->condition) { 548 discard = nir_intrinsic_instr_create(this->shader, 549 nir_intrinsic_discard_if); 550 discard->src[0] = 551 nir_src_for_ssa(evaluate_rvalue(ir->condition)); 552 } else { 553 discard = nir_intrinsic_instr_create(this->shader, nir_intrinsic_discard); 554 } 555 556 nir_builder_instr_insert(&b, &discard->instr); 557} 558 559void 560nir_visitor::visit(ir_emit_vertex *ir) 561{ 562 nir_intrinsic_instr *instr = 563 nir_intrinsic_instr_create(this->shader, nir_intrinsic_emit_vertex); 564 nir_intrinsic_set_stream_id(instr, ir->stream_id()); 565 nir_builder_instr_insert(&b, &instr->instr); 566} 567 568void 569nir_visitor::visit(ir_end_primitive *ir) 570{ 571 nir_intrinsic_instr *instr = 572 nir_intrinsic_instr_create(this->shader, nir_intrinsic_end_primitive); 573 nir_intrinsic_set_stream_id(instr, ir->stream_id()); 574 nir_builder_instr_insert(&b, &instr->instr); 575} 576 577void 578nir_visitor::visit(ir_loop_jump *ir) 579{ 580 nir_jump_type type; 581 switch (ir->mode) { 582 case ir_loop_jump::jump_break: 583 type = nir_jump_break; 584 break; 585 case ir_loop_jump::jump_continue: 586 type = nir_jump_continue; 587 break; 588 default: 589 unreachable("not reached"); 590 } 591 592 nir_jump_instr *instr = nir_jump_instr_create(this->shader, type); 593 nir_builder_instr_insert(&b, &instr->instr); 594} 595 596void 597nir_visitor::visit(ir_return *ir) 598{ 599 if (ir->value != NULL) { 600 nir_intrinsic_instr *copy = 601 nir_intrinsic_instr_create(this->shader, nir_intrinsic_copy_var); 602 603 copy->variables[0] = nir_deref_var_create(copy, this->impl->return_var); 604 copy->variables[1] = evaluate_deref(©->instr, ir->value); 605 } 606 607 nir_jump_instr *instr = nir_jump_instr_create(this->shader, nir_jump_return); 608 nir_builder_instr_insert(&b, &instr->instr); 609} 610 611void 612nir_visitor::visit(ir_call *ir) 613{ 614 if (ir->callee->is_intrinsic()) { 615 nir_intrinsic_op op; 616 617 switch (ir->callee->intrinsic_id) { 618 case ir_intrinsic_atomic_counter_read: 619 op = nir_intrinsic_atomic_counter_read_var; 620 break; 621 case ir_intrinsic_atomic_counter_increment: 622 op = nir_intrinsic_atomic_counter_inc_var; 623 break; 624 case ir_intrinsic_atomic_counter_predecrement: 625 op = nir_intrinsic_atomic_counter_dec_var; 626 break; 627 case ir_intrinsic_atomic_counter_add: 628 op = nir_intrinsic_atomic_counter_add_var; 629 break; 630 case ir_intrinsic_atomic_counter_and: 631 op = nir_intrinsic_atomic_counter_and_var; 632 break; 633 case ir_intrinsic_atomic_counter_or: 634 op = nir_intrinsic_atomic_counter_or_var; 635 break; 636 case ir_intrinsic_atomic_counter_xor: 637 op = nir_intrinsic_atomic_counter_xor_var; 638 break; 639 case ir_intrinsic_atomic_counter_min: 640 op = nir_intrinsic_atomic_counter_min_var; 641 break; 642 case ir_intrinsic_atomic_counter_max: 643 op = nir_intrinsic_atomic_counter_max_var; 644 break; 645 case ir_intrinsic_atomic_counter_exchange: 646 op = nir_intrinsic_atomic_counter_exchange_var; 647 break; 648 case ir_intrinsic_atomic_counter_comp_swap: 649 op = nir_intrinsic_atomic_counter_comp_swap_var; 650 break; 651 case ir_intrinsic_image_load: 652 op = nir_intrinsic_image_load; 653 break; 654 case ir_intrinsic_image_store: 655 op = nir_intrinsic_image_store; 656 break; 657 case ir_intrinsic_image_atomic_add: 658 op = nir_intrinsic_image_atomic_add; 659 break; 660 case ir_intrinsic_image_atomic_min: 661 op = nir_intrinsic_image_atomic_min; 662 break; 663 case ir_intrinsic_image_atomic_max: 664 op = nir_intrinsic_image_atomic_max; 665 break; 666 case ir_intrinsic_image_atomic_and: 667 op = nir_intrinsic_image_atomic_and; 668 break; 669 case ir_intrinsic_image_atomic_or: 670 op = nir_intrinsic_image_atomic_or; 671 break; 672 case ir_intrinsic_image_atomic_xor: 673 op = nir_intrinsic_image_atomic_xor; 674 break; 675 case ir_intrinsic_image_atomic_exchange: 676 op = nir_intrinsic_image_atomic_exchange; 677 break; 678 case ir_intrinsic_image_atomic_comp_swap: 679 op = nir_intrinsic_image_atomic_comp_swap; 680 break; 681 case ir_intrinsic_memory_barrier: 682 op = nir_intrinsic_memory_barrier; 683 break; 684 case ir_intrinsic_image_size: 685 op = nir_intrinsic_image_size; 686 break; 687 case ir_intrinsic_image_samples: 688 op = nir_intrinsic_image_samples; 689 break; 690 case ir_intrinsic_ssbo_store: 691 op = nir_intrinsic_store_ssbo; 692 break; 693 case ir_intrinsic_ssbo_load: 694 op = nir_intrinsic_load_ssbo; 695 break; 696 case ir_intrinsic_ssbo_atomic_add: 697 op = nir_intrinsic_ssbo_atomic_add; 698 break; 699 case ir_intrinsic_ssbo_atomic_and: 700 op = nir_intrinsic_ssbo_atomic_and; 701 break; 702 case ir_intrinsic_ssbo_atomic_or: 703 op = nir_intrinsic_ssbo_atomic_or; 704 break; 705 case ir_intrinsic_ssbo_atomic_xor: 706 op = nir_intrinsic_ssbo_atomic_xor; 707 break; 708 case ir_intrinsic_ssbo_atomic_min: 709 assert(ir->return_deref); 710 if (ir->return_deref->type == glsl_type::int_type) 711 op = nir_intrinsic_ssbo_atomic_imin; 712 else if (ir->return_deref->type == glsl_type::uint_type) 713 op = nir_intrinsic_ssbo_atomic_umin; 714 else 715 unreachable("Invalid type"); 716 break; 717 case ir_intrinsic_ssbo_atomic_max: 718 assert(ir->return_deref); 719 if (ir->return_deref->type == glsl_type::int_type) 720 op = nir_intrinsic_ssbo_atomic_imax; 721 else if (ir->return_deref->type == glsl_type::uint_type) 722 op = nir_intrinsic_ssbo_atomic_umax; 723 else 724 unreachable("Invalid type"); 725 break; 726 case ir_intrinsic_ssbo_atomic_exchange: 727 op = nir_intrinsic_ssbo_atomic_exchange; 728 break; 729 case ir_intrinsic_ssbo_atomic_comp_swap: 730 op = nir_intrinsic_ssbo_atomic_comp_swap; 731 break; 732 case ir_intrinsic_shader_clock: 733 op = nir_intrinsic_shader_clock; 734 break; 735 case ir_intrinsic_group_memory_barrier: 736 op = nir_intrinsic_group_memory_barrier; 737 break; 738 case ir_intrinsic_memory_barrier_atomic_counter: 739 op = nir_intrinsic_memory_barrier_atomic_counter; 740 break; 741 case ir_intrinsic_memory_barrier_buffer: 742 op = nir_intrinsic_memory_barrier_buffer; 743 break; 744 case ir_intrinsic_memory_barrier_image: 745 op = nir_intrinsic_memory_barrier_image; 746 break; 747 case ir_intrinsic_memory_barrier_shared: 748 op = nir_intrinsic_memory_barrier_shared; 749 break; 750 case ir_intrinsic_shared_load: 751 op = nir_intrinsic_load_shared; 752 break; 753 case ir_intrinsic_shared_store: 754 op = nir_intrinsic_store_shared; 755 break; 756 case ir_intrinsic_shared_atomic_add: 757 op = nir_intrinsic_shared_atomic_add; 758 break; 759 case ir_intrinsic_shared_atomic_and: 760 op = nir_intrinsic_shared_atomic_and; 761 break; 762 case ir_intrinsic_shared_atomic_or: 763 op = nir_intrinsic_shared_atomic_or; 764 break; 765 case ir_intrinsic_shared_atomic_xor: 766 op = nir_intrinsic_shared_atomic_xor; 767 break; 768 case ir_intrinsic_shared_atomic_min: 769 assert(ir->return_deref); 770 if (ir->return_deref->type == glsl_type::int_type) 771 op = nir_intrinsic_shared_atomic_imin; 772 else if (ir->return_deref->type == glsl_type::uint_type) 773 op = nir_intrinsic_shared_atomic_umin; 774 else 775 unreachable("Invalid type"); 776 break; 777 case ir_intrinsic_shared_atomic_max: 778 assert(ir->return_deref); 779 if (ir->return_deref->type == glsl_type::int_type) 780 op = nir_intrinsic_shared_atomic_imax; 781 else if (ir->return_deref->type == glsl_type::uint_type) 782 op = nir_intrinsic_shared_atomic_umax; 783 else 784 unreachable("Invalid type"); 785 break; 786 case ir_intrinsic_shared_atomic_exchange: 787 op = nir_intrinsic_shared_atomic_exchange; 788 break; 789 case ir_intrinsic_shared_atomic_comp_swap: 790 op = nir_intrinsic_shared_atomic_comp_swap; 791 break; 792 default: 793 unreachable("not reached"); 794 } 795 796 nir_intrinsic_instr *instr = nir_intrinsic_instr_create(shader, op); 797 nir_dest *dest = &instr->dest; 798 799 switch (op) { 800 case nir_intrinsic_atomic_counter_read_var: 801 case nir_intrinsic_atomic_counter_inc_var: 802 case nir_intrinsic_atomic_counter_dec_var: 803 case nir_intrinsic_atomic_counter_add_var: 804 case nir_intrinsic_atomic_counter_min_var: 805 case nir_intrinsic_atomic_counter_max_var: 806 case nir_intrinsic_atomic_counter_and_var: 807 case nir_intrinsic_atomic_counter_or_var: 808 case nir_intrinsic_atomic_counter_xor_var: 809 case nir_intrinsic_atomic_counter_exchange_var: 810 case nir_intrinsic_atomic_counter_comp_swap_var: { 811 /* Set the counter variable dereference. */ 812 exec_node *param = ir->actual_parameters.get_head(); 813 ir_dereference *counter = (ir_dereference *)param; 814 815 instr->variables[0] = evaluate_deref(&instr->instr, counter); 816 param = param->get_next(); 817 818 /* Set the intrinsic destination. */ 819 if (ir->return_deref) { 820 nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL); 821 } 822 823 /* Set the intrinsic parameters. */ 824 if (!param->is_tail_sentinel()) { 825 instr->src[0] = 826 nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param)); 827 param = param->get_next(); 828 } 829 830 if (!param->is_tail_sentinel()) { 831 instr->src[1] = 832 nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param)); 833 param = param->get_next(); 834 } 835 836 nir_builder_instr_insert(&b, &instr->instr); 837 break; 838 } 839 case nir_intrinsic_image_load: 840 case nir_intrinsic_image_store: 841 case nir_intrinsic_image_atomic_add: 842 case nir_intrinsic_image_atomic_min: 843 case nir_intrinsic_image_atomic_max: 844 case nir_intrinsic_image_atomic_and: 845 case nir_intrinsic_image_atomic_or: 846 case nir_intrinsic_image_atomic_xor: 847 case nir_intrinsic_image_atomic_exchange: 848 case nir_intrinsic_image_atomic_comp_swap: 849 case nir_intrinsic_image_samples: 850 case nir_intrinsic_image_size: { 851 nir_ssa_undef_instr *instr_undef = 852 nir_ssa_undef_instr_create(shader, 1, 32); 853 nir_builder_instr_insert(&b, &instr_undef->instr); 854 855 /* Set the image variable dereference. */ 856 exec_node *param = ir->actual_parameters.get_head(); 857 ir_dereference *image = (ir_dereference *)param; 858 const glsl_type *type = 859 image->variable_referenced()->type->without_array(); 860 861 instr->variables[0] = evaluate_deref(&instr->instr, image); 862 param = param->get_next(); 863 864 /* Set the intrinsic destination. */ 865 if (ir->return_deref) { 866 const nir_intrinsic_info *info = 867 &nir_intrinsic_infos[instr->intrinsic]; 868 nir_ssa_dest_init(&instr->instr, &instr->dest, 869 info->dest_components, 32, NULL); 870 } 871 872 if (op == nir_intrinsic_image_size || 873 op == nir_intrinsic_image_samples) { 874 nir_builder_instr_insert(&b, &instr->instr); 875 break; 876 } 877 878 /* Set the address argument, extending the coordinate vector to four 879 * components. 880 */ 881 nir_ssa_def *src_addr = 882 evaluate_rvalue((ir_dereference *)param); 883 nir_ssa_def *srcs[4]; 884 885 for (int i = 0; i < 4; i++) { 886 if (i < type->coordinate_components()) 887 srcs[i] = nir_channel(&b, src_addr, i); 888 else 889 srcs[i] = &instr_undef->def; 890 } 891 892 instr->src[0] = nir_src_for_ssa(nir_vec(&b, srcs, 4)); 893 param = param->get_next(); 894 895 /* Set the sample argument, which is undefined for single-sample 896 * images. 897 */ 898 if (type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS) { 899 instr->src[1] = 900 nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param)); 901 param = param->get_next(); 902 } else { 903 instr->src[1] = nir_src_for_ssa(&instr_undef->def); 904 } 905 906 /* Set the intrinsic parameters. */ 907 if (!param->is_tail_sentinel()) { 908 instr->src[2] = 909 nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param)); 910 param = param->get_next(); 911 } 912 913 if (!param->is_tail_sentinel()) { 914 instr->src[3] = 915 nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param)); 916 param = param->get_next(); 917 } 918 nir_builder_instr_insert(&b, &instr->instr); 919 break; 920 } 921 case nir_intrinsic_memory_barrier: 922 case nir_intrinsic_group_memory_barrier: 923 case nir_intrinsic_memory_barrier_atomic_counter: 924 case nir_intrinsic_memory_barrier_buffer: 925 case nir_intrinsic_memory_barrier_image: 926 case nir_intrinsic_memory_barrier_shared: 927 nir_builder_instr_insert(&b, &instr->instr); 928 break; 929 case nir_intrinsic_shader_clock: 930 nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL); 931 nir_builder_instr_insert(&b, &instr->instr); 932 break; 933 case nir_intrinsic_store_ssbo: { 934 exec_node *param = ir->actual_parameters.get_head(); 935 ir_rvalue *block = ((ir_instruction *)param)->as_rvalue(); 936 937 param = param->get_next(); 938 ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue(); 939 940 param = param->get_next(); 941 ir_rvalue *val = ((ir_instruction *)param)->as_rvalue(); 942 943 param = param->get_next(); 944 ir_constant *write_mask = ((ir_instruction *)param)->as_constant(); 945 assert(write_mask); 946 947 instr->src[0] = nir_src_for_ssa(evaluate_rvalue(val)); 948 instr->src[1] = nir_src_for_ssa(evaluate_rvalue(block)); 949 instr->src[2] = nir_src_for_ssa(evaluate_rvalue(offset)); 950 nir_intrinsic_set_write_mask(instr, write_mask->value.u[0]); 951 instr->num_components = val->type->vector_elements; 952 953 nir_builder_instr_insert(&b, &instr->instr); 954 break; 955 } 956 case nir_intrinsic_load_ssbo: { 957 exec_node *param = ir->actual_parameters.get_head(); 958 ir_rvalue *block = ((ir_instruction *)param)->as_rvalue(); 959 960 param = param->get_next(); 961 ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue(); 962 963 instr->src[0] = nir_src_for_ssa(evaluate_rvalue(block)); 964 instr->src[1] = nir_src_for_ssa(evaluate_rvalue(offset)); 965 966 const glsl_type *type = ir->return_deref->var->type; 967 instr->num_components = type->vector_elements; 968 969 /* Setup destination register */ 970 unsigned bit_size = glsl_get_bit_size(type); 971 nir_ssa_dest_init(&instr->instr, &instr->dest, 972 type->vector_elements, bit_size, NULL); 973 974 /* Insert the created nir instruction now since in the case of boolean 975 * result we will need to emit another instruction after it 976 */ 977 nir_builder_instr_insert(&b, &instr->instr); 978 979 /* 980 * In SSBO/UBO's, a true boolean value is any non-zero value, but we 981 * consider a true boolean to be ~0. Fix this up with a != 0 982 * comparison. 983 */ 984 if (type->base_type == GLSL_TYPE_BOOL) { 985 nir_alu_instr *load_ssbo_compare = 986 nir_alu_instr_create(shader, nir_op_ine); 987 load_ssbo_compare->src[0].src.is_ssa = true; 988 load_ssbo_compare->src[0].src.ssa = &instr->dest.ssa; 989 load_ssbo_compare->src[1].src = 990 nir_src_for_ssa(nir_imm_int(&b, 0)); 991 for (unsigned i = 0; i < type->vector_elements; i++) 992 load_ssbo_compare->src[1].swizzle[i] = 0; 993 nir_ssa_dest_init(&load_ssbo_compare->instr, 994 &load_ssbo_compare->dest.dest, 995 type->vector_elements, bit_size, NULL); 996 load_ssbo_compare->dest.write_mask = (1 << type->vector_elements) - 1; 997 nir_builder_instr_insert(&b, &load_ssbo_compare->instr); 998 dest = &load_ssbo_compare->dest.dest; 999 } 1000 break; 1001 } 1002 case nir_intrinsic_ssbo_atomic_add: 1003 case nir_intrinsic_ssbo_atomic_imin: 1004 case nir_intrinsic_ssbo_atomic_umin: 1005 case nir_intrinsic_ssbo_atomic_imax: 1006 case nir_intrinsic_ssbo_atomic_umax: 1007 case nir_intrinsic_ssbo_atomic_and: 1008 case nir_intrinsic_ssbo_atomic_or: 1009 case nir_intrinsic_ssbo_atomic_xor: 1010 case nir_intrinsic_ssbo_atomic_exchange: 1011 case nir_intrinsic_ssbo_atomic_comp_swap: { 1012 int param_count = ir->actual_parameters.length(); 1013 assert(param_count == 3 || param_count == 4); 1014 1015 /* Block index */ 1016 exec_node *param = ir->actual_parameters.get_head(); 1017 ir_instruction *inst = (ir_instruction *) param; 1018 instr->src[0] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1019 1020 /* Offset */ 1021 param = param->get_next(); 1022 inst = (ir_instruction *) param; 1023 instr->src[1] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1024 1025 /* data1 parameter (this is always present) */ 1026 param = param->get_next(); 1027 inst = (ir_instruction *) param; 1028 instr->src[2] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1029 1030 /* data2 parameter (only with atomic_comp_swap) */ 1031 if (param_count == 4) { 1032 assert(op == nir_intrinsic_ssbo_atomic_comp_swap); 1033 param = param->get_next(); 1034 inst = (ir_instruction *) param; 1035 instr->src[3] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1036 } 1037 1038 /* Atomic result */ 1039 assert(ir->return_deref); 1040 nir_ssa_dest_init(&instr->instr, &instr->dest, 1041 ir->return_deref->type->vector_elements, 32, NULL); 1042 nir_builder_instr_insert(&b, &instr->instr); 1043 break; 1044 } 1045 case nir_intrinsic_load_shared: { 1046 exec_node *param = ir->actual_parameters.get_head(); 1047 ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue(); 1048 1049 nir_intrinsic_set_base(instr, 0); 1050 instr->src[0] = nir_src_for_ssa(evaluate_rvalue(offset)); 1051 1052 const glsl_type *type = ir->return_deref->var->type; 1053 instr->num_components = type->vector_elements; 1054 1055 /* Setup destination register */ 1056 unsigned bit_size = glsl_get_bit_size(type); 1057 nir_ssa_dest_init(&instr->instr, &instr->dest, 1058 type->vector_elements, bit_size, NULL); 1059 1060 nir_builder_instr_insert(&b, &instr->instr); 1061 break; 1062 } 1063 case nir_intrinsic_store_shared: { 1064 exec_node *param = ir->actual_parameters.get_head(); 1065 ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue(); 1066 1067 param = param->get_next(); 1068 ir_rvalue *val = ((ir_instruction *)param)->as_rvalue(); 1069 1070 param = param->get_next(); 1071 ir_constant *write_mask = ((ir_instruction *)param)->as_constant(); 1072 assert(write_mask); 1073 1074 nir_intrinsic_set_base(instr, 0); 1075 instr->src[1] = nir_src_for_ssa(evaluate_rvalue(offset)); 1076 1077 nir_intrinsic_set_write_mask(instr, write_mask->value.u[0]); 1078 1079 instr->src[0] = nir_src_for_ssa(evaluate_rvalue(val)); 1080 instr->num_components = val->type->vector_elements; 1081 1082 nir_builder_instr_insert(&b, &instr->instr); 1083 break; 1084 } 1085 case nir_intrinsic_shared_atomic_add: 1086 case nir_intrinsic_shared_atomic_imin: 1087 case nir_intrinsic_shared_atomic_umin: 1088 case nir_intrinsic_shared_atomic_imax: 1089 case nir_intrinsic_shared_atomic_umax: 1090 case nir_intrinsic_shared_atomic_and: 1091 case nir_intrinsic_shared_atomic_or: 1092 case nir_intrinsic_shared_atomic_xor: 1093 case nir_intrinsic_shared_atomic_exchange: 1094 case nir_intrinsic_shared_atomic_comp_swap: { 1095 int param_count = ir->actual_parameters.length(); 1096 assert(param_count == 2 || param_count == 3); 1097 1098 /* Offset */ 1099 exec_node *param = ir->actual_parameters.get_head(); 1100 ir_instruction *inst = (ir_instruction *) param; 1101 instr->src[0] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1102 1103 /* data1 parameter (this is always present) */ 1104 param = param->get_next(); 1105 inst = (ir_instruction *) param; 1106 instr->src[1] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1107 1108 /* data2 parameter (only with atomic_comp_swap) */ 1109 if (param_count == 3) { 1110 assert(op == nir_intrinsic_shared_atomic_comp_swap); 1111 param = param->get_next(); 1112 inst = (ir_instruction *) param; 1113 instr->src[2] = 1114 nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue())); 1115 } 1116 1117 /* Atomic result */ 1118 assert(ir->return_deref); 1119 unsigned bit_size = glsl_get_bit_size(ir->return_deref->type); 1120 nir_ssa_dest_init(&instr->instr, &instr->dest, 1121 ir->return_deref->type->vector_elements, 1122 bit_size, NULL); 1123 nir_builder_instr_insert(&b, &instr->instr); 1124 break; 1125 } 1126 default: 1127 unreachable("not reached"); 1128 } 1129 1130 if (ir->return_deref) { 1131 nir_intrinsic_instr *store_instr = 1132 nir_intrinsic_instr_create(shader, nir_intrinsic_store_var); 1133 store_instr->num_components = ir->return_deref->type->vector_elements; 1134 nir_intrinsic_set_write_mask(store_instr, 1135 (1 << store_instr->num_components) - 1); 1136 1137 store_instr->variables[0] = 1138 evaluate_deref(&store_instr->instr, ir->return_deref); 1139 store_instr->src[0] = nir_src_for_ssa(&dest->ssa); 1140 1141 nir_builder_instr_insert(&b, &store_instr->instr); 1142 } 1143 1144 return; 1145 } 1146 1147 struct hash_entry *entry = 1148 _mesa_hash_table_search(this->overload_table, ir->callee); 1149 assert(entry); 1150 nir_function *callee = (nir_function *) entry->data; 1151 1152 nir_call_instr *instr = nir_call_instr_create(this->shader, callee); 1153 1154 unsigned i = 0; 1155 foreach_in_list(ir_dereference, param, &ir->actual_parameters) { 1156 instr->params[i] = evaluate_deref(&instr->instr, param); 1157 i++; 1158 } 1159 1160 instr->return_deref = evaluate_deref(&instr->instr, ir->return_deref); 1161 nir_builder_instr_insert(&b, &instr->instr); 1162} 1163 1164void 1165nir_visitor::visit(ir_assignment *ir) 1166{ 1167 unsigned num_components = ir->lhs->type->vector_elements; 1168 1169 b.exact = ir->lhs->variable_referenced()->data.invariant || 1170 ir->lhs->variable_referenced()->data.precise; 1171 1172 if ((ir->rhs->as_dereference() || ir->rhs->as_constant()) && 1173 (ir->write_mask == (1 << num_components) - 1 || ir->write_mask == 0)) { 1174 /* We're doing a plain-as-can-be copy, so emit a copy_var */ 1175 nir_intrinsic_instr *copy = 1176 nir_intrinsic_instr_create(this->shader, nir_intrinsic_copy_var); 1177 1178 copy->variables[0] = evaluate_deref(©->instr, ir->lhs); 1179 copy->variables[1] = evaluate_deref(©->instr, ir->rhs); 1180 1181 if (ir->condition) { 1182 nir_if *if_stmt = nir_if_create(this->shader); 1183 if_stmt->condition = nir_src_for_ssa(evaluate_rvalue(ir->condition)); 1184 nir_builder_cf_insert(&b, &if_stmt->cf_node); 1185 nir_instr_insert_after_cf_list(&if_stmt->then_list, ©->instr); 1186 b.cursor = nir_after_cf_node(&if_stmt->cf_node); 1187 } else { 1188 nir_builder_instr_insert(&b, ©->instr); 1189 } 1190 return; 1191 } 1192 1193 assert(ir->rhs->type->is_scalar() || ir->rhs->type->is_vector()); 1194 1195 ir->lhs->accept(this); 1196 nir_deref_var *lhs_deref = this->deref_head; 1197 nir_ssa_def *src = evaluate_rvalue(ir->rhs); 1198 1199 if (ir->write_mask != (1 << num_components) - 1 && ir->write_mask != 0) { 1200 /* GLSL IR will give us the input to the write-masked assignment in a 1201 * single packed vector. So, for example, if the writemask is xzw, then 1202 * we have to swizzle x -> x, y -> z, and z -> w and get the y component 1203 * from the load. 1204 */ 1205 unsigned swiz[4]; 1206 unsigned component = 0; 1207 for (unsigned i = 0; i < 4; i++) { 1208 swiz[i] = ir->write_mask & (1 << i) ? component++ : 0; 1209 } 1210 src = nir_swizzle(&b, src, swiz, num_components, !supports_ints); 1211 } 1212 1213 nir_intrinsic_instr *store = 1214 nir_intrinsic_instr_create(this->shader, nir_intrinsic_store_var); 1215 store->num_components = ir->lhs->type->vector_elements; 1216 nir_intrinsic_set_write_mask(store, ir->write_mask); 1217 store->variables[0] = nir_deref_var_clone(lhs_deref, store); 1218 store->src[0] = nir_src_for_ssa(src); 1219 1220 if (ir->condition) { 1221 nir_if *if_stmt = nir_if_create(this->shader); 1222 if_stmt->condition = nir_src_for_ssa(evaluate_rvalue(ir->condition)); 1223 nir_builder_cf_insert(&b, &if_stmt->cf_node); 1224 nir_instr_insert_after_cf_list(&if_stmt->then_list, &store->instr); 1225 b.cursor = nir_after_cf_node(&if_stmt->cf_node); 1226 } else { 1227 nir_builder_instr_insert(&b, &store->instr); 1228 } 1229} 1230 1231/* 1232 * Given an instruction, returns a pointer to its destination or NULL if there 1233 * is no destination. 1234 * 1235 * Note that this only handles instructions we generate at this level. 1236 */ 1237static nir_dest * 1238get_instr_dest(nir_instr *instr) 1239{ 1240 nir_alu_instr *alu_instr; 1241 nir_intrinsic_instr *intrinsic_instr; 1242 nir_tex_instr *tex_instr; 1243 1244 switch (instr->type) { 1245 case nir_instr_type_alu: 1246 alu_instr = nir_instr_as_alu(instr); 1247 return &alu_instr->dest.dest; 1248 1249 case nir_instr_type_intrinsic: 1250 intrinsic_instr = nir_instr_as_intrinsic(instr); 1251 if (nir_intrinsic_infos[intrinsic_instr->intrinsic].has_dest) 1252 return &intrinsic_instr->dest; 1253 else 1254 return NULL; 1255 1256 case nir_instr_type_tex: 1257 tex_instr = nir_instr_as_tex(instr); 1258 return &tex_instr->dest; 1259 1260 default: 1261 unreachable("not reached"); 1262 } 1263 1264 return NULL; 1265} 1266 1267void 1268nir_visitor::add_instr(nir_instr *instr, unsigned num_components, 1269 unsigned bit_size) 1270{ 1271 nir_dest *dest = get_instr_dest(instr); 1272 1273 if (dest) 1274 nir_ssa_dest_init(instr, dest, num_components, bit_size, NULL); 1275 1276 nir_builder_instr_insert(&b, instr); 1277 1278 if (dest) { 1279 assert(dest->is_ssa); 1280 this->result = &dest->ssa; 1281 } 1282} 1283 1284nir_ssa_def * 1285nir_visitor::evaluate_rvalue(ir_rvalue* ir) 1286{ 1287 ir->accept(this); 1288 if (ir->as_dereference() || ir->as_constant()) { 1289 /* 1290 * A dereference is being used on the right hand side, which means we 1291 * must emit a variable load. 1292 */ 1293 1294 nir_intrinsic_instr *load_instr = 1295 nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_var); 1296 load_instr->num_components = ir->type->vector_elements; 1297 load_instr->variables[0] = this->deref_head; 1298 ralloc_steal(load_instr, load_instr->variables[0]); 1299 unsigned bit_size = glsl_get_bit_size(ir->type); 1300 add_instr(&load_instr->instr, ir->type->vector_elements, bit_size); 1301 } 1302 1303 return this->result; 1304} 1305 1306static bool 1307type_is_float(glsl_base_type type) 1308{ 1309 return type == GLSL_TYPE_FLOAT || type == GLSL_TYPE_DOUBLE; 1310} 1311 1312void 1313nir_visitor::visit(ir_expression *ir) 1314{ 1315 /* Some special cases */ 1316 switch (ir->operation) { 1317 case ir_binop_ubo_load: { 1318 nir_intrinsic_instr *load = 1319 nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_ubo); 1320 unsigned bit_size = glsl_get_bit_size(ir->type); 1321 load->num_components = ir->type->vector_elements; 1322 load->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[0])); 1323 load->src[1] = nir_src_for_ssa(evaluate_rvalue(ir->operands[1])); 1324 add_instr(&load->instr, ir->type->vector_elements, bit_size); 1325 1326 /* 1327 * In UBO's, a true boolean value is any non-zero value, but we consider 1328 * a true boolean to be ~0. Fix this up with a != 0 comparison. 1329 */ 1330 1331 if (ir->type->base_type == GLSL_TYPE_BOOL) 1332 this->result = nir_ine(&b, &load->dest.ssa, nir_imm_int(&b, 0)); 1333 1334 return; 1335 } 1336 1337 case ir_unop_interpolate_at_centroid: 1338 case ir_binop_interpolate_at_offset: 1339 case ir_binop_interpolate_at_sample: { 1340 ir_dereference *deref = ir->operands[0]->as_dereference(); 1341 ir_swizzle *swizzle = NULL; 1342 if (!deref) { 1343 /* the api does not allow a swizzle here, but the varying packing code 1344 * may have pushed one into here. 1345 */ 1346 swizzle = ir->operands[0]->as_swizzle(); 1347 assert(swizzle); 1348 deref = swizzle->val->as_dereference(); 1349 assert(deref); 1350 } 1351 1352 deref->accept(this); 1353 1354 nir_intrinsic_op op; 1355 if (this->deref_head->var->data.mode == nir_var_shader_in) { 1356 switch (ir->operation) { 1357 case ir_unop_interpolate_at_centroid: 1358 op = nir_intrinsic_interp_var_at_centroid; 1359 break; 1360 case ir_binop_interpolate_at_offset: 1361 op = nir_intrinsic_interp_var_at_offset; 1362 break; 1363 case ir_binop_interpolate_at_sample: 1364 op = nir_intrinsic_interp_var_at_sample; 1365 break; 1366 default: 1367 unreachable("Invalid interpolation intrinsic"); 1368 } 1369 } else { 1370 /* This case can happen if the vertex shader does not write the 1371 * given varying. In this case, the linker will lower it to a 1372 * global variable. Since interpolating a variable makes no 1373 * sense, we'll just turn it into a load which will probably 1374 * eventually end up as an SSA definition. 1375 */ 1376 assert(this->deref_head->var->data.mode == nir_var_global); 1377 op = nir_intrinsic_load_var; 1378 } 1379 1380 nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(shader, op); 1381 intrin->num_components = deref->type->vector_elements; 1382 intrin->variables[0] = this->deref_head; 1383 ralloc_steal(intrin, intrin->variables[0]); 1384 1385 if (intrin->intrinsic == nir_intrinsic_interp_var_at_offset || 1386 intrin->intrinsic == nir_intrinsic_interp_var_at_sample) 1387 intrin->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[1])); 1388 1389 unsigned bit_size = glsl_get_bit_size(deref->type); 1390 add_instr(&intrin->instr, deref->type->vector_elements, bit_size); 1391 1392 if (swizzle) { 1393 unsigned swiz[4] = { 1394 swizzle->mask.x, swizzle->mask.y, swizzle->mask.z, swizzle->mask.w 1395 }; 1396 1397 result = nir_swizzle(&b, result, swiz, 1398 swizzle->type->vector_elements, false); 1399 } 1400 1401 return; 1402 } 1403 1404 default: 1405 break; 1406 } 1407 1408 nir_ssa_def *srcs[4]; 1409 for (unsigned i = 0; i < ir->get_num_operands(); i++) 1410 srcs[i] = evaluate_rvalue(ir->operands[i]); 1411 1412 glsl_base_type types[4]; 1413 for (unsigned i = 0; i < ir->get_num_operands(); i++) 1414 if (supports_ints) 1415 types[i] = ir->operands[i]->type->base_type; 1416 else 1417 types[i] = GLSL_TYPE_FLOAT; 1418 1419 glsl_base_type out_type; 1420 if (supports_ints) 1421 out_type = ir->type->base_type; 1422 else 1423 out_type = GLSL_TYPE_FLOAT; 1424 1425 switch (ir->operation) { 1426 case ir_unop_bit_not: result = nir_inot(&b, srcs[0]); break; 1427 case ir_unop_logic_not: 1428 result = supports_ints ? nir_inot(&b, srcs[0]) : nir_fnot(&b, srcs[0]); 1429 break; 1430 case ir_unop_neg: 1431 result = type_is_float(types[0]) ? nir_fneg(&b, srcs[0]) 1432 : nir_ineg(&b, srcs[0]); 1433 break; 1434 case ir_unop_abs: 1435 result = type_is_float(types[0]) ? nir_fabs(&b, srcs[0]) 1436 : nir_iabs(&b, srcs[0]); 1437 break; 1438 case ir_unop_saturate: 1439 assert(type_is_float(types[0])); 1440 result = nir_fsat(&b, srcs[0]); 1441 break; 1442 case ir_unop_sign: 1443 result = type_is_float(types[0]) ? nir_fsign(&b, srcs[0]) 1444 : nir_isign(&b, srcs[0]); 1445 break; 1446 case ir_unop_rcp: result = nir_frcp(&b, srcs[0]); break; 1447 case ir_unop_rsq: result = nir_frsq(&b, srcs[0]); break; 1448 case ir_unop_sqrt: result = nir_fsqrt(&b, srcs[0]); break; 1449 case ir_unop_exp: unreachable("ir_unop_exp should have been lowered"); 1450 case ir_unop_log: unreachable("ir_unop_log should have been lowered"); 1451 case ir_unop_exp2: result = nir_fexp2(&b, srcs[0]); break; 1452 case ir_unop_log2: result = nir_flog2(&b, srcs[0]); break; 1453 case ir_unop_i2f: 1454 result = supports_ints ? nir_i2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]); 1455 break; 1456 case ir_unop_u2f: 1457 result = supports_ints ? nir_u2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]); 1458 break; 1459 case ir_unop_b2f: 1460 result = supports_ints ? nir_b2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]); 1461 break; 1462 case ir_unop_f2i: result = nir_f2i(&b, srcs[0]); break; 1463 case ir_unop_f2u: result = nir_f2u(&b, srcs[0]); break; 1464 case ir_unop_f2b: result = nir_f2b(&b, srcs[0]); break; 1465 case ir_unop_i2b: result = nir_i2b(&b, srcs[0]); break; 1466 case ir_unop_b2i: result = nir_b2i(&b, srcs[0]); break; 1467 case ir_unop_d2f: result = nir_d2f(&b, srcs[0]); break; 1468 case ir_unop_f2d: result = nir_f2d(&b, srcs[0]); break; 1469 case ir_unop_d2i: result = nir_d2i(&b, srcs[0]); break; 1470 case ir_unop_d2u: result = nir_d2u(&b, srcs[0]); break; 1471 case ir_unop_d2b: result = nir_d2b(&b, srcs[0]); break; 1472 case ir_unop_i2d: 1473 assert(supports_ints); 1474 result = nir_i2d(&b, srcs[0]); 1475 break; 1476 case ir_unop_u2d: 1477 assert(supports_ints); 1478 result = nir_u2d(&b, srcs[0]); 1479 break; 1480 case ir_unop_i2u: 1481 case ir_unop_u2i: 1482 case ir_unop_bitcast_i2f: 1483 case ir_unop_bitcast_f2i: 1484 case ir_unop_bitcast_u2f: 1485 case ir_unop_bitcast_f2u: 1486 case ir_unop_subroutine_to_int: 1487 /* no-op */ 1488 result = nir_imov(&b, srcs[0]); 1489 break; 1490 case ir_unop_trunc: result = nir_ftrunc(&b, srcs[0]); break; 1491 case ir_unop_ceil: result = nir_fceil(&b, srcs[0]); break; 1492 case ir_unop_floor: result = nir_ffloor(&b, srcs[0]); break; 1493 case ir_unop_fract: result = nir_ffract(&b, srcs[0]); break; 1494 case ir_unop_round_even: result = nir_fround_even(&b, srcs[0]); break; 1495 case ir_unop_sin: result = nir_fsin(&b, srcs[0]); break; 1496 case ir_unop_cos: result = nir_fcos(&b, srcs[0]); break; 1497 case ir_unop_dFdx: result = nir_fddx(&b, srcs[0]); break; 1498 case ir_unop_dFdy: result = nir_fddy(&b, srcs[0]); break; 1499 case ir_unop_dFdx_fine: result = nir_fddx_fine(&b, srcs[0]); break; 1500 case ir_unop_dFdy_fine: result = nir_fddy_fine(&b, srcs[0]); break; 1501 case ir_unop_dFdx_coarse: result = nir_fddx_coarse(&b, srcs[0]); break; 1502 case ir_unop_dFdy_coarse: result = nir_fddy_coarse(&b, srcs[0]); break; 1503 case ir_unop_pack_snorm_2x16: 1504 result = nir_pack_snorm_2x16(&b, srcs[0]); 1505 break; 1506 case ir_unop_pack_snorm_4x8: 1507 result = nir_pack_snorm_4x8(&b, srcs[0]); 1508 break; 1509 case ir_unop_pack_unorm_2x16: 1510 result = nir_pack_unorm_2x16(&b, srcs[0]); 1511 break; 1512 case ir_unop_pack_unorm_4x8: 1513 result = nir_pack_unorm_4x8(&b, srcs[0]); 1514 break; 1515 case ir_unop_pack_half_2x16: 1516 result = nir_pack_half_2x16(&b, srcs[0]); 1517 break; 1518 case ir_unop_unpack_snorm_2x16: 1519 result = nir_unpack_snorm_2x16(&b, srcs[0]); 1520 break; 1521 case ir_unop_unpack_snorm_4x8: 1522 result = nir_unpack_snorm_4x8(&b, srcs[0]); 1523 break; 1524 case ir_unop_unpack_unorm_2x16: 1525 result = nir_unpack_unorm_2x16(&b, srcs[0]); 1526 break; 1527 case ir_unop_unpack_unorm_4x8: 1528 result = nir_unpack_unorm_4x8(&b, srcs[0]); 1529 break; 1530 case ir_unop_unpack_half_2x16: 1531 result = nir_unpack_half_2x16(&b, srcs[0]); 1532 break; 1533 case ir_unop_pack_double_2x32: 1534 result = nir_pack_double_2x32(&b, srcs[0]); 1535 break; 1536 case ir_unop_unpack_double_2x32: 1537 result = nir_unpack_double_2x32(&b, srcs[0]); 1538 break; 1539 case ir_unop_bitfield_reverse: 1540 result = nir_bitfield_reverse(&b, srcs[0]); 1541 break; 1542 case ir_unop_bit_count: 1543 result = nir_bit_count(&b, srcs[0]); 1544 break; 1545 case ir_unop_find_msb: 1546 switch (types[0]) { 1547 case GLSL_TYPE_UINT: 1548 result = nir_ufind_msb(&b, srcs[0]); 1549 break; 1550 case GLSL_TYPE_INT: 1551 result = nir_ifind_msb(&b, srcs[0]); 1552 break; 1553 default: 1554 unreachable("Invalid type for findMSB()"); 1555 } 1556 break; 1557 case ir_unop_find_lsb: 1558 result = nir_find_lsb(&b, srcs[0]); 1559 break; 1560 1561 case ir_unop_noise: 1562 switch (ir->type->vector_elements) { 1563 case 1: 1564 switch (ir->operands[0]->type->vector_elements) { 1565 case 1: result = nir_fnoise1_1(&b, srcs[0]); break; 1566 case 2: result = nir_fnoise1_2(&b, srcs[0]); break; 1567 case 3: result = nir_fnoise1_3(&b, srcs[0]); break; 1568 case 4: result = nir_fnoise1_4(&b, srcs[0]); break; 1569 default: unreachable("not reached"); 1570 } 1571 break; 1572 case 2: 1573 switch (ir->operands[0]->type->vector_elements) { 1574 case 1: result = nir_fnoise2_1(&b, srcs[0]); break; 1575 case 2: result = nir_fnoise2_2(&b, srcs[0]); break; 1576 case 3: result = nir_fnoise2_3(&b, srcs[0]); break; 1577 case 4: result = nir_fnoise2_4(&b, srcs[0]); break; 1578 default: unreachable("not reached"); 1579 } 1580 break; 1581 case 3: 1582 switch (ir->operands[0]->type->vector_elements) { 1583 case 1: result = nir_fnoise3_1(&b, srcs[0]); break; 1584 case 2: result = nir_fnoise3_2(&b, srcs[0]); break; 1585 case 3: result = nir_fnoise3_3(&b, srcs[0]); break; 1586 case 4: result = nir_fnoise3_4(&b, srcs[0]); break; 1587 default: unreachable("not reached"); 1588 } 1589 break; 1590 case 4: 1591 switch (ir->operands[0]->type->vector_elements) { 1592 case 1: result = nir_fnoise4_1(&b, srcs[0]); break; 1593 case 2: result = nir_fnoise4_2(&b, srcs[0]); break; 1594 case 3: result = nir_fnoise4_3(&b, srcs[0]); break; 1595 case 4: result = nir_fnoise4_4(&b, srcs[0]); break; 1596 default: unreachable("not reached"); 1597 } 1598 break; 1599 default: 1600 unreachable("not reached"); 1601 } 1602 break; 1603 case ir_unop_get_buffer_size: { 1604 nir_intrinsic_instr *load = nir_intrinsic_instr_create( 1605 this->shader, 1606 nir_intrinsic_get_buffer_size); 1607 load->num_components = ir->type->vector_elements; 1608 load->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[0])); 1609 unsigned bit_size = glsl_get_bit_size(ir->type); 1610 add_instr(&load->instr, ir->type->vector_elements, bit_size); 1611 return; 1612 } 1613 1614 case ir_binop_add: 1615 result = type_is_float(out_type) ? nir_fadd(&b, srcs[0], srcs[1]) 1616 : nir_iadd(&b, srcs[0], srcs[1]); 1617 break; 1618 case ir_binop_sub: 1619 result = type_is_float(out_type) ? nir_fsub(&b, srcs[0], srcs[1]) 1620 : nir_isub(&b, srcs[0], srcs[1]); 1621 break; 1622 case ir_binop_mul: 1623 result = type_is_float(out_type) ? nir_fmul(&b, srcs[0], srcs[1]) 1624 : nir_imul(&b, srcs[0], srcs[1]); 1625 break; 1626 case ir_binop_div: 1627 if (type_is_float(out_type)) 1628 result = nir_fdiv(&b, srcs[0], srcs[1]); 1629 else if (out_type == GLSL_TYPE_INT) 1630 result = nir_idiv(&b, srcs[0], srcs[1]); 1631 else 1632 result = nir_udiv(&b, srcs[0], srcs[1]); 1633 break; 1634 case ir_binop_mod: 1635 result = type_is_float(out_type) ? nir_fmod(&b, srcs[0], srcs[1]) 1636 : nir_umod(&b, srcs[0], srcs[1]); 1637 break; 1638 case ir_binop_min: 1639 if (type_is_float(out_type)) 1640 result = nir_fmin(&b, srcs[0], srcs[1]); 1641 else if (out_type == GLSL_TYPE_INT) 1642 result = nir_imin(&b, srcs[0], srcs[1]); 1643 else 1644 result = nir_umin(&b, srcs[0], srcs[1]); 1645 break; 1646 case ir_binop_max: 1647 if (type_is_float(out_type)) 1648 result = nir_fmax(&b, srcs[0], srcs[1]); 1649 else if (out_type == GLSL_TYPE_INT) 1650 result = nir_imax(&b, srcs[0], srcs[1]); 1651 else 1652 result = nir_umax(&b, srcs[0], srcs[1]); 1653 break; 1654 case ir_binop_pow: result = nir_fpow(&b, srcs[0], srcs[1]); break; 1655 case ir_binop_bit_and: result = nir_iand(&b, srcs[0], srcs[1]); break; 1656 case ir_binop_bit_or: result = nir_ior(&b, srcs[0], srcs[1]); break; 1657 case ir_binop_bit_xor: result = nir_ixor(&b, srcs[0], srcs[1]); break; 1658 case ir_binop_logic_and: 1659 result = supports_ints ? nir_iand(&b, srcs[0], srcs[1]) 1660 : nir_fand(&b, srcs[0], srcs[1]); 1661 break; 1662 case ir_binop_logic_or: 1663 result = supports_ints ? nir_ior(&b, srcs[0], srcs[1]) 1664 : nir_for(&b, srcs[0], srcs[1]); 1665 break; 1666 case ir_binop_logic_xor: 1667 result = supports_ints ? nir_ixor(&b, srcs[0], srcs[1]) 1668 : nir_fxor(&b, srcs[0], srcs[1]); 1669 break; 1670 case ir_binop_lshift: result = nir_ishl(&b, srcs[0], srcs[1]); break; 1671 case ir_binop_rshift: 1672 result = (out_type == GLSL_TYPE_INT) ? nir_ishr(&b, srcs[0], srcs[1]) 1673 : nir_ushr(&b, srcs[0], srcs[1]); 1674 break; 1675 case ir_binop_imul_high: 1676 result = (out_type == GLSL_TYPE_INT) ? nir_imul_high(&b, srcs[0], srcs[1]) 1677 : nir_umul_high(&b, srcs[0], srcs[1]); 1678 break; 1679 case ir_binop_carry: result = nir_uadd_carry(&b, srcs[0], srcs[1]); break; 1680 case ir_binop_borrow: result = nir_usub_borrow(&b, srcs[0], srcs[1]); break; 1681 case ir_binop_less: 1682 if (supports_ints) { 1683 if (type_is_float(types[0])) 1684 result = nir_flt(&b, srcs[0], srcs[1]); 1685 else if (types[0] == GLSL_TYPE_INT) 1686 result = nir_ilt(&b, srcs[0], srcs[1]); 1687 else 1688 result = nir_ult(&b, srcs[0], srcs[1]); 1689 } else { 1690 result = nir_slt(&b, srcs[0], srcs[1]); 1691 } 1692 break; 1693 case ir_binop_greater: 1694 if (supports_ints) { 1695 if (type_is_float(types[0])) 1696 result = nir_flt(&b, srcs[1], srcs[0]); 1697 else if (types[0] == GLSL_TYPE_INT) 1698 result = nir_ilt(&b, srcs[1], srcs[0]); 1699 else 1700 result = nir_ult(&b, srcs[1], srcs[0]); 1701 } else { 1702 result = nir_slt(&b, srcs[1], srcs[0]); 1703 } 1704 break; 1705 case ir_binop_lequal: 1706 if (supports_ints) { 1707 if (type_is_float(types[0])) 1708 result = nir_fge(&b, srcs[1], srcs[0]); 1709 else if (types[0] == GLSL_TYPE_INT) 1710 result = nir_ige(&b, srcs[1], srcs[0]); 1711 else 1712 result = nir_uge(&b, srcs[1], srcs[0]); 1713 } else { 1714 result = nir_slt(&b, srcs[1], srcs[0]); 1715 } 1716 break; 1717 case ir_binop_gequal: 1718 if (supports_ints) { 1719 if (type_is_float(types[0])) 1720 result = nir_fge(&b, srcs[0], srcs[1]); 1721 else if (types[0] == GLSL_TYPE_INT) 1722 result = nir_ige(&b, srcs[0], srcs[1]); 1723 else 1724 result = nir_uge(&b, srcs[0], srcs[1]); 1725 } else { 1726 result = nir_slt(&b, srcs[0], srcs[1]); 1727 } 1728 break; 1729 case ir_binop_equal: 1730 if (supports_ints) { 1731 if (type_is_float(types[0])) 1732 result = nir_feq(&b, srcs[0], srcs[1]); 1733 else 1734 result = nir_ieq(&b, srcs[0], srcs[1]); 1735 } else { 1736 result = nir_seq(&b, srcs[0], srcs[1]); 1737 } 1738 break; 1739 case ir_binop_nequal: 1740 if (supports_ints) { 1741 if (type_is_float(types[0])) 1742 result = nir_fne(&b, srcs[0], srcs[1]); 1743 else 1744 result = nir_ine(&b, srcs[0], srcs[1]); 1745 } else { 1746 result = nir_sne(&b, srcs[0], srcs[1]); 1747 } 1748 break; 1749 case ir_binop_all_equal: 1750 if (supports_ints) { 1751 if (type_is_float(types[0])) { 1752 switch (ir->operands[0]->type->vector_elements) { 1753 case 1: result = nir_feq(&b, srcs[0], srcs[1]); break; 1754 case 2: result = nir_ball_fequal2(&b, srcs[0], srcs[1]); break; 1755 case 3: result = nir_ball_fequal3(&b, srcs[0], srcs[1]); break; 1756 case 4: result = nir_ball_fequal4(&b, srcs[0], srcs[1]); break; 1757 default: 1758 unreachable("not reached"); 1759 } 1760 } else { 1761 switch (ir->operands[0]->type->vector_elements) { 1762 case 1: result = nir_ieq(&b, srcs[0], srcs[1]); break; 1763 case 2: result = nir_ball_iequal2(&b, srcs[0], srcs[1]); break; 1764 case 3: result = nir_ball_iequal3(&b, srcs[0], srcs[1]); break; 1765 case 4: result = nir_ball_iequal4(&b, srcs[0], srcs[1]); break; 1766 default: 1767 unreachable("not reached"); 1768 } 1769 } 1770 } else { 1771 switch (ir->operands[0]->type->vector_elements) { 1772 case 1: result = nir_seq(&b, srcs[0], srcs[1]); break; 1773 case 2: result = nir_fall_equal2(&b, srcs[0], srcs[1]); break; 1774 case 3: result = nir_fall_equal3(&b, srcs[0], srcs[1]); break; 1775 case 4: result = nir_fall_equal4(&b, srcs[0], srcs[1]); break; 1776 default: 1777 unreachable("not reached"); 1778 } 1779 } 1780 break; 1781 case ir_binop_any_nequal: 1782 if (supports_ints) { 1783 if (type_is_float(types[0])) { 1784 switch (ir->operands[0]->type->vector_elements) { 1785 case 1: result = nir_fne(&b, srcs[0], srcs[1]); break; 1786 case 2: result = nir_bany_fnequal2(&b, srcs[0], srcs[1]); break; 1787 case 3: result = nir_bany_fnequal3(&b, srcs[0], srcs[1]); break; 1788 case 4: result = nir_bany_fnequal4(&b, srcs[0], srcs[1]); break; 1789 default: 1790 unreachable("not reached"); 1791 } 1792 } else { 1793 switch (ir->operands[0]->type->vector_elements) { 1794 case 1: result = nir_ine(&b, srcs[0], srcs[1]); break; 1795 case 2: result = nir_bany_inequal2(&b, srcs[0], srcs[1]); break; 1796 case 3: result = nir_bany_inequal3(&b, srcs[0], srcs[1]); break; 1797 case 4: result = nir_bany_inequal4(&b, srcs[0], srcs[1]); break; 1798 default: 1799 unreachable("not reached"); 1800 } 1801 } 1802 } else { 1803 switch (ir->operands[0]->type->vector_elements) { 1804 case 1: result = nir_sne(&b, srcs[0], srcs[1]); break; 1805 case 2: result = nir_fany_nequal2(&b, srcs[0], srcs[1]); break; 1806 case 3: result = nir_fany_nequal3(&b, srcs[0], srcs[1]); break; 1807 case 4: result = nir_fany_nequal4(&b, srcs[0], srcs[1]); break; 1808 default: 1809 unreachable("not reached"); 1810 } 1811 } 1812 break; 1813 case ir_binop_dot: 1814 switch (ir->operands[0]->type->vector_elements) { 1815 case 2: result = nir_fdot2(&b, srcs[0], srcs[1]); break; 1816 case 3: result = nir_fdot3(&b, srcs[0], srcs[1]); break; 1817 case 4: result = nir_fdot4(&b, srcs[0], srcs[1]); break; 1818 default: 1819 unreachable("not reached"); 1820 } 1821 break; 1822 1823 case ir_binop_ldexp: result = nir_ldexp(&b, srcs[0], srcs[1]); break; 1824 case ir_triop_fma: 1825 result = nir_ffma(&b, srcs[0], srcs[1], srcs[2]); 1826 break; 1827 case ir_triop_lrp: 1828 result = nir_flrp(&b, srcs[0], srcs[1], srcs[2]); 1829 break; 1830 case ir_triop_csel: 1831 if (supports_ints) 1832 result = nir_bcsel(&b, srcs[0], srcs[1], srcs[2]); 1833 else 1834 result = nir_fcsel(&b, srcs[0], srcs[1], srcs[2]); 1835 break; 1836 case ir_triop_bitfield_extract: 1837 result = (out_type == GLSL_TYPE_INT) ? 1838 nir_ibitfield_extract(&b, srcs[0], srcs[1], srcs[2]) : 1839 nir_ubitfield_extract(&b, srcs[0], srcs[1], srcs[2]); 1840 break; 1841 case ir_quadop_bitfield_insert: 1842 result = nir_bitfield_insert(&b, srcs[0], srcs[1], srcs[2], srcs[3]); 1843 break; 1844 case ir_quadop_vector: 1845 result = nir_vec(&b, srcs, ir->type->vector_elements); 1846 break; 1847 1848 default: 1849 unreachable("not reached"); 1850 } 1851} 1852 1853void 1854nir_visitor::visit(ir_swizzle *ir) 1855{ 1856 unsigned swizzle[4] = { ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w }; 1857 result = nir_swizzle(&b, evaluate_rvalue(ir->val), swizzle, 1858 ir->type->vector_elements, !supports_ints); 1859} 1860 1861void 1862nir_visitor::visit(ir_texture *ir) 1863{ 1864 unsigned num_srcs; 1865 nir_texop op; 1866 switch (ir->op) { 1867 case ir_tex: 1868 op = nir_texop_tex; 1869 num_srcs = 1; /* coordinate */ 1870 break; 1871 1872 case ir_txb: 1873 case ir_txl: 1874 op = (ir->op == ir_txb) ? nir_texop_txb : nir_texop_txl; 1875 num_srcs = 2; /* coordinate, bias/lod */ 1876 break; 1877 1878 case ir_txd: 1879 op = nir_texop_txd; /* coordinate, dPdx, dPdy */ 1880 num_srcs = 3; 1881 break; 1882 1883 case ir_txf: 1884 op = nir_texop_txf; 1885 if (ir->lod_info.lod != NULL) 1886 num_srcs = 2; /* coordinate, lod */ 1887 else 1888 num_srcs = 1; /* coordinate */ 1889 break; 1890 1891 case ir_txf_ms: 1892 op = nir_texop_txf_ms; 1893 num_srcs = 2; /* coordinate, sample_index */ 1894 break; 1895 1896 case ir_txs: 1897 op = nir_texop_txs; 1898 if (ir->lod_info.lod != NULL) 1899 num_srcs = 1; /* lod */ 1900 else 1901 num_srcs = 0; 1902 break; 1903 1904 case ir_lod: 1905 op = nir_texop_lod; 1906 num_srcs = 1; /* coordinate */ 1907 break; 1908 1909 case ir_tg4: 1910 op = nir_texop_tg4; 1911 num_srcs = 1; /* coordinate */ 1912 break; 1913 1914 case ir_query_levels: 1915 op = nir_texop_query_levels; 1916 num_srcs = 0; 1917 break; 1918 1919 case ir_texture_samples: 1920 op = nir_texop_texture_samples; 1921 num_srcs = 0; 1922 break; 1923 1924 case ir_samples_identical: 1925 op = nir_texop_samples_identical; 1926 num_srcs = 1; /* coordinate */ 1927 break; 1928 1929 default: 1930 unreachable("not reached"); 1931 } 1932 1933 if (ir->projector != NULL) 1934 num_srcs++; 1935 if (ir->shadow_comparator != NULL) 1936 num_srcs++; 1937 if (ir->offset != NULL) 1938 num_srcs++; 1939 1940 nir_tex_instr *instr = nir_tex_instr_create(this->shader, num_srcs); 1941 1942 instr->op = op; 1943 instr->sampler_dim = 1944 (glsl_sampler_dim) ir->sampler->type->sampler_dimensionality; 1945 instr->is_array = ir->sampler->type->sampler_array; 1946 instr->is_shadow = ir->sampler->type->sampler_shadow; 1947 if (instr->is_shadow) 1948 instr->is_new_style_shadow = (ir->type->vector_elements == 1); 1949 switch (ir->type->base_type) { 1950 case GLSL_TYPE_FLOAT: 1951 instr->dest_type = nir_type_float; 1952 break; 1953 case GLSL_TYPE_INT: 1954 instr->dest_type = nir_type_int; 1955 break; 1956 case GLSL_TYPE_BOOL: 1957 case GLSL_TYPE_UINT: 1958 instr->dest_type = nir_type_uint; 1959 break; 1960 default: 1961 unreachable("not reached"); 1962 } 1963 1964 instr->texture = evaluate_deref(&instr->instr, ir->sampler); 1965 1966 unsigned src_number = 0; 1967 1968 if (ir->coordinate != NULL) { 1969 instr->coord_components = ir->coordinate->type->vector_elements; 1970 instr->src[src_number].src = 1971 nir_src_for_ssa(evaluate_rvalue(ir->coordinate)); 1972 instr->src[src_number].src_type = nir_tex_src_coord; 1973 src_number++; 1974 } 1975 1976 if (ir->projector != NULL) { 1977 instr->src[src_number].src = 1978 nir_src_for_ssa(evaluate_rvalue(ir->projector)); 1979 instr->src[src_number].src_type = nir_tex_src_projector; 1980 src_number++; 1981 } 1982 1983 if (ir->shadow_comparator != NULL) { 1984 instr->src[src_number].src = 1985 nir_src_for_ssa(evaluate_rvalue(ir->shadow_comparator)); 1986 instr->src[src_number].src_type = nir_tex_src_comparator; 1987 src_number++; 1988 } 1989 1990 if (ir->offset != NULL) { 1991 /* we don't support multiple offsets yet */ 1992 assert(ir->offset->type->is_vector() || ir->offset->type->is_scalar()); 1993 1994 instr->src[src_number].src = 1995 nir_src_for_ssa(evaluate_rvalue(ir->offset)); 1996 instr->src[src_number].src_type = nir_tex_src_offset; 1997 src_number++; 1998 } 1999 2000 switch (ir->op) { 2001 case ir_txb: 2002 instr->src[src_number].src = 2003 nir_src_for_ssa(evaluate_rvalue(ir->lod_info.bias)); 2004 instr->src[src_number].src_type = nir_tex_src_bias; 2005 src_number++; 2006 break; 2007 2008 case ir_txl: 2009 case ir_txf: 2010 case ir_txs: 2011 if (ir->lod_info.lod != NULL) { 2012 instr->src[src_number].src = 2013 nir_src_for_ssa(evaluate_rvalue(ir->lod_info.lod)); 2014 instr->src[src_number].src_type = nir_tex_src_lod; 2015 src_number++; 2016 } 2017 break; 2018 2019 case ir_txd: 2020 instr->src[src_number].src = 2021 nir_src_for_ssa(evaluate_rvalue(ir->lod_info.grad.dPdx)); 2022 instr->src[src_number].src_type = nir_tex_src_ddx; 2023 src_number++; 2024 instr->src[src_number].src = 2025 nir_src_for_ssa(evaluate_rvalue(ir->lod_info.grad.dPdy)); 2026 instr->src[src_number].src_type = nir_tex_src_ddy; 2027 src_number++; 2028 break; 2029 2030 case ir_txf_ms: 2031 instr->src[src_number].src = 2032 nir_src_for_ssa(evaluate_rvalue(ir->lod_info.sample_index)); 2033 instr->src[src_number].src_type = nir_tex_src_ms_index; 2034 src_number++; 2035 break; 2036 2037 case ir_tg4: 2038 instr->component = ir->lod_info.component->as_constant()->value.u[0]; 2039 break; 2040 2041 default: 2042 break; 2043 } 2044 2045 assert(src_number == num_srcs); 2046 2047 unsigned bit_size = glsl_get_bit_size(ir->type); 2048 add_instr(&instr->instr, nir_tex_instr_dest_size(instr), bit_size); 2049} 2050 2051void 2052nir_visitor::visit(ir_constant *ir) 2053{ 2054 /* 2055 * We don't know if this variable is an array or struct that gets 2056 * dereferenced, so do the safe thing an make it a variable with a 2057 * constant initializer and return a dereference. 2058 */ 2059 2060 nir_variable *var = 2061 nir_local_variable_create(this->impl, ir->type, "const_temp"); 2062 var->data.read_only = true; 2063 var->constant_initializer = constant_copy(ir, var); 2064 2065 this->deref_head = nir_deref_var_create(this->shader, var); 2066 this->deref_tail = &this->deref_head->deref; 2067} 2068 2069void 2070nir_visitor::visit(ir_dereference_variable *ir) 2071{ 2072 struct hash_entry *entry = 2073 _mesa_hash_table_search(this->var_table, ir->var); 2074 assert(entry); 2075 nir_variable *var = (nir_variable *) entry->data; 2076 2077 nir_deref_var *deref = nir_deref_var_create(this->shader, var); 2078 this->deref_head = deref; 2079 this->deref_tail = &deref->deref; 2080} 2081 2082void 2083nir_visitor::visit(ir_dereference_record *ir) 2084{ 2085 ir->record->accept(this); 2086 2087 int field_index = this->deref_tail->type->field_index(ir->field); 2088 assert(field_index >= 0); 2089 2090 nir_deref_struct *deref = nir_deref_struct_create(this->deref_tail, field_index); 2091 deref->deref.type = ir->type; 2092 this->deref_tail->child = &deref->deref; 2093 this->deref_tail = &deref->deref; 2094} 2095 2096void 2097nir_visitor::visit(ir_dereference_array *ir) 2098{ 2099 nir_deref_array *deref = nir_deref_array_create(this->shader); 2100 deref->deref.type = ir->type; 2101 2102 ir_constant *const_index = ir->array_index->as_constant(); 2103 if (const_index != NULL) { 2104 deref->deref_array_type = nir_deref_array_type_direct; 2105 deref->base_offset = const_index->value.u[0]; 2106 } else { 2107 deref->deref_array_type = nir_deref_array_type_indirect; 2108 deref->indirect = 2109 nir_src_for_ssa(evaluate_rvalue(ir->array_index)); 2110 } 2111 2112 ir->array->accept(this); 2113 2114 this->deref_tail->child = &deref->deref; 2115 ralloc_steal(this->deref_tail, deref); 2116 this->deref_tail = &deref->deref; 2117} 2118 2119void 2120nir_visitor::visit(ir_barrier *) 2121{ 2122 nir_intrinsic_instr *instr = 2123 nir_intrinsic_instr_create(this->shader, nir_intrinsic_barrier); 2124 nir_builder_instr_insert(&b, &instr->instr); 2125} 2126