tgsi_llvm: Move op_actions to lp_bulid_tgsi_context

2 files changed, 136 insertions, 184 deletions

diff --git a/src/gallium/auxiliary/tgsi/tgsi_llvm.c b/src/gallium/auxiliary/tgsi/tgsi_llvm.c
index c7996d55ab5..bf8787af50e 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_llvm.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_llvm.c
@@ -49,49 +49,51 @@ unsigned tgsi_llvm_reg_index_soa(
 
 static void
 tgsi_llvm_emit_soa(
-   struct tgsi_llvm_context * ctx,
+   struct lp_build_tgsi_context * bld_base,
    const struct tgsi_full_instruction * inst,
-   const struct tgsi_llvm_opcode_action * action,
-   struct tgsi_llvm_emit_data * emit_data,
+   const struct lp_build_opcode_action * action,
+   struct lp_build_emit_data * emit_data,
    LLVMValueRef values[4])
 {
    unsigned chan;
    FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan) {
       emit_data->chan = chan;
-      values[chan] = action->emit(action, ctx, emit_data);
+      values[chan] = action->emit(action, bld_base, emit_data);
    }
 }
 
 LLVMValueRef tgsi_llvm_emit_intr(
-   const struct tgsi_llvm_opcode_action * action,
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data)
+   const struct lp_build_opcode_action * action,
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data)
 {
-   struct lp_build_context * base = tgsi_llvm_get_base(ctx);
+   struct lp_build_context * base = &bld_base->base;
    return lp_build_intrinsic(base->gallivm->builder, action->intr_name,
                              emit_data->dst_type, emit_data->args, emit_data->arg_count);
 }
 
-void tgsi_llvm_fetch_args(
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data)
+void tgsi_llvm_fetch_args_soa(
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data)
 {
    unsigned src;
+   struct lp_build_tgsi_soa_context * bld = lp_soa_context(bld_base);
    for (src = 0; src < emit_data->info->num_src; src++) {
-      emit_data->args[src] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, emit_data->inst, src,
-                                          emit_data->chan);
+      emit_data->args[src] = lp_emit_fetch_soa(bld, emit_data->inst, src,
+                                               emit_data->chan);
    }
    emit_data->arg_count = emit_data->info->num_src;
 }
 
-void tgsi_llvm_fetch_args_2_reverse(
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data)
+void tgsi_llvm_fetch_args_2_reverse_soa(
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data)
 {
+   struct lp_build_tgsi_soa_context * bld = lp_soa_context(bld_base);
    assert(emit_data->info->num_src == 2);
-   emit_data->args[0] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, emit_data->inst,
+   emit_data->args[0] = lp_emit_fetch_soa(bld, emit_data->inst,
                                           1, emit_data->chan);
-   emit_data->args[1] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, emit_data->inst,
+   emit_data->args[1] = lp_emit_fetch_soa(bld, emit_data->inst,
                                           0, emit_data->chan);
    emit_data->arg_count = 2;
 }
@@ -175,9 +177,9 @@ emit_store_soa(
    const struct tgsi_full_dst_register *reg = &inst->Dst[index];
 
    if (inst->Instruction.Saturate != TGSI_SAT_NONE) {
-      struct tgsi_llvm_opcode_action * clamp_action =
-                                            &ctx->op_actions[TGSI_OPCODE_CLAMP];
-      struct tgsi_llvm_emit_data clamp_emit_data;
+      struct lp_build_opcode_action * clamp_action =
+                                            &bld_base->op_actions[TGSI_OPCODE_CLAMP];
+      struct lp_build_emit_data clamp_emit_data;
 
       assert(clamp_action->emit);
       memset(&clamp_emit_data, 0, sizeof(clamp_emit_data));
@@ -196,7 +198,7 @@ emit_store_soa(
       default:
             assert(0);
       }
-      value = clamp_action->emit(clamp_action, ctx, &clamp_emit_data);
+      value = clamp_action->emit(clamp_action, bld_base, &clamp_emit_data);
    }
    emit_store_switch_file_soa(bld, reg, chan_index, pred, value);
 }
@@ -302,16 +304,17 @@ merge_elements(
    return vec;
 }
 
