Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 5562 → Rev 5563

/contrib/sdk/sources/Mesa/mesa-9.2.5/src/gallium/drivers/ilo/shader/ilo_shader_fs.c
0,0 → 1,1799
/*
* Mesa 3-D graphics library
*
* Copyright (C) 2012-2013 LunarG, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Chia-I Wu <olv@lunarg.com>
*/
 
#include "tgsi/tgsi_dump.h"
#include "tgsi/tgsi_util.h"
#include "toy_compiler.h"
#include "toy_tgsi.h"
#include "toy_legalize.h"
#include "toy_optimize.h"
#include "toy_helpers.h"
#include "ilo_context.h"
#include "ilo_shader_internal.h"
 
struct fs_compile_context {
struct ilo_shader *shader;
const struct ilo_shader_variant *variant;
 
struct toy_compiler tc;
struct toy_tgsi tgsi;
 
enum brw_message_target const_cache;
int dispatch_mode;
 
struct {
int barycentric_interps[BRW_WM_BARYCENTRIC_INTERP_MODE_COUNT];
int source_depth;
int source_w;
int pos_offset;
} payloads[2];
 
int first_const_grf;
int first_attr_grf;
int first_free_grf;
int last_free_grf;
 
int num_grf_per_vrf;
 
int first_free_mrf;
int last_free_mrf;
};
 
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);
}
 
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
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));
}
}
 
static void
fs_lower_opcode_tgsi_in(struct fs_compile_context *fcc,
struct toy_dst dst, int dim, int idx)
{
int slot;
 
assert(!dim);
 
slot = toy_tgsi_find_input(&fcc->tgsi, idx);
if (slot < 0)
return;
 
switch (fcc->tgsi.inputs[slot].semantic_name) {
case TGSI_SEMANTIC_POSITION:
fetch_position(fcc, dst);
break;
case TGSI_SEMANTIC_FACE:
fetch_face(fcc, dst);
break;
default:
fetch_attr(fcc, dst, slot);
break;
}
}
 
static void
fs_lower_opcode_tgsi_indirect_const(struct fs_compile_context *fcc,
struct toy_dst dst, int dim,
struct toy_src idx)
{
const struct toy_dst offset =
tdst_ud(tdst(TOY_FILE_MRF, fcc->first_free_mrf, 0));
struct toy_compiler *tc = &fcc->tc;
unsigned simd_mode, param_size;
struct toy_inst *inst;
struct toy_src desc, real_src[4];
struct toy_dst tmp, real_dst[4];
int i;
 
tsrc_transpose(idx, real_src);
 
/* set offset */
inst = tc_MOV(tc, offset, real_src[0]);
inst->mask_ctrl = BRW_MASK_DISABLE;
 
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:
assert(!"unsupported execution size");
tc_MOV(tc, dst, tsrc_imm_f(0.0f));
return;
break;
}
 
desc = tsrc_imm_mdesc_sampler(tc, param_size, param_size * 4, false,
simd_mode,
GEN5_SAMPLER_MESSAGE_SAMPLE_LD,
0,
ILO_WM_CONST_SURFACE(dim));
 
tmp = tdst(TOY_FILE_VRF, tc_alloc_vrf(tc, param_size * 4), 0);
inst = tc_SEND(tc, tmp, tsrc_from(offset), desc, BRW_SFID_SAMPLER);
inst->mask_ctrl = BRW_MASK_DISABLE;
 
tdst_transpose(dst, real_dst);
for (i = 0; i < 4; i++) {
const struct toy_src src =
tsrc_offset(tsrc_from(tmp), param_size * i, 0);
 
/* cast to type D to make sure these are raw moves */
tc_MOV(tc, tdst_d(real_dst[i]), tsrc_d(src));
}
}
 
static void
fs_lower_opcode_tgsi_const_gen6(struct fs_compile_context *fcc,
struct toy_dst dst, int dim, struct toy_src idx)
{
const struct toy_dst header =
tdst_ud(tdst(TOY_FILE_MRF, fcc->first_free_mrf, 0));
const struct toy_dst global_offset =
tdst_ud(tdst(TOY_FILE_MRF, fcc->first_free_mrf, 2 * 4));
const struct toy_src r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0));
struct toy_compiler *tc = &fcc->tc;
unsigned msg_type, msg_ctrl, msg_len;
struct toy_inst *inst;
struct toy_src desc;
struct toy_dst tmp, real_dst[4];
int i;
 
