src/compiler/glsl/glsl_to_nir.cpp

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