From db5a7dca18e79285fd5877b0034862738a8ee6d8 Mon Sep 17 00:00:00 2001 From: Tom Stellard Date: Wed, 4 Jan 2012 18:17:36 -0500 Subject: tgsi_llvm: Move op_actions to lp_bulid_tgsi_context --- src/gallium/auxiliary/tgsi/tgsi_llvm.c | 247 +++++++++++++++++---------------- src/gallium/auxiliary/tgsi/tgsi_llvm.h | 73 ++-------- 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 */ -- cgit v1.2.3