/* set message header */
inst = tc_MOV(tc, header, r0);
inst->mask_ctrl = BRW_MASK_DISABLE;
 
/* set global offset */
inst = tc_MOV(tc, global_offset, idx);
inst->mask_ctrl = BRW_MASK_DISABLE;
inst->exec_size = BRW_EXECUTE_1;
inst->src[0].rect = TOY_RECT_010;
 
msg_type = BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ;
msg_ctrl = BRW_DATAPORT_OWORD_BLOCK_1_OWORDLOW << 8;
msg_len = 1;
 
desc = tsrc_imm_mdesc_data_port(tc, false, msg_len, 1, true, false,
msg_type, msg_ctrl, ILO_WM_CONST_SURFACE(dim));
 
tmp = tc_alloc_tmp(tc);
 
tc_SEND(tc, tmp, tsrc_from(header), desc, fcc->const_cache);
 
tdst_transpose(dst, real_dst);
for (i = 0; i < 4; i++) {
const struct toy_src src =
tsrc_offset(tsrc_rect(tsrc_from(tmp), TOY_RECT_010), 0, i);
 
/* cast to type D to make sure these are raw moves */
tc_MOV(tc, tdst_d(real_dst[i]), tsrc_d(src));
}
}
 
static void
fs_lower_opcode_tgsi_const_gen7(struct fs_compile_context *fcc,
struct toy_dst dst, int dim, struct toy_src idx)
{
struct toy_compiler *tc = &fcc->tc;
const struct toy_dst offset =
tdst_ud(tdst(TOY_FILE_MRF, fcc->first_free_mrf, 0));
struct toy_src desc;
struct toy_inst *inst;
struct toy_dst tmp, real_dst[4];
int i;
 
/*
* In 4c1fdae0a01b3f92ec03b61aac1d3df500d51fc6, pull constant load was
* changed from OWord Block Read to ld to increase performance in the
* classic driver. Since we use the constant cache instead of the data
* cache, I wonder if we still want to follow the classic driver.
*/
 
/* set offset */
inst = tc_MOV(tc, offset, tsrc_rect(idx, TOY_RECT_010));
inst->exec_size = BRW_EXECUTE_8;
inst->mask_ctrl = BRW_MASK_DISABLE;
 
desc = tsrc_imm_mdesc_sampler(tc, 1, 1, false,
BRW_SAMPLER_SIMD_MODE_SIMD4X2,
GEN5_SAMPLER_MESSAGE_SAMPLE_LD,
0,
ILO_WM_CONST_SURFACE(dim));
 
tmp = tc_alloc_tmp(tc);
inst = tc_SEND(tc, tmp, tsrc_from(offset), desc, BRW_SFID_SAMPLER);
inst->exec_size = BRW_EXECUTE_8;
inst->mask_ctrl = BRW_MASK_DISABLE;
 
tdst_transpose(dst, real_dst);
for (i = 0; i < 4; i++) {
const struct toy_src src =
tsrc_offset(tsrc_rect(tsrc_from(tmp), TOY_RECT_010), 0, i);
 
/* cast to type D to make sure these are raw moves */
tc_MOV(tc, tdst_d(real_dst[i]), tsrc_d(src));
}
}
 
static void
fs_lower_opcode_tgsi_imm(struct fs_compile_context *fcc,
struct toy_dst dst, int idx)
{
const uint32_t *imm;
struct toy_dst real_dst[4];
int ch;
 
imm = toy_tgsi_get_imm(&fcc->tgsi, idx, NULL);
 
tdst_transpose(dst, real_dst);
/* raw moves */
for (ch = 0; ch < 4; ch++)
tc_MOV(&fcc->tc, tdst_ud(real_dst[ch]), tsrc_imm_ud(imm[ch]));
}
 
