[Mesa-dev] [PATCH 05/11] radeonsi: use ctx->ac.builder
Nicolai Hähnle
nhaehnle at gmail.com
Mon Oct 2 10:06:37 UTC 2017
On 29.09.2017 16:49, Marek Olšák wrote:
> From: Marek Olšák <marek.olsak at amd.com>
>
> ---
> src/gallium/drivers/radeonsi/si_shader.c | 401 ++++++++++-----------
> src/gallium/drivers/radeonsi/si_shader_tgsi_alu.c | 161 ++++-----
> src/gallium/drivers/radeonsi/si_shader_tgsi_mem.c | 114 +++---
> .../drivers/radeonsi/si_shader_tgsi_setup.c | 84 ++---
> 4 files changed, 341 insertions(+), 419 deletions(-)
>
[snip]
> @@ -1937,38 +1920,37 @@ static void build_tex_intrinsic(const struct lp_build_tgsi_action *action,
>
> emit_data->output[emit_data->chan] = result;
> }
>
> static void si_llvm_emit_txqs(
> const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> - LLVMBuilderRef builder = gallivm->builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef res, samples;
> LLVMValueRef res_ptr, samp_ptr, fmask_ptr = NULL;
>
> tex_fetch_ptrs(bld_base, emit_data, &res_ptr, &samp_ptr, &fmask_ptr);
>
>
> /* Read the samples from the descriptor directly. */
> - res = LLVMBuildBitCast(builder, res_ptr, ctx->v8i32, "");
> + res = LLVMBuildBitCast(ctx->ac.builder, res_ptr, ctx->v8i32, "");
> samples = LLVMBuildExtractElement(
> builder, res,
This function is inconsistent about whether builder or ctx->ac.builder
is used here. Would be nice to still clean this up, but either way,
patches 2-11 are a nice cleanup and:
Reviewed-by: Nicolai Hähnle <nicolai.haehnle at amd.com>
> LLVMConstInt(ctx->i32, 3, 0), "");
> - samples = LLVMBuildLShr(builder, samples,
> + samples = LLVMBuildLShr(ctx->ac.builder, samples,
> LLVMConstInt(ctx->i32, 16, 0), "");
> - samples = LLVMBuildAnd(builder, samples,
> + samples = LLVMBuildAnd(ctx->ac.builder, samples,
> LLVMConstInt(ctx->i32, 0xf, 0), "");
> - samples = LLVMBuildShl(builder, ctx->i32_1,
> + samples = LLVMBuildShl(ctx->ac.builder, ctx->i32_1,
> samples, "");
>
> emit_data->output[emit_data->chan] = samples;
> }
>
> static const struct lp_build_tgsi_action tex_action = {
> .fetch_args = tex_fetch_args,
> .emit = build_tex_intrinsic,
> };
>
> diff --git a/src/gallium/drivers/radeonsi/si_shader_tgsi_setup.c b/src/gallium/drivers/radeonsi/si_shader_tgsi_setup.c
> index aee8cdd..2ecb112 100644
> --- a/src/gallium/drivers/radeonsi/si_shader_tgsi_setup.c
> +++ b/src/gallium/drivers/radeonsi/si_shader_tgsi_setup.c
> @@ -180,39 +180,38 @@ LLVMTypeRef tgsi2llvmtype(struct lp_build_tgsi_context *bld_base,
> case TGSI_TYPE_FLOAT:
> return LLVMFloatTypeInContext(ctx);
> default: break;
> }
> return 0;
> }
>
> LLVMValueRef bitcast(struct lp_build_tgsi_context *bld_base,
> enum tgsi_opcode_type type, LLVMValueRef value)
> {
> - LLVMBuilderRef builder = bld_base->base.gallivm->builder;
> + struct si_shader_context *ctx = si_shader_context(bld_base);
> LLVMTypeRef dst_type = tgsi2llvmtype(bld_base, type);
>
> if (dst_type)
> - return LLVMBuildBitCast(builder, value, dst_type, "");
> + return LLVMBuildBitCast(ctx->ac.builder, value, dst_type, "");
> else
> return value;
> }
>
> /**
> * Return a value that is equal to the given i32 \p index if it lies in [0,num)
> * or an undefined value in the same interval otherwise.
> */
> LLVMValueRef si_llvm_bound_index(struct si_shader_context *ctx,
> LLVMValueRef index,
> unsigned num)
> {
> - struct gallivm_state *gallivm = &ctx->gallivm;
> - LLVMBuilderRef builder = gallivm->builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef c_max = LLVMConstInt(ctx->i32, num - 1, 0);
> LLVMValueRef cc;
>
> if (util_is_power_of_two(num)) {
> index = LLVMBuildAnd(builder, index, c_max, "");
> } else {
> /* In theory, this MAX pattern should result in code that is
> * as good as the bit-wise AND above.
> *
> * In practice, LLVM generates worse code (at the time of
> @@ -264,30 +263,31 @@ push_flow(struct si_shader_context *ctx)
> return flow;
> }
>
> static LLVMValueRef emit_swizzle(struct lp_build_tgsi_context *bld_base,
> LLVMValueRef value,
> unsigned swizzle_x,
> unsigned swizzle_y,
> unsigned swizzle_z,
> unsigned swizzle_w)
> {
> + struct si_shader_context *ctx = si_shader_context(bld_base);
> LLVMValueRef swizzles[4];
> LLVMTypeRef i32t =
> LLVMInt32TypeInContext(bld_base->base.gallivm->context);
>
> swizzles[0] = LLVMConstInt(i32t, swizzle_x, 0);
> swizzles[1] = LLVMConstInt(i32t, swizzle_y, 0);
> swizzles[2] = LLVMConstInt(i32t, swizzle_z, 0);
> swizzles[3] = LLVMConstInt(i32t, swizzle_w, 0);
>
> - return LLVMBuildShuffleVector(bld_base->base.gallivm->builder,
> + return LLVMBuildShuffleVector(ctx->ac.builder,
> value,
> LLVMGetUndef(LLVMTypeOf(value)),
> LLVMConstVector(swizzles, 4), "");
> }
>
> /**
> * Return the description of the array covering the given temporary register
> * index.
> */
> static unsigned
> @@ -340,22 +340,21 @@ get_array_range(struct lp_build_tgsi_context *bld_base,
> */
> static LLVMValueRef
> get_pointer_into_array(struct si_shader_context *ctx,
> unsigned file,
> unsigned swizzle,
> unsigned reg_index,
> const struct tgsi_ind_register *reg_indirect)
> {
> unsigned array_id;
> struct tgsi_array_info *array;
> - struct gallivm_state *gallivm = &ctx->gallivm;
> - LLVMBuilderRef builder = gallivm->builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef idxs[2];
> LLVMValueRef index;
> LLVMValueRef alloca;
>
> if (file != TGSI_FILE_TEMPORARY)
> return NULL;
>
> array_id = get_temp_array_id(&ctx->bld_base, reg_index, reg_indirect);
> if (!array_id)
> return NULL;
> @@ -390,83 +389,78 @@ get_pointer_into_array(struct si_shader_context *ctx,
> builder, index,
> LLVMConstInt(ctx->i32, util_bitcount(array->writemask), 0),
> "");
> index = LLVMBuildAdd(
> builder, index,
> LLVMConstInt(ctx->i32,
> util_bitcount(array->writemask & ((1 << swizzle) - 1)), 0),
> "");
> idxs[0] = ctx->i32_0;
> idxs[1] = index;
> - return LLVMBuildGEP(builder, alloca, idxs, 2, "");
> + return LLVMBuildGEP(ctx->ac.builder, alloca, idxs, 2, "");
> }
>
> LLVMValueRef
> si_llvm_emit_fetch_64bit(struct lp_build_tgsi_context *bld_base,
> enum tgsi_opcode_type type,
> LLVMValueRef ptr,
> LLVMValueRef ptr2)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - LLVMBuilderRef builder = bld_base->base.gallivm->builder;
> LLVMValueRef result;
>
> result = LLVMGetUndef(LLVMVectorType(LLVMIntTypeInContext(bld_base->base.gallivm->context, 32), bld_base->base.type.length * 2));
>
> - result = LLVMBuildInsertElement(builder,
> + result = LLVMBuildInsertElement(ctx->ac.builder,
> result,
> ac_to_integer(&ctx->ac, ptr),
> ctx->i32_0, "");
> - result = LLVMBuildInsertElement(builder,
> + result = LLVMBuildInsertElement(ctx->ac.builder,
> result,
> ac_to_integer(&ctx->ac, ptr2),
> ctx->i32_1, "");
> return bitcast(bld_base, type, result);
> }
>
> static LLVMValueRef
> emit_array_fetch(struct lp_build_tgsi_context *bld_base,
> unsigned File, enum tgsi_opcode_type type,
> struct tgsi_declaration_range range,
> unsigned swizzle)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> -
> - LLVMBuilderRef builder = ctx->gallivm.builder;
> -
> unsigned i, size = range.Last - range.First + 1;
> LLVMTypeRef vec = LLVMVectorType(tgsi2llvmtype(bld_base, type), size);
> LLVMValueRef result = LLVMGetUndef(vec);
>
> struct tgsi_full_src_register tmp_reg = {};
> tmp_reg.Register.File = File;
>
> for (i = 0; i < size; ++i) {
> tmp_reg.Register.Index = i + range.First;
> LLVMValueRef temp = si_llvm_emit_fetch(bld_base, &tmp_reg, type, swizzle);
> - result = LLVMBuildInsertElement(builder, result, temp,
> + result = LLVMBuildInsertElement(ctx->ac.builder, result, temp,
> LLVMConstInt(ctx->i32, i, 0), "array_vector");
> }
> return result;
> }
>
> static LLVMValueRef
> load_value_from_array(struct lp_build_tgsi_context *bld_base,
> unsigned file,
> enum tgsi_opcode_type type,
> unsigned swizzle,
> unsigned reg_index,
> const struct tgsi_ind_register *reg_indirect)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> - LLVMBuilderRef builder = gallivm->builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef ptr;
>
> ptr = get_pointer_into_array(ctx, file, swizzle, reg_index, reg_indirect);
> if (ptr) {
> LLVMValueRef val = LLVMBuildLoad(builder, ptr, "");
> if (tgsi_type_is_64bit(type)) {
> LLVMValueRef ptr_hi, val_hi;
> ptr_hi = LLVMBuildGEP(builder, ptr, &ctx->i32_1, 1, "");
> val_hi = LLVMBuildLoad(builder, ptr_hi, "");
> val = si_llvm_emit_fetch_64bit(bld_base, type, val, val_hi);
> @@ -486,22 +480,21 @@ load_value_from_array(struct lp_build_tgsi_context *bld_base,
>
> static void
> store_value_to_array(struct lp_build_tgsi_context *bld_base,
> LLVMValueRef value,
> unsigned file,
> unsigned chan_index,
> unsigned reg_index,
> const struct tgsi_ind_register *reg_indirect)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> - LLVMBuilderRef builder = gallivm->builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef ptr;
>
> ptr = get_pointer_into_array(ctx, file, chan_index, reg_index, reg_indirect);
> if (ptr) {
> LLVMBuildStore(builder, value, ptr);
> } else {
> unsigned i, size;
> struct tgsi_declaration_range range = get_array_range(bld_base, file, reg_index, reg_indirect);
> LLVMValueRef index = si_get_indirect_index(ctx, reg_indirect, 1, reg_index - range.First);
> LLVMValueRef array =
> @@ -555,21 +548,21 @@ get_output_ptr(struct lp_build_tgsi_context *bld_base, unsigned index,
> assert(index <= ctx->bld_base.info->file_max[TGSI_FILE_OUTPUT]);
> return ctx->outputs[index][chan];
> }
>
> LLVMValueRef si_llvm_emit_fetch(struct lp_build_tgsi_context *bld_base,
> const struct tgsi_full_src_register *reg,
> enum tgsi_opcode_type type,
> unsigned swizzle)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - LLVMBuilderRef builder = ctx->gallivm.builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef result = NULL, ptr, ptr2;
>
> if (swizzle == ~0) {
> LLVMValueRef values[TGSI_NUM_CHANNELS];
> unsigned chan;
> for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
> values[chan] = si_llvm_emit_fetch(bld_base, reg, type, chan);
> }
> return lp_build_gather_values(&ctx->gallivm, values,
> TGSI_NUM_CHANNELS);
> @@ -653,21 +646,21 @@ LLVMValueRef si_llvm_emit_fetch(struct lp_build_tgsi_context *bld_base,
>
> return bitcast(bld_base, type, result);
> }
>
> static LLVMValueRef fetch_system_value(struct lp_build_tgsi_context *bld_base,
> const struct tgsi_full_src_register *reg,
> enum tgsi_opcode_type type,
> unsigned swizzle)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - LLVMBuilderRef builder = ctx->gallivm.builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef cval = ctx->system_values[reg->Register.Index];
>
> if (tgsi_type_is_64bit(type)) {
> LLVMValueRef lo, hi;
>
> assert(swizzle == 0 || swizzle == 2);
>
> lo = LLVMBuildExtractElement(
> builder, cval, LLVMConstInt(ctx->i32, swizzle, 0), "");
> hi = LLVMBuildExtractElement(
> @@ -683,21 +676,21 @@ static LLVMValueRef fetch_system_value(struct lp_build_tgsi_context *bld_base,
> assert(swizzle == 0);
> }
>
> return bitcast(bld_base, type, cval);
> }
>
> static void emit_declaration(struct lp_build_tgsi_context *bld_base,
> const struct tgsi_full_declaration *decl)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - LLVMBuilderRef builder = ctx->gallivm.builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> unsigned first, last, i;
> switch(decl->Declaration.File) {
> case TGSI_FILE_ADDRESS:
> {
> unsigned idx;
> for (idx = decl->Range.First; idx <= decl->Range.Last; idx++) {
> unsigned chan;
> for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
> ctx->addrs[idx][chan] = lp_build_alloca_undef(
> &ctx->gallivm,
> @@ -865,39 +858,38 @@ static void emit_declaration(struct lp_build_tgsi_context *bld_base,
> }
> }
>
> void si_llvm_emit_store(struct lp_build_tgsi_context *bld_base,
> const struct tgsi_full_instruction *inst,
> const struct tgsi_opcode_info *info,
> unsigned index,
> LLVMValueRef dst[4])
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> const struct tgsi_full_dst_register *reg = &inst->Dst[index];
> - LLVMBuilderRef builder = ctx->gallivm.builder;
> + LLVMBuilderRef builder = ctx->ac.builder;
> LLVMValueRef temp_ptr, temp_ptr2 = NULL;
> bool is_vec_store = false;
> enum tgsi_opcode_type dtype = tgsi_opcode_infer_dst_type(inst->Instruction.Opcode, index);
>
> if (dst[0]) {
> LLVMTypeKind k = LLVMGetTypeKind(LLVMTypeOf(dst[0]));
> is_vec_store = (k == LLVMVectorTypeKind);
> }
>
> if (is_vec_store) {
> LLVMValueRef values[4] = {};
> uint32_t writemask = reg->Register.WriteMask;
> while (writemask) {
> unsigned chan = u_bit_scan(&writemask);
> LLVMValueRef index = LLVMConstInt(ctx->i32, chan, 0);
> - values[chan] = LLVMBuildExtractElement(gallivm->builder,
> + values[chan] = LLVMBuildExtractElement(ctx->ac.builder,
> dst[0], index, "");
> }
> bld_base->emit_store(bld_base, inst, info, index, values);
> return;
> }
>
> uint32_t writemask = reg->Register.WriteMask;
> while (writemask) {
> unsigned chan_index = u_bit_scan(&writemask);
> LLVMValueRef value = dst[chan_index];
> @@ -999,145 +991,137 @@ static void emit_default_branch(LLVMBuilderRef builder, LLVMBasicBlockRef target
> {
> if (!LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(builder)))
> LLVMBuildBr(builder, target);
> }
>
> static void bgnloop_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *flow = push_flow(ctx);
> flow->loop_entry_block = append_basic_block(ctx, "LOOP");
> flow->next_block = append_basic_block(ctx, "ENDLOOP");
> set_basicblock_name(flow->loop_entry_block, "loop", bld_base->pc);
> - LLVMBuildBr(gallivm->builder, flow->loop_entry_block);
> - LLVMPositionBuilderAtEnd(gallivm->builder, flow->loop_entry_block);
> + LLVMBuildBr(ctx->ac.builder, flow->loop_entry_block);
> + LLVMPositionBuilderAtEnd(ctx->ac.builder, flow->loop_entry_block);
> }
>
> static void brk_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *flow = get_innermost_loop(ctx);
>
> - LLVMBuildBr(gallivm->builder, flow->next_block);
> + LLVMBuildBr(ctx->ac.builder, flow->next_block);
> }
>
> static void cont_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *flow = get_innermost_loop(ctx);
>
> - LLVMBuildBr(gallivm->builder, flow->loop_entry_block);
> + LLVMBuildBr(ctx->ac.builder, flow->loop_entry_block);
> }
>
> static void else_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *current_branch = get_current_flow(ctx);
> LLVMBasicBlockRef endif_block;
>
> assert(!current_branch->loop_entry_block);
>
> endif_block = append_basic_block(ctx, "ENDIF");
> - emit_default_branch(gallivm->builder, endif_block);
> + emit_default_branch(ctx->ac.builder, endif_block);
>
> - LLVMPositionBuilderAtEnd(gallivm->builder, current_branch->next_block);
> + LLVMPositionBuilderAtEnd(ctx->ac.builder, current_branch->next_block);
> set_basicblock_name(current_branch->next_block, "else", bld_base->pc);
>
> current_branch->next_block = endif_block;
> }
>
> static void endif_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *current_branch = get_current_flow(ctx);
>
> assert(!current_branch->loop_entry_block);
>
> - emit_default_branch(gallivm->builder, current_branch->next_block);
> - LLVMPositionBuilderAtEnd(gallivm->builder, current_branch->next_block);
> + emit_default_branch(ctx->ac.builder, current_branch->next_block);
> + LLVMPositionBuilderAtEnd(ctx->ac.builder, current_branch->next_block);
> set_basicblock_name(current_branch->next_block, "endif", bld_base->pc);
>
> ctx->flow_depth--;
> }
>
> static void endloop_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *current_loop = get_current_flow(ctx);
>
> assert(current_loop->loop_entry_block);
>
> - emit_default_branch(gallivm->builder, current_loop->loop_entry_block);
> + emit_default_branch(ctx->ac.builder, current_loop->loop_entry_block);
>
> - LLVMPositionBuilderAtEnd(gallivm->builder, current_loop->next_block);
> + LLVMPositionBuilderAtEnd(ctx->ac.builder, current_loop->next_block);
> set_basicblock_name(current_loop->next_block, "endloop", bld_base->pc);
> ctx->flow_depth--;
> }
>
> static void if_cond_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data,
> LLVMValueRef cond)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = &ctx->gallivm;
> struct si_llvm_flow *flow = push_flow(ctx);
> LLVMBasicBlockRef if_block;
>
> if_block = append_basic_block(ctx, "IF");
> flow->next_block = append_basic_block(ctx, "ELSE");
> set_basicblock_name(if_block, "if", bld_base->pc);
> - LLVMBuildCondBr(gallivm->builder, cond, if_block, flow->next_block);
> - LLVMPositionBuilderAtEnd(gallivm->builder, if_block);
> + LLVMBuildCondBr(ctx->ac.builder, cond, if_block, flow->next_block);
> + LLVMPositionBuilderAtEnd(ctx->ac.builder, if_block);
> }
>
> static void if_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> - struct gallivm_state *gallivm = bld_base->base.gallivm;
> + struct si_shader_context *ctx = si_shader_context(bld_base);
> LLVMValueRef cond;
>
> - cond = LLVMBuildFCmp(gallivm->builder, LLVMRealUNE,
> + cond = LLVMBuildFCmp(ctx->ac.builder, LLVMRealUNE,
> emit_data->args[0],
> bld_base->base.zero, "");
>
> if_cond_emit(action, bld_base, emit_data, cond);
> }
>
> static void uif_emit(const struct lp_build_tgsi_action *action,
> struct lp_build_tgsi_context *bld_base,
> struct lp_build_emit_data *emit_data)
> {
> struct si_shader_context *ctx = si_shader_context(bld_base);
> - struct gallivm_state *gallivm = bld_base->base.gallivm;
> LLVMValueRef cond;
>
> - cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE,
> + cond = LLVMBuildICmp(ctx->ac.builder, LLVMIntNE,
> ac_to_integer(&ctx->ac, emit_data->args[0]), ctx->i32_0, "");
>
> if_cond_emit(action, bld_base, emit_data, cond);
> }
>
> static void emit_immediate(struct lp_build_tgsi_context *bld_base,
> const struct tgsi_full_immediate *imm)
> {
> unsigned i;
> struct si_shader_context *ctx = si_shader_context(bld_base);
> @@ -1327,21 +1311,21 @@ void si_llvm_create_func(struct si_shader_context *ctx,
> num_return_elems, true);
> else
> ret_type = LLVMVoidTypeInContext(ctx->gallivm.context);
>
> /* Setup the function */
> ctx->return_type = ret_type;
> main_fn_type = LLVMFunctionType(ret_type, ParamTypes, ParamCount, 0);
> ctx->main_fn = LLVMAddFunction(ctx->gallivm.module, name, main_fn_type);
> main_fn_body = LLVMAppendBasicBlockInContext(ctx->gallivm.context,
> ctx->main_fn, "main_body");
> - LLVMPositionBuilderAtEnd(ctx->gallivm.builder, main_fn_body);
> + LLVMPositionBuilderAtEnd(ctx->ac.builder, main_fn_body);
>
> real_shader_type = ctx->type;
>
> /* LS is merged into HS (TCS), and ES is merged into GS. */
> if (ctx->screen->b.chip_class >= GFX9) {
> if (ctx->shader->key.as_ls)
> real_shader_type = PIPE_SHADER_TESS_CTRL;
> else if (ctx->shader->key.as_es)
> real_shader_type = PIPE_SHADER_GEOMETRY;
> }
> @@ -1403,21 +1387,21 @@ void si_llvm_optimize_module(struct si_shader_context *ctx)
> LLVMAddCFGSimplificationPass(gallivm->passmgr);
> #if HAVE_LLVM >= 0x0400
> /* This is recommended by the instruction combining pass. */
> LLVMAddEarlyCSEMemSSAPass(gallivm->passmgr);
> #endif
> LLVMAddInstructionCombiningPass(gallivm->passmgr);
>
> /* Run the pass */
> LLVMRunPassManager(gallivm->passmgr, ctx->gallivm.module);
>
> - LLVMDisposeBuilder(gallivm->builder);
> + LLVMDisposeBuilder(ctx->ac.builder);
> LLVMDisposePassManager(gallivm->passmgr);
> gallivm_dispose_target_library_info(target_library_info);
> }
>
> void si_llvm_dispose(struct si_shader_context *ctx)
> {
> LLVMDisposeModule(ctx->gallivm.module);
> LLVMContextDispose(ctx->gallivm.context);
> FREE(ctx->temp_arrays);
> ctx->temp_arrays = NULL;
>
--
Lerne, wie die Welt wirklich ist,
Aber vergiss niemals, wie sie sein sollte.
More information about the mesa-dev
mailing list