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);
}
static void
fetch_face(struct fs_compile_context *fcc, struct toy_dst dst)
{
struct toy_compiler *tc = &fcc->tc;
const struct toy_src r0 = tsrc_d(tsrc(TOY_FILE_GRF, 0, 0));
struct toy_dst tmp_f, tmp;
struct toy_dst real_dst[4];
tdst_transpose(dst, real_dst);
tmp_f = tc_alloc_tmp(tc);
tmp = tdst_d(tmp_f);
tc_SHR(tc, tmp, tsrc_rect(r0, TOY_RECT_010), tsrc_imm_d(15));
tc_AND(tc, tmp, tsrc_from(tmp), tsrc_imm_d(1));
tc_MOV(tc, tmp_f, tsrc_from(tmp));
/* convert to 1.0 and -1.0 */
tc_MUL(tc, tmp_f, tsrc_from(tmp_f), tsrc_imm_f(-2.0f));
tc_ADD(tc, real_dst[0], tsrc_from(tmp_f), tsrc_imm_f(1.0f));
tc_MOV(tc, real_dst[1], tsrc_imm_f(0.0f));
tc_MOV(tc, real_dst[2], tsrc_imm_f(0.0f));
tc_MOV(tc, real_dst[3], tsrc_imm_f(1.0f));
}
static void
gs_setup_vars(struct gs_compile_context *gcc)
{
int grf = gcc->first_free_grf;
int i;
gcc->vars.urb_write_header = tdst_d(tdst(TOY_FILE_GRF, grf, 0));
grf++;
gcc->vars.tmp = tdst(TOY_FILE_GRF, grf, 0);
grf++;
if (gcc->write_so) {
gcc->vars.buffer_needed = gcc->out_vue_min_count - 1;
for (i = 0; i < gcc->vars.buffer_needed; i++) {
gcc->vars.buffers[i] = tdst(TOY_FILE_GRF, grf, 0);
grf += gcc->shader->out.count;
}
gcc->vars.so_written = tdst_d(tdst(TOY_FILE_GRF, grf, 0));
grf++;
gcc->vars.so_index = tdst_d(tdst(TOY_FILE_GRF, grf, 0));
grf++;
}
gcc->first_free_grf = grf;
if (!gcc->tgsi.reg_mapping) {
for (i = 0; i < gcc->shader->out.count; i++)
gcc->vars.tgsi_outs[i] = tsrc(TOY_FILE_GRF, grf++, 0);
gcc->first_free_grf = grf;
return;
}
for (i = 0; i < gcc->shader->out.count; i++) {
const int slot = gcc->output_map[i];
const int vrf = (slot >= 0) ? toy_tgsi_get_vrf(&gcc->tgsi,
TGSI_FILE_OUTPUT, 0, gcc->tgsi.outputs[slot].index) : -1;
if (vrf >= 0)
gcc->vars.tgsi_outs[i] = tsrc(TOY_FILE_VRF, vrf, 0);
else
gcc->vars.tgsi_outs[i] = (i == 0) ? tsrc_imm_d(0) : tsrc_imm_f(0.0f);
}
}
static void
vs_lower_opcode_tgsi_in(struct vs_compile_context *vcc,
struct toy_dst dst, int dim, int idx)
{
struct toy_compiler *tc = &vcc->tc;
int slot;
assert(!dim);
slot = toy_tgsi_find_input(&vcc->tgsi, idx);
if (slot >= 0) {
const int first_in_grf = vcc->first_vue_grf +
(vcc->shader->in.count - vcc->tgsi.num_inputs);
const int grf = first_in_grf + vcc->tgsi.inputs[slot].semantic_index;
const struct toy_src src = tsrc(TOY_FILE_GRF, grf, 0);
tc_MOV(tc, dst, src);
}
else {
/* undeclared input */
tc_MOV(tc, dst, tsrc_imm_f(0.0f));
}
}
static void
gs_lower_opcode_tgsi_in(struct gs_compile_context *gcc,
struct toy_dst dst, int dim, int idx)
{
struct toy_compiler *tc = &gcc->tc;
struct toy_src attr;
int slot, reg = -1, subreg;
slot = toy_tgsi_find_input(&gcc->tgsi, idx);
if (slot >= 0) {
int i;
for (i = 0; i < gcc->variant->u.gs.num_inputs; i++) {
if (gcc->variant->u.gs.semantic_names[i] ==
gcc->tgsi.inputs[slot].semantic_name &&
gcc->variant->u.gs.semantic_indices[i] ==
gcc->tgsi.inputs[slot].semantic_index) {
reg = i / 2;
subreg = (i % 2) * 4;
break;
}
}
}
if (reg < 0) {
tc_MOV(tc, dst, tsrc_imm_f(0.0f));
return;
}
/* fix vertex ordering for GEN6_3DPRIM_TRISTRIP_REVERSE */
if (gcc->in_vue_count == 3 && dim < 2) {
struct toy_inst *inst;
/* get PrimType */
inst = tc_AND(tc, tdst_d(gcc->vars.tmp),
tsrc_offset(gcc->payload.header, 0, 2), tsrc_imm_d(0x1f));
inst->exec_size = GEN6_EXECSIZE_1;
inst->src[0] = tsrc_rect(inst->src[0], TOY_RECT_010);
inst->src[1] = tsrc_rect(inst->src[1], TOY_RECT_010);
inst = tc_CMP(tc, tdst_null(), tsrc_from(tdst_d(gcc->vars.tmp)),
tsrc_imm_d(GEN6_3DPRIM_TRISTRIP_REVERSE), GEN6_COND_NZ);
inst->src[0] = tsrc_rect(inst->src[0], TOY_RECT_010);
attr = tsrc_offset(gcc->payload.vues[dim], reg, subreg);
inst = tc_MOV(tc, dst, attr);
inst->pred_ctrl = GEN6_PREDCTRL_NORMAL;
/* swap IN[0] and IN[1] for GEN6_3DPRIM_TRISTRIP_REVERSE */
dim = !dim;
attr = tsrc_offset(gcc->payload.vues[dim], reg, subreg);
inst = tc_MOV(tc, dst, attr);
inst->pred_ctrl = GEN6_PREDCTRL_NORMAL;
inst->pred_inv = true;
}
else {
attr = tsrc_offset(gcc->payload.vues[dim], reg, subreg);
tc_MOV(tc, dst, attr);
}
}
/**
* Collect the toy registers to be written to the VUE.
*/
static int
vs_collect_outputs(struct vs_compile_context *vcc, struct toy_src *outs)
{
const struct toy_tgsi *tgsi = &vcc->tgsi;
unsigned i;
for (i = 0; i < vcc->shader->out.count; i++) {
const int slot = vcc->output_map[i];
const int vrf = (slot >= 0) ? toy_tgsi_get_vrf(tgsi,
TGSI_FILE_OUTPUT, 0, tgsi->outputs[slot].index) : -1;
struct toy_src src;
if (vrf >= 0) {
struct toy_dst dst;
dst = tdst(TOY_FILE_VRF, vrf, 0);
src = tsrc_from(dst);
if (i == 0) {
/* PSIZE is at channel W */
tc_MOV(&vcc->tc, tdst_writemask(dst, TOY_WRITEMASK_W),
tsrc_swizzle1(src, TOY_SWIZZLE_X));
/* the other channels are for the header */
dst = tdst_d(dst);
tc_MOV(&vcc->tc, tdst_writemask(dst, TOY_WRITEMASK_XYZ),
tsrc_imm_d(0));
}
else {
/* initialize unused channels to 0.0f */
if (tgsi->outputs[slot].undefined_mask) {
dst = tdst_writemask(dst, tgsi->outputs[slot].undefined_mask);
tc_MOV(&vcc->tc, dst, tsrc_imm_f(0.0f));
}
}
}
else {
/* XXX this is too ugly */
if (vcc->shader->out.semantic_names[i] == TGSI_SEMANTIC_CLIPDIST &&
slot < 0) {
/* ok, we need to compute clip distance */
int clipvert_slot = -1, clipvert_vrf, j;
for (j = 0; j < tgsi->num_outputs; j++) {
if (tgsi->outputs[j].semantic_name ==
TGSI_SEMANTIC_CLIPVERTEX) {
clipvert_slot = j;
break;
}
else if (tgsi->outputs[j].semantic_name ==
TGSI_SEMANTIC_POSITION) {
/* remember pos, but keep looking */
clipvert_slot = j;
}
}
clipvert_vrf = (clipvert_slot >= 0) ? toy_tgsi_get_vrf(tgsi,
TGSI_FILE_OUTPUT, 0, tgsi->outputs[clipvert_slot].index) : -1;
if (clipvert_vrf >= 0) {
struct toy_dst tmp = tc_alloc_tmp(&vcc->tc);
struct toy_src clipvert = tsrc(TOY_FILE_VRF, clipvert_vrf, 0);
int first_ucp, last_ucp;
if (vcc->shader->out.semantic_indices[i]) {
first_ucp = 4;
last_ucp = MIN2(7, vcc->variant->u.vs.num_ucps - 1);
}
else {
first_ucp = 0;
last_ucp = MIN2(3, vcc->variant->u.vs.num_ucps - 1);
}
for (j = first_ucp; j <= last_ucp; j++) {
const int plane_grf = vcc->first_ucp_grf + j / 2;
const int plane_subreg = (j & 1) * 16;
const struct toy_src plane = tsrc_rect(tsrc(TOY_FILE_GRF,
plane_grf, plane_subreg), TOY_RECT_041);
const unsigned writemask = 1 << ((j >= 4) ? j - 4 : j);
tc_DP4(&vcc->tc, tdst_writemask(tmp, writemask),
clipvert, plane);
}
src = tsrc_from(tmp);
}
else {
src = tsrc_imm_f(0.0f);
}
}
else {
src = (i == 0) ? tsrc_imm_d(0) : tsrc_imm_f(0.0f);
}
}
outs[i] = src;
}
return i;
}
static void
vs_lower_opcode_tgsi_sampling(struct vs_compile_context *vcc,
struct toy_inst *inst)
{
struct toy_compiler *tc = &vcc->tc;
struct toy_src desc;
struct toy_dst dst, tmp;
unsigned sampler_index;
int swizzles[4], i;
unsigned swizzle_zero_mask, swizzle_one_mask, swizzle_normal_mask;
bool need_filter;
desc = vs_prepare_tgsi_sampling(vcc, inst,
vcc->first_free_mrf, &sampler_index);
switch (inst->opcode) {
case TOY_OPCODE_TGSI_TXF:
case TOY_OPCODE_TGSI_TXQ:
case TOY_OPCODE_TGSI_TXQ_LZ:
need_filter = false;
break;
default:
need_filter = true;
break;
}
toy_compiler_lower_to_send(tc, inst, false, GEN6_SFID_SAMPLER);
inst->src[0] = tsrc(TOY_FILE_MRF, vcc->first_free_mrf, 0);
inst->src[1] = desc;
/* write to a temp first */
tmp = tc_alloc_tmp(tc);
tmp.type = inst->dst.type;
dst = inst->dst;
inst->dst = tmp;
tc_move_inst(tc, inst);
if (need_filter) {
assert(sampler_index < vcc->variant->num_sampler_views);
swizzles[0] = vcc->variant->sampler_view_swizzles[sampler_index].r;
swizzles[1] = vcc->variant->sampler_view_swizzles[sampler_index].g;
swizzles[2] = vcc->variant->sampler_view_swizzles[sampler_index].b;
swizzles[3] = vcc->variant->sampler_view_swizzles[sampler_index].a;
}
else {
swizzles[0] = PIPE_SWIZZLE_RED;
swizzles[1] = PIPE_SWIZZLE_GREEN;
swizzles[2] = PIPE_SWIZZLE_BLUE;
swizzles[3] = PIPE_SWIZZLE_ALPHA;
}
swizzle_zero_mask = 0;
swizzle_one_mask = 0;
swizzle_normal_mask = 0;
for (i = 0; i < 4; i++) {
switch (swizzles[i]) {
case PIPE_SWIZZLE_ZERO:
swizzle_zero_mask |= 1 << i;
swizzles[i] = i;
break;
case PIPE_SWIZZLE_ONE:
swizzle_one_mask |= 1 << i;
swizzles[i] = i;
break;
default:
swizzle_normal_mask |= 1 << i;
break;
}
}
/* swizzle the results */
if (swizzle_normal_mask) {
tc_MOV(tc, tdst_writemask(dst, swizzle_normal_mask),
tsrc_swizzle(tsrc_from(tmp), swizzles[0],
swizzles[1], swizzles[2], swizzles[3]));
}
if (swizzle_zero_mask)
tc_MOV(tc, tdst_writemask(dst, swizzle_zero_mask), tsrc_imm_f(0.0f));
if (swizzle_one_mask)
tc_MOV(tc, tdst_writemask(dst, swizzle_one_mask), tsrc_imm_f(1.0f));
}
static void
fs_lower_opcode_tgsi_sampling(struct fs_compile_context *fcc,
struct toy_inst *inst)
{
struct toy_compiler *tc = &fcc->tc;
struct toy_dst dst[4], tmp[4];
struct toy_src desc;
unsigned sampler_index;
int swizzles[4], i;
bool need_filter;
desc = fs_prepare_tgsi_sampling(tc, inst,
fcc->first_free_mrf,
fcc->variant->saturate_tex_coords,
&sampler_index);
switch (inst->opcode) {
case TOY_OPCODE_TGSI_TXF:
case TOY_OPCODE_TGSI_TXQ:
case TOY_OPCODE_TGSI_TXQ_LZ:
need_filter = false;
break;
default:
need_filter = true;
break;
}
toy_compiler_lower_to_send(tc, inst, false, BRW_SFID_SAMPLER);
inst->src[0] = tsrc(TOY_FILE_MRF, fcc->first_free_mrf, 0);
inst->src[1] = desc;
for (i = 2; i < Elements(inst->src); i++)
inst->src[i] = tsrc_null();
/* write to temps first */
tc_alloc_tmp4(tc, tmp);
tdst_transpose(inst->dst, dst);
inst->dst = tmp[0];
tc_move_inst(tc, inst);
if (need_filter) {
assert(sampler_index < fcc->variant->num_sampler_views);
swizzles[0] = fcc->variant->sampler_view_swizzles[sampler_index].r;
swizzles[1] = fcc->variant->sampler_view_swizzles[sampler_index].g;
swizzles[2] = fcc->variant->sampler_view_swizzles[sampler_index].b;
swizzles[3] = fcc->variant->sampler_view_swizzles[sampler_index].a;
}
else {
swizzles[0] = PIPE_SWIZZLE_RED;
swizzles[1] = PIPE_SWIZZLE_GREEN;
swizzles[2] = PIPE_SWIZZLE_BLUE;
swizzles[3] = PIPE_SWIZZLE_ALPHA;
}
/* swizzle the results */
for (i = 0; i < 4; i++) {
switch (swizzles[i]) {
case PIPE_SWIZZLE_ZERO:
tc_MOV(tc, dst[i], tsrc_imm_f(0.0f));
break;
case PIPE_SWIZZLE_ONE:
tc_MOV(tc, dst[i], tsrc_imm_f(1.0f));
break;
default:
tc_MOV(tc, dst[i], tsrc_from(tmp[swizzles[i]]));
break;
}
}
}
static void
fetch_position(struct fs_compile_context *fcc, struct toy_dst dst)
{
struct toy_compiler *tc = &fcc->tc;
const struct toy_src src_z =
tsrc(TOY_FILE_GRF, fcc->payloads[0].source_depth, 0);
const struct toy_src src_w =
tsrc(TOY_FILE_GRF, fcc->payloads[0].source_w, 0);
const int fb_height =
(fcc->variant->u.fs.fb_height) ? fcc->variant->u.fs.fb_height : 1;
const bool origin_upper_left =
(fcc->tgsi.props.fs_coord_origin == TGSI_FS_COORD_ORIGIN_UPPER_LEFT);
const bool pixel_center_integer =
(fcc->tgsi.props.fs_coord_pixel_center ==
TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
struct toy_src subspan_x, subspan_y;
struct toy_dst tmp, tmp_uw;
struct toy_dst real_dst[4];
tdst_transpose(dst, real_dst);
subspan_x = tsrc_uw(tsrc(TOY_FILE_GRF, 1, 2 * 4));
subspan_x = tsrc_rect(subspan_x, TOY_RECT_240);
subspan_y = tsrc_offset(subspan_x, 0, 1);
tmp_uw = tdst_uw(tc_alloc_tmp(tc));
tmp = tc_alloc_tmp(tc);
/* X */
tc_ADD(tc, tmp_uw, subspan_x, tsrc_imm_v(0x10101010));
tc_MOV(tc, tmp, tsrc_from(tmp_uw));
if (pixel_center_integer)
tc_MOV(tc, real_dst[0], tsrc_from(tmp));
else
tc_ADD(tc, real_dst[0], tsrc_from(tmp), tsrc_imm_f(0.5f));
/* Y */
tc_ADD(tc, tmp_uw, subspan_y, tsrc_imm_v(0x11001100));
tc_MOV(tc, tmp, tsrc_from(tmp_uw));
if (origin_upper_left && pixel_center_integer) {
tc_MOV(tc, real_dst[1], tsrc_from(tmp));
}
else {
struct toy_src y = tsrc_from(tmp);
float offset = 0.0f;
if (!pixel_center_integer)
offset += 0.5f;
if (!origin_upper_left) {
offset += (float) (fb_height - 1);
y = tsrc_negate(y);
}
tc_ADD(tc, real_dst[1], y, tsrc_imm_f(offset));
}
/* Z and W */
tc_MOV(tc, real_dst[2], src_z);
tc_INV(tc, real_dst[3], src_w);
}
/**
* 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);
}
static void
fetch_attr(struct fs_compile_context *fcc, struct toy_dst dst, int slot)
{
struct toy_compiler *tc = &fcc->tc;
struct toy_dst real_dst[4];
bool is_const = false;
int grf, mode, ch;
tdst_transpose(dst, real_dst);
grf = fcc->first_attr_grf + slot * 2;
switch (fcc->tgsi.inputs[slot].interp) {
case TGSI_INTERPOLATE_CONSTANT:
is_const = true;
break;
case TGSI_INTERPOLATE_LINEAR:
if (fcc->tgsi.inputs[slot].centroid)
mode = BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC;
else
mode = BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC;
break;
case TGSI_INTERPOLATE_COLOR:
if (fcc->variant->u.fs.flatshade) {
is_const = true;
break;
}
/* fall through */
case TGSI_INTERPOLATE_PERSPECTIVE:
if (fcc->tgsi.inputs[slot].centroid)
mode = BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC;
else
mode = BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC;
break;
default:
assert(!"unexpected FS interpolation");
mode = BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC;
break;
}
if (is_const) {
struct toy_src a0[4];
a0[0] = tsrc(TOY_FILE_GRF, grf + 0, 3 * 4);
a0[1] = tsrc(TOY_FILE_GRF, grf + 0, 7 * 4);
a0[2] = tsrc(TOY_FILE_GRF, grf + 1, 3 * 4);
a0[3] = tsrc(TOY_FILE_GRF, grf + 1, 7 * 4);
for (ch = 0; ch < 4; ch++)
tc_MOV(tc, real_dst[ch], tsrc_rect(a0[ch], TOY_RECT_010));
}
else {
struct toy_src attr[4], uv;
attr[0] = tsrc(TOY_FILE_GRF, grf + 0, 0);
attr[1] = tsrc(TOY_FILE_GRF, grf + 0, 4 * 4);
attr[2] = tsrc(TOY_FILE_GRF, grf + 1, 0);
attr[3] = tsrc(TOY_FILE_GRF, grf + 1, 4 * 4);
uv = tsrc(TOY_FILE_GRF, fcc->payloads[0].barycentric_interps[mode], 0);
for (ch = 0; ch < 4; ch++) {
tc_add2(tc, BRW_OPCODE_PLN, real_dst[ch],
tsrc_rect(attr[ch], TOY_RECT_010), uv);
}
}
if (fcc->tgsi.inputs[slot].semantic_name == TGSI_SEMANTIC_FOG) {
tc_MOV(tc, real_dst[1], tsrc_imm_f(0.0f));
tc_MOV(tc, real_dst[2], tsrc_imm_f(0.0f));
tc_MOV(tc, real_dst[3], tsrc_imm_f(1.0f));
}
}
/**
* Emit instructions to write the color buffers (and the depth buffer).
*/
static void
fs_write_fb(struct fs_compile_context *fcc)
{
struct toy_compiler *tc = &fcc->tc;
int base_mrf = fcc->first_free_mrf;
const struct toy_dst header = tdst_ud(tdst(TOY_FILE_MRF, base_mrf, 0));
bool header_present = false;
struct toy_src desc;
unsigned msg_type, ctrl;
int color_slots[ILO_MAX_DRAW_BUFFERS], num_cbufs;
int pos_slot = -1, cbuf, i;
for (i = 0; i < Elements(color_slots); i++)
color_slots[i] = -1;
for (i = 0; i < fcc->tgsi.num_outputs; i++) {
if (fcc->tgsi.outputs[i].semantic_name == TGSI_SEMANTIC_COLOR) {
assert(fcc->tgsi.outputs[i].semantic_index < Elements(color_slots));
color_slots[fcc->tgsi.outputs[i].semantic_index] = i;
}
else if (fcc->tgsi.outputs[i].semantic_name == TGSI_SEMANTIC_POSITION) {
pos_slot = i;
}
}
num_cbufs = fcc->variant->u.fs.num_cbufs;
/* still need to send EOT (and probably depth) */
if (!num_cbufs)
num_cbufs = 1;
/* we need the header to specify the pixel mask or render target */
if (fcc->tgsi.uses_kill || num_cbufs > 1) {
const struct toy_src r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0));
struct toy_inst *inst;
inst = tc_MOV(tc, header, r0);
inst->mask_ctrl = BRW_MASK_DISABLE;
base_mrf += fcc->num_grf_per_vrf;
/* this is a two-register header */
if (fcc->dispatch_mode == GEN6_WM_8_DISPATCH_ENABLE) {
inst = tc_MOV(tc, tdst_offset(header, 1, 0), tsrc_offset(r0, 1, 0));
inst->mask_ctrl = BRW_MASK_DISABLE;
base_mrf += fcc->num_grf_per_vrf;
}
header_present = true;
}
for (cbuf = 0; cbuf < num_cbufs; cbuf++) {
const int slot =
color_slots[(fcc->tgsi.props.fs_color0_writes_all_cbufs) ? 0 : cbuf];
int mrf = base_mrf, vrf;
struct toy_src src[4];
if (slot >= 0) {
const unsigned undefined_mask =
fcc->tgsi.outputs[slot].undefined_mask;
const int index = fcc->tgsi.outputs[slot].index;
vrf = toy_tgsi_get_vrf(&fcc->tgsi, TGSI_FILE_OUTPUT, 0, index);
if (vrf >= 0) {
const struct toy_src tmp = tsrc(TOY_FILE_VRF, vrf, 0);
tsrc_transpose(tmp, src);
}
else {
/* use (0, 0, 0, 0) */
tsrc_transpose(tsrc_imm_f(0.0f), src);
}
for (i = 0; i < 4; i++) {
const struct toy_dst dst = tdst(TOY_FILE_MRF, mrf, 0);
if (undefined_mask & (1 << i))
src[i] = tsrc_imm_f(0.0f);
tc_MOV(tc, dst, src[i]);
mrf += fcc->num_grf_per_vrf;
}
}
else {
/* use (0, 0, 0, 0) */
for (i = 0; i < 4; i++) {
const struct toy_dst dst = tdst(TOY_FILE_MRF, mrf, 0);
tc_MOV(tc, dst, tsrc_imm_f(0.0f));
mrf += fcc->num_grf_per_vrf;
}
}
/* select BLEND_STATE[rt] */
if (cbuf > 0) {
struct toy_inst *inst;
inst = tc_MOV(tc, tdst_offset(header, 0, 2), tsrc_imm_ud(cbuf));
inst->mask_ctrl = BRW_MASK_DISABLE;
inst->exec_size = BRW_EXECUTE_1;
inst->src[0].rect = TOY_RECT_010;
}
if (cbuf == 0 && pos_slot >= 0) {
const int index = fcc->tgsi.outputs[pos_slot].index;
const struct toy_dst dst = tdst(TOY_FILE_MRF, mrf, 0);
struct toy_src src[4];
int vrf;
vrf = toy_tgsi_get_vrf(&fcc->tgsi, TGSI_FILE_OUTPUT, 0, index);
if (vrf >= 0) {
const struct toy_src tmp = tsrc(TOY_FILE_VRF, vrf, 0);
tsrc_transpose(tmp, src);
}
else {
/* use (0, 0, 0, 0) */
tsrc_transpose(tsrc_imm_f(0.0f), src);
}
/* only Z */
tc_MOV(tc, dst, src[2]);
mrf += fcc->num_grf_per_vrf;
}
msg_type = (fcc->dispatch_mode == GEN6_WM_16_DISPATCH_ENABLE) ?
BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE :
BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD8_SINGLE_SOURCE_SUBSPAN01;
ctrl = (cbuf == num_cbufs - 1) << 12 |
msg_type << 8;
desc = tsrc_imm_mdesc_data_port(tc, cbuf == num_cbufs - 1,
mrf - fcc->first_free_mrf, 0,
header_present, false,
GEN6_DATAPORT_WRITE_MESSAGE_RENDER_TARGET_WRITE,
ctrl, ILO_WM_DRAW_SURFACE(cbuf));
tc_add2(tc, TOY_OPCODE_FB_WRITE, tdst_null(),
tsrc(TOY_FILE_MRF, fcc->first_free_mrf, 0), desc);
}
}