static void
fs_lower_opcode_tgsi_sv(struct fs_compile_context *fcc,
struct toy_dst dst, int dim, int idx)
{
struct toy_compiler *tc = &fcc->tc;
const struct toy_tgsi *tgsi = &fcc->tgsi;
int slot;
 
assert(!dim);
 
slot = toy_tgsi_find_system_value(tgsi, idx);
if (slot < 0)
return;
 
switch (tgsi->system_values[slot].semantic_name) {
case TGSI_SEMANTIC_PRIMID:
case TGSI_SEMANTIC_INSTANCEID:
case TGSI_SEMANTIC_VERTEXID:
default:
tc_fail(tc, "unhandled system value");
tc_MOV(tc, dst, tsrc_imm_d(0));
break;
}
}
 
static void
fs_lower_opcode_tgsi_direct(struct fs_compile_context *fcc,
struct toy_inst *inst)
{
struct toy_compiler *tc = &fcc->tc;
int dim, idx;
 
assert(inst->src[0].file == TOY_FILE_IMM);
dim = inst->src[0].val32;
 
assert(inst->src[1].file == TOY_FILE_IMM);
idx = inst->src[1].val32;
 
switch (inst->opcode) {
case TOY_OPCODE_TGSI_IN:
fs_lower_opcode_tgsi_in(fcc, inst->dst, dim, idx);
break;
case TOY_OPCODE_TGSI_CONST:
if (tc->dev->gen >= ILO_GEN(7))
fs_lower_opcode_tgsi_const_gen7(fcc, inst->dst, dim, inst->src[1]);
else
fs_lower_opcode_tgsi_const_gen6(fcc, inst->dst, dim, inst->src[1]);
break;
case TOY_OPCODE_TGSI_SV:
fs_lower_opcode_tgsi_sv(fcc, inst->dst, dim, idx);
break;
case TOY_OPCODE_TGSI_IMM:
assert(!dim);
fs_lower_opcode_tgsi_imm(fcc, inst->dst, idx);
break;
default:
tc_fail(tc, "unhandled TGSI fetch");
break;
}
 
tc_discard_inst(tc, inst);
}
 
static void
fs_lower_opcode_tgsi_indirect(struct fs_compile_context *fcc,
struct toy_inst *inst)
{
struct toy_compiler *tc = &fcc->tc;
enum tgsi_file_type file;
int dim, idx;
struct toy_src indirect_dim, indirect_idx;
 
assert(inst->src[0].file == TOY_FILE_IMM);
file = inst->src[0].val32;
 
assert(inst->src[1].file == TOY_FILE_IMM);
dim = inst->src[1].val32;
indirect_dim = inst->src[2];
 
assert(inst->src[3].file == TOY_FILE_IMM);
idx = inst->src[3].val32;
indirect_idx = inst->src[4];
 
/* no dimension indirection */
assert(indirect_dim.file == TOY_FILE_IMM);
dim += indirect_dim.val32;
 
switch (inst->opcode) {
case TOY_OPCODE_TGSI_INDIRECT_FETCH:
if (file == TGSI_FILE_CONSTANT) {
if (idx) {
struct toy_dst tmp = tc_alloc_tmp(tc);
 
tc_ADD(tc, tmp, indirect_idx, tsrc_imm_d(idx));
indirect_idx = tsrc_from(tmp);
}
 
fs_lower_opcode_tgsi_indirect_const(fcc, inst->dst, dim, indirect_idx);
break;
}
/* fall through */
case TOY_OPCODE_TGSI_INDIRECT_STORE:
default:
tc_fail(tc, "unhandled TGSI indirection");
break;
}
 
tc_discard_inst(tc, inst);
}
 
