From: Nicolai Hähnle <nicolai.haeh...@amd.com>
---
src/amd/common/ac_nir_to_llvm.c | 190 ++++++++++++++++++++--------------------
1 file changed, 95 insertions(+), 95 deletions(-)
diff --git a/src/amd/common/ac_nir_to_llvm.c b/src/amd/common/ac_nir_to_llvm.c
index e65f167..a590888 100644
--- a/src/amd/common/ac_nir_to_llvm.c
+++ b/src/amd/common/ac_nir_to_llvm.c
@@ -402,77 +402,77 @@ static LLVMValueRef get_shared_memory_ptr(struct
nir_to_llvm_context *ctx,
offset = LLVMConstInt(ctx->i32, idx * 16, false);
ptr = ctx->shared_memory;
ptr = LLVMBuildGEP(ctx->builder, ptr, &offset, 1, "");
addr_space = LLVMGetPointerAddressSpace(LLVMTypeOf(ptr));
ptr = LLVMBuildBitCast(ctx->builder, ptr, LLVMPointerType(type,
addr_space), "");
return ptr;
}
-static LLVMTypeRef to_integer_type_scalar(struct nir_to_llvm_context *ctx,
LLVMTypeRef t)
+static LLVMTypeRef to_integer_type_scalar(struct ac_llvm_context *ctx,
LLVMTypeRef t)
{
if (t == ctx->f16 || t == ctx->i16)
return ctx->i16;
else if (t == ctx->f32 || t == ctx->i32)
return ctx->i32;
else if (t == ctx->f64 || t == ctx->i64)
return ctx->i64;
else
unreachable("Unhandled integer size");
}
-static LLVMTypeRef to_integer_type(struct nir_to_llvm_context *ctx,
LLVMTypeRef t)
+static LLVMTypeRef to_integer_type(struct ac_llvm_context *ctx, LLVMTypeRef t)
{
if (LLVMGetTypeKind(t) == LLVMVectorTypeKind) {
LLVMTypeRef elem_type = LLVMGetElementType(t);
return LLVMVectorType(to_integer_type_scalar(ctx, elem_type),
LLVMGetVectorSize(t));
}
return to_integer_type_scalar(ctx, t);
}
-static LLVMValueRef to_integer(struct nir_to_llvm_context *ctx, LLVMValueRef v)
+static LLVMValueRef to_integer(struct ac_llvm_context *ctx, LLVMValueRef v)
{
LLVMTypeRef type = LLVMTypeOf(v);
return LLVMBuildBitCast(ctx->builder, v, to_integer_type(ctx, type),
"");
}
-static LLVMTypeRef to_float_type_scalar(struct nir_to_llvm_context *ctx,
LLVMTypeRef t)
+static LLVMTypeRef to_float_type_scalar(struct ac_llvm_context *ctx,
LLVMTypeRef t)
{
if (t == ctx->i16 || t == ctx->f16)
return ctx->f16;
else if (t == ctx->i32 || t == ctx->f32)
return ctx->f32;
else if (t == ctx->i64 || t == ctx->f64)
return ctx->f64;
else
unreachable("Unhandled float size");
}
-static LLVMTypeRef to_float_type(struct nir_to_llvm_context *ctx, LLVMTypeRef
t)
+static LLVMTypeRef to_float_type(struct ac_llvm_context *ctx, LLVMTypeRef t)
{
if (LLVMGetTypeKind(t) == LLVMVectorTypeKind) {
LLVMTypeRef elem_type = LLVMGetElementType(t);
return LLVMVectorType(to_float_type_scalar(ctx, elem_type),
LLVMGetVectorSize(t));
}
return to_float_type_scalar(ctx, t);
}
-static LLVMValueRef to_float(struct nir_to_llvm_context *ctx, LLVMValueRef v)
+static LLVMValueRef to_float(struct ac_llvm_context *ctx, LLVMValueRef v)
{
LLVMTypeRef type = LLVMTypeOf(v);
return LLVMBuildBitCast(ctx->builder, v, to_float_type(ctx, type), "");
}
-static int get_elem_bits(struct nir_to_llvm_context *ctx, LLVMTypeRef type)
+static int get_elem_bits(struct ac_llvm_context *ctx, LLVMTypeRef type)
{
if (LLVMGetTypeKind(type) == LLVMVectorTypeKind)
type = LLVMGetElementType(type);
if (LLVMGetTypeKind(type) == LLVMIntegerTypeKind)
return LLVMGetIntTypeWidth(type);
if (type == ctx->f16)
return 16;
if (type == ctx->f32)
@@ -1112,70 +1112,70 @@ static LLVMValueRef emit_int_cmp(struct
nir_to_llvm_context *ctx,
return LLVMBuildSelect(ctx->builder, result,
LLVMConstInt(ctx->i32, 0xFFFFFFFF, false),
LLVMConstInt(ctx->i32, 0, false), "");
}
static LLVMValueRef emit_float_cmp(struct nir_to_llvm_context *ctx,
LLVMRealPredicate pred, LLVMValueRef src0,
LLVMValueRef src1)
{
LLVMValueRef result;
- src0 = to_float(ctx, src0);
- src1 = to_float(ctx, src1);
+ src0 = to_float(&ctx->ac, src0);
+ src1 = to_float(&ctx->ac, src1);
result = LLVMBuildFCmp(ctx->builder, pred, src0, src1, "");
return LLVMBuildSelect(ctx->builder, result,
LLVMConstInt(ctx->i32, 0xFFFFFFFF, false),
LLVMConstInt(ctx->i32, 0, false), "");
}
static LLVMValueRef emit_intrin_1f_param(struct nir_to_llvm_context *ctx,
const char *intrin,
LLVMTypeRef result_type,
LLVMValueRef src0)
{
char name[64];
LLVMValueRef params[] = {
- to_float(ctx, src0),
+ to_float(&ctx->ac, src0),
};
- sprintf(name, "%s.f%d", intrin, get_elem_bits(ctx, result_type));
+ sprintf(name, "%s.f%d", intrin, get_elem_bits(&ctx->ac, result_type));
return ac_build_intrinsic(&ctx->ac, name, result_type, params, 1,
AC_FUNC_ATTR_READNONE);
}
static LLVMValueRef emit_intrin_2f_param(struct nir_to_llvm_context *ctx,
const char *intrin,
LLVMTypeRef result_type,
LLVMValueRef src0, LLVMValueRef src1)
{
char name[64];
LLVMValueRef params[] = {
- to_float(ctx, src0),
- to_float(ctx, src1),
+ to_float(&ctx->ac, src0),
+ to_float(&ctx->ac, src1),
};
- sprintf(name, "%s.f%d", intrin, get_elem_bits(ctx, result_type));
+ sprintf(name, "%s.f%d", intrin, get_elem_bits(&ctx->ac, result_type));
return ac_build_intrinsic(&ctx->ac, name, result_type, params, 2,
AC_FUNC_ATTR_READNONE);
}
static LLVMValueRef emit_intrin_3f_param(struct nir_to_llvm_context *ctx,
const char *intrin,
LLVMTypeRef result_type,
LLVMValueRef src0, LLVMValueRef src1,
LLVMValueRef src2)
{
char name[64];
LLVMValueRef params[] = {
- to_float(ctx, src0),
- to_float(ctx, src1),
- to_float(ctx, src2),
+ to_float(&ctx->ac, src0),
+ to_float(&ctx->ac, src1),
+ to_float(&ctx->ac, src2),
};
- sprintf(name, "%s.f%d", intrin, get_elem_bits(ctx, result_type));
+ sprintf(name, "%s.f%d", intrin, get_elem_bits(&ctx->ac, result_type));
return ac_build_intrinsic(&ctx->ac, name, result_type, params, 3,
AC_FUNC_ATTR_READNONE);
}
static LLVMValueRef emit_bcsel(struct nir_to_llvm_context *ctx,
LLVMValueRef src0, LLVMValueRef src1,
LLVMValueRef src2)
{
LLVMValueRef v = LLVMBuildICmp(ctx->builder, LLVMIntNE, src0,
ctx->i32zero, "");
return LLVMBuildSelect(ctx->builder, v, src1, src2, "");
}
@@ -1248,21 +1248,21 @@ static LLVMValueRef emit_isign(struct
nir_to_llvm_context *ctx,
val = LLVMBuildSelect(ctx->builder, cmp, ctx->i32one, src0, "");
cmp = LLVMBuildICmp(ctx->builder, LLVMIntSGE, val, ctx->i32zero, "");
val = LLVMBuildSelect(ctx->builder, cmp, val, LLVMConstInt(ctx->i32,
-1, true), "");
return val;
}
static LLVMValueRef emit_ffract(struct nir_to_llvm_context *ctx,
LLVMValueRef src0)
{
const char *intr = "llvm.floor.f32";
- LLVMValueRef fsrc0 = to_float(ctx, src0);
+ LLVMValueRef fsrc0 = to_float(&ctx->ac, src0);
LLVMValueRef params[] = {
fsrc0,
};
LLVMValueRef floor = ac_build_intrinsic(&ctx->ac, intr,
ctx->f32, params, 1,
AC_FUNC_ATTR_READNONE);
return LLVMBuildFSub(ctx->builder, fsrc0, floor, "");
}
static LLVMValueRef emit_uint_carry(struct nir_to_llvm_context *ctx,
@@ -1289,21 +1289,21 @@ static LLVMValueRef emit_b2f(struct nir_to_llvm_context
*ctx,
{
return LLVMBuildAnd(ctx->builder, src0, LLVMBuildBitCast(ctx->builder,
LLVMConstReal(ctx->f32, 1.0), ctx->i32, ""), "");
}
static LLVMValueRef emit_f2f16(struct nir_to_llvm_context *ctx,
LLVMValueRef src0)
{
LLVMValueRef result;
LLVMValueRef cond;
- src0 = to_float(ctx, src0);
+ src0 = to_float(&ctx->ac, src0);
result = LLVMBuildFPTrunc(ctx->builder, src0, ctx->f16, "");
/* TODO SI/CIK options here */
if (ctx->options->chip_class >= VI) {
LLVMValueRef args[2];
/* Check if the result is a denormal - and flush to 0 if so. */
args[0] = result;
args[1] = LLVMConstInt(ctx->i32, N_SUBNORMAL | P_SUBNORMAL,
false);
cond = ac_build_intrinsic(&ctx->ac, "llvm.amdgcn.class.f16",
ctx->i1, args, 2, AC_FUNC_ATTR_READNONE);
}
@@ -1385,21 +1385,21 @@ static LLVMValueRef emit_bitfield_insert(struct
nir_to_llvm_context *ctx,
return result;
}
static LLVMValueRef emit_pack_half_2x16(struct nir_to_llvm_context *ctx,
LLVMValueRef src0)
{
LLVMValueRef const16 = LLVMConstInt(ctx->i32, 16, false);
int i;
LLVMValueRef comp[2];
- src0 = to_float(ctx, src0);
+ src0 = to_float(&ctx->ac, src0);
comp[0] = LLVMBuildExtractElement(ctx->builder, src0, ctx->i32zero, "");
comp[1] = LLVMBuildExtractElement(ctx->builder, src0, ctx->i32one, "");
for (i = 0; i < 2; i++) {
comp[i] = LLVMBuildFPTrunc(ctx->builder, comp[i], ctx->f16, "");
comp[i] = LLVMBuildBitCast(ctx->builder, comp[i], ctx->i16, "");
comp[i] = LLVMBuildZExt(ctx->builder, comp[i], ctx->i32, "");
}
comp[1] = LLVMBuildShl(ctx->builder, comp[1], const16, "");
comp[0] = LLVMBuildOr(ctx->builder, comp[0], comp[1], "");
@@ -1510,89 +1510,89 @@ static void visit_alu(struct nir_to_llvm_context *ctx,
const nir_alu_instr *inst
}
for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++)
src[i] = get_alu_src(ctx, instr->src[i], src_components);
switch (instr->op) {
case nir_op_fmov:
case nir_op_imov:
result = src[0];
break;
case nir_op_fneg:
- src[0] = to_float(ctx, src[0]);
+ src[0] = to_float(&ctx->ac, src[0]);
result = LLVMBuildFNeg(ctx->builder, src[0], "");
break;
case nir_op_ineg:
result = LLVMBuildNeg(ctx->builder, src[0], "");
break;
case nir_op_inot:
result = LLVMBuildNot(ctx->builder, src[0], "");
break;
case nir_op_iadd:
result = LLVMBuildAdd(ctx->builder, src[0], src[1], "");
break;
case nir_op_fadd:
- src[0] = to_float(ctx, src[0]);
- src[1] = to_float(ctx, src[1]);
+ src[0] = to_float(&ctx->ac, src[0]);
+ src[1] = to_float(&ctx->ac, src[1]);
result = LLVMBuildFAdd(ctx->builder, src[0], src[1], "");
break;
case nir_op_fsub:
- src[0] = to_float(ctx, src[0]);
- src[1] = to_float(ctx, src[1]);
+ src[0] = to_float(&ctx->ac, src[0]);
+ src[1] = to_float(&ctx->ac, src[1]);
result = LLVMBuildFSub(ctx->builder, src[0], src[1], "");
break;
case nir_op_isub:
result = LLVMBuildSub(ctx->builder, src[0], src[1], "");
break;
case nir_op_imul:
result = LLVMBuildMul(ctx->builder, src[0], src[1], "");
break;
case nir_op_imod:
result = LLVMBuildSRem(ctx->builder, src[0], src[1], "");
break;
case nir_op_umod:
result = LLVMBuildURem(ctx->builder, src[0], src[1], "");
break;
case nir_op_fmod:
- src[0] = to_float(ctx, src[0]);
- src[1] = to_float(ctx, src[1]);
+ src[0] = to_float(&ctx->ac, src[0]);
+ src[1] = to_float(&ctx->ac, src[1]);
result = ac_build_fdiv(&ctx->ac, src[0], src[1]);
result = emit_intrin_1f_param(ctx, "llvm.floor",
- to_float_type(ctx, def_type),
result);
+ to_float_type(&ctx->ac,
def_type), result);
result = LLVMBuildFMul(ctx->builder, src[1] , result, "");
result = LLVMBuildFSub(ctx->builder, src[0], result, "");
break;
case nir_op_frem:
- src[0] = to_float(ctx, src[0]);
- src[1] = to_float(ctx, src[1]);
+ src[0] = to_float(&ctx->ac, src[0]);
+ src[1] = to_float(&ctx->ac, src[1]);
result = LLVMBuildFRem(ctx->builder, src[0], src[1], "");
break;
case nir_op_irem:
result = LLVMBuildSRem(ctx->builder, src[0], src[1], "");
break;
case nir_op_idiv:
result = LLVMBuildSDiv(ctx->builder, src[0], src[1], "");
break;
case nir_op_udiv:
result = LLVMBuildUDiv(ctx->builder, src[0], src[1], "");
break;
case nir_op_fmul:
- src[0] = to_float(ctx, src[0]);
- src[1] = to_float(ctx, src[1]);
+ src[0] = to_float(&ctx->ac, src[0]);
+ src[1] = to_float(&ctx->ac, src[1]);
result = LLVMBuildFMul(ctx->builder, src[0], src[1], "");
break;
case nir_op_fdiv:
- src[0] = to_float(ctx, src[0]);
- src[1] = to_float(ctx, src[1]);
+ src[0] = to_float(&ctx->ac, src[0]);
+ src[1] = to_float(&ctx->ac, src[1]);
result = ac_build_fdiv(&ctx->ac, src[0], src[1]);
break;
case nir_op_frcp:
- src[0] = to_float(ctx, src[0]);
+ src[0] = to_float(&ctx->ac, src[0]);
result = ac_build_fdiv(&ctx->ac, ctx->f32one, src[0]);
break;
case nir_op_iand:
result = LLVMBuildAnd(ctx->builder, src[0], src[1], "");
break;
case nir_op_ior:
result = LLVMBuildOr(ctx->builder, src[0], src[1], "");
break;
case nir_op_ixor:
result = LLVMBuildXor(ctx->builder, src[0], src[1], "");
@@ -1631,168 +1631,168 @@ static void visit_alu(struct nir_to_llvm_context
*ctx, const nir_alu_instr *inst
result = emit_float_cmp(ctx, LLVMRealUNE, src[0], src[1]);
break;
case nir_op_flt:
result = emit_float_cmp(ctx, LLVMRealULT, src[0], src[1]);
break;
case nir_op_fge:
result = emit_float_cmp(ctx, LLVMRealUGE, src[0], src[1]);
break;
case nir_op_fabs:
result = emit_intrin_1f_param(ctx, "llvm.fabs",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_iabs:
result = emit_iabs(ctx, src[0]);
break;
case nir_op_imax:
result = emit_minmax_int(ctx, LLVMIntSGT, src[0], src[1]);
break;
case nir_op_imin:
result = emit_minmax_int(ctx, LLVMIntSLT, src[0], src[1]);
break;
case nir_op_umax:
result = emit_minmax_int(ctx, LLVMIntUGT, src[0], src[1]);
break;
case nir_op_umin:
result = emit_minmax_int(ctx, LLVMIntULT, src[0], src[1]);
break;
case nir_op_isign:
result = emit_isign(ctx, src[0]);
break;
case nir_op_fsign:
- src[0] = to_float(ctx, src[0]);
+ src[0] = to_float(&ctx->ac, src[0]);
result = emit_fsign(ctx, src[0]);
break;
case nir_op_ffloor:
result = emit_intrin_1f_param(ctx, "llvm.floor",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_ftrunc:
result = emit_intrin_1f_param(ctx, "llvm.trunc",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_fceil:
result = emit_intrin_1f_param(ctx, "llvm.ceil",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_fround_even:
result = emit_intrin_1f_param(ctx, "llvm.rint",
- to_float_type(ctx,
def_type),src[0]);
+ to_float_type(&ctx->ac,
def_type),src[0]);
break;
case nir_op_ffract:
result = emit_ffract(ctx, src[0]);
break;
case nir_op_fsin:
result = emit_intrin_1f_param(ctx, "llvm.sin",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_fcos:
result = emit_intrin_1f_param(ctx, "llvm.cos",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_fsqrt:
result = emit_intrin_1f_param(ctx, "llvm.sqrt",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_fexp2:
result = emit_intrin_1f_param(ctx, "llvm.exp2",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_flog2:
result = emit_intrin_1f_param(ctx, "llvm.log2",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
break;
case nir_op_frsq:
result = emit_intrin_1f_param(ctx, "llvm.sqrt",
- to_float_type(ctx, def_type),
src[0]);
+ to_float_type(&ctx->ac,
def_type), src[0]);
result = ac_build_fdiv(&ctx->ac, ctx->f32one, result);
break;
case nir_op_fpow:
result = emit_intrin_2f_param(ctx, "llvm.pow",
- to_float_type(ctx, def_type),
src[0], src[1]);
+ to_float_type(&ctx->ac,
def_type), src[0], src[1]);
break;
case nir_op_fmax:
result = emit_intrin_2f_param(ctx, "llvm.maxnum",
- to_float_type(ctx, def_type),
src[0], src[1]);
+ to_float_type(&ctx->ac,
def_type), src[0], src[1]);
if (instr->dest.dest.ssa.bit_size == 32)
result = emit_intrin_1f_param(ctx, "llvm.canonicalize",
- to_float_type(ctx,
def_type),
+ to_float_type(&ctx->ac,
def_type),
result);
break;
case nir_op_fmin:
result = emit_intrin_2f_param(ctx, "llvm.minnum",
- to_float_type(ctx, def_type),
src[0], src[1]);
+ to_float_type(&ctx->ac,
def_type), src[0], src[1]);
if (instr->dest.dest.ssa.bit_size == 32)
result = emit_intrin_1f_param(ctx, "llvm.canonicalize",
- to_float_type(ctx,
def_type),
+ to_float_type(&ctx->ac,
def_type),
result);
break;
case nir_op_ffma:
result = emit_intrin_3f_param(ctx, "llvm.fma",
- to_float_type(ctx, def_type),
src[0], src[1], src[2]);
+ to_float_type(&ctx->ac,
def_type), src[0], src[1], src[2]);
break;
case nir_op_ibitfield_extract:
result = emit_bitfield_extract(ctx, true, src);
break;
case nir_op_ubitfield_extract:
result = emit_bitfield_extract(ctx, false, src);
break;
case nir_op_bitfield_insert:
result = emit_bitfield_insert(ctx, src[0], src[1], src[2],
src[3]);
break;
case nir_op_bitfield_reverse:
result = ac_build_intrinsic(&ctx->ac, "llvm.bitreverse.i32",
ctx->i32, src, 1, AC_FUNC_ATTR_READNONE);
break;
case nir_op_bit_count:
result = ac_build_intrinsic(&ctx->ac, "llvm.ctpop.i32",
ctx->i32, src, 1, AC_FUNC_ATTR_READNONE);
break;
case nir_op_vec2:
case nir_op_vec3:
case nir_op_vec4:
for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs;
i++)
- src[i] = to_integer(ctx, src[i]);
+ src[i] = to_integer(&ctx->ac, src[i]);
result = ac_build_gather_values(&ctx->ac, src, num_components);
break;
case nir_op_f2i32:
case nir_op_f2i64:
- src[0] = to_float(ctx, src[0]);
+ src[0] = to_float(&ctx->ac, src[0]);
result = LLVMBuildFPToSI(ctx->builder, src[0], def_type, "");
break;
case nir_op_f2u32:
case nir_op_f2u64:
- src[0] = to_float(ctx, src[0]);
+ src[0] = to_float(&ctx->ac, src[0]);
result = LLVMBuildFPToUI(ctx->builder, src[0], def_type, "");
break;
case nir_op_i2f32:
case nir_op_i2f64:
- result = LLVMBuildSIToFP(ctx->builder, src[0],
to_float_type(ctx, def_type), "");
+ result = LLVMBuildSIToFP(ctx->builder, src[0],
to_float_type(&ctx->ac, def_type), "");
break;
case nir_op_u2f32:
case nir_op_u2f64:
- result = LLVMBuildUIToFP(ctx->builder, src[0],
to_float_type(ctx, def_type), "");
+ result = LLVMBuildUIToFP(ctx->builder, src[0],
to_float_type(&ctx->ac, def_type), "");
break;
case nir_op_f2f64:
- result = LLVMBuildFPExt(ctx->builder, src[0],
to_float_type(ctx, def_type), "");
+ result = LLVMBuildFPExt(ctx->builder, src[0],
to_float_type(&ctx->ac, def_type), "");
break;
case nir_op_f2f32:
- result = LLVMBuildFPTrunc(ctx->builder, src[0],
to_float_type(ctx, def_type), "");
+ result = LLVMBuildFPTrunc(ctx->builder, src[0],
to_float_type(&ctx->ac, def_type), "");
break;
case nir_op_u2u32:
case nir_op_u2u64:
- if (get_elem_bits(ctx, LLVMTypeOf(src[0])) < get_elem_bits(ctx,
def_type))
+ if (get_elem_bits(&ctx->ac, LLVMTypeOf(src[0])) <
get_elem_bits(&ctx->ac, def_type))
result = LLVMBuildZExt(ctx->builder, src[0], def_type,
"");
else
result = LLVMBuildTrunc(ctx->builder, src[0], def_type,
"");
break;
case nir_op_i2i32:
case nir_op_i2i64:
- if (get_elem_bits(ctx, LLVMTypeOf(src[0])) < get_elem_bits(ctx,
def_type))
+ if (get_elem_bits(&ctx->ac, LLVMTypeOf(src[0])) <
get_elem_bits(&ctx->ac, def_type))
result = LLVMBuildSExt(ctx->builder, src[0], def_type,
"");
else
result = LLVMBuildTrunc(ctx->builder, src[0], def_type,
"");
break;
case nir_op_bcsel:
result = emit_bcsel(ctx, src[0], src[1], src[2]);
break;
case nir_op_find_lsb:
result = emit_find_lsb(ctx, src[0]);
break;
@@ -1836,21 +1836,21 @@ static void visit_alu(struct nir_to_llvm_context *ctx,
const nir_alu_instr *inst
break;
default:
fprintf(stderr, "Unknown NIR alu instr: ");
nir_print_instr(&instr->instr, stderr);
fprintf(stderr, "\n");
abort();
}
if (result) {
assert(instr->dest.dest.is_ssa);
- result = to_integer(ctx, result);
+ result = to_integer(&ctx->ac, result);
_mesa_hash_table_insert(ctx->defs, &instr->dest.dest.ssa,
result);
}
}
static void visit_load_const(struct nir_to_llvm_context *ctx,
const nir_load_const_instr *instr)
{
LLVMValueRef values[4], value = NULL;
LLVMTypeRef element_type =
@@ -2165,38 +2165,38 @@ static LLVMValueRef visit_get_buffer_size(struct
nir_to_llvm_context *ctx,
LLVMValueRef desc = get_src(ctx, instr->src[0]);
return get_buffer_size(ctx, desc, false);
}
static void visit_store_ssbo(struct nir_to_llvm_context *ctx,
nir_intrinsic_instr *instr)
{
const char *store_name;
LLVMValueRef src_data = get_src(ctx, instr->src[0]);
LLVMTypeRef data_type = ctx->f32;
- int elem_size_mult = get_elem_bits(ctx, LLVMTypeOf(src_data)) / 32;
+ int elem_size_mult = get_elem_bits(&ctx->ac, LLVMTypeOf(src_data)) / 32;
int components_32bit = elem_size_mult * instr->num_components;
unsigned writemask = nir_intrinsic_write_mask(instr);
LLVMValueRef base_data, base_offset;
LLVMValueRef params[6];
if (ctx->stage == MESA_SHADER_FRAGMENT)
ctx->shader_info->fs.writes_memory = true;
params[1] = get_src(ctx, instr->src[1]);
params[2] = LLVMConstInt(ctx->i32, 0, false); /* vindex */
params[4] = ctx->i1false; /* glc */
params[5] = ctx->i1false; /* slc */
if (components_32bit > 1)
data_type = LLVMVectorType(ctx->f32, components_32bit);
- base_data = to_float(ctx, src_data);
+ base_data = to_float(&ctx->ac, src_data);
base_data = trim_vector(ctx, base_data, instr->num_components);
base_data = LLVMBuildBitCast(ctx->builder, base_data,
data_type, "");
base_offset = get_src(ctx, instr->src[2]); /* voffset */
while (writemask) {
int start, count;
LLVMValueRef data;
LLVMValueRef offset;
LLVMValueRef tmp;
u_bit_scan_consecutive_range(&writemask, &start, &count);
@@ -2941,28 +2941,28 @@ static LLVMValueRef visit_load_var(struct
nir_to_llvm_context *ctx,
ret = ac_build_gather_values(&ctx->ac, values, ve);
return LLVMBuildBitCast(ctx->builder, ret, get_def_type(ctx,
&instr->dest.ssa), "");
}
static void
visit_store_var(struct nir_to_llvm_context *ctx,
nir_intrinsic_instr *instr)
{
LLVMValueRef temp_ptr, value;
int idx = instr->variables[0]->var->data.driver_location;
- LLVMValueRef src = to_float(ctx, get_src(ctx, instr->src[0]));
+ LLVMValueRef src = to_float(&ctx->ac, get_src(ctx, instr->src[0]));
int writemask = instr->const_index[0];
LLVMValueRef indir_index;
unsigned const_index;
radv_get_deref_offset(ctx, instr->variables[0], false,
NULL, NULL, &const_index, &indir_index);
- if (get_elem_bits(ctx, LLVMTypeOf(src)) == 64) {
+ if (get_elem_bits(&ctx->ac, LLVMTypeOf(src)) == 64) {
int old_writemask = writemask;
src = LLVMBuildBitCast(ctx->builder, src,
LLVMVectorType(ctx->f32,
get_llvm_num_components(src) * 2),
"");
writemask = 0;
for (unsigned chan = 0; chan < 4; chan++) {
if (old_writemask & (1 << chan))
writemask |= 3u << (2 * chan);
@@ -3045,21 +3045,21 @@ visit_store_var(struct nir_to_llvm_context *ctx,
continue;
LLVMValueRef index = LLVMConstInt(ctx->i32, chan,
false);
LLVMValueRef derived_ptr;
if (indir_index)
index = LLVMBuildAdd(ctx->builder, index,
indir_index, "");
value = llvm_extract_elem(ctx, src, chan);
derived_ptr = LLVMBuildGEP(ctx->builder, ptr, &index,
1, "");
LLVMBuildStore(ctx->builder,
- to_integer(ctx, value), derived_ptr);
+ to_integer(&ctx->ac, value),
derived_ptr);
}
break;
}
default:
break;
}
}
static int image_type_to_components_count(enum glsl_sampler_dim dim, bool
array)
{
@@ -3121,21 +3121,21 @@ static LLVMValueRef
adjust_sample_index_using_fmask(struct nir_to_llvm_context *
struct ac_image_args args = {0};
args.opcode = ac_image_load;
args.da = coord_z ? true : false;
args.resource = fmask_desc_ptr;
args.dmask = 0xf;
args.addr = ac_build_gather_values(&ctx->ac, fmask_load_address,
coord_z ? 4 : 2);
res = ac_build_image_opcode(&ctx->ac, &args);
- res = to_integer(ctx, res);
+ res = to_integer(&ctx->ac, res);
LLVMValueRef four = LLVMConstInt(ctx->i32, 4, false);
LLVMValueRef F = LLVMConstInt(ctx->i32, 0xf, false);
LLVMValueRef fmask = LLVMBuildExtractElement(ctx->builder,
res,
ctx->i32zero, "");
LLVMValueRef sample_index4 =
LLVMBuildMul(ctx->builder, sample_index, four, "");
LLVMValueRef shifted_fmask =
@@ -3259,21 +3259,21 @@ static LLVMValueRef visit_image_load(struct
nir_to_llvm_context *ctx,
params[0] = get_sampler_desc(ctx, instr->variables[0],
DESC_BUFFER);
params[1] = LLVMBuildExtractElement(ctx->builder, get_src(ctx,
instr->src[0]),
LLVMConstInt(ctx->i32, 0,
false), ""); /* vindex */
params[2] = LLVMConstInt(ctx->i32, 0, false); /* voffset */
params[3] = ctx->i1false; /* glc */
params[4] = ctx->i1false; /* slc */
res = ac_build_intrinsic(&ctx->ac,
"llvm.amdgcn.buffer.load.format.v4f32", ctx->v4f32,
params, 5, 0);
res = trim_vector(ctx, res, instr->dest.ssa.num_components);
- res = to_integer(ctx, res);
+ res = to_integer(&ctx->ac, res);
} else {
bool is_da = glsl_sampler_type_is_array(type) ||
glsl_get_sampler_dim(type) ==
GLSL_SAMPLER_DIM_CUBE;
LLVMValueRef da = is_da ? ctx->i1true : ctx->i1false;
LLVMValueRef glc = ctx->i1false;
LLVMValueRef slc = ctx->i1false;
params[0] = get_image_coords(ctx, instr);
params[1] = get_sampler_desc(ctx, instr->variables[0],
DESC_IMAGE);
params[2] = LLVMConstInt(ctx->i32, 15, false); /* dmask */
@@ -3292,52 +3292,52 @@ static LLVMValueRef visit_image_load(struct
nir_to_llvm_context *ctx,
ac_get_image_intr_name("llvm.amdgcn.image.load",
ctx->v4f32, /* vdata */
LLVMTypeOf(params[0]), /* coords */
LLVMTypeOf(params[1]), /* rsrc */
intrinsic_name, sizeof(intrinsic_name));
res = ac_build_intrinsic(&ctx->ac, intrinsic_name, ctx->v4f32,
params, 7, AC_FUNC_ATTR_READONLY);
}
- return to_integer(ctx, res);
+ return to_integer(&ctx->ac, res);
}
static void visit_image_store(struct nir_to_llvm_context *ctx,
nir_intrinsic_instr *instr)
{
LLVMValueRef params[8];
char intrinsic_name[64];
const nir_variable *var = instr->variables[0]->var;
const struct glsl_type *type = glsl_without_array(var->type);
if (ctx->stage == MESA_SHADER_FRAGMENT)
ctx->shader_info->fs.writes_memory = true;
if (glsl_get_sampler_dim(type) == GLSL_SAMPLER_DIM_BUF) {
- params[0] = to_float(ctx, get_src(ctx, instr->src[2])); /* data
*/
+ params[0] = to_float(&ctx->ac, get_src(ctx, instr->src[2])); /*
data */
params[1] = get_sampler_desc(ctx, instr->variables[0],
DESC_BUFFER);
params[2] = LLVMBuildExtractElement(ctx->builder, get_src(ctx,
instr->src[0]),
LLVMConstInt(ctx->i32, 0,
false), ""); /* vindex */
params[3] = LLVMConstInt(ctx->i32, 0, false); /* voffset */
params[4] = ctx->i1false; /* glc */
params[5] = ctx->i1false; /* slc */
ac_build_intrinsic(&ctx->ac,
"llvm.amdgcn.buffer.store.format.v4f32", ctx->voidt,
params, 6, 0);
} else {
bool is_da = glsl_sampler_type_is_array(type) ||
glsl_get_sampler_dim(type) ==
GLSL_SAMPLER_DIM_CUBE;
LLVMValueRef da = is_da ? ctx->i1true : ctx->i1false;
LLVMValueRef glc = ctx->i1false;
LLVMValueRef slc = ctx->i1false;
- params[0] = to_float(ctx, get_src(ctx, instr->src[2]));
+ params[0] = to_float(&ctx->ac, get_src(ctx, instr->src[2]));
params[1] = get_image_coords(ctx, instr); /* coords */
params[2] = get_sampler_desc(ctx, instr->variables[0],
DESC_IMAGE);
params[3] = LLVMConstInt(ctx->i32, 15, false); /* dmask */
if (HAVE_LLVM <= 0x0309) {
params[4] = ctx->i1false; /* r128 */
params[5] = da;
params[6] = glc;
params[7] = slc;
} else {
LLVMValueRef lwe = ctx->i1false;
@@ -3566,21 +3566,21 @@ static LLVMValueRef visit_var_atomic(struct
nir_to_llvm_context *ctx,
case nir_intrinsic_var_atomic_xor:
op = LLVMAtomicRMWBinOpXor;
break;
case nir_intrinsic_var_atomic_exchange:
op = LLVMAtomicRMWBinOpXchg;
break;
default:
return NULL;
}
- result = LLVMBuildAtomicRMW(ctx->builder, op, ptr,
to_integer(ctx, src),
+ result = LLVMBuildAtomicRMW(ctx->builder, op, ptr,
to_integer(&ctx->ac, src),
LLVMAtomicOrderingSequentiallyConsistent,
false);
}
return result;
}
#define INTERP_CENTER 0
#define INTERP_CENTROID 1
#define INTERP_SAMPLE 2
@@ -3653,22 +3653,22 @@ static LLVMValueRef visit_interp(struct
nir_to_llvm_context *ctx,
case nir_intrinsic_interp_var_at_sample:
case nir_intrinsic_interp_var_at_offset:
location = INTERP_CENTER;
src0 = get_src(ctx, instr->src[0]);
break;
default:
break;
}
if (instr->intrinsic == nir_intrinsic_interp_var_at_offset) {
- src_c0 = to_float(ctx, LLVMBuildExtractElement(ctx->builder,
src0, ctx->i32zero, ""));
- src_c1 = to_float(ctx, LLVMBuildExtractElement(ctx->builder,
src0, ctx->i32one, ""));
+ src_c0 = to_float(&ctx->ac,
LLVMBuildExtractElement(ctx->builder, src0, ctx->i32zero, ""));
+ src_c1 = to_float(&ctx->ac,
LLVMBuildExtractElement(ctx->builder, src0, ctx->i32one, ""));
} else if (instr->intrinsic == nir_intrinsic_interp_var_at_sample) {
LLVMValueRef sample_position;
LLVMValueRef halfval = LLVMConstReal(ctx->f32, 0.5f);
/* fetch sample ID */
sample_position = load_sample_position(ctx, src0);
src_c0 = LLVMBuildExtractElement(ctx->builder, sample_position,
ctx->i32zero, "");
src_c0 = LLVMBuildFSub(ctx->builder, src_c0, halfval, "");
src_c1 = LLVMBuildExtractElement(ctx->builder, sample_position,
ctx->i32one, "");
@@ -4180,23 +4180,23 @@ static void tex_fetch_ptrs(struct nir_to_llvm_context
*ctx,
*samp_ptr = sici_fix_sampler_aniso(ctx, *res_ptr,
*samp_ptr);
}
if (fmask_ptr && !instr->sampler && (instr->op == nir_texop_txf_ms ||
instr->op ==
nir_texop_samples_identical))
*fmask_ptr = get_sampler_desc(ctx, instr->texture, DESC_FMASK);
}
static LLVMValueRef apply_round_slice(struct nir_to_llvm_context *ctx,
LLVMValueRef coord)
{
- coord = to_float(ctx, coord);
+ coord = to_float(&ctx->ac, coord);
coord = ac_build_intrinsic(&ctx->ac, "llvm.rint.f32", ctx->f32, &coord,
1, 0);
- coord = to_integer(ctx, coord);
+ coord = to_integer(&ctx->ac, coord);
return coord;
}
static void visit_tex(struct nir_to_llvm_context *ctx, nir_tex_instr *instr)
{
LLVMValueRef result = NULL;
struct ac_image_args args = { 0 };
unsigned dmask = 0xf;
LLVMValueRef address[16];
LLVMValueRef coords[5];
@@ -4327,30 +4327,30 @@ static void visit_tex(struct nir_to_llvm_context *ctx,
nir_tex_instr *instr)
case GLSL_SAMPLER_DIM_2D:
default:
num_deriv_comp = 2;
break;
case GLSL_SAMPLER_DIM_1D:
num_deriv_comp = 1;
break;
}
for (unsigned i = 0; i < num_deriv_comp; i++) {
- derivs[i] = to_float(ctx, llvm_extract_elem(ctx, ddx,
i));
- derivs[num_deriv_comp + i] = to_float(ctx,
llvm_extract_elem(ctx, ddy, i));
+ derivs[i] = to_float(&ctx->ac, llvm_extract_elem(ctx,
ddx, i));
+ derivs[num_deriv_comp + i] = to_float(&ctx->ac,
llvm_extract_elem(ctx, ddy, i));
}
}
if (instr->sampler_dim == GLSL_SAMPLER_DIM_CUBE && coord) {
if (instr->is_array && instr->op != nir_texop_lod)
coords[3] = apply_round_slice(ctx, coords[3]);
for (chan = 0; chan < instr->coord_components; chan++)
- coords[chan] = to_float(ctx, coords[chan]);
+ coords[chan] = to_float(&ctx->ac, coords[chan]);
if (instr->coord_components == 3)
coords[3] = LLVMGetUndef(ctx->f32);
ac_prepare_cube_coords(&ctx->ac,
instr->op == nir_texop_txd, instr->is_array,
coords, derivs);
if (num_deriv_comp)
num_deriv_comp--;
}
if (ddx || ddy) {
@@ -4469,21 +4469,21 @@ static void visit_tex(struct nir_to_llvm_context *ctx,
nir_tex_instr *instr)
LLVMValueRef six = LLVMConstInt(ctx->i32, 6, false);
LLVMValueRef z = LLVMBuildExtractElement(ctx->builder, result,
two, "");
z = LLVMBuildSDiv(ctx->builder, z, six, "");
result = LLVMBuildInsertElement(ctx->builder, result, z, two,
"");
} else if (instr->dest.ssa.num_components != 4)
result = trim_vector(ctx, result,
instr->dest.ssa.num_components);
write_result:
if (result) {
assert(instr->dest.is_ssa);
- result = to_integer(ctx, result);
+ result = to_integer(&ctx->ac, result);
_mesa_hash_table_insert(ctx->defs, &instr->dest.ssa, result);
}
}
static void visit_phi(struct nir_to_llvm_context *ctx, nir_phi_instr *instr)
{
LLVMTypeRef type = get_def_type(ctx, &instr->dest.ssa);
LLVMValueRef result = LLVMBuildPhi(ctx->builder, type, "");
@@ -4699,21 +4699,21 @@ handle_vs_input_decl(struct nir_to_llvm_context *ctx,
t_list = ac_build_indexed_load_const(&ctx->ac, t_list_ptr,
t_offset);
input = ac_build_buffer_load_format(&ctx->ac, t_list,
buffer_index,
LLVMConstInt(ctx->i32, 0,
false),
true);
for (unsigned chan = 0; chan < 4; chan++) {
LLVMValueRef llvm_chan = LLVMConstInt(ctx->i32, chan,
false);
ctx->inputs[radeon_llvm_reg_index_soa(idx, chan)] =
- to_integer(ctx,
LLVMBuildExtractElement(ctx->builder,
+ to_integer(&ctx->ac,
LLVMBuildExtractElement(ctx->builder,
input, llvm_chan, ""));
}
}
}
static void interp_fs_input(struct nir_to_llvm_context *ctx,
unsigned attr,
LLVMValueRef interp_param,
LLVMValueRef prim_mask,
LLVMValueRef result[4])
@@ -4948,21 +4948,21 @@ setup_locals(struct nir_to_llvm_context *ctx,
for (j = 0; j < 4; j++) {
ctx->locals[i * 4 + j] =
si_build_alloca_undef(ctx, ctx->f32, "temp");
}
}
}
static LLVMValueRef
emit_float_saturate(struct nir_to_llvm_context *ctx, LLVMValueRef v, float lo,
float hi)
{
- v = to_float(ctx, v);
+ v = to_float(&ctx->ac, v);
v = emit_intrin_2f_param(ctx, "llvm.maxnum.f32", ctx->f32, v,
LLVMConstReal(ctx->f32, lo));
return emit_intrin_2f_param(ctx, "llvm.minnum.f32", ctx->f32, v,
LLVMConstReal(ctx->f32, hi));
}
static LLVMValueRef emit_pack_int16(struct nir_to_llvm_context *ctx,
LLVMValueRef src0, LLVMValueRef src1)
{
LLVMValueRef const16 = LLVMConstInt(ctx->i32, 16, false);
LLVMValueRef comp[2];
@@ -5079,57 +5079,57 @@ si_llvm_init_export_args(struct nir_to_llvm_context
*ctx,
args->compr = 1;
args->out[0] = emit_pack_int16(ctx, val[0], val[1]);
args->out[1] = emit_pack_int16(ctx, val[2], val[3]);
break;
case V_028714_SPI_SHADER_UINT16_ABGR: {
LLVMValueRef max = LLVMConstInt(ctx->i32, is_int8 ? 255
: 65535, 0);
for (unsigned chan = 0; chan < 4; chan++) {
- val[chan] = to_integer(ctx, values[chan]);
+ val[chan] = to_integer(&ctx->ac, values[chan]);
val[chan] = emit_minmax_int(ctx, LLVMIntULT,
val[chan], max);
}
args->compr = 1;
args->out[0] = emit_pack_int16(ctx, val[0], val[1]);
args->out[1] = emit_pack_int16(ctx, val[2], val[3]);
break;
}
case V_028714_SPI_SHADER_SINT16_ABGR: {
LLVMValueRef max = LLVMConstInt(ctx->i32, is_int8 ? 127
: 32767, 0);
LLVMValueRef min = LLVMConstInt(ctx->i32, is_int8 ?
-128 : -32768, 0);
/* Clamp. */
for (unsigned chan = 0; chan < 4; chan++) {
- val[chan] = to_integer(ctx, values[chan]);
+ val[chan] = to_integer(&ctx->ac, values[chan]);
val[chan] = emit_minmax_int(ctx, LLVMIntSLT,
val[chan], max);
val[chan] = emit_minmax_int(ctx, LLVMIntSGT,
val[chan], min);
}
args->compr = 1;
args->out[0] = emit_pack_int16(ctx, val[0], val[1]);
args->out[1] = emit_pack_int16(ctx, val[2], val[3]);
break;
}
default:
case V_028714_SPI_SHADER_32_ABGR:
memcpy(&args->out[0], values, sizeof(values[0]) * 4);
break;
}
} else
memcpy(&args->out[0], values, sizeof(values[0]) * 4);
for (unsigned i = 0; i < 4; ++i)
- args->out[i] = to_float(ctx, args->out[i]);
+ args->out[i] = to_float(&ctx->ac, args->out[i]);
}
static void
handle_vs_outputs_post(struct nir_to_llvm_context *ctx,
struct ac_vs_output_info *outinfo)
{
uint32_t param_count = 0;
unsigned target;
unsigned pos_idx, num_pos_exports = 0;
struct ac_export_args args, pos_args[4] = {};
@@ -5141,21 +5141,21 @@ handle_vs_outputs_post(struct nir_to_llvm_context *ctx,
if (ctx->output_mask & (1ull << VARYING_SLOT_CLIP_DIST0)) {
LLVMValueRef slots[8];
unsigned j;
if (outinfo->cull_dist_mask)
outinfo->cull_dist_mask <<= ctx->num_output_clips;
i = VARYING_SLOT_CLIP_DIST0;
for (j = 0; j < ctx->num_output_clips + ctx->num_output_culls;
j++)
- slots[j] = to_float(ctx, LLVMBuildLoad(ctx->builder,
+ slots[j] = to_float(&ctx->ac,
LLVMBuildLoad(ctx->builder,
ctx->outputs[radeon_llvm_reg_index_soa(i, j)], ""));
for (i = ctx->num_output_clips + ctx->num_output_culls; i < 8;
i++)
slots[i] = LLVMGetUndef(ctx->f32);
if (ctx->num_output_clips + ctx->num_output_culls > 4) {
target = V_008DFC_SQ_EXP_POS + 3;
si_llvm_init_export_args(ctx, &slots[4], target, &args);
memcpy(&pos_args[target - V_008DFC_SQ_EXP_POS],
&args, sizeof(args));
@@ -5167,21 +5167,21 @@ handle_vs_outputs_post(struct nir_to_llvm_context *ctx,
&args, sizeof(args));
}
for (unsigned i = 0; i < RADEON_LLVM_MAX_OUTPUTS; ++i) {
LLVMValueRef values[4];
if (!(ctx->output_mask & (1ull << i)))
continue;
for (unsigned j = 0; j < 4; j++)
- values[j] = to_float(ctx, LLVMBuildLoad(ctx->builder,
+ values[j] = to_float(&ctx->ac,
LLVMBuildLoad(ctx->builder,
ctx->outputs[radeon_llvm_reg_index_soa(i, j)], ""));
if (i == VARYING_SLOT_POS) {
target = V_008DFC_SQ_EXP_POS;
} else if (i == VARYING_SLOT_CLIP_DIST0) {
continue;
} else if (i == VARYING_SLOT_PSIZ) {
outinfo->writes_pointsize = true;
psize_value = values[0];
continue;
@@ -5643,34 +5643,34 @@ handle_fs_outputs_post(struct nir_to_llvm_context *ctx)
struct ac_export_args color_args[8];
for (unsigned i = 0; i < RADEON_LLVM_MAX_OUTPUTS; ++i) {
LLVMValueRef values[4];
if (!(ctx->output_mask & (1ull << i)))
continue;
if (i == FRAG_RESULT_DEPTH) {
ctx->shader_info->fs.writes_z = true;
- depth = to_float(ctx, LLVMBuildLoad(ctx->builder,
+ depth = to_float(&ctx->ac, LLVMBuildLoad(ctx->builder,
ctx->outputs[radeon_llvm_reg_index_soa(i, 0)], ""));
} else if (i == FRAG_RESULT_STENCIL) {
ctx->shader_info->fs.writes_stencil = true;
- stencil = to_float(ctx, LLVMBuildLoad(ctx->builder,
+ stencil = to_float(&ctx->ac, LLVMBuildLoad(ctx->builder,
ctx->outputs[radeon_llvm_reg_index_soa(i, 0)], ""));
} else if (i == FRAG_RESULT_SAMPLE_MASK) {
ctx->shader_info->fs.writes_sample_mask = true;
- samplemask = to_float(ctx, LLVMBuildLoad(ctx->builder,
+ samplemask = to_float(&ctx->ac,
LLVMBuildLoad(ctx->builder,
ctx->outputs[radeon_llvm_reg_index_soa(i, 0)], ""));
} else {
bool last = false;
for (unsigned j = 0; j < 4; j++)
- values[j] = to_float(ctx,
LLVMBuildLoad(ctx->builder,
+ values[j] = to_float(&ctx->ac,
LLVMBuildLoad(ctx->builder,
ctx->outputs[radeon_llvm_reg_index_soa(i, j)], ""));
if (!ctx->shader_info->fs.writes_z &&
!ctx->shader_info->fs.writes_stencil &&
!ctx->shader_info->fs.writes_sample_mask)
last = ctx->output_mask <= ((1ull << (i + 1)) -
1);
bool ret = si_export_mrt_color(ctx, values,
V_008DFC_SQ_EXP_MRT + (i - FRAG_RESULT_DATA0), last, &color_args[index]);
if (ret)
index++;
}
}
@@ -6185,21 +6185,21 @@ ac_gs_copy_shader_emit(struct nir_to_llvm_context *ctx)
(slot * 4 + j) *
ctx->gs_max_out_vertices * 16 *
4, false);
value = ac_build_intrinsic(&ctx->ac,
"llvm.SI.buffer.load.dword.i32.i32",
ctx->i32, args, 9,
AC_FUNC_ATTR_READONLY |
AC_FUNC_ATTR_LEGACY);
LLVMBuildStore(ctx->builder,
- to_float(ctx, value),
ctx->outputs[radeon_llvm_reg_index_soa(i, j)]);
+ to_float(&ctx->ac, value),
ctx->outputs[radeon_llvm_reg_index_soa(i, j)]);
}
idx += slot_inc;
}
handle_vs_outputs_post(ctx, &ctx->shader_info->vs.outinfo);
}
void ac_create_gs_copy_shader(LLVMTargetMachineRef tm,
struct nir_shader *geom_shader,
struct ac_shader_binary *binary,
struct ac_shader_config *config,
--
2.9.3
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
