X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fnir%2Fglsl_to_nir.cpp;h=5a1bbc43243d0100a1f428e590c5ca934a90b8a6;hb=45349acad01f4a27386f676e481c4eeddf64cdc0;hp=ec6bdc8acb017e9e86299926b0b50c5065a4c197;hpb=db54673b54ee7e2c49d5aa6f77d2fff3eed0aa24;p=mesa.git

diff --git a/src/glsl/nir/glsl_to_nir.cpp b/src/glsl/nir/glsl_to_nir.cpp
index ec6bdc8acb0..5a1bbc43243 100644
--- a/src/glsl/nir/glsl_to_nir.cpp
+++ b/src/glsl/nir/glsl_to_nir.cpp
@@ -27,9 +27,11 @@
 
 #include "glsl_to_nir.h"
 #include "nir_control_flow.h"
+#include "nir_builder.h"
 #include "ir_visitor.h"
 #include "ir_hierarchical_visitor.h"
 #include "ir.h"
+#include "main/imports.h"
 
 /*
  * pass to lower GLSL IR to NIR
@@ -44,7 +46,7 @@ namespace {
 class nir_visitor : public ir_visitor
 {
 public:
-   nir_visitor(nir_shader *shader);
+   nir_visitor(nir_shader *shader, gl_shader *sh);
    ~nir_visitor();
 
    virtual void visit(ir_variable *);
@@ -68,26 +70,27 @@ public:
    virtual void visit(ir_dereference_array *);
    virtual void visit(ir_barrier *);
 
-   void create_function(ir_function *ir);
+   void create_function(ir_function_signature *ir);
 
 private:
-   void create_overload(ir_function_signature *ir, nir_function *function);
    void add_instr(nir_instr *instr, unsigned num_components);
-   nir_src evaluate_rvalue(ir_rvalue *ir);
+   nir_ssa_def *evaluate_rvalue(ir_rvalue *ir);
 
-   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_src *srcs);
-   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_src src1);
-   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_src src1,
-                       nir_src src2);
-   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_src src1,
-                       nir_src src2, nir_src src3);
+   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def **srcs);
+   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def *src1);
+   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def *src1,
+                       nir_ssa_def *src2);
+   nir_alu_instr *emit(nir_op op, unsigned dest_size, nir_ssa_def *src1,
+                       nir_ssa_def *src2, nir_ssa_def *src3);
 
    bool supports_ints;
 
+   struct gl_shader *sh;
+
    nir_shader *shader;
    nir_function_impl *impl;
-   exec_list *cf_node_list;
-   nir_instr *result; /* result of the expression tree last visited */
+   nir_builder b;
+   nir_ssa_def *result; /* result of the expression tree last visited */
 
    nir_deref_var *evaluate_deref(nir_instr *mem_ctx, ir_instruction *ir);
 
@@ -137,23 +140,26 @@ glsl_to_nir(const struct gl_shader_program *shader_prog,
 
    nir_shader *shader = nir_shader_create(NULL, stage, options);
 
-   nir_visitor v1(shader);
+   nir_visitor v1(shader, sh);
    nir_function_visitor v2(&v1);
    v2.run(sh->ir);
    visit_exec_list(sh->ir, &v1);
 
-   nir_lower_outputs_to_temporaries(shader);
+   nir_function *main = NULL;
+   nir_foreach_function(shader, func) {
+      if (strcmp(func->name, "main") == 0) {
+         main = func;
+         break;
+      }
+   }
+   assert(main);
 
-   /* TODO: Use _mesa_fls instead */
-   unsigned num_textures = 0;
-   for (unsigned i = 0; i < 8 * sizeof(sh->Program->SamplersUsed); i++)
-      if (sh->Program->SamplersUsed & (1 << i))
-         num_textures = i;
+   nir_lower_outputs_to_temporaries(shader, main);
 
    shader->info.name = ralloc_asprintf(shader, "GLSL%d", shader_prog->Name);
    if (shader_prog->Label)
       shader->info.label = ralloc_strdup(shader, shader_prog->Label);
-   shader->info.num_textures = num_textures;
+   shader->info.num_textures = _mesa_fls(sh->Program->SamplersUsed);
    shader->info.num_ubos = sh->NumUniformBlocks;
    shader->info.num_abos = shader_prog->NumAtomicBuffers;
    shader->info.num_ssbos = sh->NumShaderStorageBlocks;
@@ -171,6 +177,10 @@ glsl_to_nir(const struct gl_shader_program *shader_prog,
       shader_prog->TransformFeedback.NumVarying > 0;
 
    switch (stage) {
+   case MESA_SHADER_TESS_CTRL:
+      shader->info.tcs.vertices_out = shader_prog->TessCtrl.VerticesOut;
+      break;
+
    case MESA_SHADER_GEOMETRY:
       shader->info.gs.vertices_in = shader_prog->Geom.VerticesIn;
       shader->info.gs.output_primitive = sh->Geom.OutputType;
@@ -205,10 +215,11 @@ glsl_to_nir(const struct gl_shader_program *shader_prog,
    return shader;
 }
 
-nir_visitor::nir_visitor(nir_shader *shader)
+nir_visitor::nir_visitor(nir_shader *shader, gl_shader *sh)
 {
    this->supports_ints = shader->options->native_integers;
    this->shader = shader;
+   this->sh = sh;
    this->is_global = true;
    this->var_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
                                              _mesa_key_pointer_equal);
@@ -240,6 +251,8 @@ constant_copy(ir_constant *ir, void *mem_ctx)
 
    unsigned total_elems = ir->type->components();
    unsigned i;
+
+   ret->num_elements = 0;
    switch (ir->type->base_type) {
    case GLSL_TYPE_UINT:
       for (i = 0; i < total_elems; i++)
@@ -264,6 +277,8 @@ constant_copy(ir_constant *ir, void *mem_ctx)
    case GLSL_TYPE_STRUCT:
       ret->elements = ralloc_array(mem_ctx, nir_constant *,
                                    ir->type->length);
+      ret->num_elements = ir->type->length;
+
       i = 0;
       foreach_in_list(ir_constant, field, &ir->components) {
          ret->elements[i] = constant_copy(field, mem_ctx);
@@ -274,6 +289,7 @@ constant_copy(ir_constant *ir, void *mem_ctx)
    case GLSL_TYPE_ARRAY:
       ret->elements = ralloc_array(mem_ctx, nir_constant *,
                                    ir->type->length);
+      ret->num_elements = ir->type->length;
 
       for (i = 0; i < ir->type->length; i++)
          ret->elements[i] = constant_copy(ir->array_elements[i], mem_ctx);
@@ -293,15 +309,6 @@ nir_visitor::visit(ir_variable *ir)
    var->type = ir->type;
    var->name = ralloc_strdup(var, ir->name);
 
-   if (ir->is_interface_instance() && ir->get_max_ifc_array_access() != NULL) {
-      unsigned size = ir->get_interface_type()->length;
-      var->max_ifc_array_access = ralloc_array(var, unsigned, size);
-      memcpy(var->max_ifc_array_access, ir->get_max_ifc_array_access(),
-             size * sizeof(unsigned));
-   } else {
-      var->max_ifc_array_access = NULL;
-   }
-
    var->data.read_only = ir->data.read_only;
    var->data.centroid = ir->data.centroid;
    var->data.sample = ir->data.sample;
@@ -368,7 +375,6 @@ nir_visitor::visit(ir_variable *ir)
    var->data.explicit_index = ir->data.explicit_index;
    var->data.explicit_binding = ir->data.explicit_binding;
    var->data.has_initializer = ir->data.has_initializer;
-   var->data.is_unmatched_generic_inout = ir->data.is_unmatched_generic_inout;
    var->data.location_frac = ir->data.location_frac;
    var->data.from_named_ifc_block_array = ir->data.from_named_ifc_block_array;
    var->data.from_named_ifc_block_nonarray = ir->data.from_named_ifc_block_nonarray;
@@ -394,8 +400,9 @@ nir_visitor::visit(ir_variable *ir)
    }
 
    var->data.index = ir->data.index;
+   var->data.descriptor_set = 0;
    var->data.binding = ir->data.binding;
-   var->data.atomic.offset = ir->data.atomic.offset;
+   var->data.offset = ir->data.offset;
    var->data.image.read_only = ir->data.image_read_only;
    var->data.image.write_only = ir->data.image_write_only;
    var->data.image.coherent = ir->data.image_coherent;
@@ -435,60 +442,50 @@ nir_visitor::visit(ir_variable *ir)
 ir_visitor_status
 nir_function_visitor::visit_enter(ir_function *ir)
 {
-   visitor->create_function(ir);
-   return visit_continue_with_parent;
-}
-
-
-void
-nir_visitor::create_function(ir_function *ir)
-{
-   nir_function *func = nir_function_create(this->shader, ir->name);
    foreach_in_list(ir_function_signature, sig, &ir->signatures) {
-      create_overload(sig, func);
+      visitor->create_function(sig);
    }
+   return visit_continue_with_parent;
 }
 
-
-
 void
-nir_visitor::create_overload(ir_function_signature *ir, nir_function *function)
+nir_visitor::create_function(ir_function_signature *ir)
 {
    if (ir->is_intrinsic)
       return;
 
-   nir_function_overload *overload = nir_function_overload_create(function);
+   nir_function *func = nir_function_create(shader, ir->function_name());
 
    unsigned num_params = ir->parameters.length();
-   overload->num_params = num_params;
-   overload->params = ralloc_array(shader, nir_parameter, num_params);
+   func->num_params = num_params;
+   func->params = ralloc_array(shader, nir_parameter, num_params);
 
    unsigned i = 0;
    foreach_in_list(ir_variable, param, &ir->parameters) {
       switch (param->data.mode) {
       case ir_var_function_in:
-         overload->params[i].param_type = nir_parameter_in;
+         func->params[i].param_type = nir_parameter_in;
          break;
 
       case ir_var_function_out:
-         overload->params[i].param_type = nir_parameter_out;
+         func->params[i].param_type = nir_parameter_out;
          break;
 
       case ir_var_function_inout:
-         overload->params[i].param_type = nir_parameter_inout;
+         func->params[i].param_type = nir_parameter_inout;
          break;
 
       default:
          unreachable("not reached");
       }
 
-      overload->params[i].type = param->type;
+      func->params[i].type = param->type;
       i++;
    }
 
-   overload->return_type = ir->return_type;
+   func->return_type = ir->return_type;
 
-   _mesa_hash_table_insert(this->overload_table, ir, overload);
+   _mesa_hash_table_insert(this->overload_table, ir, func);
 }
 
 void
@@ -508,13 +505,13 @@ nir_visitor::visit(ir_function_signature *ir)
       _mesa_hash_table_search(this->overload_table, ir);
 
    assert(entry);
-   nir_function_overload *overload = (nir_function_overload *) entry->data;
+   nir_function *func = (nir_function *) entry->data;
 
    if (ir->is_defined) {
-      nir_function_impl *impl = nir_function_impl_create(overload);
+      nir_function_impl *impl = nir_function_impl_create(func);
       this->impl = impl;
 
-      unsigned num_params = overload->num_params;
+      unsigned num_params = func->num_params;
       impl->num_params = num_params;
       impl->params = ralloc_array(this->shader, nir_variable *, num_params);
       unsigned i = 0;
@@ -524,57 +521,55 @@ nir_visitor::visit(ir_function_signature *ir)
          i++;
       }
 
-      if (overload->return_type == glsl_type::void_type) {
+      if (func->return_type == glsl_type::void_type) {
          impl->return_var = NULL;
       } else {
          impl->return_var = ralloc(this->shader, nir_variable);
          impl->return_var->name = ralloc_strdup(impl->return_var,
                                                 "return_var");
-         impl->return_var->type = overload->return_type;
+         impl->return_var->type = func->return_type;
       }
 
       this->is_global = false;
 
-      this->cf_node_list = &impl->body;
+      nir_builder_init(&b, impl);
+      b.cursor = nir_after_cf_list(&impl->body);
       visit_exec_list(&ir->body, this);
 
       this->is_global = true;
    } else {
-      overload->impl = NULL;
+      func->impl = NULL;
    }
 }
 
 void
 nir_visitor::visit(ir_loop *ir)
 {
-   exec_list *old_list = this->cf_node_list;
-
    nir_loop *loop = nir_loop_create(this->shader);
-   nir_cf_node_insert_end(old_list, &loop->cf_node);
-   this->cf_node_list = &loop->body;
-   visit_exec_list(&ir->body_instructions, this);
+   nir_builder_cf_insert(&b, &loop->cf_node);
 
-   this->cf_node_list = old_list;
+   b.cursor = nir_after_cf_list(&loop->body);
+   visit_exec_list(&ir->body_instructions, this);
+   b.cursor = nir_after_cf_node(&loop->cf_node);
 }
 
 void
 nir_visitor::visit(ir_if *ir)
 {
-   nir_src condition = evaluate_rvalue(ir->condition);
-
-   exec_list *old_list = this->cf_node_list;
+   nir_src condition =
+      nir_src_for_ssa(evaluate_rvalue(ir->condition));
 
    nir_if *if_stmt = nir_if_create(this->shader);
    if_stmt->condition = condition;
-   nir_cf_node_insert_end(old_list, &if_stmt->cf_node);
+   nir_builder_cf_insert(&b, &if_stmt->cf_node);
 
-   this->cf_node_list = &if_stmt->then_list;
+   b.cursor = nir_after_cf_list(&if_stmt->then_list);
    visit_exec_list(&ir->then_instructions, this);
 
-   this->cf_node_list = &if_stmt->else_list;
+   b.cursor = nir_after_cf_list(&if_stmt->else_list);
    visit_exec_list(&ir->else_instructions, this);
 
-   this->cf_node_list = old_list;
+   b.cursor = nir_after_cf_node(&if_stmt->cf_node);
 }
 
 void
@@ -591,11 +586,13 @@ nir_visitor::visit(ir_discard *ir)
    if (ir->condition) {
       discard = nir_intrinsic_instr_create(this->shader,
                                            nir_intrinsic_discard_if);
-      discard->src[0] = evaluate_rvalue(ir->condition);
+      discard->src[0] =
+         nir_src_for_ssa(evaluate_rvalue(ir->condition));
    } else {
       discard = nir_intrinsic_instr_create(this->shader, nir_intrinsic_discard);
    }
-   nir_instr_insert_after_cf_list(this->cf_node_list, &discard->instr);
+
+   nir_builder_instr_insert(&b, &discard->instr);
 }
 
 void
@@ -604,7 +601,7 @@ nir_visitor::visit(ir_emit_vertex *ir)
    nir_intrinsic_instr *instr =
       nir_intrinsic_instr_create(this->shader, nir_intrinsic_emit_vertex);
    instr->const_index[0] = ir->stream_id();
-   nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+   nir_builder_instr_insert(&b, &instr->instr);
 }
 
 void
@@ -613,7 +610,7 @@ nir_visitor::visit(ir_end_primitive *ir)
    nir_intrinsic_instr *instr =
       nir_intrinsic_instr_create(this->shader, nir_intrinsic_end_primitive);
    instr->const_index[0] = ir->stream_id();
-   nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+   nir_builder_instr_insert(&b, &instr->instr);
 }
 
 void