/**
* Emit instructions to move sampling parameters to the message registers.
*/
static int
fs_add_sampler_params_gen6(struct toy_compiler *tc, int msg_type,
int base_mrf, int param_size,
struct toy_src *coords, int num_coords,
struct toy_src bias_or_lod, struct toy_src ref_or_si,
struct toy_src *ddx, struct toy_src *ddy,
int num_derivs)
{
int num_params, i;
 
assert(num_coords <= 4);
assert(num_derivs <= 3 && num_derivs <= num_coords);
 
#define SAMPLER_PARAM(p) (tdst(TOY_FILE_MRF, base_mrf + (p) * param_size, 0))
switch (msg_type) {
case GEN5_SAMPLER_MESSAGE_SAMPLE:
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(i), coords[i]);
num_params = num_coords;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS:
case GEN5_SAMPLER_MESSAGE_SAMPLE_LOD:
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(i), coords[i]);
tc_MOV(tc, SAMPLER_PARAM(4), bias_or_lod);
num_params = 5;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_COMPARE:
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(i), coords[i]);
tc_MOV(tc, SAMPLER_PARAM(4), ref_or_si);
num_params = 5;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_DERIVS:
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(i), coords[i]);
for (i = 0; i < num_derivs; i++) {
tc_MOV(tc, SAMPLER_PARAM(4 + i * 2), ddx[i]);
tc_MOV(tc, SAMPLER_PARAM(5 + i * 2), ddy[i]);
}
num_params = 4 + num_derivs * 2;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS_COMPARE:
case GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE:
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(i), coords[i]);
tc_MOV(tc, SAMPLER_PARAM(4), ref_or_si);
tc_MOV(tc, SAMPLER_PARAM(5), bias_or_lod);
num_params = 6;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_LD:
assert(num_coords <= 3);
 
for (i = 0; i < num_coords; i++)
tc_MOV(tc, tdst_d(SAMPLER_PARAM(i)), coords[i]);
tc_MOV(tc, tdst_d(SAMPLER_PARAM(3)), bias_or_lod);
tc_MOV(tc, tdst_d(SAMPLER_PARAM(4)), ref_or_si);
num_params = 5;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_RESINFO:
tc_MOV(tc, tdst_d(SAMPLER_PARAM(0)), bias_or_lod);
num_params = 1;
break;
default:
tc_fail(tc, "unknown sampler opcode");
num_params = 0;
break;
}
#undef SAMPLER_PARAM
 
return num_params * param_size;
}
 
static int
fs_add_sampler_params_gen7(struct toy_compiler *tc, int msg_type,
int base_mrf, int param_size,
struct toy_src *coords, int num_coords,
struct toy_src bias_or_lod, struct toy_src ref_or_si,
struct toy_src *ddx, struct toy_src *ddy,
int num_derivs)
{
int num_params, i;
 
assert(num_coords <= 4);
assert(num_derivs <= 3 && num_derivs <= num_coords);
 
#define SAMPLER_PARAM(p) (tdst(TOY_FILE_MRF, base_mrf + (p) * param_size, 0))
switch (msg_type) {
case GEN5_SAMPLER_MESSAGE_SAMPLE:
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(i), coords[i]);
num_params = num_coords;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS:
case GEN5_SAMPLER_MESSAGE_SAMPLE_LOD:
tc_MOV(tc, SAMPLER_PARAM(0), bias_or_lod);
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(1 + i), coords[i]);
num_params = 1 + num_coords;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_COMPARE:
tc_MOV(tc, SAMPLER_PARAM(0), ref_or_si);
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(1 + i), coords[i]);
num_params = 1 + num_coords;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_DERIVS:
for (i = 0; i < num_coords; i++) {
tc_MOV(tc, SAMPLER_PARAM(i * 3), coords[i]);
if (i < num_derivs) {
tc_MOV(tc, SAMPLER_PARAM(i * 3 + 1), ddx[i]);
tc_MOV(tc, SAMPLER_PARAM(i * 3 + 2), ddy[i]);
}
}
num_params = num_coords * 3 - ((num_coords > num_derivs) ? 2 : 0);
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_BIAS_COMPARE:
case GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE:
tc_MOV(tc, SAMPLER_PARAM(0), ref_or_si);
tc_MOV(tc, SAMPLER_PARAM(1), bias_or_lod);
for (i = 0; i < num_coords; i++)
tc_MOV(tc, SAMPLER_PARAM(2 + i), coords[i]);
num_params = 2 + num_coords;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_LD:
assert(num_coords >= 1 && num_coords <= 3);
 