-void tgsi_llvm_fetch_args_tex(
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data)
+void tgsi_llvm_fetch_args_tex_soa(
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data)
 {
    unsigned chan;
+   struct lp_build_tgsi_soa_context * bld = lp_soa_context(bld_base);
    LLVMValueRef coords[4];
    for (chan = 0; chan < 4; chan++) {
-      coords[chan] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, emit_data->inst, 0, chan);
+      coords[chan] = lp_emit_fetch_soa(bld, emit_data->inst, 0, chan);
    }
-   emit_data->args[0] = merge_elements(&ctx->bld_ctx.soa.bld_base, coords);
+   emit_data->args[0] = merge_elements(bld_base, coords);
    emit_data->arg_count = 1;
 }
 
@@ -343,12 +346,12 @@ xpd_helper(
   LLVMValueRef d)
 {
    struct lp_build_tgsi_context * bld_base = tgsi_llvm_get_bld_base(ctx);
-   struct tgsi_llvm_opcode_action * mul_action =
-                                    &ctx->op_actions[TGSI_OPCODE_MUL];
-   struct tgsi_llvm_emit_data mul_emit_data;
+   struct lp_build_opcode_action * mul_action =
+                                    &bld_base->op_actions[TGSI_OPCODE_MUL];
+   struct lp_build_emit_data mul_emit_data;
    LLVMValueRef tmp0, tmp1;
 
-   assert(ctx->op_actions[TGSI_OPCODE_MUL].emit);
+   assert(bld_base->op_actions[TGSI_OPCODE_MUL].emit);
 
    memset(&mul_emit_data, 0, sizeof(mul_emit_data));
    mul_emit_data.dst_type = bld_base->base.elem_type;
@@ -356,11 +359,11 @@ xpd_helper(
 
    mul_emit_data.args[0] = a;
    mul_emit_data.args[1] = b;
-   tmp0 = mul_action->emit(mul_action, ctx, &mul_emit_data);
+   tmp0 = mul_action->emit(mul_action, bld_base, &mul_emit_data);
 
    mul_emit_data.args[0] = c;
    mul_emit_data.args[1] = d;
-   tmp1 = mul_action->emit(mul_action, ctx, &mul_emit_data);
+   tmp1 = mul_action->emit(mul_action, bld_base, &mul_emit_data);
 
    return LLVMBuildFSub(bld_base->base.gallivm->builder, tmp0, tmp1, "");
 }
@@ -374,15 +377,15 @@ emit_instruction(
 {
 
    unsigned opcode = inst->Instruction.Opcode;
-   const struct tgsi_llvm_opcode_action * action = &ctx->op_actions[opcode];
-   struct tgsi_llvm_emit_data emit_data;
+   struct lp_build_tgsi_context * bld_base = tgsi_llvm_get_bld_base(ctx);
+   const struct lp_build_opcode_action * action = &bld_base->op_actions[opcode];
+   struct lp_build_emit_data emit_data;
    const char * intrinsic_name = action->intr_name;
    unsigned chan;
    LLVMValueRef dst;
    LLVMValueRef src0, src1;
    LLVMTypeRef ret_type;
    LLVMValueRef values[4] = {NULL, NULL, NULL, NULL};
-   struct lp_build_tgsi_context * bld_base = tgsi_llvm_get_bld_base(ctx);
    struct lp_build_context * base = &bld_base->base;
    LLVMBuilderRef builder = base->gallivm->builder;
    struct tgsi_llvm_branch * current_branch = ctx->branch_depth > 0 ?
@@ -453,10 +456,10 @@ emit_instruction(
          emit_data.arg_count = 2;
 
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
-      dst = action->emit(action, ctx, &emit_data);
+      dst = action->emit(action, bld_base, &emit_data);
       FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan) {
          bld_base->emit_store(bld_base, inst, 0, chan, NULL, dst);
       }
@@ -480,25 +483,25 @@ emit_instruction(
                                                1, CHAN_W);
          emit_data.arg_count = 4;
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
-         assert(ctx->op_actions[TGSI_OPCODE_MUL].emit);
+         assert(bld_base->op_actions[TGSI_OPCODE_MUL].emit);
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_X) {
             values[CHAN_X] = base->one;
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Y) {
-            struct tgsi_llvm_emit_data mul_emit_data;
-            struct tgsi_llvm_opcode_action * mul_action =
-                                              &ctx->op_actions[TGSI_OPCODE_MUL];
+            struct lp_build_emit_data mul_emit_data;
+            struct lp_build_opcode_action * mul_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_MUL];
             memset(&mul_emit_data, 0, sizeof(mul_emit_data));
             mul_emit_data.dst_type = base->elem_type;
             mul_emit_data.args[0] = emit_data.args[0]; /* src0.y */
             mul_emit_data.args[1] = emit_data.args[2]; /* src1.y */
             mul_emit_data.arg_count = 2;
-            values[CHAN_Y] = mul_action->emit(mul_action, ctx, &mul_emit_data);
+            values[CHAN_Y] = mul_action->emit(mul_action, bld_base, &mul_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Z) {
@@ -509,7 +512,7 @@ emit_instruction(
             values[CHAN_W] = emit_data.args[2]; /* src1.w */
          }
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
       }
       store_values(bld_base, inst, values);
       break;
@@ -580,16 +583,16 @@ emit_instruction(
          emit_data.args[0] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, inst, 0, 0);
 
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
-         struct tgsi_llvm_emit_data flr_emit_data;
-         struct tgsi_llvm_emit_data ex2_emit_data;
-         struct tgsi_llvm_opcode_action * flr_action =
-                                              &ctx->op_actions[TGSI_OPCODE_FLR];
-         struct tgsi_llvm_opcode_action * ex2_action =
-                                              &ctx->op_actions[TGSI_OPCODE_EX2];
+         struct lp_build_emit_data flr_emit_data;
+         struct lp_build_emit_data ex2_emit_data;
+         struct lp_build_opcode_action * flr_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_FLR];
+         struct lp_build_opcode_action * ex2_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_EX2];
          LLVMValueRef floor_x;
          assert(!ctx->aos);
          assert(flr_action->emit);
