static void
fs_lower_opcode_kil(struct toy_compiler *tc, struct toy_inst *inst)
{
struct toy_dst pixel_mask_dst;
struct toy_src f0, pixel_mask;
struct toy_inst *tmp;
/* lower half of r1.7:ud */
pixel_mask_dst = tdst_uw(tdst(TOY_FILE_GRF, 1, 7 * 4));
pixel_mask = tsrc_rect(tsrc_from(pixel_mask_dst), TOY_RECT_010);
f0 = tsrc_rect(tsrc_uw(tsrc(TOY_FILE_ARF, BRW_ARF_FLAG, 0)), TOY_RECT_010);
/* KILP or KIL */
if (tsrc_is_null(inst->src[0])) {
struct toy_src dummy = tsrc_uw(tsrc(TOY_FILE_GRF, 0, 0));
struct toy_dst f0_dst = tdst_uw(tdst(TOY_FILE_ARF, BRW_ARF_FLAG, 0));
/* create a mask that masks out all pixels */
tmp = tc_MOV(tc, f0_dst, tsrc_rect(tsrc_imm_uw(0xffff), TOY_RECT_010));
tmp->exec_size = BRW_EXECUTE_1;
tmp->mask_ctrl = BRW_MASK_DISABLE;
tc_CMP(tc, tdst_null(), dummy, dummy, BRW_CONDITIONAL_NEQ);
/* swapping the two src operands breaks glBitmap()!? */
tmp = tc_AND(tc, pixel_mask_dst, f0, pixel_mask);
tmp->exec_size = BRW_EXECUTE_1;
tmp->mask_ctrl = BRW_MASK_DISABLE;
}
else {
struct toy_src src[4];
int i;
tsrc_transpose(inst->src[0], src);
/* mask out killed pixels */
for (i = 0; i < 4; i++) {
tc_CMP(tc, tdst_null(), src[i], tsrc_imm_f(0.0f),
BRW_CONDITIONAL_GE);
/* swapping the two src operands breaks glBitmap()!? */
tmp = tc_AND(tc, pixel_mask_dst, f0, pixel_mask);
tmp->exec_size = BRW_EXECUTE_1;
tmp->mask_ctrl = BRW_MASK_DISABLE;
}
}
tc_discard_inst(tc, inst);
}
/**
* Dump an instruction.
*/
static void
tc_dump_inst(struct toy_compiler *tc, const struct toy_inst *inst)
{
const char *name;
int i;
name = get_opcode_name(inst->opcode);
ilo_printf(" %s", name);
if (inst->opcode == GEN6_OPCODE_NOP) {
ilo_printf("\n");
return;
}
if (inst->saturate)
ilo_printf(".sat");
name = get_cond_modifier_name(inst->opcode, inst->cond_modifier);
if (name)
ilo_printf(".%s", name);
ilo_printf(" ");
tc_dump_dst(tc, inst->dst);
for (i = 0; i < Elements(inst->src); i++) {
if (tsrc_is_null(inst->src[i]))
break;
ilo_printf(", ");
tc_dump_src(tc, inst->src[i]);
}
ilo_printf("\n");
}
/**
* Set up message registers and return the message descriptor for sampling.
*/
static struct toy_src
vs_prepare_tgsi_sampling(struct vs_compile_context *vcc,
const struct toy_inst *inst,
int base_mrf, unsigned *ret_sampler_index)
{
struct toy_compiler *tc = &vcc->tc;
unsigned simd_mode, msg_type, msg_len, sampler_index, binding_table_index;
struct toy_src coords, ddx, ddy, bias_or_lod, ref_or_si;
int num_coords, ref_pos, num_derivs;
int sampler_src;
simd_mode = GEN6_MSG_SAMPLER_SIMD4X2;
coords = inst->src[0];
ddx = tsrc_null();
ddy = tsrc_null();
bias_or_lod = tsrc_null();
ref_or_si = tsrc_null();
num_derivs = 0;
sampler_src = 1;
num_coords = tgsi_util_get_texture_coord_dim(inst->tex.target, &ref_pos);
/* extract the parameters */
switch (inst->opcode) {
case TOY_OPCODE_TGSI_TXD:
if (ref_pos >= 0) {
assert(ref_pos < 4);
msg_type = GEN7_MSG_SAMPLER_SAMPLE_D_C;
ref_or_si = tsrc_swizzle1(coords, ref_pos);
if (ilo_dev_gen(tc->dev) < ILO_GEN(7.5))
tc_fail(tc, "TXD with shadow sampler not supported");
}
else {
msg_type = GEN6_MSG_SAMPLER_SAMPLE_D;
}
ddx = inst->src[1];
ddy = inst->src[2];
num_derivs = num_coords;
sampler_src = 3;
break;
case TOY_OPCODE_TGSI_TXL:
if (ref_pos >= 0) {
assert(ref_pos < 3);
msg_type = GEN6_MSG_SAMPLER_SAMPLE_L_C;
ref_or_si = tsrc_swizzle1(coords, ref_pos);
}
else {
msg_type = GEN6_MSG_SAMPLER_SAMPLE_L;
}
bias_or_lod = tsrc_swizzle1(coords, TOY_SWIZZLE_W);
break;
case TOY_OPCODE_TGSI_TXF:
msg_type = GEN6_MSG_SAMPLER_LD;
switch (inst->tex.target) {
case TGSI_TEXTURE_2D_MSAA:
case TGSI_TEXTURE_2D_ARRAY_MSAA:
assert(ref_pos >= 0 && ref_pos < 4);
/* lod is always 0 */
bias_or_lod = tsrc_imm_d(0);
ref_or_si = tsrc_swizzle1(coords, ref_pos);
break;
default:
bias_or_lod = tsrc_swizzle1(coords, TOY_SWIZZLE_W);
break;
}
/* offset the coordinates */
if (!tsrc_is_null(inst->tex.offsets[0])) {
struct toy_dst tmp;
tmp = tc_alloc_tmp(tc);
tc_ADD(tc, tmp, coords, inst->tex.offsets[0]);
coords = tsrc_from(tmp);
}
sampler_src = 1;
break;
case TOY_OPCODE_TGSI_TXQ:
msg_type = GEN6_MSG_SAMPLER_RESINFO;
num_coords = 0;
bias_or_lod = tsrc_swizzle1(coords, TOY_SWIZZLE_X);
break;
case TOY_OPCODE_TGSI_TXQ_LZ:
msg_type = GEN6_MSG_SAMPLER_RESINFO;
num_coords = 0;
sampler_src = 0;
break;
case TOY_OPCODE_TGSI_TXL2:
if (ref_pos >= 0) {
assert(ref_pos < 4);
msg_type = GEN6_MSG_SAMPLER_SAMPLE_L_C;
ref_or_si = tsrc_swizzle1(coords, ref_pos);
}
else {
msg_type = GEN6_MSG_SAMPLER_SAMPLE_L;
}
bias_or_lod = tsrc_swizzle1(inst->src[1], TOY_SWIZZLE_X);
sampler_src = 2;
break;
default:
assert(!"unhandled sampling opcode");
if (ret_sampler_index)
*ret_sampler_index = 0;
return tsrc_null();
break;
}
assert(inst->src[sampler_src].file == TOY_FILE_IMM);
sampler_index = inst->src[sampler_src].val32;
binding_table_index = vcc->shader->bt.tex_base + sampler_index;
/*
* From the Sandy Bridge PRM, volume 4 part 1, page 18:
*
* "Note that the (cube map) coordinates delivered to the sampling
* engine must already have been divided by the component with the
* largest absolute value."
*/
switch (inst->tex.target) {
case TGSI_TEXTURE_CUBE:
case TGSI_TEXTURE_SHADOWCUBE:
case TGSI_TEXTURE_CUBE_ARRAY:
case TGSI_TEXTURE_SHADOWCUBE_ARRAY:
/* TXQ does not need coordinates */
if (num_coords >= 3) {
struct toy_dst tmp, max;
struct toy_src abs_coords[3];
unsigned i;
tmp = tc_alloc_tmp(tc);
max = tdst_writemask(tmp, TOY_WRITEMASK_W);
for (i = 0; i < 3; i++)
abs_coords[i] = tsrc_absolute(tsrc_swizzle1(coords, i));
tc_SEL(tc, max, abs_coords[0], abs_coords[0], GEN6_COND_GE);
tc_SEL(tc, max, tsrc_from(max), abs_coords[0], GEN6_COND_GE);
tc_INV(tc, max, tsrc_from(max));
for (i = 0; i < 3; i++)
tc_MUL(tc, tdst_writemask(tmp, 1 << i), coords, tsrc_from(max));
coords = tsrc_from(tmp);
}
break;
}
/* set up sampler parameters */
msg_len = vs_add_sampler_params(tc, msg_type, base_mrf,
coords, num_coords, bias_or_lod, ref_or_si, ddx, ddy, num_derivs);
/*
* From the Sandy Bridge PRM, volume 4 part 1, page 136:
*
* "The maximum message length allowed to the sampler is 11. This would
* disallow sample_d, sample_b_c, and sample_l_c with a SIMD Mode of
* SIMD16."
*/
if (msg_len > 11)
tc_fail(tc, "maximum length for messages to the sampler is 11");
if (ret_sampler_index)
*ret_sampler_index = sampler_index;
return tsrc_imm_mdesc_sampler(tc, msg_len, 1,
false, simd_mode, msg_type, sampler_index, binding_table_index);
}
/**
* Set up message registers and return the message descriptor for sampling.
*/
static struct toy_src
fs_prepare_tgsi_sampling(struct toy_compiler *tc, const struct toy_inst *inst,
int base_mrf, const uint32_t *saturate_coords,
unsigned *ret_sampler_index)
{
unsigned simd_mode, msg_type, msg_len, sampler_index, binding_table_index;
struct toy_src coords[4], ddx[4], ddy[4], bias_or_lod, ref_or_si;
int num_coords, ref_pos, num_derivs;
int sampler_src, param_size, i;
switch (inst->exec_size) {
case BRW_EXECUTE_8:
simd_mode = BRW_SAMPLER_SIMD_MODE_SIMD8;
param_size = 1;
break;
case BRW_EXECUTE_16:
simd_mode = BRW_SAMPLER_SIMD_MODE_SIMD16;
param_size = 2;
break;
default:
tc_fail(tc, "unsupported execute size for sampling");
return tsrc_null();
break;
}
num_coords = toy_tgsi_get_texture_coord_dim(inst->tex.target, &ref_pos);
tsrc_transpose(inst->src[0], coords);
bias_or_lod = tsrc_null();
ref_or_si = tsrc_null();
num_derivs = 0;
sampler_src = 1;
/*
* For TXD,
*
* src0 := (x, y, z, w)
* src1 := ddx
* src2 := ddy
* src3 := sampler
*
* For TEX2, TXB2, and TXL2,
*
* src0 := (x, y, z, w)
* src1 := (v or bias or lod, ...)
* src2 := sampler
*
* For TEX, TXB, TXL, and TXP,
*
* src0 := (x, y, z, w or bias or lod or projection)
* src1 := sampler
*
* For TXQ,
*
* src0 := (lod, ...)
* src1 := sampler
*
* For TXQ_LZ,
*
* src0 := sampler
*
* And for TXF,
*
* src0 := (x, y, z, w or lod)
* src1 := sampler
*
* State trackers should not generate opcode+texture combinations with
* which the two definitions conflict (e.g., TXB with SHADOW2DARRAY).
*/
switch (inst->opcode) {
case TOY_OPCODE_TGSI_TEX:
if (ref_pos >= 0) {
assert(ref_pos < 4);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_COMPARE;
ref_or_si = coords[ref_pos];
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE;
}
break;
case TOY_OPCODE_TGSI_TXD:
if (ref_pos >= 0)
tc_fail(tc, "TXD with shadow sampler not supported");
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_DERIVS;
tsrc_transpose(inst->src[1], ddx);
tsrc_transpose(inst->src[2], ddy);
num_derivs = num_coords;
sampler_src = 3;
break;
case TOY_OPCODE_TGSI_TXP:
if (ref_pos >= 0) {
assert(ref_pos < 3);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_COMPARE;
ref_or_si = coords[ref_pos];
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE;
}
/* project the coordinates */
{
struct toy_dst tmp[4];
tc_alloc_tmp4(tc, tmp);
tc_INV(tc, tmp[3], coords[3]);
for (i = 0; i < num_coords && i < 3; i++) {
tc_MUL(tc, tmp[i], coords[i], tsrc_from(tmp[3]));
coords[i] = tsrc_from(tmp[i]);
}
if (ref_pos >= i) {
tc_MUL(tc, tmp[ref_pos], ref_or_si, tsrc_from(tmp[3]));
ref_or_si = tsrc_from(tmp[ref_pos]);
}
}
break;
case TOY_OPCODE_TGSI_TXB:
if (ref_pos >= 0) {
assert(ref_pos < 3);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS_COMPARE;
ref_or_si = coords[ref_pos];
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS;
}
bias_or_lod = coords[3];
break;
case TOY_OPCODE_TGSI_TXL:
if (ref_pos >= 0) {
assert(ref_pos < 3);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE;
ref_or_si = coords[ref_pos];
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD;
}
bias_or_lod = coords[3];
break;
case TOY_OPCODE_TGSI_TXF:
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LD;
switch (inst->tex.target) {
case TGSI_TEXTURE_2D_MSAA:
case TGSI_TEXTURE_2D_ARRAY_MSAA:
assert(ref_pos >= 0 && ref_pos < 4);
/* lod is always 0 */
bias_or_lod = tsrc_imm_d(0);
ref_or_si = coords[ref_pos];
break;
default:
bias_or_lod = coords[3];
break;
}
/* offset the coordinates */
if (!tsrc_is_null(inst->tex.offsets[0])) {
struct toy_dst tmp[4];
struct toy_src offsets[4];
tc_alloc_tmp4(tc, tmp);
tsrc_transpose(inst->tex.offsets[0], offsets);
for (i = 0; i < num_coords; i++) {
tc_ADD(tc, tmp[i], coords[i], offsets[i]);
coords[i] = tsrc_from(tmp[i]);
}
}
sampler_src = 1;
break;
case TOY_OPCODE_TGSI_TXQ:
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_RESINFO;
num_coords = 0;
bias_or_lod = coords[0];
break;
case TOY_OPCODE_TGSI_TXQ_LZ:
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_RESINFO;
num_coords = 0;
sampler_src = 0;
break;
case TOY_OPCODE_TGSI_TEX2:
if (ref_pos >= 0) {
assert(ref_pos < 5);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_COMPARE;
if (ref_pos >= 4) {
struct toy_src src1[4];
tsrc_transpose(inst->src[1], src1);
ref_or_si = src1[ref_pos - 4];
}
else {
ref_or_si = coords[ref_pos];
}
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE;
}
sampler_src = 2;
break;
case TOY_OPCODE_TGSI_TXB2:
if (ref_pos >= 0) {
assert(ref_pos < 4);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS_COMPARE;
ref_or_si = coords[ref_pos];
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS;
}
{
struct toy_src src1[4];
tsrc_transpose(inst->src[1], src1);
bias_or_lod = src1[0];
}
sampler_src = 2;
break;
case TOY_OPCODE_TGSI_TXL2:
if (ref_pos >= 0) {
assert(ref_pos < 4);
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE;
ref_or_si = coords[ref_pos];
}
else {
msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD;
}
{
struct toy_src src1[4];
tsrc_transpose(inst->src[1], src1);
bias_or_lod = src1[0];
}
sampler_src = 2;
break;
default:
assert(!"unhandled sampling opcode");
return tsrc_null();
break;
}
assert(inst->src[sampler_src].file == TOY_FILE_IMM);
sampler_index = inst->src[sampler_src].val32;
binding_table_index = ILO_WM_TEXTURE_SURFACE(sampler_index);
/*
* From the Sandy Bridge PRM, volume 4 part 1, page 18:
*
* "Note that the (cube map) coordinates delivered to the sampling
* engine must already have been divided by the component with the
* largest absolute value."
*/
switch (inst->tex.target) {
case TGSI_TEXTURE_CUBE:
case TGSI_TEXTURE_SHADOWCUBE:
case TGSI_TEXTURE_CUBE_ARRAY:
case TGSI_TEXTURE_SHADOWCUBE_ARRAY:
/* TXQ does not need coordinates */
if (num_coords >= 3) {
struct toy_dst tmp[4];
tc_alloc_tmp4(tc, tmp);
tc_SEL(tc, tmp[3], tsrc_absolute(coords[0]),
tsrc_absolute(coords[1]), BRW_CONDITIONAL_GE);
tc_SEL(tc, tmp[3], tsrc_from(tmp[3]),
tsrc_absolute(coords[2]), BRW_CONDITIONAL_GE);
tc_INV(tc, tmp[3], tsrc_from(tmp[3]));
for (i = 0; i < 3; i++) {
tc_MUL(tc, tmp[i], coords[i], tsrc_from(tmp[3]));
coords[i] = tsrc_from(tmp[i]);
}
}
break;
}
/*
* Saturate (s, t, r). saturate_coords is set for sampler and coordinate
* that uses linear filtering and PIPE_TEX_WRAP_CLAMP respectively. It is
* so that sampling outside the border gets the correct colors.
*/
for (i = 0; i < MIN2(num_coords, 3); i++) {
bool is_rect;
if (!(saturate_coords[i] & (1 << sampler_index)))
continue;
switch (inst->tex.target) {
case TGSI_TEXTURE_RECT:
case TGSI_TEXTURE_SHADOWRECT:
is_rect = true;
break;
default:
is_rect = false;
break;
}
if (is_rect) {
struct toy_src min, max;
struct toy_dst tmp;
tc_fail(tc, "GL_CLAMP with rectangle texture unsupported");
tmp = tc_alloc_tmp(tc);
/* saturate to [0, width] or [0, height] */
/* TODO TXQ? */
min = tsrc_imm_f(0.0f);
max = tsrc_imm_f(2048.0f);
tc_SEL(tc, tmp, coords[i], min, BRW_CONDITIONAL_G);
tc_SEL(tc, tmp, tsrc_from(tmp), max, BRW_CONDITIONAL_L);
coords[i] = tsrc_from(tmp);
}
else {
struct toy_dst tmp;
struct toy_inst *inst2;
tmp = tc_alloc_tmp(tc);
/* saturate to [0.0f, 1.0f] */
inst2 = tc_MOV(tc, tmp, coords[i]);
inst2->saturate = true;
coords[i] = tsrc_from(tmp);
}
}
/* set up sampler parameters */
if (tc->gen >= ILO_GEN(7)) {
msg_len = fs_add_sampler_params_gen7(tc, msg_type, base_mrf, param_size,
coords, num_coords, bias_or_lod, ref_or_si, ddx, ddy, num_derivs);
}
else {
msg_len = fs_add_sampler_params_gen6(tc, msg_type, base_mrf, param_size,
coords, num_coords, bias_or_lod, ref_or_si, ddx, ddy, num_derivs);
}
/*
* From the Sandy Bridge PRM, volume 4 part 1, page 136:
*
* "The maximum message length allowed to the sampler is 11. This would
* disallow sample_d, sample_b_c, and sample_l_c with a SIMD Mode of
* SIMD16."
*/
if (msg_len > 11)
tc_fail(tc, "maximum length for messages to the sampler is 11");
if (ret_sampler_index)
*ret_sampler_index = sampler_index;
return tsrc_imm_mdesc_sampler(tc, msg_len, 4 * param_size,
false, simd_mode, msg_type, sampler_index, binding_table_index);
}