@@ -632,7 +629,7 @@ nir_visitor::visit(ir_loop_jump *ir)
    }
 
    nir_jump_instr *instr = nir_jump_instr_create(this->shader, type);
-   nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+   nir_builder_instr_insert(&b, &instr->instr);
 }
 
 void
@@ -647,7 +644,7 @@ nir_visitor::visit(ir_return *ir)
    }
 
    nir_jump_instr *instr = nir_jump_instr_create(this->shader, nir_jump_return);
-   nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+   nir_builder_instr_insert(&b, &instr->instr);
 }
 
 void
@@ -691,15 +688,15 @@ nir_visitor::visit(ir_call *ir)
          op = nir_intrinsic_store_ssbo;
       } else if (strcmp(ir->callee_name(), "__intrinsic_load_ssbo") == 0) {
          op = nir_intrinsic_load_ssbo;
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_add_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_add_ssbo") == 0) {
          op = nir_intrinsic_ssbo_atomic_add;
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_and_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_and_ssbo") == 0) {
          op = nir_intrinsic_ssbo_atomic_and;
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_or_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_or_ssbo") == 0) {
          op = nir_intrinsic_ssbo_atomic_or;
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_xor_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_xor_ssbo") == 0) {
          op = nir_intrinsic_ssbo_atomic_xor;
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_min_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_min_ssbo") == 0) {
          assert(ir->return_deref);
          if (ir->return_deref->type == glsl_type::int_type)
             op = nir_intrinsic_ssbo_atomic_imin;
@@ -707,7 +704,7 @@ nir_visitor::visit(ir_call *ir)
             op = nir_intrinsic_ssbo_atomic_umin;
          else
             unreachable("Invalid type");
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_max_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_max_ssbo") == 0) {
          assert(ir->return_deref);
          if (ir->return_deref->type == glsl_type::int_type)
             op = nir_intrinsic_ssbo_atomic_imax;
@@ -715,9 +712,9 @@ nir_visitor::visit(ir_call *ir)
             op = nir_intrinsic_ssbo_atomic_umax;
          else
             unreachable("Invalid type");
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_exchange_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_exchange_ssbo") == 0) {
          op = nir_intrinsic_ssbo_atomic_exchange;
-      } else if (strcmp(ir->callee_name(), "__intrinsic_ssbo_atomic_comp_swap_internal") == 0) {
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_comp_swap_ssbo") == 0) {
          op = nir_intrinsic_ssbo_atomic_comp_swap;
       } else if (strcmp(ir->callee_name(), "__intrinsic_shader_clock") == 0) {
          op = nir_intrinsic_shader_clock;
@@ -731,6 +728,38 @@ nir_visitor::visit(ir_call *ir)
          op = nir_intrinsic_memory_barrier_image;
       } else if (strcmp(ir->callee_name(), "__intrinsic_memory_barrier_shared") == 0) {
          op = nir_intrinsic_memory_barrier_shared;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_load_shared") == 0) {
+         op = nir_intrinsic_load_shared;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_store_shared") == 0) {
+         op = nir_intrinsic_store_shared;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_add_shared") == 0) {
+         op = nir_intrinsic_shared_atomic_add;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_and_shared") == 0) {
+         op = nir_intrinsic_shared_atomic_and;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_or_shared") == 0) {
+         op = nir_intrinsic_shared_atomic_or;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_xor_shared") == 0) {
+         op = nir_intrinsic_shared_atomic_xor;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_min_shared") == 0) {
+         assert(ir->return_deref);
+         if (ir->return_deref->type == glsl_type::int_type)
+            op = nir_intrinsic_shared_atomic_imin;
+         else if (ir->return_deref->type == glsl_type::uint_type)
+            op = nir_intrinsic_shared_atomic_umin;
+         else
+            unreachable("Invalid type");
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_max_shared") == 0) {
+         assert(ir->return_deref);
+         if (ir->return_deref->type == glsl_type::int_type)
+            op = nir_intrinsic_shared_atomic_imax;
+         else if (ir->return_deref->type == glsl_type::uint_type)
+            op = nir_intrinsic_shared_atomic_umax;
+         else
+            unreachable("Invalid type");
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_exchange_shared") == 0) {
+         op = nir_intrinsic_shared_atomic_exchange;
+      } else if (strcmp(ir->callee_name(), "__intrinsic_atomic_comp_swap_shared") == 0) {
+         op = nir_intrinsic_shared_atomic_comp_swap;
       } else {
          unreachable("not reached");
       }
@@ -746,7 +775,7 @@ nir_visitor::visit(ir_call *ir)
             (ir_dereference *) ir->actual_parameters.get_head();
          instr->variables[0] = evaluate_deref(&instr->instr, param);
          nir_ssa_dest_init(&instr->instr, &instr->dest, 1, NULL);
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
          break;
       }
       case nir_intrinsic_image_load:
@@ -763,8 +792,7 @@ nir_visitor::visit(ir_call *ir)
       case nir_intrinsic_image_size: {
          nir_ssa_undef_instr *instr_undef =
             nir_ssa_undef_instr_create(shader, 1);
-         nir_instr_insert_after_cf_list(this->cf_node_list,
-                                        &instr_undef->instr);
+         nir_builder_instr_insert(&b, &instr_undef->instr);
 
          /* Set the image variable dereference. */
          exec_node *param = ir->actual_parameters.get_head();
@@ -785,35 +813,33 @@ nir_visitor::visit(ir_call *ir)
 
          if (op == nir_intrinsic_image_size ||
              op == nir_intrinsic_image_samples) {
-            nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+            nir_builder_instr_insert(&b, &instr->instr);
             break;
          }
 
          /* Set the address argument, extending the coordinate vector to four
           * components.
           */
-         const nir_src src_addr = evaluate_rvalue((ir_dereference *)param);
-         nir_alu_instr *instr_addr = nir_alu_instr_create(shader, nir_op_vec4);
-         nir_ssa_dest_init(&instr_addr->instr, &instr_addr->dest.dest, 4, NULL);
+         nir_ssa_def *src_addr =
+            evaluate_rvalue((ir_dereference *)param);
+         nir_ssa_def *srcs[4];
 
          for (int i = 0; i < 4; i++) {
-            if (i < type->coordinate_components()) {
-               instr_addr->src[i].src = src_addr;
-               instr_addr->src[i].swizzle[0] = i;
-            } else {
-               instr_addr->src[i].src = nir_src_for_ssa(&instr_undef->def);
-            }
+            if (i < type->coordinate_components())
+               srcs[i] = nir_channel(&b, src_addr, i);
+            else
+               srcs[i] = &instr_undef->def;
          }
 
-         nir_instr_insert_after_cf_list(cf_node_list, &instr_addr->instr);
-         instr->src[0] = nir_src_for_ssa(&instr_addr->dest.dest.ssa);
+         instr->src[0] = nir_src_for_ssa(nir_vec(&b, srcs, 4));
          param = param->get_next();
 
          /* Set the sample argument, which is undefined for single-sample
           * images.
           */
          if (type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS) {
-            instr->src[1] = evaluate_rvalue((ir_dereference *)param);
+            instr->src[1] =
+               nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param));
             param = param->get_next();
          } else {
             instr->src[1] = nir_src_for_ssa(&instr_undef->def);
@@ -821,15 +847,17 @@ nir_visitor::visit(ir_call *ir)
 
          /* Set the intrinsic parameters. */
          if (!param->is_tail_sentinel()) {
-            instr->src[2] = evaluate_rvalue((ir_dereference *)param);
+            instr->src[2] =
+               nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param));
             param = param->get_next();
          }
 
          if (!param->is_tail_sentinel()) {
-            instr->src[3] = evaluate_rvalue((ir_dereference *)param);
+            instr->src[3] =
+               nir_src_for_ssa(evaluate_rvalue((ir_dereference *)param));
             param = param->get_next();
          }
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
          break;
       }
       case nir_intrinsic_memory_barrier:
@@ -838,11 +866,11 @@ nir_visitor::visit(ir_call *ir)
       case nir_intrinsic_memory_barrier_buffer:
       case nir_intrinsic_memory_barrier_image:
       case nir_intrinsic_memory_barrier_shared:
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
          break;
       case nir_intrinsic_shader_clock:
          nir_ssa_dest_init(&instr->instr, &instr->dest, 1, NULL);
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
          break;
       case nir_intrinsic_store_ssbo: {
          exec_node *param = ir->actual_parameters.get_head();
@@ -858,25 +886,13 @@ nir_visitor::visit(ir_call *ir)
          ir_constant *write_mask = ((ir_instruction *)param)->as_constant();
          assert(write_mask);
 
-         /* Check if we need the indirect version */
-         ir_constant *const_offset = offset->as_constant();
-         if (!const_offset) {
-            op = nir_intrinsic_store_ssbo_indirect;
-            ralloc_free(instr);
-            instr = nir_intrinsic_instr_create(shader, op);
-            instr->src[2] = evaluate_rvalue(offset);
-            instr->const_index[0] = 0;
-         } else {
-            instr->const_index[0] = const_offset->value.u[0];
-         }
-
-         instr->const_index[1] = write_mask->value.u[0];
-
-         instr->src[0] = evaluate_rvalue(val);
+         instr->src[0] = nir_src_for_ssa(evaluate_rvalue(val));
+         instr->src[1] = nir_src_for_ssa(evaluate_rvalue(block));
+         instr->src[2] = nir_src_for_ssa(evaluate_rvalue(offset));
+         instr->const_index[0] = write_mask->value.u[0];
          instr->num_components = val->type->vector_elements;
 
-         instr->src[1] = evaluate_rvalue(block);
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
          break;
       }
       case nir_intrinsic_load_ssbo: {
@@ -886,20 +902,8 @@ nir_visitor::visit(ir_call *ir)
          param = param->get_next();
          ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue();
 
-         /* Check if we need the indirect version */
-         ir_constant *const_offset = offset->as_constant();
-         if (!const_offset) {
-            op = nir_intrinsic_load_ssbo_indirect;
-            ralloc_free(instr);
-            instr = nir_intrinsic_instr_create(shader, op);
-            instr->src[1] = evaluate_rvalue(offset);
-            instr->const_index[0] = 0;
-            dest = &instr->dest;
-         } else {
-            instr->const_index[0] = const_offset->value.u[0];
-         }
-
-         instr->src[0] = evaluate_rvalue(block);
+         instr->src[0] = nir_src_for_ssa(evaluate_rvalue(block));
+         instr->src[1] = nir_src_for_ssa(evaluate_rvalue(offset));
 
          const glsl_type *type = ir->return_deref->var->type;
          instr->num_components = type->vector_elements;
@@ -911,7 +915,7 @@ nir_visitor::visit(ir_call *ir)
          /* Insert the created nir instruction now since in the case of boolean
           * result we will need to emit another instruction after it
           */
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
 
          /*
           * In SSBO/UBO's, a true boolean value is any non-zero value, but we
@@ -919,26 +923,19 @@ nir_visitor::visit(ir_call *ir)
           * comparison.
           */
          if (type->base_type == GLSL_TYPE_BOOL) {
-            nir_load_const_instr *const_zero =
-               nir_load_const_instr_create(shader, 1);
-            const_zero->value.u[0] = 0;
-            nir_instr_insert_after_cf_list(this->cf_node_list,
-                                           &const_zero->instr);
-
             nir_alu_instr *load_ssbo_compare =
                nir_alu_instr_create(shader, nir_op_ine);
             load_ssbo_compare->src[0].src.is_ssa = true;
             load_ssbo_compare->src[0].src.ssa = &instr->dest.ssa;
-            load_ssbo_compare->src[1].src.is_ssa = true;
-            load_ssbo_compare->src[1].src.ssa = &const_zero->def;
+            load_ssbo_compare->src[1].src =
+               nir_src_for_ssa(nir_imm_int(&b, 0));
             for (unsigned i = 0; i < type->vector_elements; i++)
                load_ssbo_compare->src[1].swizzle[i] = 0;
             nir_ssa_dest_init(&load_ssbo_compare->instr,
                               &load_ssbo_compare->dest.dest,
                               type->vector_elements, NULL);
             load_ssbo_compare->dest.write_mask = (1 << type->vector_elements) - 1;
-            nir_instr_insert_after_cf_list(this->cf_node_list,
-                                           &load_ssbo_compare->instr);
+            nir_builder_instr_insert(&b, &load_ssbo_compare->instr);
             dest = &load_ssbo_compare->dest.dest;
          }
          break;
@@ -959,31 +956,109 @@ nir_visitor::visit(ir_call *ir)
          /* Block index */
          exec_node *param = ir->actual_parameters.get_head();
          ir_instruction *inst = (ir_instruction *) param;
-         instr->src[0] = evaluate_rvalue(inst->as_rvalue());
+         instr->src[0] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
 
          /* Offset */
          param = param->get_next();
          inst = (ir_instruction *) param;
-         instr->src[1] = evaluate_rvalue(inst->as_rvalue());
+         instr->src[1] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
 
          /* data1 parameter (this is always present) */
          param = param->get_next();
          inst = (ir_instruction *) param;
-         instr->src[2] = evaluate_rvalue(inst->as_rvalue());
+         instr->src[2] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
 
          /* data2 parameter (only with atomic_comp_swap) */
          if (param_count == 4) {
             assert(op == nir_intrinsic_ssbo_atomic_comp_swap);
             param = param->get_next();
             inst = (ir_instruction *) param;
-            instr->src[3] = evaluate_rvalue(inst->as_rvalue());
+            instr->src[3] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
+         }
+
+         /* Atomic result */
+         assert(ir->return_deref);
+         nir_ssa_dest_init(&instr->instr, &instr->dest,
+                           ir->return_deref->type->vector_elements, NULL);
+         nir_builder_instr_insert(&b, &instr->instr);
+         break;
+      }
+      case nir_intrinsic_load_shared: {
+         exec_node *param = ir->actual_parameters.get_head();
+         ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue();
+
+         instr->const_index[0] = 0;
+         instr->src[0] = nir_src_for_ssa(evaluate_rvalue(offset));
+
+         const glsl_type *type = ir->return_deref->var->type;
+         instr->num_components = type->vector_elements;
+
+         /* Setup destination register */
+         nir_ssa_dest_init(&instr->instr, &instr->dest,
+                           type->vector_elements, NULL);
+
+         nir_builder_instr_insert(&b, &instr->instr);
+         break;
+      }
+      case nir_intrinsic_store_shared: {
+         exec_node *param = ir->actual_parameters.get_head();
+         ir_rvalue *offset = ((ir_instruction *)param)->as_rvalue();
+
+         param = param->get_next();
+         ir_rvalue *val = ((ir_instruction *)param)->as_rvalue();
+
+         param = param->get_next();
+         ir_constant *write_mask = ((ir_instruction *)param)->as_constant();
+         assert(write_mask);
+
+         instr->const_index[0] = 0;
+         instr->src[1] = nir_src_for_ssa(evaluate_rvalue(offset));
+
+         instr->const_index[1] = write_mask->value.u[0];
+
+         instr->src[0] = nir_src_for_ssa(evaluate_rvalue(val));
+         instr->num_components = val->type->vector_elements;
+
+         nir_builder_instr_insert(&b, &instr->instr);
+         break;
+      }
+      case nir_intrinsic_shared_atomic_add:
+      case nir_intrinsic_shared_atomic_imin:
+      case nir_intrinsic_shared_atomic_umin:
+      case nir_intrinsic_shared_atomic_imax:
+      case nir_intrinsic_shared_atomic_umax:
+      case nir_intrinsic_shared_atomic_and:
+      case nir_intrinsic_shared_atomic_or:
+      case nir_intrinsic_shared_atomic_xor:
+      case nir_intrinsic_shared_atomic_exchange:
+      case nir_intrinsic_shared_atomic_comp_swap: {
+         int param_count = ir->actual_parameters.length();
+         assert(param_count == 2 || param_count == 3);
+
+         /* Offset */
+         exec_node *param = ir->actual_parameters.get_head();
+         ir_instruction *inst = (ir_instruction *) param;
+         instr->src[0] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
+
+         /* data1 parameter (this is always present) */
+         param = param->get_next();
+         inst = (ir_instruction *) param;
+         instr->src[1] = nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
+
+         /* data2 parameter (only with atomic_comp_swap) */
+         if (param_count == 3) {
+            assert(op == nir_intrinsic_shared_atomic_comp_swap);
+            param = param->get_next();
+            inst = (ir_instruction *) param;
+            instr->src[2] =
+               nir_src_for_ssa(evaluate_rvalue(inst->as_rvalue()));
          }
 
          /* Atomic result */
          assert(ir->return_deref);
          nir_ssa_dest_init(&instr->instr, &instr->dest,
                            ir->return_deref->type->vector_elements, NULL);
-         nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+         nir_builder_instr_insert(&b, &instr->instr);
          break;
       }
       default:
@@ -994,13 +1069,13 @@ nir_visitor::visit(ir_call *ir)
          nir_intrinsic_instr *store_instr =
             nir_intrinsic_instr_create(shader, nir_intrinsic_store_var);
          store_instr->num_components = ir->return_deref->type->vector_elements;
+         store_instr->const_index[0] = (1 << store_instr->num_components) - 1;
 
          store_instr->variables[0] =
             evaluate_deref(&store_instr->instr, ir->return_deref);
          store_instr->src[0] = nir_src_for_ssa(&dest->ssa);
 
-         nir_instr_insert_after_cf_list(this->cf_node_list,
-                                        &store_instr->instr);
+         nir_builder_instr_insert(&b, &store_instr->instr);
       }
 
       return;
@@ -1009,7 +1084,7 @@ nir_visitor::visit(ir_call *ir)
    struct hash_entry *entry =
       _mesa_hash_table_search(this->overload_table, ir->callee);
    assert(entry);
-   nir_function_overload *callee = (nir_function_overload *) entry->data;
+   nir_function *callee = (nir_function *) entry->data;
 
    nir_call_instr *instr = nir_call_instr_create(this->shader, callee);
 
@@ -1020,7 +1095,7 @@ nir_visitor::visit(ir_call *ir)
    }
 
    instr->return_deref = evaluate_deref(&instr->instr, ir->return_deref);
-   nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+   nir_builder_instr_insert(&b, &instr->instr);
 }
 
 void
@@ -1039,11 +1114,12 @@ nir_visitor::visit(ir_assignment *ir)
 
       if (ir->condition) {
          nir_if *if_stmt = nir_if_create(this->shader);
-         if_stmt->condition = evaluate_rvalue(ir->condition);
-         nir_cf_node_insert_end(this->cf_node_list, &if_stmt->cf_node);
+         if_stmt->condition = nir_src_for_ssa(evaluate_rvalue(ir->condition));
+         nir_builder_cf_insert(&b, &if_stmt->cf_node);
          nir_instr_insert_after_cf_list(&if_stmt->then_list, &copy->instr);
+         b.cursor = nir_after_cf_node(&if_stmt->cf_node);
       } else {
-         nir_instr_insert_after_cf_list(this->cf_node_list, &copy->instr);
+         nir_builder_instr_insert(&b, &copy->instr);
       }
       return;
    }
@@ -1052,74 +1128,38 @@ nir_visitor::visit(ir_assignment *ir)
 
    ir->lhs->accept(this);
    nir_deref_var *lhs_deref = this->deref_head;
-   nir_src src = evaluate_rvalue(ir->rhs);
+   nir_ssa_def *src = evaluate_rvalue(ir->rhs);
 
    if (ir->write_mask != (1 << num_components) - 1 && ir->write_mask != 0) {
-      /*
-       * We have no good way to update only part of a variable, so just load
-       * the LHS and do a vec operation to combine the old with the new, and
-       * then store it
-       * back into the LHS. Copy propagation should get rid of the mess.
+      /* GLSL IR will give us the input to the write-masked assignment in a
+       * single packed vector.  So, for example, if the writemask is xzw, then
+       * we have to swizzle x -> x, y -> z, and z -> w and get the y component
+       * from the load.
        */
-
-      nir_intrinsic_instr *load =
-         nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_var);
-      load->num_components = ir->lhs->type->vector_elements;
-      nir_ssa_dest_init(&load->instr, &load->dest, num_components, NULL);
-      load->variables[0] = lhs_deref;
-      ralloc_steal(load, load->variables[0]);
-      nir_instr_insert_after_cf_list(this->cf_node_list, &load->instr);
-
-      nir_op vec_op;
-      switch (ir->lhs->type->vector_elements) {
-         case 1: vec_op = nir_op_imov; break;
-         case 2: vec_op = nir_op_vec2; break;
-         case 3: vec_op = nir_op_vec3; break;
-         case 4: vec_op = nir_op_vec4; break;
-         default: unreachable("Invalid number of components"); break;
-      }
-      nir_alu_instr *vec = nir_alu_instr_create(this->shader, vec_op);
-      nir_ssa_dest_init(&vec->instr, &vec->dest.dest, num_components, NULL);
-      vec->dest.write_mask = (1 << num_components) - 1;
-
+      unsigned swiz[4];
       unsigned component = 0;
-      for (unsigned i = 0; i < ir->lhs->type->vector_elements; i++) {
-         if (ir->write_mask & (1 << i)) {
-            vec->src[i].src = src;
-
-            /* GLSL IR will give us the input to the write-masked assignment
-             * in a single packed vector.  So, for example, if the
-             * writemask is xzw, then we have to swizzle x -> x, y -> z,
-             * and z -> w and get the y component from the load.
-             */
-            vec->src[i].swizzle[0] = component++;
-         } else {
-            vec->src[i].src.is_ssa = true;
-            vec->src[i].src.ssa = &load->dest.ssa;
-            vec->src[i].swizzle[0] = i;
-         }
+      for (unsigned i = 0; i < 4; i++) {
+         swiz[i] = ir->write_mask & (1 << i) ? component++ : 0;
       }
-
-      nir_instr_insert_after_cf_list(this->cf_node_list, &vec->instr);
-
-      src.is_ssa = true;
-      src.ssa = &vec->dest.dest.ssa;
+      src = nir_swizzle(&b, src, swiz, num_components, !supports_ints);
    }
 
    nir_intrinsic_instr *store =
       nir_intrinsic_instr_create(this->shader, nir_intrinsic_store_var);
    store->num_components = ir->lhs->type->vector_elements;
+   store->const_index[0] = ir->write_mask;
    nir_deref *store_deref = nir_copy_deref(store, &lhs_deref->deref);
    store->variables[0] = nir_deref_as_var(store_deref);
-   store->src[0] = src;
+   store->src[0] = nir_src_for_ssa(src);
 
    if (ir->condition) {
       nir_if *if_stmt = nir_if_create(this->shader);
-      if_stmt->condition = evaluate_rvalue(ir->condition);
-      nir_cf_node_insert_end(this->cf_node_list, &if_stmt->cf_node);
+      if_stmt->condition = nir_src_for_ssa(evaluate_rvalue(ir->condition));
+      nir_builder_cf_insert(&b, &if_stmt->cf_node);
       nir_instr_insert_after_cf_list(&if_stmt->then_list, &store->instr);
+      b.cursor = nir_after_cf_node(&if_stmt->cf_node);
    } else {
-      nir_instr_insert_after_cf_list(this->cf_node_list, &store->instr);
+      nir_builder_instr_insert(&b, &store->instr);
    }
 }
 
@@ -1167,11 +1207,15 @@ nir_visitor::add_instr(nir_instr *instr, unsigned num_components)
    if (dest)
       nir_ssa_dest_init(instr, dest, num_components, NULL);
 
-   nir_instr_insert_after_cf_list(this->cf_node_list, instr);
-   this->result = instr;
+   nir_builder_instr_insert(&b, instr);
+
+   if (dest) {
+      assert(dest->is_ssa);
+      this->result = &dest->ssa;
+   }
 }
 
-nir_src
+nir_ssa_def *
 nir_visitor::evaluate_rvalue(ir_rvalue* ir)
 {
    ir->accept(this);
@@ -1189,46 +1233,7 @@ nir_visitor::evaluate_rvalue(ir_rvalue* ir)
       add_instr(&load_instr->instr, ir->type->vector_elements);
    }
 
-   nir_dest *dest = get_instr_dest(this->result);
-   assert(dest->is_ssa);
-
-   return nir_src_for_ssa(&dest->ssa);
-}
-
-nir_alu_instr *
-nir_visitor::emit(nir_op op, unsigned dest_size, nir_src *srcs)
-{
-   nir_alu_instr *instr = nir_alu_instr_create(this->shader, op);
-   for (unsigned i = 0; i < nir_op_infos[op].num_inputs; i++)
-      instr->src[i].src = srcs[i];
-   instr->dest.write_mask = (1 << dest_size) - 1;
-   add_instr(&instr->instr, dest_size);
-   return instr;
-}
-
-nir_alu_instr *
-nir_visitor::emit(nir_op op, unsigned dest_size, nir_src src1)
-{
-   assert(nir_op_infos[op].num_inputs == 1);
-   return emit(op, dest_size, &src1);
-}
-
-nir_alu_instr *
-nir_visitor::emit(nir_op op, unsigned dest_size, nir_src src1,
-                  nir_src src2)
-{
-   assert(nir_op_infos[op].num_inputs == 2);
-   nir_src srcs[] = { src1, src2 };
-   return emit(op, dest_size, srcs);
-}
-
-nir_alu_instr *
-nir_visitor::emit(nir_op op, unsigned dest_size, nir_src src1,
-                  nir_src src2, nir_src src3)
-{
-   assert(nir_op_infos[op].num_inputs == 3);
-   nir_src srcs[] = { src1, src2, src3 };
-   return emit(op, dest_size, srcs);
+   return this->result;
 }
 
 void
@@ -1237,20 +1242,11 @@ nir_visitor::visit(ir_expression *ir)
    /* Some special cases */
    switch (ir->operation) {
    case ir_binop_ubo_load: {
-      ir_constant *const_index = ir->operands[1]->as_constant();
-
-      nir_intrinsic_op op;
-      if (const_index) {
-         op = nir_intrinsic_load_ubo;
-      } else {
-         op = nir_intrinsic_load_ubo_indirect;
-      }
-      nir_intrinsic_instr *load = nir_intrinsic_instr_create(this->shader, op);
+      nir_intrinsic_instr *load =
+         nir_intrinsic_instr_create(this->shader, nir_intrinsic_load_ubo);
       load->num_components = ir->type->vector_elements;
-      load->const_index[0] = const_index ? const_index->value.u[0] : 0; /* base offset */
-      load->src[0] = evaluate_rvalue(ir->operands[0]);
-      if (!const_index)
-         load->src[1] = evaluate_rvalue(ir->operands[1]);
+      load->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[0]));
+      load->src[1] = nir_src_for_ssa(evaluate_rvalue(ir->operands[1]));
       add_instr(&load->instr, ir->type->vector_elements);
 
       /*
@@ -1258,22 +1254,8 @@ nir_visitor::visit(ir_expression *ir)
        * a true boolean to be ~0. Fix this up with a != 0 comparison.
        */
 