@@ -604,12 +607,12 @@ emit_instruction(
 
          /* floor( src0.x ) */
          flr_emit_data.args[0] = emit_data.args[0];
-         floor_x = flr_action->emit(flr_action, ctx, &flr_emit_data);
+         floor_x = flr_action->emit(flr_action, bld_base, &flr_emit_data);
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_X) {
             /* 2 ^ floor( src0.x ) */
             ex2_emit_data.args[0] = floor_x;
-            values[CHAN_X] = ex2_action->emit(ex2_action, ctx, &ex2_emit_data);
+            values[CHAN_X] = ex2_action->emit(ex2_action, bld_base, &ex2_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Y) {
@@ -621,14 +624,14 @@ emit_instruction(
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Z) {
             /* 2 ^ src0.x */
             ex2_emit_data.args[0] = emit_data.args[0] /* src0.x */;
-            values[CHAN_Z] = ex2_action->emit(ex2_action, ctx, &ex2_emit_data);
+            values[CHAN_Z] = ex2_action->emit(ex2_action, bld_base, &ex2_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_W) {
             values[CHAN_W] = base->one;
          }
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
       }
 
       store_values(bld_base, inst, values);
@@ -667,14 +670,14 @@ emit_instruction(
          emit_data.args[0] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, inst,
                                                0, CHAN_X);
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
-         struct tgsi_llvm_opcode_action * abs_action =
-                                              &ctx->op_actions[TGSI_OPCODE_ABS];
-         struct tgsi_llvm_emit_data abs_emit_data;
-         struct tgsi_llvm_emit_data rsq_emit_data;
+         struct lp_build_opcode_action * abs_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_ABS];
+         struct lp_build_emit_data abs_emit_data;
+         struct lp_build_emit_data rsq_emit_data;
          memset(&abs_emit_data, 0, sizeof(abs_emit_data));
          memset(&rsq_emit_data, 0, sizeof(rsq_emit_data));
          abs_emit_data.dst_type = rsq_emit_data.dst_type = base->elem_type;
@@ -682,22 +685,23 @@ emit_instruction(
          /* src0.x */
          abs_emit_data.args[0] = emit_data.args[0];
          abs_emit_data.arg_count = 1;
-         assert(ctx->rsq_action.emit);
+         assert(bld_base->rsq_action.emit);
          assert(abs_action->emit);
 
          /* abs (src0.x) */
-         rsq_emit_data.args[0] = abs_action->emit(abs_action, ctx,
+         rsq_emit_data.args[0] = abs_action->emit(abs_action, bld_base,
                                                   &abs_emit_data);
          rsq_emit_data.arg_count = 1;
 
          /* rsq( abs( src0.x ) ) */
-         dst = ctx->rsq_action.emit(&ctx->rsq_action, ctx, &rsq_emit_data);
+         dst = bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base,
+                                         &rsq_emit_data);
 
          FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan) {
             bld_base->emit_store(bld_base, inst, 0, chan, NULL, dst);
          }
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
          store_values(bld_base, inst, values);
       }
       break;