tc_MOV(tc, tdst_d(SAMPLER_PARAM(0)), coords[0]);
tc_MOV(tc, tdst_d(SAMPLER_PARAM(1)), bias_or_lod);
for (i = 1; i < num_coords; i++)
tc_MOV(tc, tdst_d(SAMPLER_PARAM(1 + i)), coords[i]);
num_params = 1 + num_coords;
break;
case GEN5_SAMPLER_MESSAGE_SAMPLE_RESINFO:
tc_MOV(tc, tdst_d(SAMPLER_PARAM(0)), bias_or_lod);
num_params = 1;
break;
default:
tc_fail(tc, "unknown sampler opcode");
num_params = 0;
break;
}
#undef SAMPLER_PARAM
 
return num_params * param_size;
}
 
/**
* 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 = tgsi_util_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->dev->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
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);
for (i = 0; i < 4; i++)
tmp[i].type = inst->dst.type;
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
fs_lower_opcode_derivative(struct toy_compiler *tc, struct toy_inst *inst)
{
struct toy_dst dst[4];
struct toy_src src[4];
int i;
 
tdst_transpose(inst->dst, dst);
tsrc_transpose(inst->src[0], src);
 
/*
* Every four fragments are from a 2x2 subspan, with
*
* fragment 1 on the top-left,
* fragment 2 on the top-right,
* fragment 3 on the bottom-left,
* fragment 4 on the bottom-right.
*
* DDX should thus produce
*
* dst = src.yyww - src.xxzz
*
* and DDY should produce
*
* dst = src.zzww - src.xxyy
*
* But since we are in BRW_ALIGN_1, swizzling does not work and we have to
* play with the region parameters.
*/
if (inst->opcode == TOY_OPCODE_DDX) {
for (i = 0; i < 4; i++) {
struct toy_src left, right;
 
left = tsrc_rect(src[i], TOY_RECT_220);
right = tsrc_offset(left, 0, 1);
 
tc_ADD(tc, dst[i], right, tsrc_negate(left));
}
}
else {
for (i = 0; i < 4; i++) {
struct toy_src top, bottom;
 
/* approximate with dst = src.zzzz - src.xxxx */
top = tsrc_rect(src[i], TOY_RECT_440);
bottom = tsrc_offset(top, 0, 2);
 
tc_ADD(tc, dst[i], bottom, tsrc_negate(top));
}
}
 
tc_discard_inst(tc, inst);
}
 
static void
fs_lower_opcode_fb_write(struct toy_compiler *tc, struct toy_inst *inst)
{
/* fs_write_fb() has set up the message registers */
toy_compiler_lower_to_send(tc, inst, true,
GEN6_SFID_DATAPORT_RENDER_CACHE);
}
 
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);
 
/* KILL or KILL_IF */
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
fs_lower_virtual_opcodes(struct fs_compile_context *fcc)
{
struct toy_compiler *tc = &fcc->tc;
struct toy_inst *inst;
 
/* lower TGSI's first, as they might be lowered to other virtual opcodes */
tc_head(tc);
while ((inst = tc_next(tc)) != NULL) {
switch (inst->opcode) {
case TOY_OPCODE_TGSI_IN:
case TOY_OPCODE_TGSI_CONST:
case TOY_OPCODE_TGSI_SV:
case TOY_OPCODE_TGSI_IMM:
fs_lower_opcode_tgsi_direct(fcc, inst);
break;
case TOY_OPCODE_TGSI_INDIRECT_FETCH:
case TOY_OPCODE_TGSI_INDIRECT_STORE:
fs_lower_opcode_tgsi_indirect(fcc, inst);
break;
case TOY_OPCODE_TGSI_TEX:
case TOY_OPCODE_TGSI_TXB:
case TOY_OPCODE_TGSI_TXD:
case TOY_OPCODE_TGSI_TXL:
case TOY_OPCODE_TGSI_TXP:
case TOY_OPCODE_TGSI_TXF:
case TOY_OPCODE_TGSI_TXQ:
case TOY_OPCODE_TGSI_TXQ_LZ:
case TOY_OPCODE_TGSI_TEX2:
case TOY_OPCODE_TGSI_TXB2:
case TOY_OPCODE_TGSI_TXL2:
case TOY_OPCODE_TGSI_SAMPLE:
case TOY_OPCODE_TGSI_SAMPLE_I:
case TOY_OPCODE_TGSI_SAMPLE_I_MS:
case TOY_OPCODE_TGSI_SAMPLE_B:
case TOY_OPCODE_TGSI_SAMPLE_C:
case TOY_OPCODE_TGSI_SAMPLE_C_LZ:
case TOY_OPCODE_TGSI_SAMPLE_D:
case TOY_OPCODE_TGSI_SAMPLE_L:
case TOY_OPCODE_TGSI_GATHER4:
case TOY_OPCODE_TGSI_SVIEWINFO:
case TOY_OPCODE_TGSI_SAMPLE_POS:
case TOY_OPCODE_TGSI_SAMPLE_INFO:
fs_lower_opcode_tgsi_sampling(fcc, inst);
break;
}
}
 
tc_head(tc);
while ((inst = tc_next(tc)) != NULL) {
switch (inst->opcode) {
case TOY_OPCODE_INV:
case TOY_OPCODE_LOG:
case TOY_OPCODE_EXP:
case TOY_OPCODE_SQRT:
case TOY_OPCODE_RSQ:
case TOY_OPCODE_SIN:
case TOY_OPCODE_COS:
case TOY_OPCODE_FDIV:
case TOY_OPCODE_POW:
case TOY_OPCODE_INT_DIV_QUOTIENT:
case TOY_OPCODE_INT_DIV_REMAINDER:
toy_compiler_lower_math(tc, inst);
break;
case TOY_OPCODE_DDX:
case TOY_OPCODE_DDY:
fs_lower_opcode_derivative(tc, inst);
break;
case TOY_OPCODE_FB_WRITE:
fs_lower_opcode_fb_write(tc, inst);
break;
case TOY_OPCODE_KIL:
fs_lower_opcode_kil(tc, inst);
break;
default:
if (inst->opcode > 127)
tc_fail(tc, "unhandled virtual opcode");
break;
}
}
}
 