-      if (ir->type->base_type == GLSL_TYPE_BOOL) {
-         nir_load_const_instr *const_zero = nir_load_const_instr_create(shader, 1);
-         const_zero->value.u[0] = 0;
-         nir_instr_insert_after_cf_list(this->cf_node_list, &const_zero->instr);
-
-         nir_alu_instr *compare = nir_alu_instr_create(shader, nir_op_ine);
-         compare->src[0].src.is_ssa = true;
-         compare->src[0].src.ssa = &load->dest.ssa;
-         compare->src[1].src.is_ssa = true;
-         compare->src[1].src.ssa = &const_zero->def;
-         for (unsigned i = 0; i < ir->type->vector_elements; i++)
-            compare->src[1].swizzle[i] = 0;
-         compare->dest.write_mask = (1 << ir->type->vector_elements) - 1;
-
-         add_instr(&compare->instr, ir->type->vector_elements);
-      }
+      if (ir->type->base_type == GLSL_TYPE_BOOL)
+         this->result = nir_ine(&b, &load->dest.ssa, nir_imm_int(&b, 0));
 
       return;
    }
@@ -1328,24 +1310,17 @@ nir_visitor::visit(ir_expression *ir)
 
       if (intrin->intrinsic == nir_intrinsic_interp_var_at_offset ||
           intrin->intrinsic == nir_intrinsic_interp_var_at_sample)
-         intrin->src[0] = evaluate_rvalue(ir->operands[1]);
+         intrin->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[1]));
 
       add_instr(&intrin->instr, deref->type->vector_elements);
 
       if (swizzle) {
-         nir_alu_instr *mov = nir_alu_instr_create(shader, nir_op_imov);
-         mov->dest.write_mask = (1 << swizzle->type->vector_elements) - 1;
-         mov->src[0].src.is_ssa = true;
-         mov->src[0].src.ssa = &intrin->dest.ssa;
-
-         mov->src[0].swizzle[0] = swizzle->mask.x;
-         mov->src[0].swizzle[1] = swizzle->mask.y;
-         mov->src[0].swizzle[2] = swizzle->mask.z;
-         mov->src[0].swizzle[3] = swizzle->mask.w;
-         for (unsigned i = deref->type->vector_elements; i < 4; i++)
-            mov->src[0].swizzle[i] = 0;
-
-         add_instr(&mov->instr, swizzle->type->vector_elements);
+         unsigned swiz[4] = {
+            swizzle->mask.x, swizzle->mask.y, swizzle->mask.z, swizzle->mask.w
+         };
+
+         result = nir_swizzle(&b, result, swiz,
+                              swizzle->type->vector_elements, false);
       }
 
       return;
@@ -1355,7 +1330,7 @@ nir_visitor::visit(ir_expression *ir)
       break;
    }
 
-   nir_src srcs[4];
+   nir_ssa_def *srcs[4];
    for (unsigned i = 0; i < ir->get_num_operands(); i++)
       srcs[i] = evaluate_rvalue(ir->operands[i]);
 
@@ -1372,53 +1347,48 @@ nir_visitor::visit(ir_expression *ir)
    else
       out_type = GLSL_TYPE_FLOAT;
 
-   unsigned dest_size = ir->type->vector_elements;
-
-   nir_alu_instr *instr;
-   nir_op op;
-
    switch (ir->operation) {
-   case ir_unop_bit_not: emit(nir_op_inot, dest_size, srcs); break;
+   case ir_unop_bit_not: result = nir_inot(&b, srcs[0]); break;
    case ir_unop_logic_not:
-      emit(supports_ints ? nir_op_inot : nir_op_fnot, dest_size, srcs);
+      result = supports_ints ? nir_inot(&b, srcs[0]) : nir_fnot(&b, srcs[0]);
       break;
    case ir_unop_neg:
-      instr = emit(types[0] == GLSL_TYPE_FLOAT ? nir_op_fneg : nir_op_ineg,
-                   dest_size, srcs);
+      result = (types[0] == GLSL_TYPE_FLOAT) ? nir_fneg(&b, srcs[0])
+                                             : nir_ineg(&b, srcs[0]);
       break;
    case ir_unop_abs:
-      instr = emit(types[0] == GLSL_TYPE_FLOAT ? nir_op_fabs : nir_op_iabs,
-                   dest_size, srcs);
+      result = (types[0] == GLSL_TYPE_FLOAT) ? nir_fabs(&b, srcs[0])
+                                             : nir_iabs(&b, srcs[0]);
       break;
    case ir_unop_saturate:
       assert(types[0] == GLSL_TYPE_FLOAT);
-      instr = emit(nir_op_fsat, dest_size, srcs);
+      result = nir_fsat(&b, srcs[0]);
       break;
    case ir_unop_sign:
-      emit(types[0] == GLSL_TYPE_FLOAT ? nir_op_fsign : nir_op_isign,
-           dest_size, srcs);
+      result = (types[0] == GLSL_TYPE_FLOAT) ? nir_fsign(&b, srcs[0])
+                                             : nir_isign(&b, srcs[0]);
       break;
-   case ir_unop_rcp:  emit(nir_op_frcp, dest_size, srcs);  break;
-   case ir_unop_rsq:  emit(nir_op_frsq, dest_size, srcs);  break;
-   case ir_unop_sqrt: emit(nir_op_fsqrt, dest_size, srcs); break;
+   case ir_unop_rcp:  result = nir_frcp(&b, srcs[0]);  break;
+   case ir_unop_rsq:  result = nir_frsq(&b, srcs[0]);  break;
+   case ir_unop_sqrt: result = nir_fsqrt(&b, srcs[0]); break;
    case ir_unop_exp:  unreachable("ir_unop_exp should have been lowered");
    case ir_unop_log:  unreachable("ir_unop_log should have been lowered");
-   case ir_unop_exp2: emit(nir_op_fexp2, dest_size, srcs); break;
-   case ir_unop_log2: emit(nir_op_flog2, dest_size, srcs); break;
+   case ir_unop_exp2: result = nir_fexp2(&b, srcs[0]); break;
+   case ir_unop_log2: result = nir_flog2(&b, srcs[0]); break;
    case ir_unop_i2f:
-      emit(supports_ints ? nir_op_i2f : nir_op_fmov, dest_size, srcs);
+      result = supports_ints ? nir_i2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]);
       break;
    case ir_unop_u2f:
-      emit(supports_ints ? nir_op_u2f : nir_op_fmov, dest_size, srcs);
+      result = supports_ints ? nir_u2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]);
       break;
    case ir_unop_b2f:
-      emit(supports_ints ? nir_op_b2f : nir_op_fmov, dest_size, srcs);
+      result = supports_ints ? nir_b2f(&b, srcs[0]) : nir_fmov(&b, srcs[0]);
       break;
-   case ir_unop_f2i:  emit(nir_op_f2i, dest_size, srcs);   break;
-   case ir_unop_f2u:  emit(nir_op_f2u, dest_size, srcs);   break;
-   case ir_unop_f2b:  emit(nir_op_f2b, dest_size, srcs);   break;
-   case ir_unop_i2b:  emit(nir_op_i2b, dest_size, srcs);   break;
-   case ir_unop_b2i:  emit(nir_op_b2i, dest_size, srcs);   break;
+   case ir_unop_f2i:  result = nir_f2i(&b, srcs[0]);   break;
+   case ir_unop_f2u:  result = nir_f2u(&b, srcs[0]);   break;
+   case ir_unop_f2b:  result = nir_f2b(&b, srcs[0]);   break;
+   case ir_unop_i2b:  result = nir_i2b(&b, srcs[0]);   break;
+   case ir_unop_b2i:  result = nir_b2i(&b, srcs[0]);   break;
    case ir_unop_i2u:
    case ir_unop_u2i:
    case ir_unop_bitcast_i2f:
@@ -1427,132 +1397,114 @@ nir_visitor::visit(ir_expression *ir)
    case ir_unop_bitcast_f2u:
    case ir_unop_subroutine_to_int:
       /* no-op */
-      emit(nir_op_imov, dest_size, srcs);
-      break;
-   case ir_unop_any:
-      switch (ir->operands[0]->type->vector_elements) {
-      case 2:
-         emit(supports_ints ? nir_op_bany2 : nir_op_fany2,
-              dest_size, srcs);
-         break;
-      case 3:
-         emit(supports_ints ? nir_op_bany3 : nir_op_fany3,
-              dest_size, srcs);
-         break;
-      case 4:
-         emit(supports_ints ? nir_op_bany4 : nir_op_fany4,
-              dest_size, srcs);
-         break;
-      default:
-         unreachable("not reached");
-      }
-      break;
-   case ir_unop_trunc: emit(nir_op_ftrunc, dest_size, srcs); break;
-   case ir_unop_ceil:  emit(nir_op_fceil,  dest_size, srcs); break;
-   case ir_unop_floor: emit(nir_op_ffloor, dest_size, srcs); break;
-   case ir_unop_fract: emit(nir_op_ffract, dest_size, srcs); break;
-   case ir_unop_round_even: emit(nir_op_fround_even, dest_size, srcs); break;
-   case ir_unop_sin:   emit(nir_op_fsin,   dest_size, srcs); break;
-   case ir_unop_cos:   emit(nir_op_fcos,   dest_size, srcs); break;
-   case ir_unop_dFdx:        emit(nir_op_fddx,        dest_size, srcs); break;
-   case ir_unop_dFdy:        emit(nir_op_fddy,        dest_size, srcs); break;
-   case ir_unop_dFdx_fine:   emit(nir_op_fddx_fine,   dest_size, srcs); break;
-   case ir_unop_dFdy_fine:   emit(nir_op_fddy_fine,   dest_size, srcs); break;
-   case ir_unop_dFdx_coarse: emit(nir_op_fddx_coarse, dest_size, srcs); break;
-   case ir_unop_dFdy_coarse: emit(nir_op_fddy_coarse, dest_size, srcs); break;
+      result = nir_imov(&b, srcs[0]);
+      break;
+   case ir_unop_trunc: result = nir_ftrunc(&b, srcs[0]); break;
+   case ir_unop_ceil:  result = nir_fceil(&b, srcs[0]); break;
+   case ir_unop_floor: result = nir_ffloor(&b, srcs[0]); break;
+   case ir_unop_fract: result = nir_ffract(&b, srcs[0]); break;
+   case ir_unop_round_even: result = nir_fround_even(&b, srcs[0]); break;
+   case ir_unop_sin:   result = nir_fsin(&b, srcs[0]); break;
+   case ir_unop_cos:   result = nir_fcos(&b, srcs[0]); break;
+   case ir_unop_dFdx:        result = nir_fddx(&b, srcs[0]); break;
+   case ir_unop_dFdy:        result = nir_fddy(&b, srcs[0]); break;
+   case ir_unop_dFdx_fine:   result = nir_fddx_fine(&b, srcs[0]); break;
+   case ir_unop_dFdy_fine:   result = nir_fddy_fine(&b, srcs[0]); break;
+   case ir_unop_dFdx_coarse: result = nir_fddx_coarse(&b, srcs[0]); break;
+   case ir_unop_dFdy_coarse: result = nir_fddy_coarse(&b, srcs[0]); break;
    case ir_unop_pack_snorm_2x16:
-      emit(nir_op_pack_snorm_2x16, dest_size, srcs);
+      result = nir_pack_snorm_2x16(&b, srcs[0]);
       break;
    case ir_unop_pack_snorm_4x8:
-      emit(nir_op_pack_snorm_4x8, dest_size, srcs);
+      result = nir_pack_snorm_4x8(&b, srcs[0]);
       break;
    case ir_unop_pack_unorm_2x16:
-      emit(nir_op_pack_unorm_2x16, dest_size, srcs);
+      result = nir_pack_unorm_2x16(&b, srcs[0]);
       break;
    case ir_unop_pack_unorm_4x8:
-      emit(nir_op_pack_unorm_4x8, dest_size, srcs);
+      result = nir_pack_unorm_4x8(&b, srcs[0]);
       break;
    case ir_unop_pack_half_2x16:
-      emit(nir_op_pack_half_2x16, dest_size, srcs);
+      result = nir_pack_half_2x16(&b, srcs[0]);
       break;
    case ir_unop_unpack_snorm_2x16:
-      emit(nir_op_unpack_snorm_2x16, dest_size, srcs);
+      result = nir_unpack_snorm_2x16(&b, srcs[0]);
       break;
    case ir_unop_unpack_snorm_4x8:
-      emit(nir_op_unpack_snorm_4x8, dest_size, srcs);
+      result = nir_unpack_snorm_4x8(&b, srcs[0]);
       break;
    case ir_unop_unpack_unorm_2x16:
-      emit(nir_op_unpack_unorm_2x16, dest_size, srcs);
+      result = nir_unpack_unorm_2x16(&b, srcs[0]);
       break;
    case ir_unop_unpack_unorm_4x8:
-      emit(nir_op_unpack_unorm_4x8, dest_size, srcs);
+      result = nir_unpack_unorm_4x8(&b, srcs[0]);
       break;
    case ir_unop_unpack_half_2x16:
-      emit(nir_op_unpack_half_2x16, dest_size, srcs);
+      result = nir_unpack_half_2x16(&b, srcs[0]);
       break;
    case ir_unop_unpack_half_2x16_split_x:
-      emit(nir_op_unpack_half_2x16_split_x, dest_size, srcs);
+      result = nir_unpack_half_2x16_split_x(&b, srcs[0]);
       break;
    case ir_unop_unpack_half_2x16_split_y:
-      emit(nir_op_unpack_half_2x16_split_y, dest_size, srcs);
+      result = nir_unpack_half_2x16_split_y(&b, srcs[0]);
       break;
    case ir_unop_bitfield_reverse:
-      emit(nir_op_bitfield_reverse, dest_size, srcs);
+      result = nir_bitfield_reverse(&b, srcs[0]);
       break;
    case ir_unop_bit_count:
-      emit(nir_op_bit_count, dest_size, srcs);
+      result = nir_bit_count(&b, srcs[0]);
       break;
    case ir_unop_find_msb:
       switch (types[0]) {
       case GLSL_TYPE_UINT:
-         emit(nir_op_ufind_msb, dest_size, srcs);
+         result = nir_ufind_msb(&b, srcs[0]);
          break;
       case GLSL_TYPE_INT:
-         emit(nir_op_ifind_msb, dest_size, srcs);
+         result = nir_ifind_msb(&b, srcs[0]);
          break;
       default:
          unreachable("Invalid type for findMSB()");
       }
       break;
    case ir_unop_find_lsb:
-      emit(nir_op_find_lsb,  dest_size, srcs);
+      result = nir_find_lsb(&b, srcs[0]);
       break;
 
    case ir_unop_noise:
       switch (ir->type->vector_elements) {
       case 1:
          switch (ir->operands[0]->type->vector_elements) {
-            case 1: emit(nir_op_fnoise1_1, dest_size, srcs); break;
-            case 2: emit(nir_op_fnoise1_2, dest_size, srcs); break;
-            case 3: emit(nir_op_fnoise1_3, dest_size, srcs); break;
-            case 4: emit(nir_op_fnoise1_4, dest_size, srcs); break;
+            case 1: result = nir_fnoise1_1(&b, srcs[0]); break;
+            case 2: result = nir_fnoise1_2(&b, srcs[0]); break;
+            case 3: result = nir_fnoise1_3(&b, srcs[0]); break;
+            case 4: result = nir_fnoise1_4(&b, srcs[0]); break;
             default: unreachable("not reached");
          }
          break;
       case 2:
          switch (ir->operands[0]->type->vector_elements) {
-            case 1: emit(nir_op_fnoise2_1, dest_size, srcs); break;
-            case 2: emit(nir_op_fnoise2_2, dest_size, srcs); break;
-            case 3: emit(nir_op_fnoise2_3, dest_size, srcs); break;
-            case 4: emit(nir_op_fnoise2_4, dest_size, srcs); break;
+            case 1: result = nir_fnoise2_1(&b, srcs[0]); break;
+            case 2: result = nir_fnoise2_2(&b, srcs[0]); break;
+            case 3: result = nir_fnoise2_3(&b, srcs[0]); break;
+            case 4: result = nir_fnoise2_4(&b, srcs[0]); break;
             default: unreachable("not reached");
          }
          break;
       case 3:
          switch (ir->operands[0]->type->vector_elements) {
-            case 1: emit(nir_op_fnoise3_1, dest_size, srcs); break;
-            case 2: emit(nir_op_fnoise3_2, dest_size, srcs); break;
-            case 3: emit(nir_op_fnoise3_3, dest_size, srcs); break;
-            case 4: emit(nir_op_fnoise3_4, dest_size, srcs); break;
+            case 1: result = nir_fnoise3_1(&b, srcs[0]); break;
+            case 2: result = nir_fnoise3_2(&b, srcs[0]); break;
+            case 3: result = nir_fnoise3_3(&b, srcs[0]); break;
+            case 4: result = nir_fnoise3_4(&b, srcs[0]); break;
             default: unreachable("not reached");
          }
          break;
       case 4:
          switch (ir->operands[0]->type->vector_elements) {
-            case 1: emit(nir_op_fnoise4_1, dest_size, srcs); break;
-            case 2: emit(nir_op_fnoise4_2, dest_size, srcs); break;
-            case 3: emit(nir_op_fnoise4_3, dest_size, srcs); break;
-            case 4: emit(nir_op_fnoise4_4, dest_size, srcs); break;
+            case 1: result = nir_fnoise4_1(&b, srcs[0]); break;
+            case 2: result = nir_fnoise4_2(&b, srcs[0]); break;
+            case 3: result = nir_fnoise4_3(&b, srcs[0]); break;
+            case 4: result = nir_fnoise4_4(&b, srcs[0]); break;
             default: unreachable("not reached");
          }
          break;
@@ -1565,240 +1517,173 @@ nir_visitor::visit(ir_expression *ir)
          this->shader,
          nir_intrinsic_get_buffer_size);
       load->num_components = ir->type->vector_elements;
-      load->src[0] = evaluate_rvalue(ir->operands[0]);
+      load->src[0] = nir_src_for_ssa(evaluate_rvalue(ir->operands[0]));
       add_instr(&load->instr, ir->type->vector_elements);
       return;
    }
 
    case ir_binop_add:
+      result = (out_type == GLSL_TYPE_FLOAT) ? nir_fadd(&b, srcs[0], srcs[1])
+                                             : nir_iadd(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_sub:
+      result = (out_type == GLSL_TYPE_FLOAT) ? nir_fsub(&b, srcs[0], srcs[1])
+                                             : nir_isub(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_mul:
+      result = (out_type == GLSL_TYPE_FLOAT) ? nir_fmul(&b, srcs[0], srcs[1])
+                                             : nir_imul(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_div:
+      if (out_type == GLSL_TYPE_FLOAT)
+         result = nir_fdiv(&b, srcs[0], srcs[1]);
+      else if (out_type == GLSL_TYPE_INT)
+         result = nir_idiv(&b, srcs[0], srcs[1]);
+      else
+         result = nir_udiv(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_mod:
+      result = (out_type == GLSL_TYPE_FLOAT) ? nir_fmod(&b, srcs[0], srcs[1])
+                                             : nir_umod(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_min:
+      if (out_type == GLSL_TYPE_FLOAT)
+         result = nir_fmin(&b, srcs[0], srcs[1]);
+      else if (out_type == GLSL_TYPE_INT)
+         result = nir_imin(&b, srcs[0], srcs[1]);
+      else
+         result = nir_umin(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_max:
-   case ir_binop_pow:
-   case ir_binop_bit_and:
-   case ir_binop_bit_or:
-   case ir_binop_bit_xor:
+      if (out_type == GLSL_TYPE_FLOAT)
+         result = nir_fmax(&b, srcs[0], srcs[1]);
+      else if (out_type == GLSL_TYPE_INT)
+         result = nir_imax(&b, srcs[0], srcs[1]);
+      else
+         result = nir_umax(&b, srcs[0], srcs[1]);
+      break;
+   case ir_binop_pow: result = nir_fpow(&b, srcs[0], srcs[1]); break;
+   case ir_binop_bit_and: result = nir_iand(&b, srcs[0], srcs[1]); break;
+   case ir_binop_bit_or: result = nir_ior(&b, srcs[0], srcs[1]); break;
+   case ir_binop_bit_xor: result = nir_ixor(&b, srcs[0], srcs[1]); break;
    case ir_binop_logic_and:
+      result = supports_ints ? nir_iand(&b, srcs[0], srcs[1])
+                             : nir_fand(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_logic_or:
+      result = supports_ints ? nir_ior(&b, srcs[0], srcs[1])
+                             : nir_for(&b, srcs[0], srcs[1]);
+      break;
    case ir_binop_logic_xor:
-   case ir_binop_lshift:
+      result = supports_ints ? nir_ixor(&b, srcs[0], srcs[1])
+                             : nir_fxor(&b, srcs[0], srcs[1]);
+      break;
+   case ir_binop_lshift: result = nir_ishl(&b, srcs[0], srcs[1]); break;
    case ir_binop_rshift:
-      switch (ir->operation) {
-      case ir_binop_add:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fadd;
-         else
-            op = nir_op_iadd;
-         break;
-      case ir_binop_sub:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fsub;
-         else
-            op = nir_op_isub;
-         break;
-      case ir_binop_mul:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fmul;
-         else
-            op = nir_op_imul;
-         break;
-      case ir_binop_div:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fdiv;
-         else if (out_type == GLSL_TYPE_INT)
-            op = nir_op_idiv;
-         else
-            op = nir_op_udiv;
-         break;
-      case ir_binop_mod:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fmod;
-         else
-            op = nir_op_umod;
-         break;
-      case ir_binop_min:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fmin;
-         else if (out_type == GLSL_TYPE_INT)
-            op = nir_op_imin;
-         else
-            op = nir_op_umin;
-         break;
-      case ir_binop_max:
-         if (out_type == GLSL_TYPE_FLOAT)
-            op = nir_op_fmax;
-         else if (out_type == GLSL_TYPE_INT)
-            op = nir_op_imax;
-         else
-            op = nir_op_umax;
-         break;
-      case ir_binop_bit_and:
-         op = nir_op_iand;
-         break;
-      case ir_binop_bit_or:
-         op = nir_op_ior;
-         break;
-      case ir_binop_bit_xor:
-         op = nir_op_ixor;
-         break;
-      case ir_binop_logic_and:
-         if (supports_ints)
-            op = nir_op_iand;
-         else
-            op = nir_op_fand;
-         break;
-      case ir_binop_logic_or:
-         if (supports_ints)
-            op = nir_op_ior;
-         else
-            op = nir_op_for;
-         break;
-      case ir_binop_logic_xor:
-         if (supports_ints)
-            op = nir_op_ixor;
-         else
-            op = nir_op_fxor;
-         break;
-      case ir_binop_lshift:
-         op = nir_op_ishl;
-         break;
-      case ir_binop_rshift:
-         if (out_type == GLSL_TYPE_INT)
-            op = nir_op_ishr;
-         else
-            op = nir_op_ushr;
-         break;
-      case ir_binop_pow:
-         op = nir_op_fpow;
-         break;
-
-      default:
-         unreachable("not reached");
-      }
-
-      instr = emit(op, dest_size, srcs);
-
-      if (ir->operands[0]->type->vector_elements != 1 &&
-          ir->operands[1]->type->vector_elements == 1) {
-         for (unsigned i = 0; i < ir->operands[0]->type->vector_elements;
-              i++) {
-            instr->src[1].swizzle[i] = 0;
-         }
-      }
-
-      if (ir->operands[1]->type->vector_elements != 1 &&
-          ir->operands[0]->type->vector_elements == 1) {
-         for (unsigned i = 0; i < ir->operands[1]->type->vector_elements;
-              i++) {
-            instr->src[0].swizzle[i] = 0;
-         }
-      }
-
+      result = (out_type == GLSL_TYPE_INT) ? nir_ishr(&b, srcs[0], srcs[1])
+                                           : nir_ushr(&b, srcs[0], srcs[1]);
       break;
    case ir_binop_imul_high:
-      emit(out_type == GLSL_TYPE_UINT ? nir_op_umul_high : nir_op_imul_high,
-           dest_size, srcs);
+      result = (out_type == GLSL_TYPE_INT) ? nir_imul_high(&b, srcs[0], srcs[1])
+                                           : nir_umul_high(&b, srcs[0], srcs[1]);
       break;
-   case ir_binop_carry:  emit(nir_op_uadd_carry, dest_size, srcs);  break;
-   case ir_binop_borrow: emit(nir_op_usub_borrow, dest_size, srcs); break;
+   case ir_binop_carry:  result = nir_uadd_carry(&b, srcs[0], srcs[1]);  break;
+   case ir_binop_borrow: result = nir_usub_borrow(&b, srcs[0], srcs[1]); break;
    case ir_binop_less:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT)
-            emit(nir_op_flt, dest_size, srcs);
+            result = nir_flt(&b, srcs[0], srcs[1]);
          else if (types[0] == GLSL_TYPE_INT)
-            emit(nir_op_ilt, dest_size, srcs);
+            result = nir_ilt(&b, srcs[0], srcs[1]);
          else
-            emit(nir_op_ult, dest_size, srcs);
+            result = nir_ult(&b, srcs[0], srcs[1]);
       } else {
-         emit(nir_op_slt, dest_size, srcs);
+         result = nir_slt(&b, srcs[0], srcs[1]);
       }
       break;
    case ir_binop_greater:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT)
-            emit(nir_op_flt, dest_size, srcs[1], srcs[0]);
+            result = nir_flt(&b, srcs[1], srcs[0]);
          else if (types[0] == GLSL_TYPE_INT)
-            emit(nir_op_ilt, dest_size, srcs[1], srcs[0]);
+            result = nir_ilt(&b, srcs[1], srcs[0]);
          else
-            emit(nir_op_ult, dest_size, srcs[1], srcs[0]);
+            result = nir_ult(&b, srcs[1], srcs[0]);
       } else {
-         emit(nir_op_slt, dest_size, srcs[1], srcs[0]);
+         result = nir_slt(&b, srcs[1], srcs[0]);
       }
       break;
    case ir_binop_lequal:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT)
-            emit(nir_op_fge, dest_size, srcs[1], srcs[0]);
+            result = nir_fge(&b, srcs[1], srcs[0]);
          else if (types[0] == GLSL_TYPE_INT)
-            emit(nir_op_ige, dest_size, srcs[1], srcs[0]);
+            result = nir_ige(&b, srcs[1], srcs[0]);
          else
-            emit(nir_op_uge, dest_size, srcs[1], srcs[0]);
+            result = nir_uge(&b, srcs[1], srcs[0]);
       } else {
-         emit(nir_op_slt, dest_size, srcs[1], srcs[0]);
+         result = nir_slt(&b, srcs[1], srcs[0]);
       }
       break;
    case ir_binop_gequal:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT)
-            emit(nir_op_fge, dest_size, srcs);
+            result = nir_fge(&b, srcs[0], srcs[1]);
          else if (types[0] == GLSL_TYPE_INT)
-            emit(nir_op_ige, dest_size, srcs);
+            result = nir_ige(&b, srcs[0], srcs[1]);
          else
-            emit(nir_op_uge, dest_size, srcs);
+            result = nir_uge(&b, srcs[0], srcs[1]);
       } else {
-         emit(nir_op_slt, dest_size, srcs);
+         result = nir_slt(&b, srcs[0], srcs[1]);
       }
       break;
    case ir_binop_equal:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT)
-            emit(nir_op_feq, dest_size, srcs);
+            result = nir_feq(&b, srcs[0], srcs[1]);
          else
-            emit(nir_op_ieq, dest_size, srcs);
+            result = nir_ieq(&b, srcs[0], srcs[1]);
       } else {
-         emit(nir_op_seq, dest_size, srcs);
+         result = nir_seq(&b, srcs[0], srcs[1]);
       }
       break;
    case ir_binop_nequal:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT)
-            emit(nir_op_fne, dest_size, srcs);
+            result = nir_fne(&b, srcs[0], srcs[1]);
          else