@@ -709,34 +713,34 @@ emit_instruction(
          emit_data.args[0] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, inst,
                                                0, CHAN_X);
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_X) {
-            struct tgsi_llvm_opcode_action * cos_action =
-                                             &ctx->op_actions[TGSI_OPCODE_COS];
-            struct tgsi_llvm_emit_data cos_emit_data;
+            struct lp_build_opcode_action * cos_action =
+                                             &bld_base->op_actions[TGSI_OPCODE_COS];
+            struct lp_build_emit_data cos_emit_data;
 
             assert(cos_action->emit);
             memset(&cos_emit_data, 0, sizeof(cos_emit_data));
             cos_emit_data.dst_type = base->elem_type;
             cos_emit_data.args[0] = emit_data.args[0] /* src0.x */;
             cos_emit_data.arg_count = 1;
-            values[CHAN_X] = cos_action->emit(cos_action, ctx, &cos_emit_data);
+            values[CHAN_X] = cos_action->emit(cos_action, bld_base, &cos_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Y) {
-            struct tgsi_llvm_opcode_action * sin_action =
-                                             &ctx->op_actions[TGSI_OPCODE_SIN];
-            struct tgsi_llvm_emit_data sin_emit_data;
+            struct lp_build_opcode_action * sin_action =
+                                             &bld_base->op_actions[TGSI_OPCODE_SIN];
+            struct lp_build_emit_data sin_emit_data;
 
             assert(sin_action->emit);
             memset(&sin_emit_data, 0, sizeof(sin_emit_data));
             sin_emit_data.dst_type = base->elem_type;
             sin_emit_data.args[0] = emit_data.args[0] /* src0.x */;
             sin_emit_data.arg_count = 1;
-            values[CHAN_Y] = sin_action->emit(sin_action, ctx, &sin_emit_data);
+            values[CHAN_Y] = sin_action->emit(sin_action, bld_base, &sin_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Z) {
@@ -748,7 +752,7 @@ emit_instruction(
          }
 
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
       }
       store_values(bld_base, inst, values);
       break;
@@ -760,20 +764,20 @@ emit_instruction(
          emit_data.args[0] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, inst,
                                                 0, CHAN_X);
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
          LLVMValueRef abs_x, log_abs_x, flr_log_abs_x;
-         struct tgsi_llvm_opcode_action * abs_action =
-                                              &ctx->op_actions[TGSI_OPCODE_ABS];
-         struct tgsi_llvm_opcode_action * lg2_action =
-                                              &ctx->op_actions[TGSI_OPCODE_LG2];
-         struct tgsi_llvm_opcode_action * flr_action =
-                                              &ctx->op_actions[TGSI_OPCODE_FLR];
-         struct tgsi_llvm_emit_data abs_emit_data;
-         struct tgsi_llvm_emit_data lg2_emit_data;
-         struct tgsi_llvm_emit_data flr_emit_data;
+         struct lp_build_opcode_action * abs_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_ABS];
+         struct lp_build_opcode_action * lg2_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_LG2];
+         struct lp_build_opcode_action * flr_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_FLR];
+         struct lp_build_emit_data abs_emit_data;
+         struct lp_build_emit_data lg2_emit_data;
+         struct lp_build_emit_data flr_emit_data;
 
          assert(!ctx->aos);
          assert(abs_action->emit);
