LLVMValueRef buf_ptr = ac_get_arg(&ctx->ac, ctx->rw_buffers);
return ac_build_load_to_sgpr(&ctx->ac, buf_ptr,
- LLVMConstInt(ctx->i32, GFX10_GS_QUERY_BUF, false));
+ LLVMConstInt(ctx->ac.i32, GFX10_GS_QUERY_BUF, false));
}
static LLVMValueRef ngg_get_initial_edgeflag(struct si_shader_context *ctx, unsigned index)
LLVMConstInt(ctx->ac.i32, 8 + index, false), "");
return LLVMBuildTrunc(ctx->ac.builder, tmp, ctx->ac.i1, "");
}
- return ctx->i1false;
+ return ctx->ac.i1false;
}
/**
if (info->properties[TGSI_PROPERTY_VS_BLIT_SGPRS_AMD]) {
/* Blits always use axis-aligned rectangles with 3 vertices. */
*num_vertices = 3;
- return LLVMConstInt(ctx->i32, 3, 0);
+ return LLVMConstInt(ctx->ac.i32, 3, 0);
} else {
/* We always build up all three indices for the prim export
* independent of the primitive type. The additional garbage
/* Extract OUTPRIM field. */
LLVMValueRef num = si_unpack_param(ctx, ctx->vs_state_bits, 2, 2);
- return LLVMBuildAdd(ctx->ac.builder, num, ctx->i32_1, "");
+ return LLVMBuildAdd(ctx->ac.builder, num, ctx->ac.i32_1, "");
}
} else {
assert(ctx->type == PIPE_SHADER_TESS_EVAL);
else
*num_vertices = 3;
- return LLVMConstInt(ctx->i32, *num_vertices, false);
+ return LLVMConstInt(ctx->ac.i32, *num_vertices, false);
}
}
*/
if (ctx->shader->selector->info.writes_edgeflag) {
unsigned all_bits_no_edgeflags = ~SI_NGG_PRIM_EDGE_FLAG_BITS;
- LLVMValueRef edgeflags = LLVMConstInt(ctx->i32, all_bits_no_edgeflags, 0);
+ LLVMValueRef edgeflags = LLVMConstInt(ctx->ac.i32, all_bits_no_edgeflags, 0);
unsigned num_vertices;
ngg_get_vertices_per_prim(ctx, &num_vertices);
LLVMValueRef edge;
edge = LLVMBuildLoad(builder, user_edgeflags[i], "");
- edge = LLVMBuildZExt(builder, edge, ctx->i32, "");
- edge = LLVMBuildShl(builder, edge, LLVMConstInt(ctx->i32, shift, 0), "");
+ edge = LLVMBuildZExt(builder, edge, ctx->ac.i32, "");
+ edge = LLVMBuildShl(builder, edge, LLVMConstInt(ctx->ac.i32, shift, 0), "");
edgeflags = LLVMBuildOr(builder, edgeflags, edge, "");
}
prim.passthrough = LLVMBuildAnd(builder, prim.passthrough, edgeflags, "");
continue;
tmp = LLVMBuildMul(builder, offset_vtx,
- LLVMConstInt(ctx->i32, so->stride[buffer], false), "");
+ LLVMConstInt(ctx->ac.i32, so->stride[buffer], false), "");
tmp = LLVMBuildAdd(builder, wg_offset_dw[buffer], tmp, "");
- offset[buffer] = LLVMBuildShl(builder, tmp, LLVMConstInt(ctx->i32, 2, false), "");
+ offset[buffer] = LLVMBuildShl(builder, tmp, LLVMConstInt(ctx->ac.i32, 2, false), "");
}
for (unsigned i = 0; i < so->num_outputs; ++i) {
for (unsigned comp = 0; comp < 4; comp++) {
tmp = ac_build_gep0(&ctx->ac, vertexptr,
- LLVMConstInt(ctx->i32, 4 * reg + comp, false));
+ LLVMConstInt(ctx->ac.i32, 4 * reg + comp, false));
out.values[comp] = LLVMBuildLoad(builder, tmp, "");
out.vertex_stream[comp] =
(info->output_streams[reg] >> (2 * comp)) & 3;
LLVMValueRef buf_ptr = ac_get_arg(&ctx->ac, ctx->rw_buffers);
LLVMValueRef tid = get_thread_id_in_tg(ctx);
LLVMValueRef tmp, tmp2;
- LLVMValueRef i32_2 = LLVMConstInt(ctx->i32, 2, false);
- LLVMValueRef i32_4 = LLVMConstInt(ctx->i32, 4, false);
- LLVMValueRef i32_8 = LLVMConstInt(ctx->i32, 8, false);
+ LLVMValueRef i32_2 = LLVMConstInt(ctx->ac.i32, 2, false);
+ LLVMValueRef i32_4 = LLVMConstInt(ctx->ac.i32, 4, false);
+ LLVMValueRef i32_8 = LLVMConstInt(ctx->ac.i32, 8, false);
LLVMValueRef so_buffer[4] = {};
unsigned max_num_vertices = 1 + (nggso->vertices[1] ? 1 : 0) +
(nggso->vertices[2] ? 1 : 0);
LLVMValueRef prim_stride_dw[4] = {};
- LLVMValueRef prim_stride_dw_vgpr = LLVMGetUndef(ctx->i32);
+ LLVMValueRef prim_stride_dw_vgpr = LLVMGetUndef(ctx->ac.i32);
int stream_for_buffer[4] = { -1, -1, -1, -1 };
unsigned bufmask_for_stream[4] = {};
bool isgs = ctx->type == PIPE_SHADER_GEOMETRY;
unsigned scratch_emit_base = isgs ? 4 : 0;
- LLVMValueRef scratch_emit_basev = isgs ? i32_4 : ctx->i32_0;
+ LLVMValueRef scratch_emit_basev = isgs ? i32_4 : ctx->ac.i32_0;
unsigned scratch_offset_base = isgs ? 8 : 4;
LLVMValueRef scratch_offset_basev = isgs ? i32_8 : i32_4;
assert(so->stride[buffer]);
- tmp = LLVMConstInt(ctx->i32, so->stride[buffer], false);
+ tmp = LLVMConstInt(ctx->ac.i32, so->stride[buffer], false);
prim_stride_dw[buffer] = LLVMBuildMul(builder, tmp, nggso->num_vertices, "");
prim_stride_dw_vgpr = ac_build_writelane(
&ctx->ac, prim_stride_dw_vgpr, prim_stride_dw[buffer],
- LLVMConstInt(ctx->i32, buffer, false));
+ LLVMConstInt(ctx->ac.i32, buffer, false));
so_buffer[buffer] = ac_build_load_to_sgpr(
&ctx->ac, buf_ptr,
- LLVMConstInt(ctx->i32, SI_VS_STREAMOUT_BUF0 + buffer, false));
+ LLVMConstInt(ctx->ac.i32, SI_VS_STREAMOUT_BUF0 + buffer, false));
}
- tmp = LLVMBuildICmp(builder, LLVMIntEQ, get_wave_id_in_tg(ctx), ctx->i32_0, "");
+ tmp = LLVMBuildICmp(builder, LLVMIntEQ, get_wave_id_in_tg(ctx), ctx->ac.i32_0, "");
ac_build_ifcc(&ctx->ac, tmp, 5200);
{
- LLVMTypeRef gdsptr = LLVMPointerType(ctx->i32, AC_ADDR_SPACE_GDS);
- LLVMValueRef gdsbase = LLVMBuildIntToPtr(builder, ctx->i32_0, gdsptr, "");
+ LLVMTypeRef gdsptr = LLVMPointerType(ctx->ac.i32, AC_ADDR_SPACE_GDS);
+ LLVMValueRef gdsbase = LLVMBuildIntToPtr(builder, ctx->ac.i32_0, gdsptr, "");
/* Advance the streamout offsets in GDS. */
- LLVMValueRef offsets_vgpr = ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
- LLVMValueRef generated_by_stream_vgpr = ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
+ LLVMValueRef offsets_vgpr = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
+ LLVMValueRef generated_by_stream_vgpr = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
tmp = LLVMBuildICmp(builder, LLVMIntULT, ac_get_thread_id(&ctx->ac), i32_4, "");
ac_build_ifcc(&ctx->ac, tmp, 5210);
tmp = ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch, tid);
tmp = LLVMBuildLoad(builder, tmp, "");
} else {
- tmp = ac_build_writelane(&ctx->ac, ctx->i32_0,
- ngg_get_prim_cnt(ctx), ctx->i32_0);
+ tmp = ac_build_writelane(&ctx->ac, ctx->ac.i32_0,
+ ngg_get_prim_cnt(ctx), ctx->ac.i32_0);
}
LLVMBuildStore(builder, tmp, generated_by_stream_vgpr);
LLVMValueRef args[] = {
LLVMBuildIntToPtr(builder, ngg_get_ordered_id(ctx), gdsptr, ""),
tmp,
- ctx->i32_0, // ordering
- ctx->i32_0, // scope
+ ctx->ac.i32_0, // ordering
+ ctx->ac.i32_0, // scope
ctx->ac.i1false, // isVolatile
- LLVMConstInt(ctx->i32, 4 << 24, false), // OA index
+ LLVMConstInt(ctx->ac.i32, 4 << 24, false), // OA index
ctx->ac.i1true, // wave release
ctx->ac.i1true, // wave done
};
tmp = ac_build_intrinsic(&ctx->ac, "llvm.amdgcn.ds.ordered.add",
- ctx->i32, args, ARRAY_SIZE(args), 0);
+ ctx->ac.i32, args, ARRAY_SIZE(args), 0);
/* Keep offsets in a VGPR for quick retrieval via readlane by
* the first wave for bounds checking, and also store in LDS
tmp = LLVMBuildLoad(builder, offsets_vgpr, "");
LLVMValueRef offset_dw =
ac_build_readlane(&ctx->ac, tmp,
- LLVMConstInt(ctx->i32, buffer, false));
+ LLVMConstInt(ctx->ac.i32, buffer, false));
tmp = LLVMBuildSub(builder, bufsize_dw, offset_dw, "");
tmp = LLVMBuildUDiv(builder, tmp, prim_stride_dw[buffer], "");
tmp2 = LLVMBuildICmp(builder, LLVMIntULT, bufsize_dw, offset_dw, "");
- max_emit[buffer] = LLVMBuildSelect(builder, tmp2, ctx->i32_0, tmp, "");
+ max_emit[buffer] = LLVMBuildSelect(builder, tmp2, ctx->ac.i32_0, tmp, "");
}
/* Determine the number of emitted primitives per stream and fixup the
* This is complicated by the fact that a single stream can emit to
* multiple buffers (but luckily not vice versa).
*/
- LLVMValueRef emit_vgpr = ctx->i32_0;
+ LLVMValueRef emit_vgpr = ctx->ac.i32_0;
for (unsigned stream = 0; stream < 4; ++stream) {
if (!info->num_stream_output_components[stream])
tmp = LLVMBuildLoad(builder, generated_by_stream_vgpr, "");
LLVMValueRef generated =
ac_build_readlane(&ctx->ac, tmp,
- LLVMConstInt(ctx->i32, stream, false));
+ LLVMConstInt(ctx->ac.i32, stream, false));
LLVMValueRef emit = generated;
for (unsigned buffer = 0; buffer < 4; ++buffer) {
}
emit_vgpr = ac_build_writelane(&ctx->ac, emit_vgpr, emit,
- LLVMConstInt(ctx->i32, stream, false));
+ LLVMConstInt(ctx->ac.i32, stream, false));
/* Fixup the offset using a plain GDS atomic if we overflowed. */
tmp = LLVMBuildICmp(builder, LLVMIntULT, emit, generated, "");
ac_build_ifcc(&ctx->ac, tmp, 5221); /* scalar branch */
tmp = LLVMBuildLShr(builder,
- LLVMConstInt(ctx->i32, bufmask_for_stream[stream], false),
+ LLVMConstInt(ctx->ac.i32, bufmask_for_stream[stream], false),
ac_get_thread_id(&ctx->ac), "");
- tmp = LLVMBuildTrunc(builder, tmp, ctx->i1, "");
+ tmp = LLVMBuildTrunc(builder, tmp, ctx->ac.i1, "");
ac_build_ifcc(&ctx->ac, tmp, 5222);
{
tmp = LLVMBuildSub(builder, generated, emit, "");
primemit_scan[stream].src = nggso->prim_enable[stream];
primemit_scan[stream].scratch =
ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch,
- LLVMConstInt(ctx->i32, 12 + 8 * stream, false));
+ LLVMConstInt(ctx->ac.i32, 12 + 8 * stream, false));
primemit_scan[stream].waveidx = get_wave_id_in_tg(ctx);
primemit_scan[stream].numwaves = get_tgsize(ctx);
primemit_scan[stream].maxwaves = 8;
if (stream_for_buffer[buffer] >= 0) {
wgoffset_dw[buffer] = ac_build_readlane(
&ctx->ac, scratch_vgpr,
- LLVMConstInt(ctx->i32, scratch_offset_base + buffer, false));
+ LLVMConstInt(ctx->ac.i32, scratch_offset_base + buffer, false));
}
}
if (info->num_stream_output_components[stream]) {
nggso->emit[stream] = ac_build_readlane(
&ctx->ac, scratch_vgpr,
- LLVMConstInt(ctx->i32, scratch_emit_base + stream, false));
+ LLVMConstInt(ctx->ac.i32, scratch_emit_base + stream, false));
}
}
}
for (unsigned i = 0; i < max_num_vertices; ++i) {
tmp = LLVMBuildICmp(builder, LLVMIntULT,
- LLVMConstInt(ctx->i32, i, false),
+ LLVMConstInt(ctx->ac.i32, i, false),
nggso->num_vertices, "");
ac_build_ifcc(&ctx->ac, tmp, 5241);
build_streamout_vertex(ctx, so_buffer, wgoffset_dw,
stream, offset_vtx, nggso->vertices[i]);
ac_build_endif(&ctx->ac, 5241);
- offset_vtx = LLVMBuildAdd(builder, offset_vtx, ctx->i32_1, "");
+ offset_vtx = LLVMBuildAdd(builder, offset_vtx, ctx->ac.i32_1, "");
}
}
ac_build_endif(&ctx->ac, 5240);
LLVMValueRef ptr, unsigned byte_index)
{
assert(byte_index < 4);
- LLVMTypeRef pi8 = LLVMPointerType(ctx->i8, AC_ADDR_SPACE_LDS);
- LLVMValueRef index = LLVMConstInt(ctx->i32, byte_index, 0);
+ LLVMTypeRef pi8 = LLVMPointerType(ctx->ac.i8, AC_ADDR_SPACE_LDS);
+ LLVMValueRef index = LLVMConstInt(ctx->ac.i32, byte_index, 0);
return LLVMBuildGEP(ctx->ac.builder,
LLVMBuildPointerCast(ctx->ac.builder, ptr, pi8, ""),
{
/* The extra dword is used to avoid LDS bank conflicts. */
unsigned vertex_size = ngg_nogs_vertex_size(ctx->shader);
- LLVMTypeRef ai32 = LLVMArrayType(ctx->i32, vertex_size);
+ LLVMTypeRef ai32 = LLVMArrayType(ctx->ac.i32, vertex_size);
LLVMTypeRef pai32 = LLVMPointerType(ai32, AC_ADDR_SPACE_LDS);
LLVMValueRef tmp = LLVMBuildBitCast(ctx->ac.builder, ctx->esgs_ring, pai32, "");
return LLVMBuildGEP(ctx->ac.builder, tmp, &vtxid, 1, "");
{
LLVMBuilderRef builder = ctx->ac.builder;
LLVMValueRef ptr64 = LLVMBuildPointerCast(builder, lds_ptr,
- LLVMPointerType(LLVMArrayType(ctx->i64, 2),
+ LLVMPointerType(LLVMArrayType(ctx->ac.i64, 2),
AC_ADDR_SPACE_LDS), "");
for (unsigned i = 0; i < 2; i++) {
- LLVMValueRef index = LLVMConstInt(ctx->i32, dw_offset / 2 + i, 0);
+ LLVMValueRef index = LLVMConstInt(ctx->ac.i32, dw_offset / 2 + i, 0);
mask[i] = LLVMBuildLoad(builder, ac_build_gep0(&ctx->ac, ptr64, index), "");
}
/* Update the total thread count. */
unsigned tg_info_mask = ~(u_bit_consecutive(0, tg_info_num_bits) << tg_info_shift);
*tg_info = LLVMBuildAnd(builder, *tg_info,
- LLVMConstInt(ctx->i32, tg_info_mask, 0), "");
+ LLVMConstInt(ctx->ac.i32, tg_info_mask, 0), "");
*tg_info = LLVMBuildOr(builder, *tg_info,
LLVMBuildShl(builder, *new_num_threads,
- LLVMConstInt(ctx->i32, tg_info_shift, 0), ""), "");
+ LLVMConstInt(ctx->ac.i32, tg_info_shift, 0), ""), "");
/* Update the per-wave thread count. */
LLVMValueRef prev_threads = LLVMBuildMul(builder, get_wave_id_in_tg(ctx),
- LLVMConstInt(ctx->i32, ctx->ac.wave_size, 0), "");
+ LLVMConstInt(ctx->ac.i32, ctx->ac.wave_size, 0), "");
*new_num_threads = LLVMBuildSub(builder, *new_num_threads, prev_threads, "");
- *new_num_threads = ac_build_imax(&ctx->ac, *new_num_threads, ctx->i32_0);
+ *new_num_threads = ac_build_imax(&ctx->ac, *new_num_threads, ctx->ac.i32_0);
*new_num_threads = ac_build_imin(&ctx->ac, *new_num_threads,
- LLVMConstInt(ctx->i32, ctx->ac.wave_size, 0));
+ LLVMConstInt(ctx->ac.i32, ctx->ac.wave_size, 0));
unsigned wave_info_mask = ~(u_bit_consecutive(0, wave_info_num_bits) << wave_info_shift);
*wave_info = LLVMBuildAnd(builder, *wave_info,
- LLVMConstInt(ctx->i32, wave_info_mask, 0), "");
+ LLVMConstInt(ctx->ac.i32, wave_info_mask, 0), "");
*wave_info = LLVMBuildOr(builder, *wave_info,
LLVMBuildShl(builder, *new_num_threads,
- LLVMConstInt(ctx->i32, wave_info_shift, 0), ""), "");
+ LLVMConstInt(ctx->ac.i32, wave_info_shift, 0), ""), "");
}
/**
for (unsigned chan = 0; chan < 4; chan++) {
LLVMBuildStore(builder, ac_to_integer(&ctx->ac, position[chan]),
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_pos_x + chan, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_pos_x + chan, 0)));
}
/* Store Position.XY / W into LDS. */
for (unsigned chan = 0; chan < 2; chan++) {
LLVMValueRef val = ac_build_fdiv(&ctx->ac, position[chan], position[3]);
LLVMBuildStore(builder, ac_to_integer(&ctx->ac, val),
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_pos_x_div_w + chan, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_pos_x_div_w + chan, 0)));
}
/* Store VertexID and InstanceID. ES threads will have to load them
*/
bool uses_instance_id = false;
bool uses_tes_prim_id = false;
- LLVMValueRef packed_data = ctx->i32_0;
+ LLVMValueRef packed_data = ctx->ac.i32_0;
if (ctx->type == PIPE_SHADER_VERTEX) {
uses_instance_id = sel->info.uses_instanceid ||
LLVMBuildStore(builder, ctx->abi.vertex_id,
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_vertex_id, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_vertex_id, 0)));
if (uses_instance_id) {
LLVMBuildStore(builder, ctx->abi.instance_id,
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_instance_id, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_instance_id, 0)));
}
} else {
uses_tes_prim_id = sel->info.uses_primid ||
assert(ctx->type == PIPE_SHADER_TESS_EVAL);
LLVMBuildStore(builder, ac_to_integer(&ctx->ac, ac_get_arg(&ctx->ac, ctx->tes_u)),
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_tes_u, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_tes_u, 0)));
LLVMBuildStore(builder, ac_to_integer(&ctx->ac, ac_get_arg(&ctx->ac, ctx->tes_v)),
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_tes_v, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_tes_v, 0)));
packed_data = LLVMBuildShl(builder, ac_get_arg(&ctx->ac, ctx->tes_rel_patch_id),
- LLVMConstInt(ctx->i32, lds_byte2_tes_rel_patch_id * 8, 0), "");
+ LLVMConstInt(ctx->ac.i32, lds_byte2_tes_rel_patch_id * 8, 0), "");
if (uses_tes_prim_id) {
LLVMBuildStore(builder, ac_get_arg(&ctx->ac, ctx->args.tes_patch_id),
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_tes_patch_id, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_tes_patch_id, 0)));
}
}
/* Initialize the packed data. */
LLVMBuildStore(builder, packed_data,
ac_build_gep0(&ctx->ac, es_vtxptr,
- LLVMConstInt(ctx->i32, lds_packed_data, 0)));
+ LLVMConstInt(ctx->ac.i32, lds_packed_data, 0)));
ac_build_endif(&ctx->ac, ctx->merged_wrap_if_label);
LLVMValueRef tid = ac_get_thread_id(&ctx->ac);
*/
ac_build_ifcc(&ctx->ac,
LLVMBuildICmp(builder, LLVMIntULT, get_thread_id_in_tg(ctx),
- LLVMConstInt(ctx->i32, 3, 0), ""), 16101);
+ LLVMConstInt(ctx->ac.i32, 3, 0), ""), 16101);
{
- LLVMValueRef index = LLVMBuildAdd(builder, tid, ctx->i32_1, "");
- LLVMBuildStore(builder, ctx->i32_0,
+ LLVMValueRef index = LLVMBuildAdd(builder, tid, ctx->ac.i32_1, "");
+ LLVMBuildStore(builder, ctx->ac.i32_0,
ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch, index));
}
ac_build_endif(&ctx->ac, 16101);
};
es_vtxptr = ngg_nogs_vertex_ptr(ctx, get_thread_id_in_tg(ctx));
- LLVMValueRef gs_accepted = ac_build_alloca(&ctx->ac, ctx->i32, "");
+ LLVMValueRef gs_accepted = ac_build_alloca(&ctx->ac, ctx->ac.i32, "");
/* Do culling in GS threads. */
ac_build_ifcc(&ctx->ac, si_is_gs_thread(ctx), 16002);
continue;
LLVMValueRef addr = ac_build_gep0(&ctx->ac, gs_vtxptr[vtx],
- LLVMConstInt(ctx->i32, index, 0));
+ LLVMConstInt(ctx->ac.i32, index, 0));
pos[vtx][chan] = LLVMBuildLoad(builder, addr, "");
pos[vtx][chan] = ac_to_float(&ctx->ac, pos[vtx][chan]);
}
/* Load the viewport state for small prim culling. */
LLVMValueRef vp = ac_build_load_invariant(&ctx->ac,
ac_get_arg(&ctx->ac, ctx->small_prim_cull_info),
- ctx->i32_0);
- vp = LLVMBuildBitCast(builder, vp, ctx->v4f32, "");
+ ctx->ac.i32_0);
+ vp = LLVMBuildBitCast(builder, vp, ctx->ac.v4f32, "");
LLVMValueRef vp_scale[2], vp_translate[2];
vp_scale[0] = ac_llvm_extract_elem(&ctx->ac, vp, 0);
vp_scale[1] = ac_llvm_extract_elem(&ctx->ac, vp, 1);
/* Get the small prim filter precision. */
LLVMValueRef small_prim_precision = si_unpack_param(ctx, ctx->vs_state_bits, 7, 4);
small_prim_precision = LLVMBuildOr(builder, small_prim_precision,
- LLVMConstInt(ctx->i32, 0x70, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0x70, 0), "");
small_prim_precision = LLVMBuildShl(builder, small_prim_precision,
- LLVMConstInt(ctx->i32, 23, 0), "");
- small_prim_precision = LLVMBuildBitCast(builder, small_prim_precision, ctx->f32, "");
+ LLVMConstInt(ctx->ac.i32, 23, 0), "");
+ small_prim_precision = LLVMBuildBitCast(builder, small_prim_precision, ctx->ac.f32, "");
/* Execute culling code. */
struct ac_cull_options options = {};
options.cull_w = true;
/* Tell ES threads whether their vertex survived. */
- ac_build_ifcc(&ctx->ac, ac_cull_triangle(&ctx->ac, pos, ctx->i1true,
+ ac_build_ifcc(&ctx->ac, ac_cull_triangle(&ctx->ac, pos, ctx->ac.i1true,
vp_scale, vp_translate,
small_prim_precision, &options), 16003);
{
gs_accepted = LLVMBuildLoad(builder, gs_accepted, "");
- LLVMValueRef es_accepted = ac_build_alloca(&ctx->ac, ctx->i1, "");
+ LLVMValueRef es_accepted = ac_build_alloca(&ctx->ac, ctx->ac.i1, "");
/* Convert the per-vertex flag to a thread bitmask in ES threads and store it in LDS. */
ac_build_ifcc(&ctx->ac, si_is_es_thread(ctx), 16007);
LLVMBuildStore(builder, es_accepted_bool, es_accepted);
ac_build_ifcc(&ctx->ac, LLVMBuildICmp(builder, LLVMIntEQ,
- tid, ctx->i32_0, ""), 16008);
+ tid, ctx->ac.i32_0, ""), 16008);
{
LLVMBuildStore(builder, es_mask,
ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch,
LLVMValueRef old_id = get_thread_id_in_tg(ctx);
LLVMValueRef new_id = ac_prefix_bitcount_2x64(&ctx->ac, es_mask, old_id);
- LLVMBuildStore(builder, LLVMBuildTrunc(builder, old_id, ctx->i8, ""),
+ LLVMBuildStore(builder, LLVMBuildTrunc(builder, old_id, ctx->ac.i8, ""),
si_build_gep_i8(ctx, ngg_nogs_vertex_ptr(ctx, new_id),
lds_byte0_old_thread_id));
- LLVMBuildStore(builder, LLVMBuildTrunc(builder, new_id, ctx->i8, ""),
+ LLVMBuildStore(builder, LLVMBuildTrunc(builder, new_id, ctx->ac.i8, ""),
si_build_gep_i8(ctx, es_vtxptr, lds_byte1_new_thread_id));
}
ac_build_endif(&ctx->ac, 16009);
kill_wave = LLVMBuildICmp(builder, LLVMIntULE,
ac_build_imax(&ctx->ac, new_num_es_threads, ngg_get_prim_cnt(ctx)),
LLVMBuildMul(builder, get_wave_id_in_tg(ctx),
- LLVMConstInt(ctx->i32, ctx->ac.wave_size, 0), ""), "");
+ LLVMConstInt(ctx->ac.i32, ctx->ac.wave_size, 0), ""), "");
ac_build_ifcc(&ctx->ac, kill_wave, 19202);
{
/* If we are killing wave 0, send that there are no primitives
* in this threadgroup.
*/
ac_build_sendmsg_gs_alloc_req(&ctx->ac, get_wave_id_in_tg(ctx),
- ctx->i32_0, ctx->i32_0);
+ ctx->ac.i32_0, ctx->ac.i32_0);
ac_build_s_endpgm(&ctx->ac);
}
ac_build_endif(&ctx->ac, 19202);
&new_merged_wave_info, 8, 0);
/* Update vertex indices in VGPR0 (same format as NGG passthrough). */
- LLVMValueRef new_vgpr0 = ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
+ LLVMValueRef new_vgpr0 = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
/* Set the null flag at the beginning (culled), and then
* overwrite it for accepted primitives.
*/
- LLVMBuildStore(builder, LLVMConstInt(ctx->i32, 1u << 31, 0), new_vgpr0);
+ LLVMBuildStore(builder, LLVMConstInt(ctx->ac.i32, 1u << 31, 0), new_vgpr0);
/* Get vertex indices after vertex compaction. */
- ac_build_ifcc(&ctx->ac, LLVMBuildTrunc(builder, gs_accepted, ctx->i1, ""), 16011);
+ ac_build_ifcc(&ctx->ac, LLVMBuildTrunc(builder, gs_accepted, ctx->ac.i1, ""), 16011);
{
struct ac_ngg_prim prim = {};
prim.num_vertices = 3;
- prim.isnull = ctx->i1false;
+ prim.isnull = ctx->ac.i1false;
for (unsigned vtx = 0; vtx < 3; vtx++) {
prim.index[vtx] =
LLVMBuildLoad(builder,
si_build_gep_i8(ctx, gs_vtxptr[vtx],
lds_byte1_new_thread_id), "");
- prim.index[vtx] = LLVMBuildZExt(builder, prim.index[vtx], ctx->i32, "");
+ prim.index[vtx] = LLVMBuildZExt(builder, prim.index[vtx], ctx->ac.i32, "");
prim.edgeflag[vtx] = ngg_get_initial_edgeflag(ctx, vtx);
}
/* Set the new ES input VGPRs. */
LLVMValueRef es_data[4];
- LLVMValueRef old_thread_id = ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
+ LLVMValueRef old_thread_id = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
for (unsigned i = 0; i < 4; i++)
- es_data[i] = ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
+ es_data[i] = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
ac_build_ifcc(&ctx->ac, LLVMBuildICmp(ctx->ac.builder, LLVMIntULT, tid,
new_num_es_threads, ""), 16012);
/* Load ES input VGPRs from the ES thread before compaction. */
old_id = LLVMBuildLoad(builder,
si_build_gep_i8(ctx, es_vtxptr, lds_byte0_old_thread_id), "");
- old_id = LLVMBuildZExt(builder, old_id, ctx->i32, "");
+ old_id = LLVMBuildZExt(builder, old_id, ctx->ac.i32, "");
LLVMBuildStore(builder, old_id, old_thread_id);
old_es_vtxptr = ngg_nogs_vertex_ptr(ctx, old_id);
for (unsigned i = 0; i < 2; i++) {
tmp = LLVMBuildLoad(builder,
ac_build_gep0(&ctx->ac, old_es_vtxptr,
- LLVMConstInt(ctx->i32, lds_vertex_id + i, 0)), "");
+ LLVMConstInt(ctx->ac.i32, lds_vertex_id + i, 0)), "");
LLVMBuildStore(builder, tmp, es_data[i]);
}
tmp = LLVMBuildLoad(builder,
si_build_gep_i8(ctx, old_es_vtxptr,
lds_byte2_tes_rel_patch_id), "");
- tmp = LLVMBuildZExt(builder, tmp, ctx->i32, "");
+ tmp = LLVMBuildZExt(builder, tmp, ctx->ac.i32, "");
LLVMBuildStore(builder, tmp, es_data[2]);
if (uses_tes_prim_id) {
tmp = LLVMBuildLoad(builder,
ac_build_gep0(&ctx->ac, old_es_vtxptr,
- LLVMConstInt(ctx->i32, lds_tes_patch_id, 0)), "");
+ LLVMConstInt(ctx->ac.i32, lds_tes_patch_id, 0)), "");
LLVMBuildStore(builder, tmp, es_data[3]);
}
}
*/
if (sel->so.num_outputs) {
tmp = ac_build_gep0(&ctx->ac, vertex_ptr,
- LLVMConstInt(ctx->i32, 4 * i + j, false));
+ LLVMConstInt(ctx->ac.i32, 4 * i + j, false));
tmp2 = LLVMBuildLoad(builder, addrs[4 * i + j], "");
tmp2 = ac_to_integer(&ctx->ac, tmp2);
LLVMBuildStore(builder, tmp2, tmp);
sel->info.writes_edgeflag) {
LLVMValueRef edgeflag = LLVMBuildLoad(builder, addrs[4 * i], "");
/* The output is a float, but the hw expects a 1-bit integer. */
- edgeflag = LLVMBuildFPToUI(ctx->ac.builder, edgeflag, ctx->i32, "");
- edgeflag = ac_build_umin(&ctx->ac, edgeflag, ctx->i32_1);
+ edgeflag = LLVMBuildFPToUI(ctx->ac.builder, edgeflag, ctx->ac.i32, "");
+ edgeflag = ac_build_umin(&ctx->ac, edgeflag, ctx->ac.i32_1);
- tmp = LLVMConstInt(ctx->i32, ngg_nogs_vertex_size(ctx->shader) - 1, 0);
+ tmp = LLVMConstInt(ctx->ac.i32, ngg_nogs_vertex_size(ctx->shader) - 1, 0);
tmp = ac_build_gep0(&ctx->ac, vertex_ptr, tmp);
LLVMBuildStore(builder, edgeflag, tmp);
}
/* Load edge flags from ES threads and store them into VGPRs in GS threads. */
for (unsigned i = 0; i < num_vertices; i++) {
tmp = ngg_nogs_vertex_ptr(ctx, vtxindex[i]);
- tmp2 = LLVMConstInt(ctx->i32, ngg_nogs_vertex_size(ctx->shader) - 1, 0);
+ tmp2 = LLVMConstInt(ctx->ac.i32, ngg_nogs_vertex_size(ctx->shader) - 1, 0);
tmp = ac_build_gep0(&ctx->ac, tmp, tmp2);
tmp = LLVMBuildLoad(builder, tmp, "");
- tmp = LLVMBuildTrunc(builder, tmp, ctx->i1, "");
+ tmp = LLVMBuildTrunc(builder, tmp, ctx->ac.i1, "");
- user_edgeflags[i] = ac_build_alloca_undef(&ctx->ac, ctx->i1, "");
+ user_edgeflags[i] = ac_build_alloca_undef(&ctx->ac, ctx->ac.i1, "");
LLVMBuildStore(builder, tmp, user_edgeflags[i]);
}
ac_build_endif(&ctx->ac, 5400);
LLVMValueRef vertex_ptr = ngg_nogs_vertex_ptr(ctx, provoking_vtx_index);
LLVMBuildStore(builder, ac_get_arg(&ctx->ac, ctx->args.gs_prim_id),
- ac_build_gep0(&ctx->ac, vertex_ptr, ctx->i32_0));
+ ac_build_gep0(&ctx->ac, vertex_ptr, ctx->ac.i32_0));
ac_build_endif(&ctx->ac, 5400);
}
assert(!unterminated_es_if_block);
tmp = si_unpack_param(ctx, ctx->vs_state_bits, 6, 1);
- tmp = LLVMBuildTrunc(builder, tmp, ctx->i1, "");
+ tmp = LLVMBuildTrunc(builder, tmp, ctx->ac.i1, "");
ac_build_ifcc(&ctx->ac, tmp, 5029); /* if (STREAMOUT_QUERY_ENABLED) */
tmp = LLVMBuildICmp(builder, LLVMIntEQ, get_wave_id_in_tg(ctx), ctx->ac.i32_0, "");
ac_build_ifcc(&ctx->ac, tmp, 5030);
LLVMValueRef args[] = {
ngg_get_prim_cnt(ctx),
ngg_get_query_buf(ctx),
- LLVMConstInt(ctx->i32, 16, false), /* offset of stream[0].generated_primitives */
- ctx->i32_0, /* soffset */
- ctx->i32_0, /* cachepolicy */
+ LLVMConstInt(ctx->ac.i32, 16, false), /* offset of stream[0].generated_primitives */
+ ctx->ac.i32_0, /* soffset */
+ ctx->ac.i32_0, /* cachepolicy */
};
if (sel->so.num_outputs) {
- args[0] = ac_build_writelane(&ctx->ac, args[0], emitted_prims, ctx->i32_1);
+ args[0] = ac_build_writelane(&ctx->ac, args[0], emitted_prims, ctx->ac.i32_1);
args[2] = ac_build_writelane(&ctx->ac, args[2],
- LLVMConstInt(ctx->i32, 24, false), ctx->i32_1);
+ LLVMConstInt(ctx->ac.i32, 24, false), ctx->ac.i32_1);
}
/* TODO: should this be 64-bit atomics? */
ac_build_intrinsic(&ctx->ac, "llvm.amdgcn.raw.buffer.atomic.add.i32",
- ctx->i32, args, 5, 0);
+ ctx->ac.i32, args, 5, 0);
}
ac_build_endif(&ctx->ac, 5031);
ac_build_endif(&ctx->ac, 5030);
ac_get_arg(&ctx->ac, ctx->ngg_old_thread_id));
for (unsigned j = 0; j < 4; j++) {
- tmp = LLVMConstInt(ctx->i32, lds_pos_x + j, 0);
+ tmp = LLVMConstInt(ctx->ac.i32, lds_pos_x + j, 0);
tmp = ac_build_gep0(&ctx->ac, vertex_ptr, tmp);
tmp = LLVMBuildLoad(builder, tmp, "");
outputs[i].values[j] = ac_to_float(&ctx->ac, tmp);
ac_build_s_barrier(&ctx->ac);
tmp = ngg_nogs_vertex_ptr(ctx, get_thread_id_in_tg(ctx));
- tmp = ac_build_gep0(&ctx->ac, tmp, ctx->i32_0);
+ tmp = ac_build_gep0(&ctx->ac, tmp, ctx->ac.i32_0);
outputs[i].values[0] = LLVMBuildLoad(builder, tmp, "");
} else {
assert(ctx->type == PIPE_SHADER_TESS_EVAL);
outputs[i].values[0] = ac_to_float(&ctx->ac, outputs[i].values[0]);
for (unsigned j = 1; j < 4; j++)
- outputs[i].values[j] = LLVMGetUndef(ctx->f32);
+ outputs[i].values[j] = LLVMGetUndef(ctx->ac.f32);
memset(outputs[i].vertex_stream, 0,
sizeof(outputs[i].vertex_stream));
*/
const LLVMValueRef can_emit =
LLVMBuildICmp(builder, LLVMIntULT, vertexidx,
- LLVMConstInt(ctx->i32, sel->gs_max_out_vertices, false), "");
+ LLVMConstInt(ctx->ac.i32, sel->gs_max_out_vertices, false), "");
tmp = LLVMBuildAdd(builder, vertexidx, ctx->ac.i32_1, "");
tmp = LLVMBuildSelect(builder, can_emit, tmp, vertexidx, "");
* track which primitive is odd and swap vertex indices to get
* the correct vertex order.
*/
- LLVMValueRef is_odd = ctx->i1false;
+ LLVMValueRef is_odd = ctx->ac.i1false;
if (stream == 0 && u_vertices_per_prim(sel->gs_output_prim) == 3) {
- tmp = LLVMBuildAnd(builder, curverts, ctx->i32_1, "");
- is_odd = LLVMBuildICmp(builder, LLVMIntEQ, tmp, ctx->i32_1, "");
+ tmp = LLVMBuildAnd(builder, curverts, ctx->ac.i32_1, "");
+ is_odd = LLVMBuildICmp(builder, LLVMIntEQ, tmp, ctx->ac.i32_1, "");
}
tmp = LLVMBuildAdd(builder, curverts, ctx->ac.i32_1, "");
LLVMValueRef tid = get_thread_id_in_tg(ctx);
LLVMValueRef tmp;
- tmp = LLVMBuildICmp(builder, LLVMIntULT, tid, LLVMConstInt(ctx->i32, 4, false), "");
+ tmp = LLVMBuildICmp(builder, LLVMIntULT, tid, LLVMConstInt(ctx->ac.i32, 4, false), "");
ac_build_ifcc(&ctx->ac, tmp, 5090);
{
LLVMValueRef ptr = ac_build_gep0(&ctx->ac, scratchptr, tid);
- LLVMBuildStore(builder, ctx->i32_0, ptr);
+ LLVMBuildStore(builder, ctx->ac.i32_0, ptr);
}
ac_build_endif(&ctx->ac, 5090);
LLVMBuildLoad(builder, ctx->gs_generated_prims[stream], "");
numprims = ac_build_reduce(&ctx->ac, numprims, nir_op_iadd, ctx->ac.wave_size);
- tmp = LLVMBuildICmp(builder, LLVMIntEQ, ac_get_thread_id(&ctx->ac), ctx->i32_0, "");
+ tmp = LLVMBuildICmp(builder, LLVMIntEQ, ac_get_thread_id(&ctx->ac), ctx->ac.i32_0, "");
ac_build_ifcc(&ctx->ac, tmp, 5105);
{
LLVMBuildAtomicRMW(builder, LLVMAtomicRMWBinOpAdd,
ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch,
- LLVMConstInt(ctx->i32, stream, false)),
+ LLVMConstInt(ctx->ac.i32, stream, false)),
numprims, LLVMAtomicOrderingMonotonic, false);
}
ac_build_endif(&ctx->ac, 5105);
if (sel->so.num_outputs) {
struct ngg_streamout nggso = {};
- nggso.num_vertices = LLVMConstInt(ctx->i32, verts_per_prim, false);
+ nggso.num_vertices = LLVMConstInt(ctx->ac.i32, verts_per_prim, false);
LLVMValueRef vertexptr = ngg_gs_vertex_ptr(ctx, tid);
for (unsigned stream = 0; stream < 4; ++stream) {
continue;
tmp = LLVMBuildLoad(builder, ngg_gs_get_emit_primflag_ptr(ctx, vertexptr, stream), "");
- tmp = LLVMBuildTrunc(builder, tmp, ctx->i1, "");
+ tmp = LLVMBuildTrunc(builder, tmp, ctx->ac.i1, "");
tmp2 = LLVMBuildICmp(builder, LLVMIntULT, tid, num_emit_threads, "");
nggso.prim_enable[stream] = LLVMBuildAnd(builder, tmp, tmp2, "");
}
for (unsigned i = 0; i < verts_per_prim; ++i) {
tmp = LLVMBuildSub(builder, tid,
- LLVMConstInt(ctx->i32, verts_per_prim - i - 1, false), "");
+ LLVMConstInt(ctx->ac.i32, verts_per_prim - i - 1, false), "");
tmp = ngg_gs_vertex_ptr(ctx, tmp);
- nggso.vertices[i] = ac_build_gep0(&ctx->ac, tmp, ctx->i32_0);
+ nggso.vertices[i] = ac_build_gep0(&ctx->ac, tmp, ctx->ac.i32_0);
}
build_streamout(ctx, &nggso);
/* Write shader query data. */
if (ctx->screen->use_ngg_streamout) {
tmp = si_unpack_param(ctx, ctx->vs_state_bits, 6, 1);
- tmp = LLVMBuildTrunc(builder, tmp, ctx->i1, "");
+ tmp = LLVMBuildTrunc(builder, tmp, ctx->ac.i1, "");
ac_build_ifcc(&ctx->ac, tmp, 5109); /* if (STREAMOUT_QUERY_ENABLED) */
unsigned num_query_comps = sel->so.num_outputs ? 8 : 4;
tmp = LLVMBuildICmp(builder, LLVMIntULT, tid,
- LLVMConstInt(ctx->i32, num_query_comps, false), "");
+ LLVMConstInt(ctx->ac.i32, num_query_comps, false), "");
ac_build_ifcc(&ctx->ac, tmp, 5110);
{
LLVMValueRef offset;
tmp = tid;
if (sel->so.num_outputs)
- tmp = LLVMBuildAnd(builder, tmp, LLVMConstInt(ctx->i32, 3, false), "");
- offset = LLVMBuildNUWMul(builder, tmp, LLVMConstInt(ctx->i32, 32, false), "");
+ tmp = LLVMBuildAnd(builder, tmp, LLVMConstInt(ctx->ac.i32, 3, false), "");
+ offset = LLVMBuildNUWMul(builder, tmp, LLVMConstInt(ctx->ac.i32, 32, false), "");
if (sel->so.num_outputs) {
- tmp = LLVMBuildLShr(builder, tid, LLVMConstInt(ctx->i32, 2, false), "");
- tmp = LLVMBuildNUWMul(builder, tmp, LLVMConstInt(ctx->i32, 8, false), "");
+ tmp = LLVMBuildLShr(builder, tid, LLVMConstInt(ctx->ac.i32, 2, false), "");
+ tmp = LLVMBuildNUWMul(builder, tmp, LLVMConstInt(ctx->ac.i32, 8, false), "");
offset = LLVMBuildAdd(builder, offset, tmp, "");
}
tmp,
ngg_get_query_buf(ctx),
offset,
- LLVMConstInt(ctx->i32, 16, false), /* soffset */
- ctx->i32_0, /* cachepolicy */
+ LLVMConstInt(ctx->ac.i32, 16, false), /* soffset */
+ ctx->ac.i32_0, /* cachepolicy */
};
ac_build_intrinsic(&ctx->ac, "llvm.amdgcn.raw.buffer.atomic.add.i32",
- ctx->i32, args, 5, 0);
+ ctx->ac.i32, args, 5, 0);
}
ac_build_endif(&ctx->ac, 5110);
ac_build_endif(&ctx->ac, 5109);
vertlive_scan.enable_reduce = true;
vertlive_scan.enable_exclusive = true;
vertlive_scan.src = vertlive;
- vertlive_scan.scratch = ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch, ctx->i32_0);
+ vertlive_scan.scratch = ac_build_gep0(&ctx->ac, ctx->gs_ngg_scratch, ctx->ac.i32_0);
vertlive_scan.waveidx = get_wave_id_in_tg(ctx);
vertlive_scan.numwaves = get_tgsize(ctx);
vertlive_scan.maxwaves = 8;
tmp = ngg_gs_vertex_ptr(ctx, tid);
flags = LLVMBuildLoad(builder, ngg_gs_get_emit_primflag_ptr(ctx, tmp, 0), "");
- prim.isnull = LLVMBuildNot(builder, LLVMBuildTrunc(builder, flags, ctx->i1, ""), "");
+ prim.isnull = LLVMBuildNot(builder, LLVMBuildTrunc(builder, flags, ctx->ac.i1, ""), "");
for (unsigned i = 0; i < verts_per_prim; ++i) {
prim.index[i] = LLVMBuildSub(builder, vertlive_scan.result_exclusive,
/* Geometry shaders output triangle strips, but NGG expects triangles. */
if (verts_per_prim == 3) {
LLVMValueRef is_odd = LLVMBuildLShr(builder, flags, ctx->ac.i8_1, "");
- is_odd = LLVMBuildTrunc(builder, is_odd, ctx->i1, "");
+ is_odd = LLVMBuildTrunc(builder, is_odd, ctx->ac.i1, "");
LLVMValueRef flatshade_first =
LLVMBuildICmp(builder, LLVMIntEQ,
si_unpack_param(ctx, ctx->vs_state_bits, 4, 2),
- ctx->i32_0, "");
+ ctx->ac.i32_0, "");
ac_build_triangle_strip_indices_to_triangle(&ctx->ac, is_odd,
flatshade_first,
{
LLVMValueRef args[] = {
LLVMBuildIntToPtr(ctx->ac.builder, m0,
- LLVMPointerType(ctx->i32, AC_ADDR_SPACE_GDS), ""),
+ LLVMPointerType(ctx->ac.i32, AC_ADDR_SPACE_GDS), ""),
value,
- LLVMConstInt(ctx->i32, LLVMAtomicOrderingMonotonic, 0), /* ordering */
- ctx->i32_0, /* scope */
- ctx->i1false, /* volatile */
- LLVMConstInt(ctx->i32, ordered_count_index, 0),
- LLVMConstInt(ctx->i1, release, 0),
- LLVMConstInt(ctx->i1, done, 0),
+ LLVMConstInt(ctx->ac.i32, LLVMAtomicOrderingMonotonic, 0), /* ordering */
+ ctx->ac.i32_0, /* scope */
+ ctx->ac.i1false, /* volatile */
+ LLVMConstInt(ctx->ac.i32, ordered_count_index, 0),
+ LLVMConstInt(ctx->ac.i1, release, 0),
+ LLVMConstInt(ctx->ac.i1, done, 0),
};
char intrinsic[64];
snprintf(intrinsic, sizeof(intrinsic), "llvm.amdgcn.ds.ordered.%s", opcode);
- return ac_build_intrinsic(&ctx->ac, intrinsic, ctx->i32, args, ARRAY_SIZE(args), 0);
+ return ac_build_intrinsic(&ctx->ac, intrinsic, ctx->ac.i32, args, ARRAY_SIZE(args), 0);
}
static LLVMValueRef si_expand_32bit_pointer(struct si_shader_context *ctx, LLVMValueRef ptr)
{
uint64_t hi = (uint64_t)ctx->screen->info.address32_hi << 32;
- ptr = LLVMBuildZExt(ctx->ac.builder, ptr, ctx->i64, "");
- ptr = LLVMBuildOr(ctx->ac.builder, ptr, LLVMConstInt(ctx->i64, hi, 0), "");
+ ptr = LLVMBuildZExt(ctx->ac.builder, ptr, ctx->ac.i64, "");
+ ptr = LLVMBuildOr(ctx->ac.builder, ptr, LLVMConstInt(ctx->ac.i64, hi, 0), "");
return LLVMBuildIntToPtr(ctx->ac.builder, ptr,
- LLVMPointerType(ctx->i32, AC_ADDR_SPACE_GLOBAL), "");
+ LLVMPointerType(ctx->ac.i32, AC_ADDR_SPACE_GLOBAL), "");
}
struct si_thread0_section {
LLVMValueRef thread_id)
{
section->ctx = ctx;
- section->vgpr_result = ac_build_alloca_undef(&ctx->ac, ctx->i32, "result0");
+ section->vgpr_result = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "result0");
/* This IF has 4 instructions:
* v_and_b32_e32 v, 63, v ; get the thread ID
*/
ac_build_ifcc(&ctx->ac,
LLVMBuildICmp(ctx->ac.builder, LLVMIntEQ, thread_id,
- ctx->i32_0, ""), 12601);
+ ctx->ac.i32_0, ""), 12601);
}
/* Exit a section that only executes on thread 0 and broadcast the result
vs_params[num_vs_params++] = LLVMGetUndef(LLVMTypeOf(LLVMGetParam(vs, 1))); /* BINDLESS */
vs_params[num_vs_params++] = ac_get_arg(&ctx->ac, param_const_desc);
vs_params[num_vs_params++] = ac_get_arg(&ctx->ac, param_sampler_desc);
- vs_params[num_vs_params++] = LLVMConstInt(ctx->i32,
+ vs_params[num_vs_params++] = LLVMConstInt(ctx->ac.i32,
S_VS_STATE_INDEXED(key->opt.cs_indexed), 0);
vs_params[num_vs_params++] = ac_get_arg(&ctx->ac, param_base_vertex);
vs_params[num_vs_params++] = ac_get_arg(&ctx->ac, param_start_instance);
- vs_params[num_vs_params++] = ctx->i32_0; /* DrawID */
+ vs_params[num_vs_params++] = ctx->ac.i32_0; /* DrawID */
vs_params[num_vs_params++] = ac_get_arg(&ctx->ac, param_vb_desc);
vs_params[(param_vertex_id = num_vs_params++)] = NULL; /* VertexID */
vs_params[(param_instance_id = num_vs_params++)] = NULL; /* InstanceID */
- vs_params[num_vs_params++] = ctx->i32_0; /* unused (PrimID) */
- vs_params[num_vs_params++] = ctx->i32_0; /* unused */
+ vs_params[num_vs_params++] = ctx->ac.i32_0; /* unused (PrimID) */
+ vs_params[num_vs_params++] = ctx->ac.i32_0; /* unused */
assert(num_vs_params <= ARRAY_SIZE(vs_params));
assert(num_vs_params == LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(vs))));
LLVMValueRef index_buffers_and_constants = ac_get_arg(&ctx->ac, param_index_buffers_and_constants);
tmp = LLVMBuildPointerCast(builder, index_buffers_and_constants,
- ac_array_in_const32_addr_space(ctx->v8i32), "");
- tmp = ac_build_load_to_sgpr(&ctx->ac, tmp, ctx->i32_0);
+ ac_array_in_const32_addr_space(ctx->ac.v8i32), "");
+ tmp = ac_build_load_to_sgpr(&ctx->ac, tmp, ctx->ac.i32_0);
for (unsigned i = 0; i < 8; i++)
desc[i] = ac_llvm_extract_elem(&ctx->ac, tmp, i);
/* Compute PrimID and InstanceID. */
LLVMValueRef global_thread_id =
ac_build_imad(&ctx->ac, ac_get_arg(&ctx->ac, param_block_id),
- LLVMConstInt(ctx->i32, THREADGROUP_SIZE, 0),
+ LLVMConstInt(ctx->ac.i32, THREADGROUP_SIZE, 0),
ac_get_arg(&ctx->ac, param_local_id));
LLVMValueRef prim_id = global_thread_id; /* PrimID within an instance */
- LLVMValueRef instance_id = ctx->i32_0;
+ LLVMValueRef instance_id = ctx->ac.i32_0;
if (key->opt.cs_instancing) {
LLVMValueRef num_prims_udiv_terms =
ac_get_arg(&ctx->ac, param_num_prims_udiv_multiplier);
/* Unpack num_prims_udiv_terms. */
LLVMValueRef post_shift = LLVMBuildAnd(builder, num_prims_udiv_terms,
- LLVMConstInt(ctx->i32, 0x1f, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0x1f, 0), "");
LLVMValueRef prims_per_instance = LLVMBuildLShr(builder, num_prims_udiv_terms,
- LLVMConstInt(ctx->i32, 5, 0), "");
+ LLVMConstInt(ctx->ac.i32, 5, 0), "");
/* Divide the total prim_id by the number of prims per instance. */
instance_id = ac_build_fast_udiv_u31_d_not_one(&ctx->ac, prim_id,
num_prims_udiv_multiplier,
}
/* Generate indices (like a non-indexed draw call). */
- LLVMValueRef index[4] = {NULL, NULL, NULL, LLVMGetUndef(ctx->i32)};
+ LLVMValueRef index[4] = {NULL, NULL, NULL, LLVMGetUndef(ctx->ac.i32)};
unsigned vertices_per_prim = 3;
switch (key->opt.cs_prim_type) {
case PIPE_PRIM_TRIANGLES:
for (unsigned i = 0; i < 3; i++) {
index[i] = ac_build_imad(&ctx->ac, prim_id,
- LLVMConstInt(ctx->i32, 3, 0),
- LLVMConstInt(ctx->i32, i, 0));
+ LLVMConstInt(ctx->ac.i32, 3, 0),
+ LLVMConstInt(ctx->ac.i32, i, 0));
}
break;
case PIPE_PRIM_TRIANGLE_STRIP:
for (unsigned i = 0; i < 3; i++) {
index[i] = LLVMBuildAdd(builder, prim_id,
- LLVMConstInt(ctx->i32, i, 0), "");
+ LLVMConstInt(ctx->ac.i32, i, 0), "");
}
break;
case PIPE_PRIM_TRIANGLE_FAN:
* gl_VertexID is preserved, because it's equal to the index.
*/
if (key->opt.cs_provoking_vertex_first) {
- index[0] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->i32, 1, 0), "");
- index[1] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->i32, 2, 0), "");
- index[2] = ctx->i32_0;
+ index[0] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->ac.i32, 1, 0), "");
+ index[1] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->ac.i32, 2, 0), "");
+ index[2] = ctx->ac.i32_0;
} else {
- index[0] = ctx->i32_0;
- index[1] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->i32, 1, 0), "");
- index[2] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->i32, 2, 0), "");
+ index[0] = ctx->ac.i32_0;
+ index[1] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->ac.i32, 1, 0), "");
+ index[2] = LLVMBuildAdd(builder, prim_id, LLVMConstInt(ctx->ac.i32, 2, 0), "");
}
break;
default:
if (key->opt.cs_indexed) {
for (unsigned i = 0; i < 3; i++) {
index[i] = ac_build_buffer_load_format(&ctx->ac, input_indexbuf,
- index[i], ctx->i32_0, 1,
+ index[i], ctx->ac.i32_0, 1,
0, true);
index[i] = ac_to_integer(&ctx->ac, index[i]);
}
/* Extract the ordered wave ID. */
if (VERTEX_COUNTER_GDS_MODE == 2) {
ordered_wave_id = LLVMBuildLShr(builder, ordered_wave_id,
- LLVMConstInt(ctx->i32, 6, 0), "");
+ LLVMConstInt(ctx->ac.i32, 6, 0), "");
ordered_wave_id = LLVMBuildAnd(builder, ordered_wave_id,
- LLVMConstInt(ctx->i32, 0xfff, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0xfff, 0), "");
}
LLVMValueRef thread_id =
LLVMBuildAnd(builder, ac_get_arg(&ctx->ac, param_local_id),
- LLVMConstInt(ctx->i32, 63, 0), "");
+ LLVMConstInt(ctx->ac.i32, 63, 0), "");
/* Every other triangle in a strip has a reversed vertex order, so we
* need to swap vertices of odd primitives to get the correct primitive
* orientation when converting triangle strips to triangles. Primitive
* restart complicates it, because a strip can start anywhere.
*/
- LLVMValueRef prim_restart_accepted = ctx->i1true;
+ LLVMValueRef prim_restart_accepted = ctx->ac.i1true;
LLVMValueRef vertex_counter = ac_get_arg(&ctx->ac, param_vertex_counter);
if (key->opt.cs_prim_type == PIPE_PRIM_TRIANGLE_STRIP) {
* Only primitive restart can flip it with respect to the first vertex
* of the draw call.
*/
- LLVMValueRef first_is_odd = ctx->i1false;
+ LLVMValueRef first_is_odd = ctx->ac.i1false;
/* Handle primitive restart. */
if (key->opt.cs_primitive_restart) {
*/
LLVMValueRef gds_prim_restart_continue =
LLVMBuildLShr(builder, vertex_counter,
- LLVMConstInt(ctx->i32, 31, 0), "");
+ LLVMConstInt(ctx->ac.i32, 31, 0), "");
gds_prim_restart_continue =
- LLVMBuildTrunc(builder, gds_prim_restart_continue, ctx->i1, "");
+ LLVMBuildTrunc(builder, gds_prim_restart_continue, ctx->ac.i1, "");
vertex_counter = LLVMBuildAnd(builder, vertex_counter,
- LLVMConstInt(ctx->i32, 0x7fffffff, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0x7fffffff, 0), "");
LLVMValueRef index0_is_reset;
LLVMValueRef preceding_threads_mask =
LLVMBuildSub(builder,
LLVMBuildShl(builder, ctx->ac.i64_1,
- LLVMBuildZExt(builder, thread_id, ctx->i64, ""), ""),
+ LLVMBuildZExt(builder, thread_id, ctx->ac.i64, ""), ""),
ctx->ac.i64_1, "");
LLVMValueRef reset_threadmask = ac_get_i1_sgpr_mask(&ctx->ac, index0_is_reset);
LLVMBuildAnd(builder, reset_threadmask, preceding_threads_mask, "");
LLVMValueRef strip_start =
ac_build_umsb(&ctx->ac, preceding_reset_threadmask, NULL);
- strip_start = LLVMBuildAdd(builder, strip_start, ctx->i32_1, "");
+ strip_start = LLVMBuildAdd(builder, strip_start, ctx->ac.i32_1, "");
/* This flips the orientatino based on reset indices within this wave only. */
- first_is_odd = LLVMBuildTrunc(builder, strip_start, ctx->i1, "");
+ first_is_odd = LLVMBuildTrunc(builder, strip_start, ctx->ac.i1, "");
LLVMValueRef last_strip_start, prev_wave_state, ret, tmp;
LLVMValueRef is_first_wave, current_wave_resets_index;
* be 64.
*/
last_strip_start = ac_build_umsb(&ctx->ac, reset_threadmask, NULL);
- last_strip_start = LLVMBuildAdd(builder, last_strip_start, ctx->i32_1, "");
+ last_strip_start = LLVMBuildAdd(builder, last_strip_start, ctx->ac.i32_1, "");
struct si_thread0_section section;
si_enter_thread0_section(ctx, §ion, thread_id);
* NOTE: This will need to be different if we wanna support
* instancing with primitive restart.
*/
- is_first_wave = LLVMBuildICmp(builder, LLVMIntEQ, prim_id, ctx->i32_0, "");
+ is_first_wave = LLVMBuildICmp(builder, LLVMIntEQ, prim_id, ctx->ac.i32_0, "");
is_first_wave = LLVMBuildAnd(builder, is_first_wave,
LLVMBuildNot(builder,
gds_prim_restart_continue, ""), "");
current_wave_resets_index = LLVMBuildICmp(builder, LLVMIntNE,
- last_strip_start, ctx->i32_0, "");
+ last_strip_start, ctx->ac.i32_0, "");
- ret = ac_build_alloca_undef(&ctx->ac, ctx->i32, "prev_state");
+ ret = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "prev_state");
/* Save the last strip start primitive index in GDS and read
* the value that previous waves stored.
{
/* Just read the value from GDS. */
tmp = si_build_ds_ordered_op(ctx, "add",
- ordered_wave_id, ctx->i32_0,
+ ordered_wave_id, ctx->ac.i32_0,
1, true, false);
LLVMBuildStore(builder, tmp, ret);
}
prev_wave_state = LLVMBuildLoad(builder, ret, "");
/* Ignore the return value if this is the first wave. */
prev_wave_state = LLVMBuildSelect(builder, is_first_wave,
- ctx->i32_0, prev_wave_state, "");
+ ctx->ac.i32_0, prev_wave_state, "");
si_exit_thread0_section(§ion, &prev_wave_state);
- prev_wave_state = LLVMBuildTrunc(builder, prev_wave_state, ctx->i1, "");
+ prev_wave_state = LLVMBuildTrunc(builder, prev_wave_state, ctx->ac.i1, "");
/* If the strip start appears to be on thread 0 for the current primitive
* (meaning the reset index is not present in this wave and might have
* the value from the current wave to determine primitive orientation.
*/
LLVMValueRef strip_start_is0 = LLVMBuildICmp(builder, LLVMIntEQ,
- strip_start, ctx->i32_0, "");
+ strip_start, ctx->ac.i32_0, "");
first_is_odd = LLVMBuildSelect(builder, strip_start_is0, prev_wave_state,
first_is_odd, "");
}
/* prim_is_odd = (first_is_odd + current_is_odd) % 2. */
LLVMValueRef prim_is_odd =
LLVMBuildXor(builder, first_is_odd,
- LLVMBuildTrunc(builder, thread_id, ctx->i1, ""), "");
+ LLVMBuildTrunc(builder, thread_id, ctx->ac.i1, ""), "");
/* Convert triangle strip indices to triangle indices. */
ac_build_triangle_strip_indices_to_triangle(&ctx->ac, prim_is_odd,
- LLVMConstInt(ctx->i1, key->opt.cs_provoking_vertex_first, 0),
+ LLVMConstInt(ctx->ac.i1, key->opt.cs_provoking_vertex_first, 0),
index);
}
/* Load the viewport state. */
LLVMValueRef vp = ac_build_load_invariant(&ctx->ac, index_buffers_and_constants,
- LLVMConstInt(ctx->i32, 2, 0));
- vp = LLVMBuildBitCast(builder, vp, ctx->v4f32, "");
+ LLVMConstInt(ctx->ac.i32, 2, 0));
+ vp = LLVMBuildBitCast(builder, vp, ctx->ac.v4f32, "");
LLVMValueRef vp_scale[2], vp_translate[2];
vp_scale[0] = ac_llvm_extract_elem(&ctx->ac, vp, 0);
vp_scale[1] = ac_llvm_extract_elem(&ctx->ac, vp, 1);
/* Count the number of active threads by doing bitcount(accepted). */
LLVMValueRef num_prims_accepted =
- ac_build_intrinsic(&ctx->ac, "llvm.ctpop.i64", ctx->i64,
+ ac_build_intrinsic(&ctx->ac, "llvm.ctpop.i64", ctx->ac.i64,
&accepted_threadmask, 1, AC_FUNC_ATTR_READNONE);
- num_prims_accepted = LLVMBuildTrunc(builder, num_prims_accepted, ctx->i32, "");
+ num_prims_accepted = LLVMBuildTrunc(builder, num_prims_accepted, ctx->ac.i32, "");
LLVMValueRef start;
{
if (VERTEX_COUNTER_GDS_MODE == 0) {
LLVMValueRef num_indices = LLVMBuildMul(builder, num_prims_accepted,
- LLVMConstInt(ctx->i32, vertices_per_prim, 0), "");
+ LLVMConstInt(ctx->ac.i32, vertices_per_prim, 0), "");
vertex_counter = si_expand_32bit_pointer(ctx, vertex_counter);
start = LLVMBuildAtomicRMW(builder, LLVMAtomicRMWBinOpAdd,
vertex_counter, num_indices,
LLVMAtomicOrderingMonotonic, false);
} else if (VERTEX_COUNTER_GDS_MODE == 1) {
LLVMValueRef num_indices = LLVMBuildMul(builder, num_prims_accepted,
- LLVMConstInt(ctx->i32, vertices_per_prim, 0), "");
+ LLVMConstInt(ctx->ac.i32, vertices_per_prim, 0), "");
vertex_counter = LLVMBuildIntToPtr(builder, vertex_counter,
- LLVMPointerType(ctx->i32, AC_ADDR_SPACE_GDS), "");
+ LLVMPointerType(ctx->ac.i32, AC_ADDR_SPACE_GDS), "");
start = LLVMBuildAtomicRMW(builder, LLVMAtomicRMWBinOpAdd,
vertex_counter, num_indices,
LLVMAtomicOrderingMonotonic, false);
} else if (VERTEX_COUNTER_GDS_MODE == 2) {
- LLVMValueRef tmp_store = ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
+ LLVMValueRef tmp_store = ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
/* If the draw call was split into multiple subdraws, each using
* a separate draw packet, we need to start counting from 0 for
/* The GDS address is always 0 with ordered append. */
si_build_ds_ordered_op(ctx, "swap", ordered_wave_id,
num_prims_accepted, 0, true, true);
- LLVMBuildStore(builder, ctx->i32_0, tmp_store);
+ LLVMBuildStore(builder, ctx->ac.i32_0, tmp_store);
}
ac_build_else(&ctx->ac, 12605);
{
12606);
LLVMValueRef count = LLVMBuildAdd(builder, start, num_prims_accepted, "");
count = LLVMBuildMul(builder, count,
- LLVMConstInt(ctx->i32, vertices_per_prim, 0), "");
+ LLVMConstInt(ctx->ac.i32, vertices_per_prim, 0), "");
/* GFX8 needs to disable caching, so that the CP can see the stored value.
* MTYPE=3 bypasses TC L2.
if (ctx->screen->info.chip_class <= GFX8) {
LLVMValueRef desc[] = {
ac_get_arg(&ctx->ac, param_vertex_count_addr),
- LLVMConstInt(ctx->i32,
+ LLVMConstInt(ctx->ac.i32,
S_008F04_BASE_ADDRESS_HI(ctx->screen->info.address32_hi), 0),
- LLVMConstInt(ctx->i32, 4, 0),
- LLVMConstInt(ctx->i32, S_008F0C_DATA_FORMAT(V_008F0C_BUF_DATA_FORMAT_32) |
+ LLVMConstInt(ctx->ac.i32, 4, 0),
+ LLVMConstInt(ctx->ac.i32, S_008F0C_DATA_FORMAT(V_008F0C_BUF_DATA_FORMAT_32) |
S_008F0C_MTYPE(3 /* uncached */), 0),
};
LLVMValueRef rsrc = ac_build_gather_values(&ctx->ac, desc, 4);
- ac_build_buffer_store_dword(&ctx->ac, rsrc, count, 1, ctx->i32_0,
- ctx->i32_0, 0, ac_glc | ac_slc);
+ ac_build_buffer_store_dword(&ctx->ac, rsrc, count, 1, ctx->ac.i32_0,
+ ctx->ac.i32_0, 0, ac_glc | ac_slc);
} else {
LLVMBuildStore(builder, count,
si_expand_32bit_pointer(ctx,
* primitive count, convert it into the primitive index.
*/
start = LLVMBuildUDiv(builder, start,
- LLVMConstInt(ctx->i32, vertices_per_prim, 0), "");
+ LLVMConstInt(ctx->ac.i32, vertices_per_prim, 0), "");
}
/* Now we need to store the indices of accepted primitives into
/* We have lowered instancing. Pack the instance ID into vertex ID. */
if (key->opt.cs_instancing) {
instance_id = LLVMBuildShl(builder, instance_id,
- LLVMConstInt(ctx->i32, 16, 0), "");
+ LLVMConstInt(ctx->ac.i32, 16, 0), "");
for (unsigned i = 0; i < vertices_per_prim; i++)
index[i] = LLVMBuildOr(builder, index[i], instance_id, "");
vdata = ac_build_expand_to_vec4(&ctx->ac, vdata, 3);
ac_build_buffer_store_format(&ctx->ac, output_indexbuf, vdata,
- vindex, ctx->i32_0, 3,
+ vindex, ctx->ac.i32_0, 3,
ac_glc | (INDEX_STORES_USE_SLC ? ac_slc : 0));
}
ac_build_endif(&ctx->ac, 16607);
if (rshift)
value = LLVMBuildLShr(ctx->ac.builder, value,
- LLVMConstInt(ctx->i32, rshift, 0), "");
+ LLVMConstInt(ctx->ac.i32, rshift, 0), "");
if (rshift + bitwidth < 32) {
unsigned mask = (1 << bitwidth) - 1;
value = LLVMBuildAnd(ctx->ac.builder, value,
- LLVMConstInt(ctx->i32, mask, 0), "");
+ LLVMConstInt(ctx->ac.i32, mask, 0), "");
}
return value;
if (index == 1)
return LLVMBuildAShr(ctx->ac.builder, i32,
- LLVMConstInt(ctx->i32, 16, 0), "");
+ LLVMConstInt(ctx->ac.i32, 16, 0), "");
return LLVMBuildSExt(ctx->ac.builder,
LLVMBuildTrunc(ctx->ac.builder, i32,
ctx->ac.i16, ""),
- ctx->i32, "");
+ ctx->ac.i32, "");
}
void si_llvm_load_input_vs(
LLVMValueRef vertex_id = ctx->abi.vertex_id;
LLVMValueRef sel_x1 = LLVMBuildICmp(ctx->ac.builder,
LLVMIntULE, vertex_id,
- ctx->i32_1, "");
+ ctx->ac.i32_1, "");
/* Use LLVMIntNE, because we have 3 vertices and only
* the middle one should use y2.
*/
LLVMValueRef sel_y1 = LLVMBuildICmp(ctx->ac.builder,
LLVMIntNE, vertex_id,
- ctx->i32_1, "");
+ ctx->ac.i32_1, "");
unsigned param_vs_blit_inputs = ctx->vs_blit_inputs.arg_index;
if (input_index == 0) {
LLVMValueRef y = LLVMBuildSelect(ctx->ac.builder, sel_y1,
y1, y2, "");
- out[0] = LLVMBuildSIToFP(ctx->ac.builder, x, ctx->f32, "");
- out[1] = LLVMBuildSIToFP(ctx->ac.builder, y, ctx->f32, "");
+ out[0] = LLVMBuildSIToFP(ctx->ac.builder, x, ctx->ac.f32, "");
+ out[1] = LLVMBuildSIToFP(ctx->ac.builder, y, ctx->ac.f32, "");
out[2] = LLVMGetParam(ctx->main_fn,
param_vs_blit_inputs + 2);
out[3] = ctx->ac.f32_1;
unsigned index= input_index - num_vbos_in_user_sgprs;
vb_desc = ac_build_load_to_sgpr(&ctx->ac,
ac_get_arg(&ctx->ac, ctx->vertex_buffers),
- LLVMConstInt(ctx->i32, index, 0));
+ LLVMConstInt(ctx->ac.i32, index, 0));
}
vertex_index = LLVMGetParam(ctx->main_fn,
fix_fetch.u.format, fix_fetch.u.reverse, !opencode,
vb_desc, vertex_index, ctx->ac.i32_0, ctx->ac.i32_0, 0, true);
for (unsigned i = 0; i < 4; ++i)
- out[i] = LLVMBuildExtractElement(ctx->ac.builder, tmp, LLVMConstInt(ctx->i32, i, false), "");
+ out[i] = LLVMBuildExtractElement(ctx->ac.builder, tmp, LLVMConstInt(ctx->ac.i32, i, false), "");
return;
}
}
for (unsigned i = 0; i < num_fetches; ++i) {
- LLVMValueRef voffset = LLVMConstInt(ctx->i32, fetch_stride * i, 0);
+ LLVMValueRef voffset = LLVMConstInt(ctx->ac.i32, fetch_stride * i, 0);
fetches[i] = ac_build_buffer_load_format(&ctx->ac, vb_desc, vertex_index, voffset,
channels_per_fetch, 0, true);
}
if (num_fetches == 1 && channels_per_fetch > 1) {
LLVMValueRef fetch = fetches[0];
for (unsigned i = 0; i < channels_per_fetch; ++i) {
- tmp = LLVMConstInt(ctx->i32, i, false);
+ tmp = LLVMConstInt(ctx->ac.i32, i, false);
fetches[i] = LLVMBuildExtractElement(
ctx->ac.builder, fetch, tmp, "");
}
}
for (unsigned i = num_fetches; i < 4; ++i)
- fetches[i] = LLVMGetUndef(ctx->f32);
+ fetches[i] = LLVMGetUndef(ctx->ac.f32);
if (fix_fetch.u.log_size <= 1 && fix_fetch.u.num_channels_m1 == 2 &&
required_channels == 4) {
* convert it to a signed one.
*/
LLVMValueRef tmp = fetches[3];
- LLVMValueRef c30 = LLVMConstInt(ctx->i32, 30, 0);
+ LLVMValueRef c30 = LLVMConstInt(ctx->ac.i32, 30, 0);
/* First, recover the sign-extended signed integer value. */
if (fix_fetch.u.format == AC_FETCH_FORMAT_SSCALED)
- tmp = LLVMBuildFPToUI(ctx->ac.builder, tmp, ctx->i32, "");
+ tmp = LLVMBuildFPToUI(ctx->ac.builder, tmp, ctx->ac.i32, "");
else
tmp = ac_to_integer(&ctx->ac, tmp);
*/
tmp = LLVMBuildShl(ctx->ac.builder, tmp,
fix_fetch.u.format == AC_FETCH_FORMAT_SNORM ?
- LLVMConstInt(ctx->i32, 7, 0) : c30, "");
+ LLVMConstInt(ctx->ac.i32, 7, 0) : c30, "");
tmp = LLVMBuildAShr(ctx->ac.builder, tmp, c30, "");
/* Convert back to the right type. */
if (fix_fetch.u.format == AC_FETCH_FORMAT_SNORM) {
LLVMValueRef clamp;
- LLVMValueRef neg_one = LLVMConstReal(ctx->f32, -1.0);
- tmp = LLVMBuildSIToFP(ctx->ac.builder, tmp, ctx->f32, "");
+ LLVMValueRef neg_one = LLVMConstReal(ctx->ac.f32, -1.0);
+ tmp = LLVMBuildSIToFP(ctx->ac.builder, tmp, ctx->ac.f32, "");
clamp = LLVMBuildFCmp(ctx->ac.builder, LLVMRealULT, tmp, neg_one, "");
tmp = LLVMBuildSelect(ctx->ac.builder, clamp, neg_one, tmp, "");
} else if (fix_fetch.u.format == AC_FETCH_FORMAT_SSCALED) {
- tmp = LLVMBuildSIToFP(ctx->ac.builder, tmp, ctx->f32, "");
+ tmp = LLVMBuildSIToFP(ctx->ac.builder, tmp, ctx->ac.f32, "");
}
fetches[3] = tmp;
unsigned swizzle)
{
if (swizzle > 0)
- return ctx->i32_0;
+ return ctx->ac.i32_0;
switch (ctx->type) {
case PIPE_SHADER_VERTEX:
return ac_get_arg(&ctx->ac, ctx->args.gs_prim_id);
default:
assert(0);
- return ctx->i32_0;
+ return ctx->ac.i32_0;
}
}
ctx->vs_state_bits);
LLVMValueRef indexed;
- indexed = LLVMBuildLShr(ctx->ac.builder, vs_state, ctx->i32_1, "");
- indexed = LLVMBuildTrunc(ctx->ac.builder, indexed, ctx->i1, "");
+ indexed = LLVMBuildLShr(ctx->ac.builder, vs_state, ctx->ac.i32_1, "");
+ indexed = LLVMBuildTrunc(ctx->ac.builder, indexed, ctx->ac.i1, "");
return LLVMBuildSelect(ctx->ac.builder, indexed,
ac_get_arg(&ctx->ac, ctx->args.base_vertex),
- ctx->i32_0, "");
+ ctx->ac.i32_0, "");
}
static LLVMValueRef get_block_size(struct ac_shader_abi *abi)
};
for (i = 0; i < 3; ++i)
- values[i] = LLVMConstInt(ctx->i32, sizes[i], 0);
+ values[i] = LLVMConstInt(ctx->ac.i32, sizes[i], 0);
result = ac_build_gather_values(&ctx->ac, values, 3);
} else {
struct si_shader_selector *sel = ctx->shader->selector;
unsigned lds_size = sel->info.properties[TGSI_PROPERTY_CS_LOCAL_SIZE];
- LLVMTypeRef i8p = LLVMPointerType(ctx->i8, AC_ADDR_SPACE_LDS);
+ LLVMTypeRef i8p = LLVMPointerType(ctx->ac.i8, AC_ADDR_SPACE_LDS);
LLVMValueRef var;
assert(!ctx->ac.lds);
var = LLVMAddGlobalInAddressSpace(ctx->ac.module,
- LLVMArrayType(ctx->i8, lds_size),
+ LLVMArrayType(ctx->ac.i8, lds_size),
"compute_lds",
AC_ADDR_SPACE_LDS);
LLVMSetAlignment(var, 64 * 1024);
unsigned const_chan;
LLVMValueRef base_elt;
LLVMValueRef ptr = ac_get_arg(&ctx->ac, ctx->rw_buffers);
- LLVMValueRef constbuf_index = LLVMConstInt(ctx->i32,
+ LLVMValueRef constbuf_index = LLVMConstInt(ctx->ac.i32,
SI_VS_CONST_CLIP_PLANES, 0);
LLVMValueRef const_resource = ac_build_load_to_sgpr(&ctx->ac, ptr, constbuf_index);
args->out[0] =
args->out[1] =
args->out[2] =
- args->out[3] = LLVMConstReal(ctx->f32, 0.0f);
+ args->out[3] = LLVMConstReal(ctx->ac.f32, 0.0f);
/* Compute dot products of position and user clip plane vectors */
for (chan = 0; chan < 4; chan++) {
for (const_chan = 0; const_chan < 4; const_chan++) {
LLVMValueRef addr =
- LLVMConstInt(ctx->i32, ((reg_index * 4 + chan) * 4 +
+ LLVMConstInt(ctx->ac.i32, ((reg_index * 4 + chan) * 4 +
const_chan) * 4, 0);
base_elt = si_buffer_load_const(ctx, const_resource,
addr);
break;
}
/* as v4i32 (aligned to 4) */
- out[3] = LLVMGetUndef(ctx->i32);
+ out[3] = LLVMGetUndef(ctx->ac.i32);
/* fall through */
case 4: /* as v4i32 */
vdata = ac_build_gather_values(&ctx->ac, out, util_next_power_of_two(num_comps));
ac_build_buffer_store_dword(&ctx->ac, so_buffers[buf_idx],
vdata, num_comps,
so_write_offsets[buf_idx],
- ctx->i32_0,
+ ctx->ac.i32_0,
stream_out->dst_offset * 4, ac_glc | ac_slc);
}
if (!so->stride[i])
continue;
- LLVMValueRef offset = LLVMConstInt(ctx->i32,
+ LLVMValueRef offset = LLVMConstInt(ctx->ac.i32,
SI_VS_STREAMOUT_BUF0 + i, 0);
so_buffers[i] = ac_build_load_to_sgpr(&ctx->ac, buf_ptr, offset);
LLVMValueRef so_offset = ac_get_arg(&ctx->ac,
ctx->streamout_offset[i]);
- so_offset = LLVMBuildMul(builder, so_offset, LLVMConstInt(ctx->i32, 4, 0), "");
+ so_offset = LLVMBuildMul(builder, so_offset, LLVMConstInt(ctx->ac.i32, 4, 0), "");
so_write_offset[i] = ac_build_imad(&ctx->ac, so_write_index,
- LLVMConstInt(ctx->i32, so->stride[i]*4, 0),
+ LLVMConstInt(ctx->ac.i32, so->stride[i]*4, 0),
so_offset);
}
continue;
for (unsigned j = 0; j < 4; j++) {
- addr[i][j] = ac_build_alloca_undef(&ctx->ac, ctx->f32, "");
+ addr[i][j] = ac_build_alloca_undef(&ctx->ac, ctx->ac.f32, "");
LLVMBuildStore(ctx->ac.builder, outputs[i].values[j], addr[i][j]);
}
has_colors = true;
/* The state is in the first bit of the user SGPR. */
LLVMValueRef cond = ac_get_arg(&ctx->ac, ctx->vs_state_bits);
- cond = LLVMBuildTrunc(ctx->ac.builder, cond, ctx->i1, "");
+ cond = LLVMBuildTrunc(ctx->ac.builder, cond, ctx->ac.i1, "");
ac_build_ifcc(&ctx->ac, cond, 6502);
* with the first bit containing the edge flag. */
edgeflag_value = LLVMBuildFPToUI(ctx->ac.builder,
edgeflag_value,
- ctx->i32, "");
+ ctx->ac.i32, "");
edgeflag_value = ac_build_umin(&ctx->ac,
edgeflag_value,
- ctx->i32_1);
+ ctx->ac.i32_1);
/* The LLVM intrinsic expects a float. */
pos_args[1].out[1] = ac_to_float(&ctx->ac, edgeflag_value);
v = ac_to_integer(&ctx->ac, v);
v = LLVMBuildShl(ctx->ac.builder, v,
- LLVMConstInt(ctx->i32, 16, 0), "");
+ LLVMConstInt(ctx->ac.i32, 16, 0), "");
v = LLVMBuildOr(ctx->ac.builder, v,
ac_to_integer(&ctx->ac, pos_args[1].out[2]), "");
pos_args[1].out[2] = ac_to_float(&ctx->ac, v);
outputs[i].semantic_index = 0;
outputs[i].values[0] = ac_to_float(&ctx->ac, si_get_primitive_id(ctx, 0));
for (j = 1; j < 4; j++)
- outputs[i].values[j] = LLVMConstReal(ctx->f32, 0);
+ outputs[i].values[j] = LLVMConstReal(ctx->ac.f32, 0);
memset(outputs[i].vertex_stream, 0,
sizeof(outputs[i].vertex_stream));
/* Return values */
if (shader->key.opt.vs_as_prim_discard_cs) {
for (i = 0; i < 4; i++)
- returns[num_returns++] = ctx->f32; /* VGPRs */
+ returns[num_returns++] = ctx->ac.f32; /* VGPRs */
}
break;
* placed after the user SGPRs.
*/
for (i = 0; i < GFX6_TCS_NUM_USER_SGPR + 2; i++)
- returns[num_returns++] = ctx->i32; /* SGPRs */
+ returns[num_returns++] = ctx->ac.i32; /* SGPRs */
for (i = 0; i < 11; i++)
- returns[num_returns++] = ctx->f32; /* VGPRs */
+ returns[num_returns++] = ctx->ac.f32; /* VGPRs */
break;
case SI_SHADER_MERGED_VERTEX_TESSCTRL:
/* LS return values are inputs to the TCS main shader part. */
for (i = 0; i < 8 + GFX9_TCS_NUM_USER_SGPR; i++)
- returns[num_returns++] = ctx->i32; /* SGPRs */
+ returns[num_returns++] = ctx->ac.i32; /* SGPRs */
for (i = 0; i < 2; i++)
- returns[num_returns++] = ctx->f32; /* VGPRs */
+ returns[num_returns++] = ctx->ac.f32; /* VGPRs */
} else {
/* TCS return values are inputs to the TCS epilog.
*
* should be passed to the epilog.
*/
for (i = 0; i <= 8 + GFX9_SGPR_TCS_OUT_LAYOUT; i++)
- returns[num_returns++] = ctx->i32; /* SGPRs */
+ returns[num_returns++] = ctx->ac.i32; /* SGPRs */
for (i = 0; i < 11; i++)
- returns[num_returns++] = ctx->f32; /* VGPRs */
+ returns[num_returns++] = ctx->ac.f32; /* VGPRs */
}
break;
/* ES return values are inputs to GS. */
for (i = 0; i < 8 + num_user_sgprs; i++)
- returns[num_returns++] = ctx->i32; /* SGPRs */
+ returns[num_returns++] = ctx->ac.i32; /* SGPRs */
for (i = 0; i < num_vgprs; i++)
- returns[num_returns++] = ctx->f32; /* VGPRs */
+ returns[num_returns++] = ctx->ac.f32; /* VGPRs */
}
break;
PS_EPILOG_SAMPLEMASK_MIN_LOC + 1);
for (i = 0; i < num_return_sgprs; i++)
- returns[i] = ctx->i32;
+ returns[i] = ctx->ac.i32;
for (; i < num_returns; i++)
- returns[i] = ctx->f32;
+ returns[i] = ctx->ac.f32;
break;
case PIPE_SHADER_COMPUTE:
* own LDS-based lowering).
*/
ctx->ac.lds = LLVMAddGlobalInAddressSpace(
- ctx->ac.module, LLVMArrayType(ctx->i32, 0),
+ ctx->ac.module, LLVMArrayType(ctx->ac.i32, 0),
"__lds_end", AC_ADDR_SPACE_LDS);
LLVMSetAlignment(ctx->ac.lds, 256);
} else {
{
LLVMValueRef args[] = {
ac_get_arg(&ctx->ac, param),
- LLVMConstInt(ctx->i32, bitoffset, 0),
+ LLVMConstInt(ctx->ac.i32, bitoffset, 0),
};
ac_build_intrinsic(&ctx->ac,
"llvm.amdgcn.init.exec.from.input",
- ctx->voidt, args, 2, AC_FUNC_ATTR_CONVERGENT);
+ ctx->ac.voidt, args, 2, AC_FUNC_ATTR_CONVERGENT);
}
static bool si_vs_needs_prolog(const struct si_shader_selector *sel,
sel->info.tessfactors_are_def_in_all_invocs) {
for (unsigned i = 0; i < 6; i++) {
ctx->invoc0_tess_factors[i] =
- ac_build_alloca_undef(&ctx->ac, ctx->i32, "");
+ ac_build_alloca_undef(&ctx->ac, ctx->ac.i32, "");
}
}
if (ctx->type == PIPE_SHADER_GEOMETRY) {
for (unsigned i = 0; i < 4; i++) {
ctx->gs_next_vertex[i] =
- ac_build_alloca(&ctx->ac, ctx->i32, "");
+ ac_build_alloca(&ctx->ac, ctx->ac.i32, "");
}
if (shader->key.as_ngg) {
for (unsigned i = 0; i < 4; ++i) {
scratch_size = 44;
assert(!ctx->gs_ngg_scratch);
- LLVMTypeRef ai32 = LLVMArrayType(ctx->i32, scratch_size);
+ LLVMTypeRef ai32 = LLVMArrayType(ctx->ac.i32, scratch_size);
ctx->gs_ngg_scratch = LLVMAddGlobalInAddressSpace(ctx->ac.module,
ai32, "ngg_scratch", AC_ADDR_SPACE_LDS);
LLVMSetInitializer(ctx->gs_ngg_scratch, LLVMGetUndef(ai32));
LLVMSetAlignment(ctx->gs_ngg_scratch, 4);
ctx->gs_ngg_emit = LLVMAddGlobalInAddressSpace(ctx->ac.module,
- LLVMArrayType(ctx->i32, 0), "ngg_emit", AC_ADDR_SPACE_LDS);
+ LLVMArrayType(ctx->ac.i32, 0), "ngg_emit", AC_ADDR_SPACE_LDS);
LLVMSetLinkage(ctx->gs_ngg_emit, LLVMExternalLinkage);
LLVMSetAlignment(ctx->gs_ngg_emit, 4);
}
*/
if (!ctx->gs_ngg_scratch &&
(sel->so.num_outputs || shader->key.opt.ngg_culling)) {
- LLVMTypeRef asi32 = LLVMArrayType(ctx->i32, 8);
+ LLVMTypeRef asi32 = LLVMArrayType(ctx->ac.i32, 8);
ctx->gs_ngg_scratch = LLVMAddGlobalInAddressSpace(ctx->ac.module,
asi32, "ngg_scratch", AC_ADDR_SPACE_LDS);
LLVMSetInitializer(ctx->gs_ngg_scratch, LLVMGetUndef(asi32));
}
if (sel->force_correct_derivs_after_kill) {
- ctx->postponed_kill = ac_build_alloca_undef(&ctx->ac, ctx->i1, "");
+ ctx->postponed_kill = ac_build_alloca_undef(&ctx->ac, ctx->ac.i1, "");
/* true = don't kill. */
- LLVMBuildStore(ctx->ac.builder, ctx->i1true,
+ LLVMBuildStore(ctx->ac.builder, ctx->ac.i1true,
ctx->postponed_kill);
}
arg_type = AC_ARG_CONST_IMAGE_PTR;
else
assert(0);
- } else if (type == ctx->f32) {
+ } else if (type == ctx->ac.f32) {
arg_type = AC_ARG_CONST_FLOAT_PTR;
} else {
assert(0);
for (unsigned i = 0; i < ctx->args.arg_count; ++i) {
LLVMValueRef param = LLVMGetParam(ctx->main_fn, i);
LLVMTypeRef param_type = LLVMTypeOf(param);
- LLVMTypeRef out_type = ctx->args.args[i].file == AC_ARG_SGPR ? ctx->i32 : ctx->f32;
+ LLVMTypeRef out_type = ctx->args.args[i].file == AC_ARG_SGPR ? ctx->ac.i32 : ctx->ac.f32;
unsigned size = ac_get_type_size(param_type) / 4;
if (size == 1) {
if (LLVMGetTypeKind(param_type) == LLVMPointerTypeKind) {
- param = LLVMBuildPtrToInt(builder, param, ctx->i32, "");
- param_type = ctx->i32;
+ param = LLVMBuildPtrToInt(builder, param, ctx->ac.i32, "");
+ param_type = ctx->ac.i32;
}
if (param_type != out_type)
LLVMTypeRef vector_type = LLVMVectorType(out_type, size);
if (LLVMGetTypeKind(param_type) == LLVMPointerTypeKind) {
- param = LLVMBuildPtrToInt(builder, param, ctx->i64, "");
- param_type = ctx->i64;
+ param = LLVMBuildPtrToInt(builder, param, ctx->ac.i64, "");
+ param_type = ctx->ac.i64;
}
if (param_type != vector_type)
for (unsigned j = 0; j < size; ++j)
out[num_out++] = LLVMBuildExtractElement(
- builder, param, LLVMConstInt(ctx->i32, j, 0), "");
+ builder, param, LLVMConstInt(ctx->ac.i32, j, 0), "");
}
if (ctx->args.args[i].file == AC_ARG_SGPR)
LLVMValueRef ena, count = initial[3];
count = LLVMBuildAnd(builder, count,
- LLVMConstInt(ctx->i32, 0x7f, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0x7f, 0), "");
ena = LLVMBuildICmp(builder, LLVMIntULT,
ac_get_thread_id(&ctx->ac), count, "");
ac_build_ifcc(&ctx->ac, ena, 6506);
if (LLVMGetTypeKind(param_type) == LLVMPointerTypeKind) {
if (LLVMGetPointerAddressSpace(param_type) ==
AC_ADDR_SPACE_CONST_32BIT) {
- arg = LLVMBuildBitCast(builder, arg, ctx->i32, "");
+ arg = LLVMBuildBitCast(builder, arg, ctx->ac.i32, "");
arg = LLVMBuildIntToPtr(builder, arg, param_type, "");
} else {
- arg = LLVMBuildBitCast(builder, arg, ctx->i64, "");
+ arg = LLVMBuildBitCast(builder, arg, ctx->ac.i64, "");
arg = LLVMBuildIntToPtr(builder, arg, param_type, "");
}
} else {
assert(num_out < ARRAY_SIZE(out));
out[num_out++] = val;
- if (LLVMTypeOf(val) == ctx->i32) {
+ if (LLVMTypeOf(val) == ctx->ac.i32) {
assert(num_out_sgpr + 1 == num_out);
num_out_sgpr = num_out;
}
for (i = 0; i < key->vs_prolog.num_input_sgprs; i++) {
ac_add_arg(&ctx->args, AC_ARG_SGPR, 1, AC_ARG_INT,
&input_sgpr_param[i]);
- returns[num_returns++] = ctx->i32;
+ returns[num_returns++] = ctx->ac.i32;
}
struct ac_arg merged_wave_info = input_sgpr_param[3];
/* Preloaded VGPRs (outputs must be floats) */
for (i = 0; i < num_input_vgprs; i++) {
ac_add_arg(&ctx->args, AC_ARG_VGPR, 1, AC_ARG_INT, &input_vgpr_param[i]);
- returns[num_returns++] = ctx->f32;
+ returns[num_returns++] = ctx->ac.f32;
}
/* Vertex load indices. */
for (i = 0; i < key->vs_prolog.num_inputs; i++)
- returns[num_returns++] = ctx->f32;
+ returns[num_returns++] = ctx->ac.f32;
/* Create the function. */
si_llvm_create_func(ctx, "vs_prolog", returns, num_returns, 0);
LLVMValueRef has_hs_threads =
LLVMBuildICmp(ctx->ac.builder, LLVMIntNE,
si_unpack_param(ctx, input_sgpr_param[3], 8, 8),
- ctx->i32_0, "");
+ ctx->ac.i32_0, "");
for (i = 4; i > 0; --i) {
input_vgprs[i + 1] =
*/
if (key->vs_prolog.gs_fast_launch_tri_list) {
input_vgprs[0] = ac_build_imad(&ctx->ac, thread_id_in_tg, /* gs_vtx01_offset */
- LLVMConstInt(ctx->i32, 3, 0), /* Vertex 0 */
- LLVMConstInt(ctx->i32, 0, 0));
+ LLVMConstInt(ctx->ac.i32, 3, 0), /* Vertex 0 */
+ LLVMConstInt(ctx->ac.i32, 0, 0));
input_vgprs[1] = ac_build_imad(&ctx->ac, thread_id_in_tg, /* gs_vtx23_offset */
- LLVMConstInt(ctx->i32, 3, 0), /* Vertex 1 */
- LLVMConstInt(ctx->i32, 1, 0));
+ LLVMConstInt(ctx->ac.i32, 3, 0), /* Vertex 1 */
+ LLVMConstInt(ctx->ac.i32, 1, 0));
input_vgprs[4] = ac_build_imad(&ctx->ac, thread_id_in_tg, /* gs_vtx45_offset */
- LLVMConstInt(ctx->i32, 3, 0), /* Vertex 2 */
- LLVMConstInt(ctx->i32, 2, 0));
+ LLVMConstInt(ctx->ac.i32, 3, 0), /* Vertex 2 */
+ LLVMConstInt(ctx->ac.i32, 2, 0));
} else {
assert(key->vs_prolog.gs_fast_launch_tri_strip);
LLVMBuilderRef builder = ctx->ac.builder;
LLVMValueRef index[3] = {
thread_id_in_tg,
LLVMBuildAdd(builder, thread_id_in_tg,
- LLVMConstInt(ctx->i32, 1, 0), ""),
+ LLVMConstInt(ctx->ac.i32, 1, 0), ""),
LLVMBuildAdd(builder, thread_id_in_tg,
- LLVMConstInt(ctx->i32, 2, 0), ""),
+ LLVMConstInt(ctx->ac.i32, 2, 0), ""),
};
LLVMValueRef is_odd = LLVMBuildTrunc(ctx->ac.builder,
- thread_id_in_tg, ctx->i1, "");
+ thread_id_in_tg, ctx->ac.i1, "");
LLVMValueRef flatshade_first =
LLVMBuildICmp(builder, LLVMIntEQ,
si_unpack_param(ctx, ctx->vs_state_bits, 4, 2),
- ctx->i32_0, "");
+ ctx->ac.i32_0, "");
ac_build_triangle_strip_indices_to_triangle(&ctx->ac, is_odd,
flatshade_first, index);
}
/* Triangles always have all edge flags set initially. */
- input_vgprs[3] = LLVMConstInt(ctx->i32, 0x7 << 8, 0);
+ input_vgprs[3] = LLVMConstInt(ctx->ac.i32, 0x7 << 8, 0);
input_vgprs[2] = LLVMBuildAdd(ctx->ac.builder, input_vgprs[2],
thread_id_in_tg, ""); /* PrimID */
*/
if (key->vs_prolog.states.unpack_instance_id_from_vertex_id) {
ctx->abi.instance_id = LLVMBuildLShr(ctx->ac.builder, ctx->abi.vertex_id,
- LLVMConstInt(ctx->i32, 16, 0), "");
+ LLVMConstInt(ctx->ac.i32, 16, 0), "");
ctx->abi.vertex_id = LLVMBuildAnd(ctx->ac.builder, ctx->abi.vertex_id,
- LLVMConstInt(ctx->i32, 0xffff, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0xffff, 0), "");
}
/* Copy inputs to outputs. This should be no-op, as the registers match,
if (key->vs_prolog.states.instance_divisor_is_fetched) {
LLVMValueRef list = si_prolog_get_rw_buffers(ctx);
LLVMValueRef buf_index =
- LLVMConstInt(ctx->i32, SI_VS_CONST_INSTANCE_DIVISORS, 0);
+ LLVMConstInt(ctx->ac.i32, SI_VS_CONST_INSTANCE_DIVISORS, 0);
instance_divisor_constbuf =
ac_build_load_to_sgpr(&ctx->ac, list, buf_index);
}
for (unsigned j = 0; j < 4; j++) {
udiv_factors[j] =
si_buffer_load_const(ctx, instance_divisor_constbuf,
- LLVMConstInt(ctx->i32, i*16 + j*4, 0));
+ LLVMConstInt(ctx->ac.i32, i*16 + j*4, 0));
udiv_factors[j] = ac_to_integer(&ctx->ac, udiv_factors[j]);
}
/* The faster NUW version doesn't work when InstanceID == UINT_MAX.
LLVMValueRef gs_ngg_scratch;
LLVMValueRef postponed_kill;
LLVMValueRef return_value;
-
- LLVMTypeRef voidt;
- LLVMTypeRef i1;
- LLVMTypeRef i8;
- LLVMTypeRef i32;
- LLVMTypeRef i64;
- LLVMTypeRef i128;
- LLVMTypeRef f32;
- LLVMTypeRef v2i32;
- LLVMTypeRef v4i32;
- LLVMTypeRef v4f32;
- LLVMTypeRef v8i32;
-
- LLVMValueRef i32_0;
- LLVMValueRef i32_1;
- LLVMValueRef i1false;
- LLVMValueRef i1true;
};
static inline struct si_shader_context *
struct ac_llvm_compiler *compiler,
unsigned wave_size)
{
- /* Initialize the gallivm object:
- * We are only using the module, context, and builder fields of this struct.
- * This should be enough for us to be able to pass our gallivm struct to the
- * helper functions in the gallivm module.
- */
memset(ctx, 0, sizeof(*ctx));
ctx->screen = sscreen;
ctx->compiler = compiler;
sscreen->info.family,
AC_FLOAT_MODE_NO_SIGNED_ZEROS_FP_MATH,
wave_size, 64);
-
- ctx->voidt = LLVMVoidTypeInContext(ctx->ac.context);
- ctx->i1 = LLVMInt1TypeInContext(ctx->ac.context);
- ctx->i8 = LLVMInt8TypeInContext(ctx->ac.context);
- ctx->i32 = LLVMInt32TypeInContext(ctx->ac.context);
- ctx->i64 = LLVMInt64TypeInContext(ctx->ac.context);
- ctx->i128 = LLVMIntTypeInContext(ctx->ac.context, 128);
- ctx->f32 = LLVMFloatTypeInContext(ctx->ac.context);
- ctx->v2i32 = LLVMVectorType(ctx->i32, 2);
- ctx->v4i32 = LLVMVectorType(ctx->i32, 4);
- ctx->v4f32 = LLVMVectorType(ctx->f32, 4);
- ctx->v8i32 = LLVMVectorType(ctx->i32, 8);
-
- ctx->i32_0 = LLVMConstInt(ctx->i32, 0, 0);
- ctx->i32_1 = LLVMConstInt(ctx->i32, 1, 0);
- ctx->i1false = LLVMConstInt(ctx->i1, 0, 0);
- ctx->i1true = LLVMConstInt(ctx->i1, 1, 0);
}
/* Set the context to a certain shader. Can be called repeatedly
return_types,
num_return_elems, true);
else
- ret_type = ctx->voidt;
+ ret_type = ctx->ac.voidt;
real_shader_type = ctx->type;
{
LLVMBuilderRef builder = ctx->ac.builder;
LLVMValueRef ptr = ac_get_arg(&ctx->ac, param);
- ptr = LLVMBuildPtrToInt(builder, ptr, ctx->i32, "");
+ ptr = LLVMBuildPtrToInt(builder, ptr, ctx->ac.i32, "");
return LLVMBuildInsertValue(builder, ret, ptr, return_index, "");
}
ptr[0] = LLVMGetParam(ctx->main_fn, (merged_shader ? 8 : 0) + SI_SGPR_RW_BUFFERS);
list = LLVMBuildIntToPtr(ctx->ac.builder, ptr[0],
- ac_array_in_const32_addr_space(ctx->v4i32), "");
+ ac_array_in_const32_addr_space(ctx->ac.v4i32), "");
return list;
}
assert(!LLVMGetNamedGlobal(ctx->ac.module, "esgs_ring"));
ctx->esgs_ring = LLVMAddGlobalInAddressSpace(
- ctx->ac.module, LLVMArrayType(ctx->i32, 0),
+ ctx->ac.module, LLVMArrayType(ctx->ac.i32, 0),
"esgs_ring",
AC_ADDR_SPACE_LDS);
LLVMSetLinkage(ctx->esgs_ring, LLVMExternalLinkage);
unsigned offset = param * 4 + swizzle;
vtx_offset = LLVMBuildAdd(ctx->ac.builder, vtx_offset,
- LLVMConstInt(ctx->i32, offset, false), "");
+ LLVMConstInt(ctx->ac.i32, offset, false), "");
LLVMValueRef ptr = ac_build_gep0(&ctx->ac, ctx->esgs_ring, vtx_offset);
LLVMValueRef value = LLVMBuildLoad(ctx->ac.builder, ptr, "");
ctx->gs_vtx_offset[vtx_offset_param]);
vtx_offset = LLVMBuildMul(ctx->ac.builder, gs_vtx_offset,
- LLVMConstInt(ctx->i32, 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, 4, 0), "");
- soffset = LLVMConstInt(ctx->i32, (param * 4 + swizzle) * 256, 0);
+ soffset = LLVMConstInt(ctx->ac.i32, (param * 4 + swizzle) * 256, 0);
- value = ac_build_buffer_load(&ctx->ac, ctx->esgs_ring, 1, ctx->i32_0,
+ value = ac_build_buffer_load(&ctx->ac, ctx->esgs_ring, 1, ctx->ac.i32_0,
vtx_offset, soffset, 0, ac_glc, true, false);
if (ac_get_type_size(type) == 8) {
LLVMValueRef value2;
- soffset = LLVMConstInt(ctx->i32, (param * 4 + swizzle + 1) * 256, 0);
+ soffset = LLVMConstInt(ctx->ac.i32, (param * 4 + swizzle + 1) * 256, 0);
value2 = ac_build_buffer_load(&ctx->ac, ctx->esgs_ring, 1,
- ctx->i32_0, vtx_offset, soffset,
+ ctx->ac.i32_0, vtx_offset, soffset,
0, ac_glc, true, false);
return si_build_gather_64bit(ctx, type, value, value2);
}
LLVMValueRef wave_idx = si_unpack_param(ctx, ctx->merged_wave_info, 24, 4);
vertex_idx = LLVMBuildOr(ctx->ac.builder, vertex_idx,
LLVMBuildMul(ctx->ac.builder, wave_idx,
- LLVMConstInt(ctx->i32, ctx->ac.wave_size, false), ""), "");
+ LLVMConstInt(ctx->ac.i32, ctx->ac.wave_size, false), ""), "");
lds_base = LLVMBuildMul(ctx->ac.builder, vertex_idx,
- LLVMConstInt(ctx->i32, itemsize_dw, 0), "");
+ LLVMConstInt(ctx->ac.i32, itemsize_dw, 0), "");
}
for (i = 0; i < info->num_outputs; i++) {
/* GFX9 has the ESGS ring in LDS. */
if (ctx->screen->info.chip_class >= GFX9) {
- LLVMValueRef idx = LLVMConstInt(ctx->i32, param * 4 + chan, false);
+ LLVMValueRef idx = LLVMConstInt(ctx->ac.i32, param * 4 + chan, false);
idx = LLVMBuildAdd(ctx->ac.builder, lds_base, idx, "");
ac_build_indexed_store(&ctx->ac, ctx->esgs_ring, idx, out_val);
continue;
* altogether.
*/
can_emit = LLVMBuildICmp(ctx->ac.builder, LLVMIntULT, gs_next_vertex,
- LLVMConstInt(ctx->i32,
+ LLVMConstInt(ctx->ac.i32,
shader->selector->gs_max_out_vertices, 0), "");
bool use_kill = !info->writes_memory;
LLVMValueRef out_val = LLVMBuildLoad(ctx->ac.builder, addrs[4 * i + chan], "");
LLVMValueRef voffset =
- LLVMConstInt(ctx->i32, offset *
+ LLVMConstInt(ctx->ac.i32, offset *
shader->selector->gs_max_out_vertices, 0);
offset++;
voffset = LLVMBuildAdd(ctx->ac.builder, voffset, gs_next_vertex, "");
voffset = LLVMBuildMul(ctx->ac.builder, voffset,
- LLVMConstInt(ctx->i32, 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, 4, 0), "");
out_val = ac_to_integer(&ctx->ac, out_val);
}
}
- gs_next_vertex = LLVMBuildAdd(ctx->ac.builder, gs_next_vertex, ctx->i32_1, "");
+ gs_next_vertex = LLVMBuildAdd(ctx->ac.builder, gs_next_vertex, ctx->ac.i32_1, "");
LLVMBuildStore(ctx->ac.builder, gs_next_vertex, ctx->gs_next_vertex[stream]);
/* Signal vertex emission if vertex data was written. */
unsigned ring =
ctx->type == PIPE_SHADER_GEOMETRY ? SI_GS_RING_ESGS
: SI_ES_RING_ESGS;
- LLVMValueRef offset = LLVMConstInt(ctx->i32, ring, 0);
+ LLVMValueRef offset = LLVMConstInt(ctx->ac.i32, ring, 0);
LLVMValueRef buf_ptr = ac_get_arg(&ctx->ac, ctx->rw_buffers);
ctx->esgs_ring =
{
const struct si_shader_selector *sel = ctx->shader->selector;
LLVMBuilderRef builder = ctx->ac.builder;
- LLVMValueRef offset = LLVMConstInt(ctx->i32, SI_RING_GSVS, 0);
+ LLVMValueRef offset = LLVMConstInt(ctx->ac.i32, SI_RING_GSVS, 0);
LLVMValueRef buf_ptr = ac_get_arg(&ctx->ac, ctx->rw_buffers);
LLVMValueRef base_ring = ac_build_load_to_sgpr(&ctx->ac, buf_ptr, offset);
* t16v0c0 ..
* Override the buffer descriptor accordingly.
*/
- LLVMTypeRef v2i64 = LLVMVectorType(ctx->i64, 2);
+ LLVMTypeRef v2i64 = LLVMVectorType(ctx->ac.i64, 2);
uint64_t stream_offset = 0;
for (unsigned stream = 0; stream < 4; ++stream) {
num_records = ctx->ac.wave_size;
ring = LLVMBuildBitCast(builder, base_ring, v2i64, "");
- tmp = LLVMBuildExtractElement(builder, ring, ctx->i32_0, "");
+ tmp = LLVMBuildExtractElement(builder, ring, ctx->ac.i32_0, "");
tmp = LLVMBuildAdd(builder, tmp,
- LLVMConstInt(ctx->i64,
+ LLVMConstInt(ctx->ac.i64,
stream_offset, 0), "");
stream_offset += stride * ctx->ac.wave_size;
- ring = LLVMBuildInsertElement(builder, ring, tmp, ctx->i32_0, "");
- ring = LLVMBuildBitCast(builder, ring, ctx->v4i32, "");
- tmp = LLVMBuildExtractElement(builder, ring, ctx->i32_1, "");
+ ring = LLVMBuildInsertElement(builder, ring, tmp, ctx->ac.i32_0, "");
+ ring = LLVMBuildBitCast(builder, ring, ctx->ac.v4i32, "");
+ tmp = LLVMBuildExtractElement(builder, ring, ctx->ac.i32_1, "");
tmp = LLVMBuildOr(builder, tmp,
- LLVMConstInt(ctx->i32,
+ LLVMConstInt(ctx->ac.i32,
S_008F04_STRIDE(stride) |
S_008F04_SWIZZLE_ENABLE(1), 0), "");
- ring = LLVMBuildInsertElement(builder, ring, tmp, ctx->i32_1, "");
+ ring = LLVMBuildInsertElement(builder, ring, tmp, ctx->ac.i32_1, "");
ring = LLVMBuildInsertElement(builder, ring,
- LLVMConstInt(ctx->i32, num_records, 0),
- LLVMConstInt(ctx->i32, 2, 0), "");
+ LLVMConstInt(ctx->ac.i32, num_records, 0),
+ LLVMConstInt(ctx->ac.i32, 2, 0), "");
uint32_t rsrc3 =
S_008F0C_DST_SEL_X(V_008F0C_SQ_SEL_X) |
}
ring = LLVMBuildInsertElement(builder, ring,
- LLVMConstInt(ctx->i32, rsrc3, false),
- LLVMConstInt(ctx->i32, 3, 0), "");
+ LLVMConstInt(ctx->ac.i32, rsrc3, false),
+ LLVMConstInt(ctx->ac.i32, 3, 0), "");
ctx->gsvs_ring[stream] = ring;
}
LLVMValueRef buf_ptr = ac_get_arg(&ctx.ac, ctx.rw_buffers);
ctx.gsvs_ring[0] = ac_build_load_to_sgpr(&ctx.ac, buf_ptr,
- LLVMConstInt(ctx.i32, SI_RING_GSVS, 0));
+ LLVMConstInt(ctx.ac.i32, SI_RING_GSVS, 0));
LLVMValueRef voffset =
LLVMBuildMul(ctx.ac.builder, ctx.abi.vertex_id,
- LLVMConstInt(ctx.i32, 4, 0), "");
+ LLVMConstInt(ctx.ac.i32, 4, 0), "");
/* Fetch the vertex stream ID.*/
LLVMValueRef stream_id;
if (!sscreen->use_ngg_streamout && gs_selector->so.num_outputs)
stream_id = si_unpack_param(&ctx, ctx.streamout_config, 24, 2);
else
- stream_id = ctx.i32_0;
+ stream_id = ctx.ac.i32_0;
/* Fill in output information. */
for (i = 0; i < gsinfo->num_outputs; ++i) {
continue;
bb = LLVMInsertBasicBlockInContext(ctx.ac.context, end_bb, "out");
- LLVMAddCase(switch_inst, LLVMConstInt(ctx.i32, stream, 0), bb);
+ LLVMAddCase(switch_inst, LLVMConstInt(ctx.ac.i32, stream, 0), bb);
LLVMPositionBuilderAtEnd(builder, bb);
/* Fetch vertex data from GSVS ring */
for (unsigned chan = 0; chan < 4; chan++) {
if (!(gsinfo->output_usagemask[i] & (1 << chan)) ||
outputs[i].vertex_stream[chan] != stream) {
- outputs[i].values[chan] = LLVMGetUndef(ctx.f32);
+ outputs[i].values[chan] = LLVMGetUndef(ctx.ac.f32);
continue;
}
- LLVMValueRef soffset = LLVMConstInt(ctx.i32,
+ LLVMValueRef soffset = LLVMConstInt(ctx.ac.i32,
offset * gs_selector->gs_max_out_vertices * 16 * 4, 0);
offset++;
outputs[i].values[chan] =
ac_build_buffer_load(&ctx.ac,
ctx.gsvs_ring[0], 1,
- ctx.i32_0, voffset,
+ ctx.ac.i32_0, voffset,
soffset, 0, ac_glc | ac_slc,
true, false);
}
for (unsigned i = 0; i < num_sgprs; ++i) {
ac_add_arg(&ctx->args, AC_ARG_SGPR, 1, AC_ARG_INT, NULL);
- returns[i] = ctx->i32;
+ returns[i] = ctx->ac.i32;
}
for (unsigned i = 0; i < num_vgprs; ++i) {
ac_add_arg(&ctx->args, AC_ARG_VGPR, 1, AC_ARG_INT, NULL);
- returns[num_sgprs + i] = ctx->f32;
+ returns[num_sgprs + i] = ctx->ac.f32;
}
/* Create the function. */
}
prim_id = LLVMGetParam(func, num_sgprs + 2);
- rotate = LLVMBuildTrunc(builder, prim_id, ctx->i1, "");
+ rotate = LLVMBuildTrunc(builder, prim_id, ctx->ac.i1, "");
for (unsigned i = 0; i < 6; ++i) {
LLVMValueRef base, rotated;
LLVMValueRef hi, out;
hi = LLVMBuildShl(builder, vtx_out[i*2+1],
- LLVMConstInt(ctx->i32, 16, 0), "");
+ LLVMConstInt(ctx->ac.i32, 16, 0), "");
out = LLVMBuildOr(builder, vtx_out[i*2], hi, "");
out = ac_to_float(&ctx->ac, out);
ret = LLVMBuildInsertValue(builder, ret, out,
{
struct si_shader_context *ctx = si_shader_context_from_abi(abi);
LLVMValueRef desc = ac_get_arg(&ctx->ac, ctx->rw_buffers);
- LLVMValueRef buf_index = LLVMConstInt(ctx->i32, SI_PS_CONST_SAMPLE_POSITIONS, 0);
+ LLVMValueRef buf_index = LLVMConstInt(ctx->ac.i32, SI_PS_CONST_SAMPLE_POSITIONS, 0);
LLVMValueRef resource = ac_build_load_to_sgpr(&ctx->ac, desc, buf_index);
/* offset = sample_id * 8 (8 = 2 floats containing samplepos.xy) */
- LLVMValueRef offset0 = LLVMBuildMul(ctx->ac.builder, sample_id, LLVMConstInt(ctx->i32, 8, 0), "");
- LLVMValueRef offset1 = LLVMBuildAdd(ctx->ac.builder, offset0, LLVMConstInt(ctx->i32, 4, 0), "");
+ LLVMValueRef offset0 = LLVMBuildMul(ctx->ac.builder, sample_id, LLVMConstInt(ctx->ac.i32, 8, 0), "");
+ LLVMValueRef offset1 = LLVMBuildAdd(ctx->ac.builder, offset0, LLVMConstInt(ctx->ac.i32, 4, 0), "");
LLVMValueRef pos[4] = {
si_buffer_load_const(ctx, resource, offset0),
si_buffer_load_const(ctx, resource, offset1),
- LLVMConstReal(ctx->f32, 0),
- LLVMConstReal(ctx->f32, 0)
+ LLVMConstReal(ctx->ac.f32, 0),
+ LLVMConstReal(ctx->ac.f32, 0)
};
return ac_build_gather_values(&ctx->ac, pos, 4);
STATIC_ASSERT(SI_PS_IMAGE_COLORBUF0 % 2 == 0);
ptr = ac_get_arg(&ctx->ac, ctx->rw_buffers);
ptr = LLVMBuildPointerCast(ctx->ac.builder, ptr,
- ac_array_in_const32_addr_space(ctx->v8i32), "");
+ ac_array_in_const32_addr_space(ctx->ac.v8i32), "");
image = ac_build_load_to_sgpr(&ctx->ac, ptr,
- LLVMConstInt(ctx->i32, SI_PS_IMAGE_COLORBUF0 / 2, 0));
+ LLVMConstInt(ctx->ac.i32, SI_PS_IMAGE_COLORBUF0 / 2, 0));
unsigned chan = 0;
if (ctx->shader->key.mono.u.ps.fbfetch_msaa &&
!(ctx->screen->debug_flags & DBG(NO_FMASK))) {
fmask = ac_build_load_to_sgpr(&ctx->ac, ptr,
- LLVMConstInt(ctx->i32, SI_PS_IMAGE_COLORBUF0_FMASK / 2, 0));
+ LLVMConstInt(ctx->ac.i32, SI_PS_IMAGE_COLORBUF0_FMASK / 2, 0));
ac_apply_fmask_to_sample(&ctx->ac, fmask, args.coords,
ctx->shader->key.mono.u.ps.fbfetch_layered);
{
if (i || j) {
return ac_build_fs_interp(&ctx->ac,
- LLVMConstInt(ctx->i32, chan, 0),
- LLVMConstInt(ctx->i32, attr_index, 0),
+ LLVMConstInt(ctx->ac.i32, chan, 0),
+ LLVMConstInt(ctx->ac.i32, attr_index, 0),
prim_mask, i, j);
}
return ac_build_fs_interp_mov(&ctx->ac,
- LLVMConstInt(ctx->i32, 2, 0), /* P0 */
- LLVMConstInt(ctx->i32, chan, 0),
- LLVMConstInt(ctx->i32, attr_index, 0),
+ LLVMConstInt(ctx->ac.i32, 2, 0), /* P0 */
+ LLVMConstInt(ctx->ac.i32, chan, 0),
+ LLVMConstInt(ctx->ac.i32, attr_index, 0),
prim_mask);
}
if (interp) {
interp_param = LLVMBuildBitCast(ctx->ac.builder, interp_param,
- LLVMVectorType(ctx->f32, 2), "");
+ LLVMVectorType(ctx->ac.f32, 2), "");
i = LLVMBuildExtractElement(ctx->ac.builder, interp_param,
- ctx->i32_0, "");
+ ctx->ac.i32_0, "");
j = LLVMBuildExtractElement(ctx->ac.builder, interp_param,
- ctx->i32_1, "");
+ ctx->ac.i32_1, "");
}
if (ctx->shader->key.part.ps.prolog.color_two_side) {
back_attr_offset += 1;
is_face_positive = LLVMBuildICmp(ctx->ac.builder, LLVMIntNE,
- face, ctx->i32_0, "");
+ face, ctx->ac.i32_0, "");
for (chan = 0; chan < 4; chan++) {
LLVMValueRef front, back;
LLVMBuildFCmp(ctx->ac.builder, cond, alpha, alpha_ref, "");
ac_build_kill_if_false(&ctx->ac, alpha_pass);
} else {
- ac_build_kill_if_false(&ctx->ac, ctx->i1false);
+ ac_build_kill_if_false(&ctx->ac, ctx->ac.i1false);
}
}
coverage = ac_to_integer(&ctx->ac, coverage);
coverage = ac_build_intrinsic(&ctx->ac, "llvm.ctpop.i32",
- ctx->i32,
+ ctx->ac.i32,
&coverage, 1, AC_FUNC_ATTR_READNONE);
coverage = LLVMBuildUIToFP(ctx->ac.builder, coverage,
- ctx->f32, "");
+ ctx->ac.f32, "");
coverage = LLVMBuildFMul(ctx->ac.builder, coverage,
- LLVMConstReal(ctx->f32,
+ LLVMConstReal(ctx->ac.f32,
1.0 / SI_NUM_SMOOTH_AA_SAMPLES), "");
return LLVMBuildFMul(ctx->ac.builder, alpha, coverage, "");
address[1] = si_unpack_param(ctx, param_pos_fixed_pt, 16, 5);
/* Load the buffer descriptor. */
- slot = LLVMConstInt(ctx->i32, SI_PS_CONST_POLY_STIPPLE, 0);
+ slot = LLVMConstInt(ctx->ac.i32, SI_PS_CONST_POLY_STIPPLE, 0);
desc = ac_build_load_to_sgpr(&ctx->ac, param_rw_buffers, slot);
/* The stipple pattern is 32x32, each row has 32 bits. */
offset = LLVMBuildMul(builder, address[1],
- LLVMConstInt(ctx->i32, 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, 4, 0), "");
row = si_buffer_load_const(ctx, desc, offset);
row = ac_to_integer(&ctx->ac, row);
bit = LLVMBuildLShr(builder, row, address[0], "");
- bit = LLVMBuildTrunc(builder, bit, ctx->i1, "");
+ bit = LLVMBuildTrunc(builder, bit, ctx->ac.i1, "");
ac_build_kill_if_false(&ctx->ac, bit);
}
num_color_channels <= AC_MAX_ARGS);
for (i = 0; i < key->ps_prolog.num_input_sgprs; i++) {
ac_add_arg(&ctx->args, AC_ARG_SGPR, 1, AC_ARG_INT, NULL);
- return_types[num_returns++] = ctx->i32;
+ return_types[num_returns++] = ctx->ac.i32;
}
arg = &pos_fixed_pt;
}
ac_add_arg(&ctx->args, AC_ARG_VGPR, 1, AC_ARG_FLOAT, arg);
- return_types[num_returns++] = ctx->f32;
+ return_types[num_returns++] = ctx->ac.f32;
}
/* Declare outputs (same as inputs + add colors if needed) */
for (i = 0; i < num_color_channels; i++)
- return_types[num_returns++] = ctx->f32;
+ return_types[num_returns++] = ctx->ac.f32;
/* Create the function. */
si_llvm_create_func(ctx, "ps_prolog", return_types, num_returns, 0);
*/
bc_optimize = LLVMGetParam(func, SI_PS_NUM_USER_SGPR);
bc_optimize = LLVMBuildLShr(ctx->ac.builder, bc_optimize,
- LLVMConstInt(ctx->i32, 31, 0), "");
+ LLVMConstInt(ctx->ac.i32, 31, 0), "");
bc_optimize = LLVMBuildTrunc(ctx->ac.builder, bc_optimize,
- ctx->i1, "");
+ ctx->ac.i1, "");
if (key->ps_prolog.states.bc_optimize_for_persp) {
/* Read PERSP_CENTER. */
ctx->ac.builder,
samplemask,
LLVMBuildShl(ctx->ac.builder,
- LLVMConstInt(ctx->i32, ps_iter_mask, false),
+ LLVMConstInt(ctx->ac.i32, ps_iter_mask, false),
sampleid, ""),
"");
samplemask = ac_to_float(&ctx->ac, samplemask);
unsigned num)
{
LLVMBuilderRef builder = ctx->ac.builder;
- LLVMValueRef c_max = LLVMConstInt(ctx->i32, num - 1, 0);
+ LLVMValueRef c_max = LLVMConstInt(ctx->ac.i32, num - 1, 0);
LLVMValueRef cc;
if (util_is_power_of_two_or_zero(num)) {
LLVMValueRef desc0, desc1;
desc0 = ptr;
- desc1 = LLVMConstInt(ctx->i32,
+ desc1 = LLVMConstInt(ctx->ac.i32,
S_008F04_BASE_ADDRESS_HI(ctx->screen->info.address32_hi), 0);
uint32_t rsrc3 = S_008F0C_DST_SEL_X(V_008F0C_SQ_SEL_X) |
LLVMValueRef desc_elems[] = {
desc0,
desc1,
- LLVMConstInt(ctx->i32, sel->info.constbuf0_num_slots * 16, 0),
- LLVMConstInt(ctx->i32, rsrc3, false)
+ LLVMConstInt(ctx->ac.i32, sel->info.constbuf0_num_slots * 16, 0),
+ LLVMConstInt(ctx->ac.i32, rsrc3, false)
};
return ac_build_gather_values(&ctx->ac, desc_elems, 4);
index = si_llvm_bound_index(ctx, index, ctx->num_const_buffers);
index = LLVMBuildAdd(ctx->ac.builder, index,
- LLVMConstInt(ctx->i32, SI_NUM_SHADER_BUFFERS, 0), "");
+ LLVMConstInt(ctx->ac.i32, SI_NUM_SHADER_BUFFERS, 0), "");
return ac_build_load_to_sgpr(&ctx->ac, ptr, index);
}
index = si_llvm_bound_index(ctx, index, ctx->num_shader_buffers);
index = LLVMBuildSub(ctx->ac.builder,
- LLVMConstInt(ctx->i32, SI_NUM_SHADER_BUFFERS - 1, 0),
+ LLVMConstInt(ctx->ac.i32, SI_NUM_SHADER_BUFFERS - 1, 0),
index, "");
return ac_build_load_to_sgpr(&ctx->ac, rsrc_ptr, index);
if (ctx->screen->info.chip_class <= GFX7) {
return rsrc;
} else {
- LLVMValueRef i32_6 = LLVMConstInt(ctx->i32, 6, 0);
- LLVMValueRef i32_C = LLVMConstInt(ctx->i32, C_008F28_COMPRESSION_EN, 0);
+ LLVMValueRef i32_6 = LLVMConstInt(ctx->ac.i32, 6, 0);
+ LLVMValueRef i32_C = LLVMConstInt(ctx->ac.i32, C_008F28_COMPRESSION_EN, 0);
LLVMValueRef tmp;
tmp = LLVMBuildExtractElement(ctx->ac.builder, rsrc, i32_6, "");
LLVMValueRef rsrc;
if (desc_type == AC_DESC_BUFFER) {
- index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->i32, 2, 0),
- ctx->i32_1);
+ index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->ac.i32, 2, 0),
+ ctx->ac.i32_1);
list = LLVMBuildPointerCast(builder, list,
- ac_array_in_const32_addr_space(ctx->v4i32), "");
+ ac_array_in_const32_addr_space(ctx->ac.v4i32), "");
} else {
assert(desc_type == AC_DESC_IMAGE ||
desc_type == AC_DESC_FMASK);
switch (type) {
case AC_DESC_IMAGE:
/* The image is at [0:7]. */
- index = LLVMBuildMul(builder, index, LLVMConstInt(ctx->i32, 2, 0), "");
+ index = LLVMBuildMul(builder, index, LLVMConstInt(ctx->ac.i32, 2, 0), "");
break;
case AC_DESC_BUFFER:
/* The buffer is in [4:7]. */
- index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->i32, 4, 0),
- ctx->i32_1);
+ index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->ac.i32, 4, 0),
+ ctx->ac.i32_1);
list = LLVMBuildPointerCast(builder, list,
- ac_array_in_const32_addr_space(ctx->v4i32), "");
+ ac_array_in_const32_addr_space(ctx->ac.v4i32), "");
break;
case AC_DESC_FMASK:
/* The FMASK is at [8:15]. */
- index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->i32, 2, 0),
- ctx->i32_1);
+ index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->ac.i32, 2, 0),
+ ctx->ac.i32_1);
break;
case AC_DESC_SAMPLER:
/* The sampler state is at [12:15]. */
- index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->i32, 4, 0),
- LLVMConstInt(ctx->i32, 3, 0));
+ index = ac_build_imad(&ctx->ac, index, LLVMConstInt(ctx->ac.i32, 4, 0),
+ LLVMConstInt(ctx->ac.i32, 3, 0));
list = LLVMBuildPointerCast(builder, list,
- ac_array_in_const32_addr_space(ctx->v4i32), "");
+ ac_array_in_const32_addr_space(ctx->ac.v4i32), "");
break;
case AC_DESC_PLANE_0:
case AC_DESC_PLANE_1:
if (image) {
/* Bindless image descriptors use 16-dword slots. */
dynamic_index = LLVMBuildMul(ctx->ac.builder, dynamic_index,
- LLVMConstInt(ctx->i64, 2, 0), "");
+ LLVMConstInt(ctx->ac.i64, 2, 0), "");
/* FMASK is right after the image. */
if (desc_type == AC_DESC_FMASK) {
dynamic_index = LLVMBuildAdd(ctx->ac.builder, dynamic_index,
- ctx->i32_1, "");
+ ctx->ac.i32_1, "");
}
return si_load_image_desc(ctx, list, dynamic_index, desc_type,
* to prevent incorrect code generation and hangs.
*/
dynamic_index = LLVMBuildMul(ctx->ac.builder, dynamic_index,
- LLVMConstInt(ctx->i64, 2, 0), "");
+ LLVMConstInt(ctx->ac.i64, 2, 0), "");
list = ac_build_pointer_add(&ctx->ac, list, dynamic_index);
- return si_load_sampler_desc(ctx, list, ctx->i32_0, desc_type);
+ return si_load_sampler_desc(ctx, list, ctx->ac.i32_0, desc_type);
}
unsigned num_slots = image ? ctx->num_images : ctx->num_samplers;
/* FMASKs are separate from images. */
if (desc_type == AC_DESC_FMASK) {
index = LLVMBuildAdd(ctx->ac.builder, index,
- LLVMConstInt(ctx->i32, SI_NUM_IMAGES, 0), "");
+ LLVMConstInt(ctx->ac.i32, SI_NUM_IMAGES, 0), "");
}
index = LLVMBuildSub(ctx->ac.builder,
- LLVMConstInt(ctx->i32, SI_NUM_IMAGE_SLOTS - 1, 0),
+ LLVMConstInt(ctx->ac.i32, SI_NUM_IMAGE_SLOTS - 1, 0),
index, "");
return si_load_image_desc(ctx, list, index, desc_type, write, false);
}
index = LLVMBuildAdd(ctx->ac.builder, index,
- LLVMConstInt(ctx->i32, SI_NUM_IMAGE_SLOTS / 2, 0), "");
+ LLVMConstInt(ctx->ac.i32, SI_NUM_IMAGE_SLOTS / 2, 0), "");
return si_load_sampler_desc(ctx, list, index, desc_type);
}
{
unsigned stride = get_tcs_out_vertex_dw_stride_constant(ctx);
- return LLVMConstInt(ctx->i32, stride, 0);
+ return LLVMConstInt(ctx->ac.i32, stride, 0);
}
static LLVMValueRef get_tcs_out_patch_stride(struct si_shader_context *ctx)
unsigned num_patch_outputs = util_last_bit64(ctx->shader->selector->patch_outputs_written);
unsigned patch_dw_stride = tcs_out_vertices * vertex_dw_stride +
num_patch_outputs * 4;
- return LLVMConstInt(ctx->i32, patch_dw_stride, 0);
+ return LLVMConstInt(ctx->ac.i32, patch_dw_stride, 0);
}
static LLVMValueRef
{
return LLVMBuildMul(ctx->ac.builder,
si_unpack_param(ctx, ctx->tcs_out_lds_offsets, 0, 16),
- LLVMConstInt(ctx->i32, 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, 4, 0), "");
}
static LLVMValueRef
{
return LLVMBuildMul(ctx->ac.builder,
si_unpack_param(ctx, ctx->tcs_out_lds_offsets, 16, 16),
- LLVMConstInt(ctx->i32, 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, 4, 0), "");
}
static LLVMValueRef
/* If !tcs_out_vertices, it's either the fixed-func TCS or the TCS epilog. */
if (ctx->type == PIPE_SHADER_TESS_CTRL && tcs_out_vertices)
- return LLVMConstInt(ctx->i32, tcs_out_vertices, 0);
+ return LLVMConstInt(ctx->ac.i32, tcs_out_vertices, 0);
return si_unpack_param(ctx, ctx->tcs_offchip_layout, 6, 6);
}
switch (ctx->type) {
case PIPE_SHADER_VERTEX:
stride = ctx->shader->selector->lshs_vertex_stride / 4;
- return LLVMConstInt(ctx->i32, stride, 0);
+ return LLVMConstInt(ctx->ac.i32, stride, 0);
case PIPE_SHADER_TESS_CTRL:
if (ctx->screen->info.chip_class >= GFX9 &&
ctx->shader->is_monolithic) {
stride = ctx->shader->key.part.tcs.ls->lshs_vertex_stride / 4;
- return LLVMConstInt(ctx->i32, stride, 0);
+ return LLVMConstInt(ctx->ac.i32, stride, 0);
}
return si_unpack_param(ctx, ctx->vs_state_bits, 24, 8);
if (param_index) {
base_addr = ac_build_imad(&ctx->ac, param_index,
- LLVMConstInt(ctx->i32, 4, 0), base_addr);
+ LLVMConstInt(ctx->ac.i32, 4, 0), base_addr);
}
int param = name == TGSI_SEMANTIC_PATCH ||
/* Add the base address of the element. */
return LLVMBuildAdd(ctx->ac.builder, base_addr,
- LLVMConstInt(ctx->i32, param * 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, param * 4, 0), "");
}
/* The offchip buffer layout for TCS->TES is
total_vertices = LLVMBuildMul(ctx->ac.builder, vertices_per_patch,
num_patches, "");
- constant16 = LLVMConstInt(ctx->i32, 16, 0);
+ constant16 = LLVMConstInt(ctx->ac.i32, 16, 0);
if (vertex_index) {
base_addr = ac_build_imad(&ctx->ac, rel_patch_id,
vertices_per_patch, vertex_index);
if (param_index) {
param_index = LLVMBuildAdd(ctx->ac.builder, param_index,
- LLVMConstInt(ctx->i32, param_index_base, 0),
+ LLVMConstInt(ctx->ac.i32, param_index_base, 0),
"");
} else {
- param_index = LLVMConstInt(ctx->i32, param_index_base, 0);
+ param_index = LLVMConstInt(ctx->ac.i32, param_index_base, 0);
}
return get_tcs_tes_buffer_address(ctx, get_rel_patch_id(ctx),
value = LLVMBuildBitCast(ctx->ac.builder, value, vec_type, "");
return LLVMBuildExtractElement(ctx->ac.builder, value,
- LLVMConstInt(ctx->i32, swizzle, 0), "");
+ LLVMConstInt(ctx->ac.i32, swizzle, 0), "");
}
value = ac_build_buffer_load(&ctx->ac, buffer, 1, NULL, base, offset,
if (ac_get_type_size(type) == 8) {
LLVMValueRef lo, hi;
- lo = lshs_lds_load(ctx, ctx->i32, swizzle, dw_addr);
- hi = lshs_lds_load(ctx, ctx->i32, swizzle + 1, dw_addr);
+ lo = lshs_lds_load(ctx, ctx->ac.i32, swizzle, dw_addr);
+ hi = lshs_lds_load(ctx, ctx->ac.i32, swizzle + 1, dw_addr);
return si_build_gather_64bit(ctx, type, lo, hi);
}
dw_addr = LLVMBuildAdd(ctx->ac.builder, dw_addr,
- LLVMConstInt(ctx->i32, swizzle, 0), "");
+ LLVMConstInt(ctx->ac.i32, swizzle, 0), "");
value = ac_lds_load(&ctx->ac, dw_addr);
LLVMValueRef value)
{
dw_addr = LLVMBuildAdd(ctx->ac.builder, dw_addr,
- LLVMConstInt(ctx->i32, dw_offset_imm, 0), "");
+ LLVMConstInt(ctx->ac.i32, dw_offset_imm, 0), "");
ac_lds_store(&ctx->ac, dw_addr, value);
}
/* TCS only receives high 13 bits of the address. */
if (ring == TESS_OFFCHIP_RING_TCS || ring == TCS_FACTOR_RING) {
addr = LLVMBuildAnd(builder, addr,
- LLVMConstInt(ctx->i32, 0xfff80000, 0), "");
+ LLVMConstInt(ctx->ac.i32, 0xfff80000, 0), "");
}
if (ring == TCS_FACTOR_RING) {
unsigned tf_offset = ctx->screen->tess_offchip_ring_size;
addr = LLVMBuildAdd(builder, addr,
- LLVMConstInt(ctx->i32, tf_offset, 0), "");
+ LLVMConstInt(ctx->ac.i32, tf_offset, 0), "");
}
uint32_t rsrc3 = S_008F0C_DST_SEL_X(V_008F0C_SQ_SEL_X) |
LLVMValueRef desc[4];
desc[0] = addr;
- desc[1] = LLVMConstInt(ctx->i32,
+ desc[1] = LLVMConstInt(ctx->ac.i32,
S_008F04_BASE_ADDRESS_HI(ctx->screen->info.address32_hi), 0);
- desc[2] = LLVMConstInt(ctx->i32, 0xffffffff, 0);
- desc[3] = LLVMConstInt(ctx->i32, rsrc3, false);
+ desc[2] = LLVMConstInt(ctx->ac.i32, 0xffffffff, 0);
+ desc[3] = LLVMConstInt(ctx->ac.i32, rsrc3, false);
return ac_build_gather_values(&ctx->ac, desc, 4);
}
}
if (!param_index) {
- param_index = LLVMConstInt(ctx->i32, const_index, 0);
+ param_index = LLVMConstInt(ctx->ac.i32, const_index, 0);
}
dw_addr = get_dw_address_from_generic_indices(ctx, stride, dw_addr,
base = ac_get_arg(&ctx->ac, ctx->tcs_offchip_offset);
if (!param_index) {
- param_index = LLVMConstInt(ctx->i32, const_index, 0);
+ param_index = LLVMConstInt(ctx->ac.i32, const_index, 0);
}
addr = get_tcs_tes_buffer_address_from_generic_indices(ctx, vertex_index,
bool is_const = !param_index;
if (!param_index)
- param_index = LLVMConstInt(ctx->i32, const_index, 0);
+ param_index = LLVMConstInt(ctx->ac.i32, const_index, 0);
const bool is_patch = var->data.patch ||
var->data.location == VARYING_SLOT_TESS_LEVEL_INNER ||
base = ac_get_arg(&ctx->ac, ctx->tcs_offchip_offset);
addr = get_tcs_tes_buffer_address(ctx, get_rel_patch_id(ctx), NULL,
- LLVMConstInt(ctx->i32, param, 0));
+ LLVMConstInt(ctx->ac.i32, param, 0));
- return buffer_load(ctx, ctx->f32,
+ return buffer_load(ctx, ctx->ac.f32,
~0, ctx->tess_offchip_ring, base, addr, true);
}
LLVMValueRef buf, slot, val[4];
int i, offset;
- slot = LLVMConstInt(ctx->i32, SI_HS_CONST_DEFAULT_TESS_LEVELS, 0);
+ slot = LLVMConstInt(ctx->ac.i32, SI_HS_CONST_DEFAULT_TESS_LEVELS, 0);
buf = ac_get_arg(&ctx->ac, ctx->rw_buffers);
buf = ac_build_load_to_sgpr(&ctx->ac, buf, slot);
offset = semantic_name == TGSI_SEMANTIC_TESS_DEFAULT_INNER_LEVEL ? 4 : 0;
for (i = 0; i < 4; i++)
val[i] = si_buffer_load_const(ctx, buf,
- LLVMConstInt(ctx->i32, (offset + i) * 4, 0));
+ LLVMConstInt(ctx->ac.i32, (offset + i) * 4, 0));
return ac_build_gather_values(&ctx->ac, val, 4);
}
unsigned i = u_bit_scan64(&inputs);
LLVMValueRef lds_ptr = LLVMBuildAdd(ctx->ac.builder, lds_base,
- LLVMConstInt(ctx->i32, 4 * i, 0),
+ LLVMConstInt(ctx->ac.i32, 4 * i, 0),
"");
LLVMValueRef buffer_addr = get_tcs_tes_buffer_address(ctx,
get_rel_patch_id(ctx),
invocation_id,
- LLVMConstInt(ctx->i32, i, 0));
+ LLVMConstInt(ctx->ac.i32, i, 0));
LLVMValueRef value = lshs_lds_load(ctx, ctx->ac.i32, ~0, lds_ptr);
*/
ac_build_ifcc(&ctx->ac,
LLVMBuildICmp(ctx->ac.builder, LLVMIntEQ,
- invocation_id, ctx->i32_0, ""), 6503);
+ invocation_id, ctx->ac.i32_0, ""), 6503);
/* Determine the layout of one tess factor element in the buffer. */
switch (shader->key.part.tcs.epilog.prim_mode) {
}
for (i = 0; i < 4; i++) {
- inner[i] = LLVMGetUndef(ctx->i32);
- outer[i] = LLVMGetUndef(ctx->i32);
+ inner[i] = LLVMGetUndef(ctx->ac.i32);
+ outer[i] = LLVMGetUndef(ctx->ac.i32);
}
if (shader->key.part.tcs.epilog.invoc0_tess_factors_are_def) {
lds_base = tcs_out_current_patch_data_offset;
lds_inner = LLVMBuildAdd(ctx->ac.builder, lds_base,
- LLVMConstInt(ctx->i32,
+ LLVMConstInt(ctx->ac.i32,
tess_inner_index * 4, 0), "");
lds_outer = LLVMBuildAdd(ctx->ac.builder, lds_base,
- LLVMConstInt(ctx->i32,
+ LLVMConstInt(ctx->ac.i32,
tess_outer_index * 4, 0), "");
for (i = 0; i < outer_comps; i++) {
tf_base = ac_get_arg(&ctx->ac,
ctx->tcs_factor_offset);
byteoffset = LLVMBuildMul(ctx->ac.builder, rel_patch_id,
- LLVMConstInt(ctx->i32, 4 * stride, 0), "");
+ LLVMConstInt(ctx->ac.i32, 4 * stride, 0), "");
ac_build_ifcc(&ctx->ac,
LLVMBuildICmp(ctx->ac.builder, LLVMIntEQ,
- rel_patch_id, ctx->i32_0, ""), 6504);
+ rel_patch_id, ctx->ac.i32_0, ""), 6504);
/* Store the dynamic HS control word. */
offset = 0;
if (ctx->screen->info.chip_class <= GFX8) {
ac_build_buffer_store_dword(&ctx->ac, buffer,
- LLVMConstInt(ctx->i32, 0x80000000, 0),
- 1, ctx->i32_0, tf_base,
+ LLVMConstInt(ctx->ac.i32, 0x80000000, 0),
+ 1, ctx->ac.i32_0, tf_base,
offset, ac_glc);
offset += 4;
}
param_outer = si_shader_io_get_unique_index_patch(
TGSI_SEMANTIC_TESSOUTER, 0);
tf_outer_offset = get_tcs_tes_buffer_address(ctx, rel_patch_id, NULL,
- LLVMConstInt(ctx->i32, param_outer, 0));
+ LLVMConstInt(ctx->ac.i32, param_outer, 0));
unsigned outer_vec_size =
ac_has_vec3_support(ctx->screen->info.chip_class, false) ?
param_inner = si_shader_io_get_unique_index_patch(
TGSI_SEMANTIC_TESSINNER, 0);
tf_inner_offset = get_tcs_tes_buffer_address(ctx, rel_patch_id, NULL,
- LLVMConstInt(ctx->i32, param_inner, 0));
+ LLVMConstInt(ctx->ac.i32, param_inner, 0));
inner_vec = inner_comps == 1 ? inner[0] :
ac_build_gather_values(&ctx->ac, inner, inner_comps);
ac_build_endif(&ctx->ac, ctx->merged_wrap_if_label);
values[0] = rel_patch_id;
- values[1] = LLVMGetUndef(ctx->i32);
- rel_patch_id = ac_build_phi(&ctx->ac, ctx->i32, 2, values, blocks);
+ values[1] = LLVMGetUndef(ctx->ac.i32);
+ rel_patch_id = ac_build_phi(&ctx->ac, ctx->ac.i32, 2, values, blocks);
values[0] = tf_lds_offset;
- values[1] = LLVMGetUndef(ctx->i32);
- tf_lds_offset = ac_build_phi(&ctx->ac, ctx->i32, 2, values, blocks);
+ values[1] = LLVMGetUndef(ctx->ac.i32);
+ tf_lds_offset = ac_build_phi(&ctx->ac, ctx->ac.i32, 2, values, blocks);
values[0] = invocation_id;
- values[1] = ctx->i32_1; /* cause the epilog to skip threads */
- invocation_id = ac_build_phi(&ctx->ac, ctx->i32, 2, values, blocks);
+ values[1] = ctx->ac.i32_1; /* cause the epilog to skip threads */
+ invocation_id = ac_build_phi(&ctx->ac, ctx->ac.i32, 2, values, blocks);
}
/* Return epilog parameters from this function. */
int param = si_shader_io_get_unique_index(name, index, false);
LLVMValueRef dw_addr = LLVMBuildAdd(ctx->ac.builder, base_dw_addr,
- LLVMConstInt(ctx->i32, param * 4, 0), "");
+ LLVMConstInt(ctx->ac.i32, param * 4, 0), "");
for (chan = 0; chan < 4; chan++) {
if (!(info->output_usagemask[i] & (1 << chan)))
ctx->shader->selector->info.colors_read;
LLVMValueRef main_fn = ctx->main_fn;
- LLVMValueRef undef = LLVMGetUndef(ctx->f32);
+ LLVMValueRef undef = LLVMGetUndef(ctx->ac.f32);
unsigned offset = SI_PARAM_POS_FIXED_PT + 1;
projects / mesa.git / commitdiff