/**
* Compile the shader.
*/
static bool
fs_compile(struct fs_compile_context *fcc)
{
struct toy_compiler *tc = &fcc->tc;
struct ilo_shader *sh = fcc->shader;
 
fs_lower_virtual_opcodes(fcc);
toy_compiler_legalize_for_ra(tc);
toy_compiler_optimize(tc);
toy_compiler_allocate_registers(tc,
fcc->first_free_grf,
fcc->last_free_grf,
fcc->num_grf_per_vrf);
toy_compiler_legalize_for_asm(tc);
 
if (tc->fail) {
ilo_err("failed to legalize FS instructions: %s\n", tc->reason);
return false;
}
 
if (ilo_debug & ILO_DEBUG_FS) {
ilo_printf("legalized instructions:\n");
toy_compiler_dump(tc);
ilo_printf("\n");
}
 
if (true) {
sh->kernel = toy_compiler_assemble(tc, &sh->kernel_size);
}
else {
static const uint32_t microcode[] = {
/* fill in the microcode here */
0x0, 0x0, 0x0, 0x0,
};
const bool swap = true;
 
sh->kernel_size = sizeof(microcode);
sh->kernel = MALLOC(sh->kernel_size);
 
if (sh->kernel) {
const int num_dwords = sizeof(microcode) / 4;
const uint32_t *src = microcode;
uint32_t *dst = (uint32_t *) sh->kernel;
int i;
 
for (i = 0; i < num_dwords; i += 4) {
if (swap) {
dst[i + 0] = src[i + 3];
dst[i + 1] = src[i + 2];
dst[i + 2] = src[i + 1];
dst[i + 3] = src[i + 0];
}
else {
memcpy(dst, src, 16);
}
}
}
}
 
if (!sh->kernel) {
ilo_err("failed to compile FS: %s\n", tc->reason);
return false;
}
 
if (ilo_debug & ILO_DEBUG_FS) {
ilo_printf("disassembly:\n");
toy_compiler_disassemble(tc, sh->kernel, sh->kernel_size);
ilo_printf("\n");
}
 
return true;
}
 
/**
* 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);
}
}
 
/**
* Set up shader outputs for fixed-function units.
*/
static void
fs_setup_shader_out(struct ilo_shader *sh, const struct toy_tgsi *tgsi)
{
int i;
 
sh->out.count = tgsi->num_outputs;
for (i = 0; i < tgsi->num_outputs; i++) {
sh->out.register_indices[i] = tgsi->outputs[i].index;
sh->out.semantic_names[i] = tgsi->outputs[i].semantic_name;
sh->out.semantic_indices[i] = tgsi->outputs[i].semantic_index;
 
if (tgsi->outputs[i].semantic_name == TGSI_SEMANTIC_POSITION)
sh->out.has_pos = true;
}
}
 