@@ -792,27 +796,27 @@ emit_instruction(
 
          /* abs( src0.x) */
          abs_emit_data.args[0] = emit_data.args[0] /* src0.x */;
-         abs_x = abs_action->emit(abs_action, ctx, &abs_emit_data);
+         abs_x = abs_action->emit(abs_action, bld_base, &abs_emit_data);
 
          /* log( abs( src0.x ) ) */
          lg2_emit_data.args[0] = abs_x;
-         log_abs_x = lg2_action->emit(lg2_action, ctx, &lg2_emit_data);
+         log_abs_x = lg2_action->emit(lg2_action, bld_base, &lg2_emit_data);
 
          /* floor( log( abs( src0.x ) ) ) */
          flr_emit_data.args[0] = log_abs_x;
-         flr_log_abs_x = flr_action->emit(flr_action, ctx, &flr_emit_data);
+         flr_log_abs_x = flr_action->emit(flr_action, bld_base, &flr_emit_data);
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_X) {
             values[CHAN_X] = flr_log_abs_x;
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Y) {
-            struct tgsi_llvm_opcode_action * ex2_action =
-                                                 &ctx->op_actions[TGSI_OPCODE_EX2];
-            struct tgsi_llvm_opcode_action * div_action =
-                                                 &ctx->op_actions[TGSI_OPCODE_DIV];
-            struct tgsi_llvm_emit_data ex2_emit_data;
-            struct tgsi_llvm_emit_data div_emit_data;
+            struct lp_build_opcode_action * ex2_action =
+                                                 &bld_base->op_actions[TGSI_OPCODE_EX2];
+            struct lp_build_opcode_action * div_action =
+                                                 &bld_base->op_actions[TGSI_OPCODE_DIV];
+            struct lp_build_emit_data ex2_emit_data;
+            struct lp_build_emit_data div_emit_data;
 
             memset(&ex2_emit_data, 0, sizeof(ex2_emit_data));
             memset(&div_emit_data, 0, sizeof(div_emit_data));
@@ -823,11 +827,11 @@ emit_instruction(
 
             div_emit_data.arg_count = 2;
             div_emit_data.args[0] = abs_x;
-            div_emit_data.args[1] = ex2_action->emit(ex2_action, ctx,
+            div_emit_data.args[1] = ex2_action->emit(ex2_action, bld_base,
                                                      &ex2_emit_data);
 
             /* abs( src0.x ) / 2^( floor( lg2( abs( src0.x ) ) ) ) */
-            values[CHAN_Y] = div_action->emit(div_action, ctx, &div_emit_data);
+            values[CHAN_Y] = div_action->emit(div_action, bld_base, &div_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Z) {
@@ -838,7 +842,7 @@ emit_instruction(
             values[CHAN_W] = base->one;
          }
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
       }
       store_values(bld_base, inst, values);
       break;
@@ -856,13 +860,13 @@ emit_instruction(
          emit_data.args[2] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, inst,
                                                0, CHAN_W);
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
-         struct tgsi_llvm_opcode_action * max_action =
-                                              &ctx->op_actions[TGSI_OPCODE_MAX];
-         struct tgsi_llvm_emit_data max_emit_data;
+         struct lp_build_opcode_action * max_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_MAX];
+         struct lp_build_emit_data max_emit_data;
 
          assert(max_action->emit);
          assert(!ctx->aos);
@@ -878,7 +882,7 @@ emit_instruction(
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Y) {
             max_emit_data.args[0] = emit_data.args[0] /* src0.x */;
             max_emit_data.args[1] = base->zero;
-            values[CHAN_Y] = max_action->emit(max_action, ctx, &max_emit_data);
+            values[CHAN_Y] = max_action->emit(max_action, bld_base, &max_emit_data);
          }
 
          if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Z) {
@@ -892,7 +896,7 @@ emit_instruction(
             values[CHAN_W] = base->one;
          }
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
       }
       store_values(bld_base, inst, values);
       break;
@@ -906,11 +910,11 @@ emit_instruction(
       assert(!ctx->aos);
       emit_data.dst_type = LLVMVectorType(base->elem_type, 4);
       if (!action->fetch_args) {
-         tgsi_llvm_fetch_args_tex(ctx, &emit_data);
+         tgsi_llvm_fetch_args_tex_soa(bld_base, &emit_data);
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
-      dst = action->emit(action, ctx, &emit_data);
+      dst = action->emit(action, bld_base, &emit_data);
       store_vec4_soa(bld_base, inst, dst);
       break;
 
@@ -919,9 +923,9 @@ emit_instruction(
       emit_data.dst_type = LLVMVectorType(base->elem_type, 4);
       if (!action->fetch_args) {
          LLVMValueRef coords[4];
-         struct tgsi_llvm_opcode_action * div_action =
-                                              &ctx->op_actions[TGSI_OPCODE_DIV];
-         struct tgsi_llvm_emit_data div_emit_data;
+         struct lp_build_opcode_action * div_action =
+                                              &bld_base->op_actions[TGSI_OPCODE_DIV];
+         struct lp_build_emit_data div_emit_data;
 
          assert(div_action->emit);
 
@@ -933,15 +937,15 @@ emit_instruction(
          for (chan = 0; chan < 3; chan++) {
             div_emit_data.args[0] = lp_emit_fetch_soa(&ctx->bld_ctx.soa, inst,
                                                       0, chan);
-            coords[chan] = div_action->emit(div_action, ctx, &div_emit_data);
+            coords[chan] = div_action->emit(div_action, bld_base, &div_emit_data);
          }
          coords[3] = base->one;
          emit_data.args[0] = merge_elements(bld_base, coords);
          emit_data.arg_count = 1;
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
-      dst = action->emit(action, ctx, &emit_data);
+      dst = action->emit(action, bld_base, &emit_data);
       store_vec4_soa(bld_base, inst, dst);
       break;
 
@@ -956,7 +960,7 @@ emit_instruction(
             }
          }
       } else {
-         action->fetch_args(ctx, &emit_data);
+         action->fetch_args(bld_base, &emit_data);
       }
 
       if (!action->emit) {
@@ -984,7 +988,7 @@ emit_instruction(
          }
 
       } else {
-         tgsi_llvm_emit_soa(ctx, inst, action, &emit_data, values);
+         tgsi_llvm_emit_soa(bld_base, inst, action, &emit_data, values);
       }
       store_values(bld_base, inst, values);
       break;
@@ -996,11 +1000,11 @@ emit_instruction(
          if (info->num_dst == 0) {
             emit_data.dst_type = LLVMVoidTypeInContext(base->gallivm->context);
             if (!action->fetch_args) {
-               tgsi_llvm_fetch_args(ctx, &emit_data);
+               tgsi_llvm_fetch_args_soa(bld_base, &emit_data);
             } else {
-               action->fetch_args(ctx, &emit_data);
+               action->fetch_args(bld_base, &emit_data);
             }
-            action->emit(action, ctx, &emit_data);
+            action->emit(action, bld_base, &emit_data);
          } else {
             /* XXX: We should set this to the correct type based on the opcode. */
             emit_data.dst_type = base->elem_type;
@@ -1008,11 +1012,11 @@ emit_instruction(
          FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan_index) {
             emit_data.chan = chan_index;
             if (!action->fetch_args) {
-               tgsi_llvm_fetch_args(ctx, &emit_data);
+               tgsi_llvm_fetch_args_soa(bld_base, &emit_data);
             } else {
-               action->fetch_args(ctx, &emit_data);
+               action->fetch_args(bld_base, &emit_data);
             }
-            values[chan_index] = action->emit(action, ctx, &emit_data);
+            values[chan_index] = action->emit(action, bld_base, &emit_data);
          }
          store_values(bld_base, inst, values);
       } else {
@@ -1200,8 +1204,6 @@ tgsi_llvm_setup(
          TGSI_SWIZZLE_W
       };
 
-      memset(&ctx->bld_ctx.aos, 0, sizeof(ctx->bld_ctx.aos));
-
       /* Initialize lp_type:  XXX: Why is this set globally?  It seems like some
        * isntructions might need a different lp_type. */
       type.floating = TRUE;
@@ -1230,7 +1232,6 @@ tgsi_llvm_setup(
       lp_bld_tgsi_list_init(&ctx->bld_ctx.aos.inst_list);
 
    } else {
-      memset(&ctx->bld_ctx.soa, 0, sizeof(ctx->bld_ctx.soa));
       /* XXX: We need to revisit this.  I think the correct way to do this is
        * to use length = 4 here and use the elem_bld for everything. */
       type.floating = TRUE;
diff --git a/src/gallium/auxiliary/tgsi/tgsi_llvm.h b/src/gallium/auxiliary/tgsi/tgsi_llvm.h
index bb9e1b69779..1974b94751a 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_llvm.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_llvm.h
@@ -26,45 +26,6 @@ struct tgsi_llvm_loop {
       LLVMBasicBlockRef endloop_block;
 };
 
-struct tgsi_llvm_emit_data {
-   /* Arguments that are passed to tgsi_llvm_opcode_action::emit.  The
-    * order of the arguments should be as follows:
-    * SOA: s0.x, s0.y, s0.z, s0.w, s1.x, s1.y, s1.z, s1.w, s2.x, s2.y, s2.x, s2.w
-    * AOS: s0.xyzw, s1.xyzw, s2.xyzw
-    * TEXTURE Instructions: coord.xyzw
-    *
-    * Arguments should be packed into the args array.  For example an SOA
-    * instructions that reads s0.x and s1.x args should look like this:
-    * args[0] = s0.x;
-    * args[1] = s1.x;
-    */
-   LLVMValueRef args[12];
-   unsigned arg_count;
-   LLVMTypeRef dst_type;
-   unsigned chan;
-
-   /* These fields (inst and info) should be NULL if the
-    * tgsi_llvm_opcode_action::emit is called without first calling the
-    * tgsi_llvm_opcode_action::fetch_args function.
-    * For example, if TGSI_OPCODE_MAD is implemented using a MUL
-    * instruction and an ADD instruction, when the emit functions are
-    * called for MUL and ADD inst and info should be NULL.
-    */
-   const struct tgsi_full_instruction * inst;
-   const struct tgsi_opcode_info * info;
-};
-
-struct tgsi_llvm_opcode_action {
-   void (*fetch_args)(struct tgsi_llvm_context *,
-                      struct tgsi_llvm_emit_data *);
-
-   LLVMValueRef (*emit)(const struct tgsi_llvm_opcode_action *,
-                        struct tgsi_llvm_context *,
-                        struct tgsi_llvm_emit_data *);
-
-   const char * intr_name;
-};
-
 
 struct tgsi_llvm_context {
 
@@ -90,18 +51,8 @@ struct tgsi_llvm_context {
     */
    const char * swizzle_intr;
 
-   /** This array stores functions that are used to transform TGSI opcodes to
-     * LLVM instructions.
-     */
-   struct tgsi_llvm_opcode_action op_actions[TGSI_OPCODE_LAST];
-
    /* Instructions that are not described by any of the TGSI opcodes. */
 
-   /* The TGSI_OPCODE_RSQ is defined as 1 / sqrt( abs(src0.x) ), rsq_action
-    * should compute 1 / sqrt (src0.x) */
-   struct tgsi_llvm_opcode_action rsq_action;
-
-
    /** This function allows the user to insert some instructions at the
      * beginning of the program.  It is optional and does not need to be
      * implemented.
@@ -175,20 +126,20 @@ struct lp_build_context * tgsi_llvm_get_base(struct tgsi_llvm_context * ctx);
 unsigned tgsi_llvm_reg_index_soa(unsigned index, unsigned chan); 
 
 LLVMValueRef tgsi_llvm_emit_intr(
-   const struct tgsi_llvm_opcode_action * action,
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data);
+   const struct lp_build_opcode_action * action,
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data);
 
-void tgsi_llvm_fetch_args(
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data);
+void tgsi_llvm_fetch_args_soa(
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data);
 
-void tgsi_llvm_fetch_args_2_reverse(
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data);
+void tgsi_llvm_fetch_args_2_reverse_soa(
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data);
 
-void tgsi_llvm_fetch_args_tex(
-   struct tgsi_llvm_context * ctx,
-   struct tgsi_llvm_emit_data * emit_data);
+void tgsi_llvm_fetch_args_tex_soa(
+   struct lp_build_tgsi_context * bld_base,
+   struct lp_build_emit_data * emit_data);
 
 #endif /* TGSI_LLVM_H */