-            emit(nir_op_ine, dest_size, srcs);
+            result = nir_ine(&b, srcs[0], srcs[1]);
       } else {
-         emit(nir_op_sne, dest_size, srcs);
+         result = nir_sne(&b, srcs[0], srcs[1]);
       }
       break;
    case ir_binop_all_equal:
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT) {
             switch (ir->operands[0]->type->vector_elements) {
-               case 1: emit(nir_op_feq, dest_size, srcs); break;
-               case 2: emit(nir_op_ball_fequal2, dest_size, srcs); break;
-               case 3: emit(nir_op_ball_fequal3, dest_size, srcs); break;
-               case 4: emit(nir_op_ball_fequal4, dest_size, srcs); break;
+               case 1: result = nir_feq(&b, srcs[0], srcs[1]); break;
+               case 2: result = nir_ball_fequal2(&b, srcs[0], srcs[1]); break;
+               case 3: result = nir_ball_fequal3(&b, srcs[0], srcs[1]); break;
+               case 4: result = nir_ball_fequal4(&b, srcs[0], srcs[1]); break;
                default:
                   unreachable("not reached");
             }
          } else {
             switch (ir->operands[0]->type->vector_elements) {
-               case 1: emit(nir_op_ieq, dest_size, srcs); break;
-               case 2: emit(nir_op_ball_iequal2, dest_size, srcs); break;
-               case 3: emit(nir_op_ball_iequal3, dest_size, srcs); break;
-               case 4: emit(nir_op_ball_iequal4, dest_size, srcs); break;
+               case 1: result = nir_ieq(&b, srcs[0], srcs[1]); break;
+               case 2: result = nir_ball_iequal2(&b, srcs[0], srcs[1]); break;
+               case 3: result = nir_ball_iequal3(&b, srcs[0], srcs[1]); break;
+               case 4: result = nir_ball_iequal4(&b, srcs[0], srcs[1]); break;
                default:
                   unreachable("not reached");
             }
          }
       } else {
          switch (ir->operands[0]->type->vector_elements) {
-            case 1: emit(nir_op_seq, dest_size, srcs); break;
-            case 2: emit(nir_op_fall_equal2, dest_size, srcs); break;
-            case 3: emit(nir_op_fall_equal3, dest_size, srcs); break;
-            case 4: emit(nir_op_fall_equal4, dest_size, srcs); break;
+            case 1: result = nir_seq(&b, srcs[0], srcs[1]); break;
+            case 2: result = nir_fall_equal2(&b, srcs[0], srcs[1]); break;
+            case 3: result = nir_fall_equal3(&b, srcs[0], srcs[1]); break;
+            case 4: result = nir_fall_equal4(&b, srcs[0], srcs[1]); break;
             default:
                unreachable("not reached");
          }
@@ -1808,29 +1693,29 @@ nir_visitor::visit(ir_expression *ir)
       if (supports_ints) {
          if (types[0] == GLSL_TYPE_FLOAT) {
             switch (ir->operands[0]->type->vector_elements) {
-               case 1: emit(nir_op_fne, dest_size, srcs); break;
-               case 2: emit(nir_op_bany_fnequal2, dest_size, srcs); break;
-               case 3: emit(nir_op_bany_fnequal3, dest_size, srcs); break;
-               case 4: emit(nir_op_bany_fnequal4, dest_size, srcs); break;
+               case 1: result = nir_fne(&b, srcs[0], srcs[1]); break;
+               case 2: result = nir_bany_fnequal2(&b, srcs[0], srcs[1]); break;
+               case 3: result = nir_bany_fnequal3(&b, srcs[0], srcs[1]); break;
+               case 4: result = nir_bany_fnequal4(&b, srcs[0], srcs[1]); break;
                default:
                   unreachable("not reached");
             }
          } else {
             switch (ir->operands[0]->type->vector_elements) {
-               case 1: emit(nir_op_ine, dest_size, srcs); break;
-               case 2: emit(nir_op_bany_inequal2, dest_size, srcs); break;
-               case 3: emit(nir_op_bany_inequal3, dest_size, srcs); break;
-               case 4: emit(nir_op_bany_inequal4, dest_size, srcs); break;
+               case 1: result = nir_ine(&b, srcs[0], srcs[1]); break;
+               case 2: result = nir_bany_inequal2(&b, srcs[0], srcs[1]); break;
+               case 3: result = nir_bany_inequal3(&b, srcs[0], srcs[1]); break;
+               case 4: result = nir_bany_inequal4(&b, srcs[0], srcs[1]); break;
                default:
                   unreachable("not reached");
             }
          }
       } else {
          switch (ir->operands[0]->type->vector_elements) {
-            case 1: emit(nir_op_sne, dest_size, srcs); break;
-            case 2: emit(nir_op_fany_nequal2, dest_size, srcs); break;
-            case 3: emit(nir_op_fany_nequal3, dest_size, srcs); break;
-            case 4: emit(nir_op_fany_nequal4, dest_size, srcs); break;
+            case 1: result = nir_sne(&b, srcs[0], srcs[1]); break;
+            case 2: result = nir_fany_nequal2(&b, srcs[0], srcs[1]); break;
+            case 3: result = nir_fany_nequal3(&b, srcs[0], srcs[1]); break;
+            case 4: result = nir_fany_nequal4(&b, srcs[0], srcs[1]); break;
             default:
                unreachable("not reached");
          }
@@ -1838,64 +1723,40 @@ nir_visitor::visit(ir_expression *ir)
       break;
    case ir_binop_dot:
       switch (ir->operands[0]->type->vector_elements) {
-         case 2: emit(nir_op_fdot2, dest_size, srcs); break;
-         case 3: emit(nir_op_fdot3, dest_size, srcs); break;
-         case 4: emit(nir_op_fdot4, dest_size, srcs); break;
+         case 2: result = nir_fdot2(&b, srcs[0], srcs[1]); break;
+         case 3: result = nir_fdot3(&b, srcs[0], srcs[1]); break;
+         case 4: result = nir_fdot4(&b, srcs[0], srcs[1]); break;
          default:
             unreachable("not reached");
       }
       break;
 
    case ir_binop_pack_half_2x16_split:
-         emit(nir_op_pack_half_2x16_split, dest_size, srcs);
+         result = nir_pack_half_2x16_split(&b, srcs[0], srcs[1]);
          break;
-   case ir_binop_bfm:   emit(nir_op_bfm, dest_size, srcs);   break;
-   case ir_binop_ldexp: emit(nir_op_ldexp, dest_size, srcs); break;
-   case ir_triop_fma:   emit(nir_op_ffma, dest_size, srcs);  break;
+   case ir_binop_ldexp: result = nir_ldexp(&b, srcs[0], srcs[1]); break;
+   case ir_triop_fma:
+      result = nir_ffma(&b, srcs[0], srcs[1], srcs[2]);
+      break;
    case ir_triop_lrp:
-      instr = emit(nir_op_flrp, dest_size, srcs);
-      if (ir->operands[0]->type->vector_elements != 1 &&
-          ir->operands[2]->type->vector_elements == 1) {
-         for (unsigned i = 0; i < ir->operands[0]->type->vector_elements;
-              i++) {
-            instr->src[2].swizzle[i] = 0;
-         }
-      }
+      result = nir_flrp(&b, srcs[0], srcs[1], srcs[2]);
       break;
    case ir_triop_csel:
       if (supports_ints)
-         emit(nir_op_bcsel, dest_size, srcs);
+         result = nir_bcsel(&b, srcs[0], srcs[1], srcs[2]);
       else
-         emit(nir_op_fcsel, dest_size, srcs);
-      break;
-   case ir_triop_bfi:
-      instr = emit(nir_op_bfi, dest_size, srcs);
-      for (unsigned i = 0; i < ir->operands[1]->type->vector_elements; i++) {
-         instr->src[0].swizzle[i] = 0;
-      }
+         result = nir_fcsel(&b, srcs[0], srcs[1], srcs[2]);
       break;
    case ir_triop_bitfield_extract:
-      instr = emit(out_type == GLSL_TYPE_INT ? nir_op_ibitfield_extract :
-                   nir_op_ubitfield_extract, dest_size, srcs);
-      for (unsigned i = 0; i < ir->operands[0]->type->vector_elements; i++) {
-         instr->src[1].swizzle[i] = 0;
-         instr->src[2].swizzle[i] = 0;
-      }
+      result = (out_type == GLSL_TYPE_INT) ?
+         nir_ibitfield_extract(&b, srcs[0], srcs[1], srcs[2]) :
+         nir_ubitfield_extract(&b, srcs[0], srcs[1], srcs[2]);
       break;
    case ir_quadop_bitfield_insert:
-      instr = emit(nir_op_bitfield_insert, dest_size, srcs);
-      for (unsigned i = 0; i < ir->operands[0]->type->vector_elements; i++) {
-         instr->src[2].swizzle[i] = 0;
-         instr->src[3].swizzle[i] = 0;
-      }
+      result = nir_bitfield_insert(&b, srcs[0], srcs[1], srcs[2], srcs[3]);
       break;
    case ir_quadop_vector:
-      switch (ir->type->vector_elements) {
-         case 2: emit(nir_op_vec2, dest_size, srcs); break;
-         case 3: emit(nir_op_vec3, dest_size, srcs); break;
-         case 4: emit(nir_op_vec4, dest_size, srcs); break;
-         default: unreachable("not reached");
-      }
+      result = nir_vec(&b, srcs, ir->type->vector_elements);
       break;
 
    default:
@@ -1906,13 +1767,9 @@ nir_visitor::visit(ir_expression *ir)
 void
 nir_visitor::visit(ir_swizzle *ir)
 {
-   nir_alu_instr *instr = emit(supports_ints ? nir_op_imov : nir_op_fmov,
-                               ir->type->vector_elements,
-                               evaluate_rvalue(ir->val));
-
    unsigned swizzle[4] = { ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w };
-   for (unsigned i = 0; i < ir->type->vector_elements; i++)
-      instr->src[0].swizzle[i] = swizzle[i];
+   result = nir_swizzle(&b, evaluate_rvalue(ir->val), swizzle,
+                        ir->type->vector_elements, !supports_ints);
 }
 
 void
@@ -1978,6 +1835,11 @@ nir_visitor::visit(ir_texture *ir)
       num_srcs = 0;
       break;
 
+   case ir_samples_identical:
+      op = nir_texop_samples_identical;
+      num_srcs = 1; /* coordinate */
+      break;
+
    default:
       unreachable("not reached");
    }
@@ -2005,8 +1867,9 @@ nir_visitor::visit(ir_texture *ir)
    case GLSL_TYPE_INT:
       instr->dest_type = nir_type_int;
       break;
+   case GLSL_TYPE_BOOL:
    case GLSL_TYPE_UINT:
-      instr->dest_type = nir_type_unsigned;
+      instr->dest_type = nir_type_uint;
       break;
    default:
       unreachable("not reached");
@@ -2018,19 +1881,22 @@ nir_visitor::visit(ir_texture *ir)
 
    if (ir->coordinate != NULL) {
       instr->coord_components = ir->coordinate->type->vector_elements;
-      instr->src[src_number].src = evaluate_rvalue(ir->coordinate);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->coordinate));
       instr->src[src_number].src_type = nir_tex_src_coord;
       src_number++;
    }
 
    if (ir->projector != NULL) {
-      instr->src[src_number].src = evaluate_rvalue(ir->projector);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->projector));
       instr->src[src_number].src_type = nir_tex_src_projector;
       src_number++;
    }
 
    if (ir->shadow_comparitor != NULL) {
-      instr->src[src_number].src = evaluate_rvalue(ir->shadow_comparitor);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->shadow_comparitor));
       instr->src[src_number].src_type = nir_tex_src_comparitor;
       src_number++;
    }
@@ -2044,7 +1910,8 @@ nir_visitor::visit(ir_texture *ir)
          for (unsigned i = 0; i < const_offset->type->vector_elements; i++)
             instr->const_offset[i] = const_offset->value.i[i];
       } else {
-         instr->src[src_number].src = evaluate_rvalue(ir->offset);
+         instr->src[src_number].src =
+            nir_src_for_ssa(evaluate_rvalue(ir->offset));
          instr->src[src_number].src_type = nir_tex_src_offset;
          src_number++;
       }
@@ -2052,7 +1919,8 @@ nir_visitor::visit(ir_texture *ir)
 
    switch (ir->op) {
    case ir_txb:
-      instr->src[src_number].src = evaluate_rvalue(ir->lod_info.bias);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->lod_info.bias));
       instr->src[src_number].src_type = nir_tex_src_bias;
       src_number++;
       break;
@@ -2061,23 +1929,27 @@ nir_visitor::visit(ir_texture *ir)
    case ir_txf:
    case ir_txs:
       if (ir->lod_info.lod != NULL) {
-         instr->src[src_number].src = evaluate_rvalue(ir->lod_info.lod);
+         instr->src[src_number].src =
+            nir_src_for_ssa(evaluate_rvalue(ir->lod_info.lod));
          instr->src[src_number].src_type = nir_tex_src_lod;
          src_number++;
       }
       break;
 
    case ir_txd:
-      instr->src[src_number].src = evaluate_rvalue(ir->lod_info.grad.dPdx);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->lod_info.grad.dPdx));
       instr->src[src_number].src_type = nir_tex_src_ddx;
       src_number++;
-      instr->src[src_number].src = evaluate_rvalue(ir->lod_info.grad.dPdy);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->lod_info.grad.dPdy));
       instr->src[src_number].src_type = nir_tex_src_ddy;
       src_number++;
       break;
 
    case ir_txf_ms:
-      instr->src[src_number].src = evaluate_rvalue(ir->lod_info.sample_index);
+      instr->src[src_number].src =
+         nir_src_for_ssa(evaluate_rvalue(ir->lod_info.sample_index));
       instr->src[src_number].src_type = nir_tex_src_ms_index;
       src_number++;
       break;
@@ -2152,7 +2024,8 @@ nir_visitor::visit(ir_dereference_array *ir)
       deref->base_offset = const_index->value.u[0];
    } else {
       deref->deref_array_type = nir_deref_array_type_indirect;
-      deref->indirect = evaluate_rvalue(ir->array_index);
+      deref->indirect =
+         nir_src_for_ssa(evaluate_rvalue(ir->array_index));
    }
 
    ir->array->accept(this);
@@ -2167,5 +2040,5 @@ nir_visitor::visit(ir_barrier *ir)
 {
    nir_intrinsic_instr *instr =
       nir_intrinsic_instr_create(this->shader, nir_intrinsic_barrier);
-   nir_instr_insert_after_cf_list(this->cf_node_list, &instr->instr);
+   nir_builder_instr_insert(&b, &instr->instr);
 }