/**
* Set up shader inputs for fixed-function units.
*/
static void
fs_setup_shader_in(struct ilo_shader *sh, const struct toy_tgsi *tgsi,
bool flatshade)
{
int i;
 
sh->in.count = tgsi->num_inputs;
for (i = 0; i < tgsi->num_inputs; i++) {
sh->in.semantic_names[i] = tgsi->inputs[i].semantic_name;
sh->in.semantic_indices[i] = tgsi->inputs[i].semantic_index;
sh->in.interp[i] = tgsi->inputs[i].interp;
sh->in.centroid[i] = tgsi->inputs[i].centroid;
 
if (tgsi->inputs[i].semantic_name == TGSI_SEMANTIC_POSITION) {
sh->in.has_pos = true;
continue;
}
else if (tgsi->inputs[i].semantic_name == TGSI_SEMANTIC_FACE) {
continue;
}
 
switch (tgsi->inputs[i].interp) {
case TGSI_INTERPOLATE_CONSTANT:
sh->in.const_interp_enable |= 1 << i;
break;
case TGSI_INTERPOLATE_LINEAR:
sh->in.has_linear_interp = true;
 
if (tgsi->inputs[i].centroid) {
sh->in.barycentric_interpolation_mode |=
1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC;
}
else {
sh->in.barycentric_interpolation_mode |=
1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC;
}
break;
case TGSI_INTERPOLATE_COLOR:
if (flatshade) {
sh->in.const_interp_enable |= 1 << i;
break;
}
/* fall through */
case TGSI_INTERPOLATE_PERSPECTIVE:
if (tgsi->inputs[i].centroid) {
sh->in.barycentric_interpolation_mode |=
1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC;
}
else {
sh->in.barycentric_interpolation_mode |=
1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC;
}
break;
default:
break;
}
}
}
 
static int
fs_setup_payloads(struct fs_compile_context *fcc)
{
const struct ilo_shader *sh = fcc->shader;
int grf, i;
 
grf = 0;
 
/* r0: header */
grf++;
 
/* r1-r2: coordinates and etc. */
grf += (fcc->dispatch_mode == GEN6_WM_32_DISPATCH_ENABLE) ? 2 : 1;
 
for (i = 0; i < Elements(fcc->payloads); i++) {
int interp;
 
/* r3-r26 or r32-r55: barycentric interpolation parameters */
for (interp = 0; interp < BRW_WM_BARYCENTRIC_INTERP_MODE_COUNT; interp++) {
if (!(sh->in.barycentric_interpolation_mode & (1 << interp)))
continue;
 
fcc->payloads[i].barycentric_interps[interp] = grf;
grf += (fcc->dispatch_mode == GEN6_WM_8_DISPATCH_ENABLE) ? 2 : 4;
}
 
/* r27-r28 or r56-r57: interpoloated depth */
if (sh->in.has_pos) {
fcc->payloads[i].source_depth = grf;
grf += (fcc->dispatch_mode == GEN6_WM_8_DISPATCH_ENABLE) ? 1 : 2;
}
 
/* r29-r30 or r58-r59: interpoloated w */
if (sh->in.has_pos) {
fcc->payloads[i].source_w = grf;
grf += (fcc->dispatch_mode == GEN6_WM_8_DISPATCH_ENABLE) ? 1 : 2;
}
 
/* r31 or r60: position offset */
if (false) {
fcc->payloads[i].pos_offset = grf;
grf++;
}
 
if (fcc->dispatch_mode != GEN6_WM_32_DISPATCH_ENABLE)
break;
}
 
return grf;
}
 
/**
* Translate the TGSI tokens.
*/
static bool
fs_setup_tgsi(struct toy_compiler *tc, const struct tgsi_token *tokens,
struct toy_tgsi *tgsi)
{
if (ilo_debug & ILO_DEBUG_FS) {
ilo_printf("dumping fragment shader\n");
ilo_printf("\n");
 
tgsi_dump(tokens, 0);
ilo_printf("\n");
}
 
toy_compiler_translate_tgsi(tc, tokens, false, tgsi);
if (tc->fail) {
ilo_err("failed to translate FS TGSI tokens: %s\n", tc->reason);
return false;
}
 
if (ilo_debug & ILO_DEBUG_FS) {
ilo_printf("TGSI translator:\n");
toy_tgsi_dump(tgsi);
ilo_printf("\n");
toy_compiler_dump(tc);
ilo_printf("\n");
}
 
return true;
}
 
/**
* Set up FS compile context. This includes translating the TGSI tokens.
*/
static bool
fs_setup(struct fs_compile_context *fcc,
const struct ilo_shader_state *state,
const struct ilo_shader_variant *variant)
{
int num_consts;
 
memset(fcc, 0, sizeof(*fcc));
 
fcc->shader = CALLOC_STRUCT(ilo_shader);
if (!fcc->shader)
return false;
 
fcc->variant = variant;
 
toy_compiler_init(&fcc->tc, state->info.dev);
 
fcc->dispatch_mode = GEN6_WM_8_DISPATCH_ENABLE;
 
fcc->tc.templ.access_mode = BRW_ALIGN_1;
if (fcc->dispatch_mode == GEN6_WM_16_DISPATCH_ENABLE) {
fcc->tc.templ.qtr_ctrl = GEN6_COMPRESSION_1H;
fcc->tc.templ.exec_size = BRW_EXECUTE_16;
}
else {
fcc->tc.templ.qtr_ctrl = GEN6_COMPRESSION_1Q;
fcc->tc.templ.exec_size = BRW_EXECUTE_8;
}
 
fcc->tc.rect_linear_width = 8;
 
/*
* The classic driver uses the sampler cache (gen6) or the data cache
* (gen7). Why?
*/
fcc->const_cache = GEN6_SFID_DATAPORT_CONSTANT_CACHE;
 
if (!fs_setup_tgsi(&fcc->tc, state->info.tokens, &fcc->tgsi)) {
toy_compiler_cleanup(&fcc->tc);
FREE(fcc->shader);
return false;
}
 
fs_setup_shader_in(fcc->shader, &fcc->tgsi, fcc->variant->u.fs.flatshade);
fs_setup_shader_out(fcc->shader, &fcc->tgsi);
 
/* we do not make use of push constant buffers yet */
num_consts = 0;
 
fcc->first_const_grf = fs_setup_payloads(fcc);
fcc->first_attr_grf = fcc->first_const_grf + num_consts;
fcc->first_free_grf = fcc->first_attr_grf + fcc->shader->in.count * 2;
fcc->last_free_grf = 127;
 
/* m0 is reserved for system routines */
fcc->first_free_mrf = 1;
fcc->last_free_mrf = 15;
 
/* instructions are compressed with BRW_EXECUTE_16 */
fcc->num_grf_per_vrf =
(fcc->dispatch_mode == GEN6_WM_16_DISPATCH_ENABLE) ? 2 : 1;
 
if (fcc->tc.dev->gen >= ILO_GEN(7)) {
fcc->last_free_grf -= 15;
fcc->first_free_mrf = fcc->last_free_grf + 1;
fcc->last_free_mrf = fcc->first_free_mrf + 14;
}
 
fcc->shader->in.start_grf = fcc->first_const_grf;
fcc->shader->has_kill = fcc->tgsi.uses_kill;
fcc->shader->dispatch_16 =
(fcc->dispatch_mode == GEN6_WM_16_DISPATCH_ENABLE);
 
return true;
}
 
/**
* Compile the fragment shader.
*/
struct ilo_shader *
ilo_shader_compile_fs(const struct ilo_shader_state *state,
const struct ilo_shader_variant *variant)
{
struct fs_compile_context fcc;
 
if (!fs_setup(&fcc, state, variant))
return NULL;
 
fs_write_fb(&fcc);
 
if (!fs_compile(&fcc)) {
FREE(fcc.shader);
fcc.shader = NULL;
}
 
toy_tgsi_cleanup(&fcc.tgsi);
toy_compiler_cleanup(&fcc.tc);
 
return fcc.shader;
}