ilo: compile VS/GS/FS with the toy compiler

6 files changed, 4460 insertions, 20 deletions

diff --git a/src/gallium/drivers/ilo/Makefile.sources b/src/gallium/drivers/ilo/Makefile.sources
index c19801e7281..661f3f12f3e 100644
--- a/src/gallium/drivers/ilo/Makefile.sources
+++ b/src/gallium/drivers/ilo/Makefile.sources
@@ -17,6 +17,10 @@ C_SOURCES := \
 	ilo_shader.c \
 	ilo_state.c \
 	ilo_video.c \
+	shader/ilo_shader_cs.c \
+	shader/ilo_shader_fs.c \
+	shader/ilo_shader_gs.c \
+	shader/ilo_shader_vs.c \
 	shader/toy_compiler.c \
 	shader/toy_compiler_asm.c \
 	shader/toy_compiler_disasm.c \
diff --git a/src/gallium/drivers/ilo/ilo_shader.h b/src/gallium/drivers/ilo/ilo_shader.h
index ffe5611131c..2c9e556adf8 100644
--- a/src/gallium/drivers/ilo/ilo_shader.h
+++ b/src/gallium/drivers/ilo/ilo_shader.h
@@ -211,33 +211,27 @@ ilo_shader_cache_mark_busy(struct ilo_shader_cache *shc)
       shc->busy = true;
 }
 
-static inline struct ilo_shader *
+struct ilo_shader *
 ilo_shader_compile_vs(const struct ilo_shader_state *state,
-                      const struct ilo_shader_variant *variant)
-{
-   return NULL;
-}
+                      const struct ilo_shader_variant *variant);
 
-static inline struct ilo_shader *
+struct ilo_shader *
 ilo_shader_compile_gs(const struct ilo_shader_state *state,
-                      const struct ilo_shader_variant *variant)
-{
-   return NULL;
-}
+                      const struct ilo_shader_variant *variant);
+
+bool
+ilo_shader_compile_gs_passthrough(const struct ilo_shader_state *vs_state,
+                                  const struct ilo_shader_variant *vs_variant,
+                                  const int *so_mapping,
+                                  struct ilo_shader *vs);
 
-static inline struct ilo_shader *
+struct ilo_shader *
 ilo_shader_compile_fs(const struct ilo_shader_state *state,
-                      const struct ilo_shader_variant *variant)
-{
-   return NULL;
-}
+                      const struct ilo_shader_variant *variant);
 
-static inline struct ilo_shader *
+struct ilo_shader *
 ilo_shader_compile_cs(const struct ilo_shader_state *state,
-                      const struct ilo_shader_variant *variant)
-{
-   return NULL;
-}
+                      const struct ilo_shader_variant *variant);
 
 static inline void
 ilo_shader_destroy(struct ilo_shader *sh)
diff --git a/src/gallium/drivers/ilo/shader/ilo_shader_cs.c b/src/gallium/drivers/ilo/shader/ilo_shader_cs.c
new file mode 100644
index 00000000000..85182f2a1b7
--- /dev/null
+++ b/src/gallium/drivers/ilo/shader/ilo_shader_cs.c
@@ -0,0 +1,38 @@
+/*
+ * 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 <[email protected]>
+ */
+
+#include "ilo_shader.h"
+
+/**
+ * Compile the compute shader.
+ */
+struct ilo_shader *
+ilo_shader_compile_cs(const struct ilo_shader_state *state,
+                      const struct ilo_shader_variant *variant)
+{
+   return NULL;
+}
diff --git a/src/gallium/drivers/ilo/shader/ilo_shader_fs.c b/src/gallium/drivers/ilo/shader/ilo_shader_fs.c
new file mode 100644
index 00000000000..d5f365cb4d7
--- /dev/null
+++ b/src/gallium/drivers/ilo/shader/ilo_shader_fs.c
@@ -0,0 +1,1694 @@
+/*
+ * 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 <[email protected]>
+ */
+
+#include "tgsi/tgsi_dump.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.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_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->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)
+{
+   tc_fail(&fcc->tc, "no TGSI indirection support");
+}
+
+/**
+ * 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 = 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
+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
+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);
+
+   /* 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
+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.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_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)
+            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.gen);
+
+   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.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;
+}
diff --git a/src/gallium/drivers/ilo/shader/ilo_shader_gs.c b/src/gallium/drivers/ilo/shader/ilo_shader_gs.c
new file mode 100644
index 00000000000..620e0bffc15
--- /dev/null
+++ b/src/gallium/drivers/ilo/shader/ilo_shader_gs.c
@@ -0,0 +1,1437 @@
+/*
+ * 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 <[email protected]>
+ */
+
+#include "tgsi/tgsi_dump.h"
+#include "toy_compiler.h"
+#include "toy_tgsi.h"
+#include "toy_legalize.h"
+#include "toy_optimize.h"
+#include "toy_helpers.h"
+#include "ilo_shader.h"
+
+/* XXX Below is proof-of-concept code.  Skip this file! */
+
+/*
+ * TODO
+ * - primitive id is in r0.1.  FS receives PID as a flat attribute.
+ * - set VUE header m0.1 for layered rendering
+ */
+struct gs_compile_context {
+   struct ilo_shader *shader;
+   const struct ilo_shader_variant *variant;
+   const struct pipe_stream_output_info *so_info;
+
+   struct toy_compiler tc;
+   struct toy_tgsi tgsi;
+   int output_map[PIPE_MAX_SHADER_OUTPUTS];
+
+   bool write_so;
+   bool write_vue;
+
+   int in_vue_size;
+   int in_vue_count;
+
+   int out_vue_size;
+   int out_vue_min_count;
+
+   bool is_static;
+
+   struct {
+      struct toy_src header;
+      struct toy_src svbi;
+      struct toy_src vues[6];
+   } payload;
+
+   struct {
+      struct toy_dst urb_write_header;
+      bool prim_start;
+      bool prim_end;
+      int prim_type;
+
+      struct toy_dst tmp;
+
+      /* buffered tgsi_outs */
+      struct toy_dst buffers[3];
+      int buffer_needed, buffer_cur;
+
+      struct toy_dst so_written;
+      struct toy_dst so_index;
+
+      struct toy_src tgsi_outs[PIPE_MAX_SHADER_OUTPUTS];
+   } vars;
+
+   struct {
+      struct toy_dst total_vertices;
+      struct toy_dst total_prims;
+
+      struct toy_dst num_vertices;
+      struct toy_dst num_vertices_in_prim;
+   } dynamic_data;
+
+   struct {
+      int total_vertices;
+      int total_prims;
+      /* this limits the max vertice count to be 256 */
+      uint32_t last_vertex[8];
+
+      int num_vertices;
+      int num_vertices_in_prim;
+   } static_data;
+
+   int first_free_grf;
+   int last_free_grf;
+   int first_free_mrf;
+   int last_free_mrf;
+};
+
+static void
+gs_COPY8(struct toy_compiler *tc, struct toy_dst dst, struct toy_src src)
+{
+   struct toy_inst *inst;
+
+   inst = tc_MOV(tc, dst, src);
+   inst->exec_size = BRW_EXECUTE_8;
+   inst->mask_ctrl = BRW_MASK_DISABLE;
+}
+
+static void
+gs_COPY4(struct toy_compiler *tc,
+         struct toy_dst dst, int dst_ch,
+         struct toy_src src, int src_ch)
+{
+   struct toy_inst *inst;
+
+   inst = tc_MOV(tc,
+         tdst_offset(dst, 0, dst_ch),
+         tsrc_offset(src, 0, src_ch));
+   inst->exec_size = BRW_EXECUTE_4;
+   inst->mask_ctrl = BRW_MASK_DISABLE;
+}
+
+static void
+gs_COPY1(struct toy_compiler *tc,
+         struct toy_dst dst, int dst_ch,
+         struct toy_src src, int src_ch)
+{
+   struct toy_inst *inst;
+
+   inst = tc_MOV(tc,
+         tdst_offset(dst, 0, dst_ch),
+         tsrc_rect(tsrc_offset(src, 0, src_ch), TOY_RECT_010));
+   inst->exec_size = BRW_EXECUTE_1;
+   inst->mask_ctrl = BRW_MASK_DISABLE;
+}
+
+static void
+gs_init_vars(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_dst dst;
+
+   /* init URB_WRITE header */
+   dst = gcc->vars.urb_write_header;
+
+   gs_COPY8(tc, dst, gcc->payload.header);
+
+   gcc->vars.prim_start = true;
+   gcc->vars.prim_end = false;
+   switch (gcc->out_vue_min_count) {
+   case 1:
+      gcc->vars.prim_type = _3DPRIM_POINTLIST;
+      break;
+   case 2:
+      gcc->vars.prim_type = _3DPRIM_LINESTRIP;
+      break;
+   case 3:
+      gcc->vars.prim_type = _3DPRIM_TRISTRIP;
+      break;
+   }
+
+   if (gcc->write_so)
+      tc_MOV(tc, gcc->vars.so_written, tsrc_imm_d(0));
+}
+
+static void
+gs_save_output(struct gs_compile_context *gcc, const struct toy_src *outs)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   const struct toy_dst buf = gcc->vars.buffers[gcc->vars.buffer_cur];
+   int i;
+
+   for (i = 0; i < gcc->shader->out.count; i++)
+      tc_MOV(tc, tdst_offset(buf, i, 0), outs[i]);
+
+   /* advance the cursor */
+   gcc->vars.buffer_cur++;
+   gcc->vars.buffer_cur %= gcc->vars.buffer_needed;
+}
+
+static void
+gs_write_so(struct gs_compile_context *gcc,
+            struct toy_dst dst,
+            struct toy_src index, struct toy_src out,
+            bool send_write_commit_message,
+            int binding_table_index)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_dst mrf_header;
+   struct toy_src desc;
+
+   mrf_header = tdst_d(tdst(TOY_FILE_MRF, gcc->first_free_mrf, 0));
+
+   /* m0.5: destination index */
+   gs_COPY1(tc, mrf_header, 5, index, 0);
+
+   /* m0.0 - m0.3: RGBA */
+   gs_COPY4(tc, mrf_header, 0, tsrc_type(out, mrf_header.type), 0);
+
+   desc = tsrc_imm_mdesc_data_port(tc, false,
+         1, send_write_commit_message,
+         true, send_write_commit_message,
+         GEN6_DATAPORT_WRITE_MESSAGE_STREAMED_VB_WRITE, 0,
+         binding_table_index);
+
+   tc_SEND(tc, dst, tsrc_from(mrf_header), desc,
+         GEN6_SFID_DATAPORT_RENDER_CACHE);
+}
+
+static void
+gs_write_vue(struct gs_compile_context *gcc,
+             struct toy_dst dst, struct toy_src msg_header,
+             const struct toy_src *outs, int num_outs,
+             bool eot)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_dst mrf_header;
+   struct toy_src desc;
+   int sent = 0;
+
+   mrf_header = tdst_d(tdst(TOY_FILE_MRF, gcc->first_free_mrf, 0));
+   gs_COPY8(tc, mrf_header, msg_header);
+
+   while (sent < num_outs) {
+      int mrf = gcc->first_free_mrf + 1;
+      const int mrf_avail = gcc->last_free_mrf - mrf + 1;
+      int msg_len, num_entries, i;
+      bool complete;
+
+      num_entries = (num_outs - sent + 1) / 2;
+      complete = true;
+      if (num_entries > mrf_avail) {
+         num_entries = mrf_avail;
+         complete = false;
+      }
+
+      for (i = 0; i < num_entries; i++) {
+         gs_COPY4(tc, tdst(TOY_FILE_MRF, mrf + i / 2, 0), 0,
+               outs[sent + 2 * i], 0);
+         if (sent + i * 2 + 1 < gcc->shader->out.count) {
+            gs_COPY4(tc, tdst(TOY_FILE_MRF, mrf + i / 2, 0), 4,
+                  outs[sent + 2 * i + 1], 0);
+         }
+         mrf++;
+      }
+
+      /* do not forget the header */
+      msg_len = num_entries + 1;
+
+      if (complete) {
+         desc = tsrc_imm_mdesc_urb(tc,
+               eot, msg_len, !eot, true, true, !eot,
+               BRW_URB_SWIZZLE_NONE, sent, 0);
+      }
+      else {
+         desc = tsrc_imm_mdesc_urb(tc,
+               false, msg_len, 0, false, true, false,
+               BRW_URB_SWIZZLE_NONE, sent, 0);
+      }
+
+      tc_add2(tc, TOY_OPCODE_URB_WRITE,
+            (complete) ? dst : tdst_null(), tsrc_from(mrf_header), desc);
+
+      sent += num_entries * 2;
+   }
+}
+
+static void
+gs_ff_sync(struct gs_compile_context *gcc, struct toy_dst dst,
+           struct toy_src num_prims)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_dst mrf_header =
+      tdst_d(tdst(TOY_FILE_MRF, gcc->first_free_mrf, 0));
+   struct toy_src desc;
+   bool allocate;
+
+   gs_COPY8(tc, mrf_header, gcc->payload.header);
+
+   /* set NumSOVertsToWrite and NumSOPrimsNeeded */
+   if (gcc->write_so) {
+      if (num_prims.file == TOY_FILE_IMM) {
+         const uint32_t v =
+            (num_prims.val32 * gcc->in_vue_count) << 16 | num_prims.val32;
+
+         gs_COPY1(tc, mrf_header, 0, tsrc_imm_d(v), 0);
+      }
+      else {
+         struct toy_dst m0_0 = tdst_d(gcc->vars.tmp);
+
+         tc_MUL(tc, m0_0, num_prims, tsrc_imm_d(gcc->in_vue_count << 16));
+         tc_OR(tc, m0_0, tsrc_from(m0_0), num_prims);
+
+         gs_COPY1(tc, mrf_header, 0, tsrc_from(m0_0), 0);
+      }
+   }
+
+   /* set NumGSPrimsGenerated */
+   if (gcc->write_vue)
+      gs_COPY1(tc, mrf_header, 1, num_prims, 0);
+
+   /*
+    * From the Sandy Bridge PRM, volume 2 part 1, page 173:
+    *
+    *     "Programming Note: If the GS stage is enabled, software must always
+    *      allocate at least one GS URB Entry. This is true even if the GS
+    *      thread never needs to output vertices to the pipeline, e.g., when
+    *      only performing stream output. This is an artifact of the need to
+    *      pass the GS thread an initial destination URB handle."
+    */
+   allocate = true;
+   desc = tsrc_imm_mdesc_urb(tc, false, 1, 1,
+         false, false, allocate,
+         BRW_URB_SWIZZLE_NONE, 0, 1);
+
+   tc_SEND(tc, dst, tsrc_from(mrf_header), desc, BRW_SFID_URB);
+}
+
+static void
+gs_discard(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_dst mrf_header;
+   struct toy_src desc;
+
+   mrf_header = tdst_d(tdst(TOY_FILE_MRF, gcc->first_free_mrf, 0));
+
+   gs_COPY8(tc, mrf_header, tsrc_from(gcc->vars.urb_write_header));
+
+   desc = tsrc_imm_mdesc_urb(tc,
+         true, 1, 0, true, false, false,
+         BRW_URB_SWIZZLE_NONE, 0, 0);
+
+   tc_add2(tc, TOY_OPCODE_URB_WRITE,
+         tdst_null(), tsrc_from(mrf_header), desc);
+}
+
+static void
+gs_lower_opcode_endprim(struct gs_compile_context *gcc, struct toy_inst *inst)
+{
+   /* if has control flow, set PrimEnd on the last vertex and URB_WRITE */
+}
+
+static void
+gs_lower_opcode_emit_vue_dynamic(struct gs_compile_context *gcc)
+{
+   /* TODO similar to the static version */
+
+   /*
+    * When SO is enabled and the inputs are lines or triangles, vertices are
+    * always buffered.  we can defer the emission of the current vertex until
+    * the next EMIT or ENDPRIM.  Or, we can emit two URB_WRITEs with the later
+    * patching the former.
+    */
+}
+
+static void
+gs_lower_opcode_emit_so_dynamic(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+
+   tc_IF(tc, tdst_null(),
+         tsrc_from(gcc->dynamic_data.num_vertices_in_prim),
+         tsrc_imm_d(gcc->out_vue_min_count),
+         BRW_CONDITIONAL_GE);
+
+   {
+      tc_ADD(tc, gcc->vars.tmp, tsrc_from(gcc->vars.so_index), tsrc_imm_d(0x03020100));
+
+      /* TODO same as static version */
+   }
+
+   tc_ENDIF(tc);
+
+   tc_ADD(tc, gcc->vars.so_index,
+         tsrc_from(gcc->vars.so_index), tsrc_imm_d(gcc->out_vue_min_count));
+}
+
+static void
+gs_lower_opcode_emit_vue_static(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_inst *inst2;
+   bool eot;
+
+   eot = (gcc->static_data.num_vertices == gcc->static_data.total_vertices);
+
+   gcc->vars.prim_end =
+      ((gcc->static_data.last_vertex[(gcc->static_data.num_vertices - 1) / 32] &
+        1 << ((gcc->static_data.num_vertices - 1) % 32)) != 0);
+
+   if (eot && gcc->write_so) {
+      inst2 = tc_OR(tc, tdst_offset(gcc->vars.urb_write_header, 0, 2),
+            tsrc_from(gcc->vars.so_written),
+            tsrc_imm_d(gcc->vars.prim_type << 2 |
+                       gcc->vars.prim_start << 1 |
+                       gcc->vars.prim_end));
+      inst2->exec_size = BRW_EXECUTE_1;
+      inst2->src[0] = tsrc_rect(inst2->src[0], TOY_RECT_010);
+      inst2->src[1] = tsrc_rect(inst2->src[1], TOY_RECT_010);
+   }
+   else {
+      gs_COPY1(tc, gcc->vars.urb_write_header, 2,
+            tsrc_imm_d(gcc->vars.prim_type << 2 |
+                       gcc->vars.prim_start << 1 |
+                       gcc->vars.prim_end), 0);
+   }
+
+   gs_write_vue(gcc, tdst_d(gcc->vars.tmp),
+         tsrc_from(gcc->vars.urb_write_header),
+         gcc->vars.tgsi_outs,
+         gcc->shader->out.count, eot);
+
+   if (!eot) {
+      gs_COPY1(tc, gcc->vars.urb_write_header, 0,
+            tsrc_from(tdst_d(gcc->vars.tmp)), 0);
+   }
+
+   gcc->vars.prim_start = gcc->vars.prim_end;
+   gcc->vars.prim_end = false;
+}
+
+static void
+gs_lower_opcode_emit_so_static(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_inst *inst;
+   int i, j;
+
+   if (gcc->static_data.num_vertices_in_prim < gcc->out_vue_min_count)
+      return;
+
+   inst = tc_MOV(tc, tdst_w(gcc->vars.tmp), tsrc_imm_v(0x03020100));
+   inst->exec_size = BRW_EXECUTE_8;
+   inst->mask_ctrl = BRW_MASK_DISABLE;
+
+   tc_ADD(tc, tdst_d(gcc->vars.tmp), tsrc_from(tdst_d(gcc->vars.tmp)),
+         tsrc_rect(tsrc_from(gcc->vars.so_index), TOY_RECT_010));
+
+   tc_IF(tc, tdst_null(),
+         tsrc_rect(tsrc_offset(tsrc_from(tdst_d(gcc->vars.tmp)), 0, gcc->out_vue_min_count - 1), TOY_RECT_010),
+         tsrc_rect(tsrc_offset(gcc->payload.svbi, 0, 4), TOY_RECT_010),
+         BRW_CONDITIONAL_LE);
+   {
+      for (i = 0; i < gcc->out_vue_min_count; i++) {
+         for (j = 0; j < gcc->so_info->num_outputs; j++) {
+            const int idx = gcc->so_info->output[j].register_index;
+            struct toy_src index, out;
+            int binding_table_index;
+            bool write_commit;
+
+            index = tsrc_d(tsrc_offset(tsrc_from(gcc->vars.tmp), 0, i));
+
+            if (i == gcc->out_vue_min_count - 1) {
+               out = gcc->vars.tgsi_outs[idx];
+            }
+            else {
+               /* gcc->vars.buffer_cur also points to the first vertex */
+               const int buf =
+                  (gcc->vars.buffer_cur + i) % gcc->vars.buffer_needed;
+
+               out = tsrc_offset(tsrc_from(gcc->vars.buffers[buf]), idx, 0);
+            }
+
+            out = tsrc_offset(out, 0, gcc->so_info->output[j].start_component);
+
+            /*
+             * From the Sandy Bridge PRM, volume 4 part 2, page 19:
+             *
+             *     "The Kernel must do a write commit on the last write to DAP
+             *      prior to a URB_WRITE with End of Thread."
+             */
+            write_commit =
+               (gcc->static_data.num_vertices == gcc->static_data.total_vertices &&
+                i == gcc->out_vue_min_count - 1 &&
+                j == gcc->so_info->num_outputs - 1);
+
+
+            binding_table_index = ILO_GS_SO_SURFACE(j);
+
+            gs_write_so(gcc, gcc->vars.tmp, index,
+                  out, write_commit, binding_table_index);
+
+            /*
+             * From the Sandy Bridge PRM, volume 4 part 1, page 168:
+             *
+             *     "The write commit does not modify the destination register, but
+             *      merely clears the dependency associated with the destination
+             *      register. Thus, a simple "mov" instruction using the register as a
+             *      source is sufficient to wait for the write commit to occur."
+             */
+            if (write_commit)
+               tc_MOV(tc, gcc->vars.tmp, tsrc_from(gcc->vars.tmp));
+         }
+      }
+
+      /* SONumPrimsWritten occupies the higher word of m0.2 of URB_WRITE */
+      tc_ADD(tc, gcc->vars.so_written,
+            tsrc_from(gcc->vars.so_written), tsrc_imm_d(1 << 16));
+      tc_ADD(tc, gcc->vars.so_index,
+            tsrc_from(gcc->vars.so_index), tsrc_imm_d(gcc->out_vue_min_count));
+   }
+   tc_ENDIF(tc);
+}
+
+static void
+gs_lower_opcode_emit_static(struct gs_compile_context *gcc,
+                            struct toy_inst *inst)
+{
+   gcc->static_data.num_vertices++;
+   gcc->static_data.num_vertices_in_prim++;
+
+   if (gcc->write_so) {
+      gs_lower_opcode_emit_so_static(gcc);
+
+      if (gcc->out_vue_min_count > 1 &&
+          gcc->static_data.num_vertices != gcc->static_data.total_vertices)
+         gs_save_output(gcc, gcc->vars.tgsi_outs);
+   }
+
+   if (gcc->write_vue)
+      gs_lower_opcode_emit_vue_static(gcc);
+}
+
+static void
+gs_lower_opcode_emit_dynamic(struct gs_compile_context *gcc,
+                             struct toy_inst *inst)
+{
+   struct toy_compiler *tc = &gcc->tc;
+
+   tc_ADD(tc, gcc->dynamic_data.num_vertices,
+         tsrc_from(gcc->dynamic_data.num_vertices), tsrc_imm_d(1));
+   tc_ADD(tc, gcc->dynamic_data.num_vertices_in_prim,
+         tsrc_from(gcc->dynamic_data.num_vertices_in_prim), tsrc_imm_d(1));
+
+   if (gcc->write_so) {
+      gs_lower_opcode_emit_so_dynamic(gcc);
+
+      if (gcc->out_vue_min_count > 1)
+         gs_save_output(gcc, gcc->vars.tgsi_outs);
+   }
+
+   if (gcc->write_vue)
+      gs_lower_opcode_emit_vue_dynamic(gcc);
+}
+
+static void
+gs_lower_opcode_emit(struct gs_compile_context *gcc, struct toy_inst *inst)
+{
+   if (gcc->is_static)
+      gs_lower_opcode_emit_static(gcc, inst);
+   else
+      gs_lower_opcode_emit_dynamic(gcc, inst);
+}
+
+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 _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 = BRW_EXECUTE_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(_3DPRIM_TRISTRIP_REVERSE), BRW_CONDITIONAL_NEQ);
+      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 = BRW_PREDICATE_NORMAL;
+
+      /* swap IN[0] and IN[1] for _3DPRIM_TRISTRIP_REVERSE */
+      dim = !dim;
+
+      attr = tsrc_offset(gcc->payload.vues[dim], reg, subreg);
+      inst = tc_MOV(tc, dst, attr);
+      inst->pred_ctrl = BRW_PREDICATE_NORMAL;
+      inst->pred_inv = true;
+   }
+   else {
+      attr = tsrc_offset(gcc->payload.vues[dim], reg, subreg);
+      tc_MOV(tc, dst, attr);
+   }
+
+
+}
+
+static void
+gs_lower_opcode_tgsi_imm(struct gs_compile_context *gcc,
+                         struct toy_dst dst, int idx)
+{
+   const uint32_t *imm;
+   int ch;
+
+   imm = toy_tgsi_get_imm(&gcc->tgsi, idx, NULL);
+
+   for (ch = 0; ch < 4; ch++) {
+      struct toy_inst *inst;
+
+      /* raw moves */
+      inst = tc_MOV(&gcc->tc,
+            tdst_writemask(tdst_ud(dst), 1 << ch),
+            tsrc_imm_ud(imm[ch]));
+      inst->access_mode = BRW_ALIGN_16;
+   }
+}
+
+static void
+gs_lower_opcode_tgsi_direct(struct gs_compile_context *gcc,
+                            struct toy_inst *inst)
+{
+   struct toy_compiler *tc = &gcc->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:
+      gs_lower_opcode_tgsi_in(gcc, inst->dst, dim, idx);
+      /* fetch all dimensions */
+      if (dim == 0) {
+         int i;
+
+         for (i = 1; i < gcc->in_vue_count; i++) {
+            const int vrf = toy_tgsi_get_vrf(&gcc->tgsi, TGSI_FILE_INPUT, i, idx);
+            struct toy_dst dst;
+
+            if (vrf < 0)
+               continue;
+
+            dst = tdst(TOY_FILE_VRF, vrf, 0);
+            gs_lower_opcode_tgsi_in(gcc, dst, i, idx);
+         }
+      }
+      break;
+   case TOY_OPCODE_TGSI_IMM:
+      assert(!dim);
+      gs_lower_opcode_tgsi_imm(gcc, inst->dst, idx);
+      break;
+   case TOY_OPCODE_TGSI_CONST:
+   case TOY_OPCODE_TGSI_SV:
+   default:
+      tc_fail(tc, "unhandled TGSI fetch");
+      break;
+   }
+
+   tc_discard_inst(tc, inst);
+}
+
+static void
+gs_lower_virtual_opcodes(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct toy_inst *inst;
+
+   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:
+         gs_lower_opcode_tgsi_direct(gcc, inst);
+         break;
+      case TOY_OPCODE_TGSI_INDIRECT_FETCH:
+      case TOY_OPCODE_TGSI_INDIRECT_STORE:
+         /* TODO similar to VS */
+         tc_fail(tc, "no indirection support");
+         tc_discard_inst(tc, 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:
+         /* TODO similar to VS */
+         tc_fail(tc, "no sampling support");
+         tc_discard_inst(tc, inst);
+         break;
+      case TOY_OPCODE_EMIT:
+         gs_lower_opcode_emit(gcc, inst);
+         tc_discard_inst(tc, inst);
+         break;
+      case TOY_OPCODE_ENDPRIM:
+         gs_lower_opcode_endprim(gcc, inst);
+         tc_discard_inst(tc, inst);
+         break;
+      default:
+         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_URB_WRITE:
+         toy_compiler_lower_to_send(tc, inst, false, BRW_SFID_URB);
+         break;
+      default:
+         if (inst->opcode > 127)
+            tc_fail(tc, "unhandled virtual opcode");
+         break;
+      }
+   }
+}
+
+/**
+ * Get the number of (tessellated) primitives generated by this shader.
+ * Return false if that is unknown until runtime.
+ */
+static void
+get_num_prims_static(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   const struct toy_inst *inst;
+   int num_vertices_in_prim = 0, if_depth = 0, do_depth = 0;
+   bool is_static = true;
+
+   tc_head(tc);
+   while ((inst = tc_next_no_skip(tc)) != NULL) {
+      switch (inst->opcode) {
+      case BRW_OPCODE_IF:
+         if_depth++;
+         break;
+      case BRW_OPCODE_ENDIF:
+         if_depth--;
+         break;
+      case BRW_OPCODE_DO:
+         do_depth++;
+         break;
+      case BRW_OPCODE_WHILE:
+         do_depth--;
+         break;
+      case TOY_OPCODE_EMIT:
+         if (if_depth || do_depth) {
+            is_static = false;
+         }
+         else {
+            gcc->static_data.total_vertices++;
+
+            num_vertices_in_prim++;
+            if (num_vertices_in_prim >= gcc->out_vue_min_count)
+               gcc->static_data.total_prims++;
+         }
+         break;
+      case TOY_OPCODE_ENDPRIM:
+         if (if_depth || do_depth) {
+            is_static = false;
+         }
+         else {
+            const int vertidx = gcc->static_data.total_vertices - 1;
+            const int idx = vertidx / 32;
+            const int subidx = vertidx % 32;
+
+            gcc->static_data.last_vertex[idx] |= 1 << subidx;
+            num_vertices_in_prim = 0;
+         }
+         break;
+      default:
+         break;
+      }
+
+      if (!is_static)
+         break;
+   }
+
+   gcc->is_static = is_static;
+}
+
+/**
+ * Compile the shader.
+ */
+static bool
+gs_compile(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct ilo_shader *sh = gcc->shader;
+
+   get_num_prims_static(gcc);
+
+   if (gcc->is_static) {
+      tc_head(tc);
+
+      gs_init_vars(gcc);
+      gs_ff_sync(gcc, tdst_d(gcc->vars.tmp), tsrc_imm_d(gcc->static_data.total_prims));
+      gs_COPY1(tc, gcc->vars.urb_write_header, 0, tsrc_from(tdst_d(gcc->vars.tmp)), 0);
+      if (gcc->write_so)
+         gs_COPY4(tc, gcc->vars.so_index, 0, tsrc_from(tdst_d(gcc->vars.tmp)), 1);
+
+      tc_tail(tc);
+   }
+   else {
+      tc_fail(tc, "no control flow support");
+      return false;
+   }
+
+   if (!gcc->write_vue)
+      gs_discard(gcc);
+
+   gs_lower_virtual_opcodes(gcc);
+   toy_compiler_legalize_for_ra(tc);
+   toy_compiler_optimize(tc);
+   toy_compiler_allocate_registers(tc,
+         gcc->first_free_grf,
+         gcc->last_free_grf,
+         1);
+   toy_compiler_legalize_for_asm(tc);
+
+   if (tc->fail) {
+      ilo_err("failed to legalize GS instructions: %s\n", tc->reason);
+      return false;
+   }
+
+   if (ilo_debug & ILO_DEBUG_GS) {
+      ilo_printf("legalized instructions:\n");
+      toy_compiler_dump(tc);
+      ilo_printf("\n");
+   }
+
+   sh->kernel = toy_compiler_assemble(tc, &sh->kernel_size);
+   if (!sh->kernel)
+      return false;
+
+   if (ilo_debug & ILO_DEBUG_GS) {
+      ilo_printf("disassembly:\n");
+      toy_compiler_disassemble(tc, sh->kernel, sh->kernel_size);
+      ilo_printf("\n");
+   }
+
+   return true;
+}
+
+static bool
+gs_compile_passthrough(struct gs_compile_context *gcc)
+{
+   struct toy_compiler *tc = &gcc->tc;
+   struct ilo_shader *sh = gcc->shader;
+
+   gcc->is_static = true;
+   gcc->static_data.total_vertices = gcc->in_vue_count;
+   gcc->static_data.total_prims = 1;
+   gcc->static_data.last_vertex[0] = 1 << (gcc->in_vue_count - 1);
+
+   gs_init_vars(gcc);
+   gs_ff_sync(gcc, tdst_d(gcc->vars.tmp), tsrc_imm_d(gcc->static_data.total_prims));
+   gs_COPY1(tc, gcc->vars.urb_write_header, 0, tsrc_from(tdst_d(gcc->vars.tmp)), 0);
+   if (gcc->write_so)
+      gs_COPY4(tc, gcc->vars.so_index, 0, tsrc_from(tdst_d(gcc->vars.tmp)), 1);
+
+   {
+      int vert, attr;
+
+      for (vert = 0; vert < gcc->out_vue_min_count; vert++) {
+         for (attr = 0; attr < gcc->shader->out.count; attr++) {
+            tc_MOV(tc, tdst_from(gcc->vars.tgsi_outs[attr]),
+                  tsrc_offset(gcc->payload.vues[vert], attr / 2, (attr % 2) * 4));
+         }
+
+         gs_lower_opcode_emit(gcc, NULL);
+      }
+
+      gs_lower_opcode_endprim(gcc, NULL);
+   }
+
+   if (!gcc->write_vue)
+      gs_discard(gcc);
+
+   gs_lower_virtual_opcodes(gcc);
+
+   toy_compiler_legalize_for_ra(tc);
+   toy_compiler_optimize(tc);
+   toy_compiler_allocate_registers(tc,
+         gcc->first_free_grf,
+         gcc->last_free_grf,
+         1);
+
+   toy_compiler_legalize_for_asm(tc);
+
+   if (tc->fail) {
+      ilo_err("failed to translate GS TGSI tokens: %s\n", tc->reason);
+      return false;
+   }
+
+   if (ilo_debug & ILO_DEBUG_GS) {
+      int i;
+
+      ilo_printf("VUE count %d, VUE size %d\n",
+            gcc->in_vue_count, gcc->in_vue_size);
+      ilo_printf("%srasterizer discard\n",
+            (gcc->variant->u.gs.rasterizer_discard) ? "" : "no ");
+
+      for (i = 0; i < gcc->so_info->num_outputs; i++) {
+         ilo_printf("SO[%d] = OUT[%d]\n", i,
+               gcc->so_info->output[i].register_index);
+      }
+
+      ilo_printf("legalized instructions:\n");
+      toy_compiler_dump(tc);
+      ilo_printf("\n");
+   }
+
+   sh->kernel = toy_compiler_assemble(tc, &sh->kernel_size);
+   if (!sh->kernel) {
+      ilo_err("failed to compile GS: %s\n", tc->reason);
+      return false;
+   }
+
+   if (ilo_debug & ILO_DEBUG_GS) {
+      ilo_printf("disassembly:\n");
+      toy_compiler_disassemble(tc, sh->kernel, sh->kernel_size);
+      ilo_printf("\n");
+   }
+
+   return true;
+}
+
+/**
+ * Translate the TGSI tokens.
+ */
+static bool
+gs_setup_tgsi(struct toy_compiler *tc, const struct tgsi_token *tokens,
+              struct toy_tgsi *tgsi)
+{
+   if (ilo_debug & ILO_DEBUG_GS) {
+      ilo_printf("dumping geometry shader\n");
+      ilo_printf("\n");
+
+      tgsi_dump(tokens, 0);
+      ilo_printf("\n");
+   }
+
+   toy_compiler_translate_tgsi(tc, tokens, true, tgsi);
+   if (tc->fail)
+      return false;
+
+   if (ilo_debug & ILO_DEBUG_GS) {
+      ilo_printf("TGSI translator:\n");
+      toy_tgsi_dump(tgsi);
+      ilo_printf("\n");
+      toy_compiler_dump(tc);
+      ilo_printf("\n");
+   }
+
+   return true;
+}
+
+/**
+ * Set up shader inputs for fixed-function units.
+ */
+static void
+gs_setup_shader_in(struct ilo_shader *sh,
+                   const struct ilo_shader_variant *variant)
+{
+   int i;
+
+   for (i = 0; i < variant->u.gs.num_inputs; i++) {
+      sh->in.semantic_names[i] = variant->u.gs.semantic_names[i];
+      sh->in.semantic_indices[i] = variant->u.gs.semantic_indices[i];
+      sh->in.interp[i] = TGSI_INTERPOLATE_CONSTANT;
+      sh->in.centroid[i] = false;
+   }
+
+   sh->in.count = variant->u.gs.num_inputs;
+
+   sh->in.has_pos = false;
+   sh->in.has_linear_interp = false;
+   sh->in.barycentric_interpolation_mode = 0;
+}
+
+/**
+ * Set up shader outputs for fixed-function units.
+ *
+ * XXX share the code with VS
+ */
+static void
+gs_setup_shader_out(struct ilo_shader *sh, const struct toy_tgsi *tgsi,
+                    bool output_clipdist, int *output_map)
+{
+   int psize_slot = -1, pos_slot = -1;
+   int clipdist_slot[2] = { -1, -1 };
+   int color_slot[4] = { -1, -1, -1, -1 };
+   int num_outs, i;
+
+   /* find out the slots of outputs that need special care */
+   for (i = 0; i < tgsi->num_outputs; i++) {
+      switch (tgsi->outputs[i].semantic_name) {
+      case TGSI_SEMANTIC_PSIZE:
+         psize_slot = i;
+         break;
+      case TGSI_SEMANTIC_POSITION:
+         pos_slot = i;
+         break;
+      case TGSI_SEMANTIC_CLIPDIST:
+         if (tgsi->outputs[i].semantic_index)
+            clipdist_slot[1] = i;
+         else
+            clipdist_slot[0] = i;
+         break;
+      case TGSI_SEMANTIC_COLOR:
+         if (tgsi->outputs[i].semantic_index)
+            color_slot[2] = i;
+         else
+            color_slot[0] = i;
+         break;
+      case TGSI_SEMANTIC_BCOLOR:
+         if (tgsi->outputs[i].semantic_index)
+            color_slot[3] = i;
+         else
+            color_slot[1] = i;
+         break;
+      default:
+         break;
+      }
+   }
+
+   /* the first two VUEs are always PSIZE and POSITION */
+   num_outs = 2;
+   sh->out.semantic_names[0] = TGSI_SEMANTIC_PSIZE;
+   sh->out.semantic_indices[0] = 0;
+   sh->out.semantic_names[1] = TGSI_SEMANTIC_POSITION;
+   sh->out.semantic_indices[1] = 0;
+
+   sh->out.has_pos = true;
+   output_map[0] = psize_slot;
+   output_map[1] = pos_slot;
+
+   /* followed by optional clip distances */
+   if (output_clipdist) {
+      sh->out.semantic_names[num_outs] = TGSI_SEMANTIC_CLIPDIST;
+      sh->out.semantic_indices[num_outs] = 0;
+      output_map[num_outs++] = clipdist_slot[0];
+
+      sh->out.semantic_names[num_outs] = TGSI_SEMANTIC_CLIPDIST;
+      sh->out.semantic_indices[num_outs] = 1;
+      output_map[num_outs++] = clipdist_slot[1];
+   }
+
+   /*
+    * make BCOLOR follow COLOR so that we can make use of
+    * ATTRIBUTE_SWIZZLE_INPUTATTR_FACING in 3DSTATE_SF
+    */
+   for (i = 0; i < 4; i++) {
+      const int slot = color_slot[i];
+
+      if (slot < 0)
+         continue;
+
+      sh->out.semantic_names[num_outs] = tgsi->outputs[slot].semantic_name;
+      sh->out.semantic_indices[num_outs] = tgsi->outputs[slot].semantic_index;
+
+      output_map[num_outs++] = slot;
+   }
+
+   /* add the rest of the outputs */
+   for (i = 0; i < tgsi->num_outputs; i++) {
+      switch (tgsi->outputs[i].semantic_name) {
+      case TGSI_SEMANTIC_PSIZE:
+      case TGSI_SEMANTIC_POSITION:
+      case TGSI_SEMANTIC_CLIPDIST:
+      case TGSI_SEMANTIC_COLOR:
+      case TGSI_SEMANTIC_BCOLOR:
+         break;
+      default:
+         sh->out.semantic_names[num_outs] = tgsi->outputs[i].semantic_name;
+         sh->out.semantic_indices[num_outs] = tgsi->outputs[i].semantic_index;
+         output_map[num_outs++] = i;
+         break;
+      }
+   }
+
+   sh->out.count = num_outs;
+}
+
+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
+gs_setup_payload(struct gs_compile_context *gcc)
+{
+   int grf, i;
+
+   grf = 0;
+
+   /* r0: payload header */
+   gcc->payload.header = tsrc_d(tsrc(TOY_FILE_GRF, grf, 0));
+   grf++;
+
+   /* r1: SVBI */
+   if (gcc->write_so) {
+      gcc->payload.svbi = tsrc_ud(tsrc(TOY_FILE_GRF, grf, 0));
+      grf++;
+   }
+
+   /* URB data */
+   gcc->shader->in.start_grf = grf;
+
+   /* no pull constants */
+
+   /* VUEs */
+   for (i = 0; i < gcc->in_vue_count; i++) {
+      gcc->payload.vues[i] = tsrc(TOY_FILE_GRF, grf, 0);
+      grf += gcc->in_vue_size;
+   }
+
+   gcc->first_free_grf = grf;
+   gcc->last_free_grf = 127;
+}
+
+/**
+ * Set up GS compile context.  This includes translating the TGSI tokens.
+ */
+static bool
+gs_setup(struct gs_compile_context *gcc,
+         const struct ilo_shader_state *state,
+         const struct ilo_shader_variant *variant,
+         int num_verts)
+{
+   memset(gcc, 0, sizeof(*gcc));
+
+   gcc->shader = CALLOC_STRUCT(ilo_shader);
+   if (!gcc->shader)
+      return false;
+
+   gcc->variant = variant;
+   gcc->so_info = &state->info.stream_output;
+
+   toy_compiler_init(&gcc->tc, state->info.gen);
+
+   gcc->write_so = (state->info.stream_output.num_outputs > 0);
+   gcc->write_vue = !gcc->variant->u.gs.rasterizer_discard;
+
+   gcc->tc.templ.access_mode = BRW_ALIGN_16;
+   gcc->tc.templ.exec_size = BRW_EXECUTE_4;
+   gcc->tc.rect_linear_width = 4;
+
+   if (state->info.tokens) {
+      if (!gs_setup_tgsi(&gcc->tc, state->info.tokens, &gcc->tgsi)) {
+         toy_compiler_cleanup(&gcc->tc);
+         FREE(gcc->shader);
+         return false;
+      }
+
+      switch (gcc->tgsi.props.gs_input_prim) {
+      case PIPE_PRIM_POINTS:
+         gcc->in_vue_count = 1;
+         break;
+      case PIPE_PRIM_LINES:
+         gcc->in_vue_count = 2;
+         gcc->shader->in.discard_adj = true;
+         break;
+      case PIPE_PRIM_TRIANGLES:
+         gcc->in_vue_count = 3;
+         gcc->shader->in.discard_adj = true;
+         break;
+      case PIPE_PRIM_LINES_ADJACENCY:
+         gcc->in_vue_count = 4;
+         break;
+      case PIPE_PRIM_TRIANGLES_ADJACENCY:
+         gcc->in_vue_count = 6;
+         break;
+      default:
+         tc_fail(&gcc->tc, "unsupported GS input type");
+         gcc->in_vue_count = 0;
+         break;
+      }
+
+      switch (gcc->tgsi.props.gs_output_prim) {
+      case PIPE_PRIM_POINTS:
+         gcc->out_vue_min_count = 1;
+         break;
+      case PIPE_PRIM_LINE_STRIP:
+         gcc->out_vue_min_count = 2;
+         break;
+      case PIPE_PRIM_TRIANGLE_STRIP:
+         gcc->out_vue_min_count = 3;
+         break;
+      default:
+         tc_fail(&gcc->tc, "unsupported GS output type");
+         gcc->out_vue_min_count = 0;
+         break;
+      }
+   }
+   else {
+      int i;
+
+      gcc->in_vue_count = num_verts;
+      gcc->out_vue_min_count = num_verts;
+
+      gcc->tgsi.num_outputs = gcc->variant->u.gs.num_inputs;
+      for (i = 0; i < gcc->variant->u.gs.num_inputs; i++) {
+         gcc->tgsi.outputs[i].semantic_name =
+            gcc->variant->u.gs.semantic_names[i];
+         gcc->tgsi.outputs[i].semantic_index =
+            gcc->variant->u.gs.semantic_indices[i];
+      }
+   }
+
+   gcc->tc.templ.access_mode = BRW_ALIGN_1;
+
+   gs_setup_shader_in(gcc->shader, gcc->variant);
+   gs_setup_shader_out(gcc->shader, &gcc->tgsi, false, gcc->output_map);
+
+   gcc->in_vue_size = (gcc->shader->in.count + 1) / 2;
+
+   gcc->out_vue_size = (gcc->shader->out.count + 1) / 2;
+
+   gs_setup_payload(gcc);
+   gs_setup_vars(gcc);
+
+   /* m0 is reserved for system routines */
+   gcc->first_free_mrf = 1;
+   gcc->last_free_mrf = 15;
+
+   return true;
+}
+
+/**
+ * Compile the geometry shader.
+ */
+struct ilo_shader *
+ilo_shader_compile_gs(const struct ilo_shader_state *state,
+                      const struct ilo_shader_variant *variant)
+{
+   struct gs_compile_context gcc;
+
+   if (!gs_setup(&gcc, state, variant, 0))
+      return NULL;
+
+   if (!gs_compile(&gcc)) {
+      FREE(gcc.shader);
+      gcc.shader = NULL;
+   }
+
+   toy_tgsi_cleanup(&gcc.tgsi);
+   toy_compiler_cleanup(&gcc.tc);
+
+   return gcc.shader;;
+}
+
+static bool
+append_gs_to_vs(struct ilo_shader *vs, struct ilo_shader *gs, int num_verts)
+{
+   void *combined;
+   int gs_offset;
+
+   if (!gs)
+      return false;
+
+   /* kernels must be aligned to 64-byte */
+   gs_offset = align(vs->kernel_size, 64);
+   combined = REALLOC(vs->kernel, vs->kernel_size,
+         gs_offset + gs->kernel_size);
+   if (!combined)
+      return false;
+
+   memcpy(combined + gs_offset, gs->kernel, gs->kernel_size);
+
+   vs->kernel = combined;
+   vs->kernel_size = gs_offset + gs->kernel_size;
+
+   vs->stream_output = true;
+   vs->gs_offsets[num_verts - 1] = gs_offset;
+   vs->gs_start_grf = gs->in.start_grf;
+
+   ilo_shader_destroy(gs);
+
+   return true;
+}
+
+bool
+ilo_shader_compile_gs_passthrough(const struct ilo_shader_state *vs_state,
+                                  const struct ilo_shader_variant *vs_variant,
+                                  const int *so_mapping,
+                                  struct ilo_shader *vs)
+{
+   struct gs_compile_context gcc;
+   struct ilo_shader_state state;
+   struct ilo_shader_variant variant;
+   const int num_verts = 3;
+   int i;
+
+   /* init GS state and variant */
+   state = *vs_state;
+   state.info.tokens = NULL;
+   for (i = 0; i < state.info.stream_output.num_outputs; i++) {
+      const int reg = state.info.stream_output.output[i].register_index;
+
+      state.info.stream_output.output[i].register_index = so_mapping[reg];
+   }
+
+   variant = *vs_variant;
+   variant.u.gs.rasterizer_discard = vs_variant->u.vs.rasterizer_discard;
+   variant.u.gs.num_inputs = vs->out.count;
+   for (i = 0; i < vs->out.count; i++) {
+      variant.u.gs.semantic_names[i] =
+         vs->out.semantic_names[i];
+      variant.u.gs.semantic_indices[i] =
+         vs->out.semantic_indices[i];
+   }
+
+   if (!gs_setup(&gcc, &state, &variant, num_verts))
+      return false;
+
+   if (!gs_compile_passthrough(&gcc)) {
+      FREE(gcc.shader);
+      gcc.shader = NULL;
+   }
+
+   /* no need to call toy_tgsi_cleanup() */
+   toy_compiler_cleanup(&gcc.tc);
+
+   return append_gs_to_vs(vs, gcc.shader, num_verts);
+}
diff --git a/src/gallium/drivers/ilo/shader/ilo_shader_vs.c b/src/gallium/drivers/ilo/shader/ilo_shader_vs.c
new file mode 100644
index 00000000000..09a7b0424e7
--- /dev/null
+++ b/src/gallium/drivers/ilo/shader/ilo_shader_vs.c
@@ -0,0 +1,1273 @@
+/*
+ * 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 <[email protected]>
+ */
+
+#include "tgsi/tgsi_dump.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.h"
+
+struct vs_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 output_map[PIPE_MAX_SHADER_OUTPUTS];
+
+   int num_grf_per_vrf;
+   int first_const_grf;
+   int first_vue_grf;
+   int first_free_grf;
+   int last_free_grf;
+
+   int first_free_mrf;
+   int last_free_mrf;
+};
+
+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
+vs_lower_opcode_tgsi_const_gen6(struct vs_compile_context *vcc,
+                                struct toy_dst dst, int dim,
+                                struct toy_src idx)
+{
+   const struct toy_dst header =
+      tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf, 0));
+   const struct toy_dst block_offsets =
+      tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf + 1, 0));
+   const struct toy_src r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0));
+   struct toy_compiler *tc = &vcc->tc;
+   unsigned msg_type, msg_ctrl, msg_len;
+   struct toy_inst *inst;
+   struct toy_src desc;
+
+   /* set message header */
+   inst = tc_MOV(tc, header, r0);
+   inst->mask_ctrl = BRW_MASK_DISABLE;
+
+   /* set block offsets */
+   tc_MOV(tc, block_offsets, idx);
+
+   msg_type = GEN6_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ;
+   msg_ctrl = BRW_DATAPORT_OWORD_DUAL_BLOCK_1OWORD << 8;;
+   msg_len = 2;
+
+   desc = tsrc_imm_mdesc_data_port(tc, false, msg_len, 1, true, false,
+         msg_type, msg_ctrl, ILO_VS_CONST_SURFACE(dim));
+
+   tc_SEND(tc, dst, tsrc_from(header), desc, vcc->const_cache);
+}
+
+static void
+vs_lower_opcode_tgsi_const_gen7(struct vs_compile_context *vcc,
+                                struct toy_dst dst, int dim,
+                                struct toy_src idx)
+{
+   struct toy_compiler *tc = &vcc->tc;
+   const struct toy_dst offset =
+      tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf, 0));
+   struct toy_src desc;
+
+   /*
+    * In 259b65e2e7938de4aab323033cfe2b33369ddb07, pull constant load was
+    * changed from OWord Dual 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 */
+   tc_MOV(tc, offset, idx);
+
+   desc = tsrc_imm_mdesc_sampler(tc, 1, 1, false,
+         BRW_SAMPLER_SIMD_MODE_SIMD4X2,
+         GEN5_SAMPLER_MESSAGE_SAMPLE_LD,
+         0,
+         ILO_VS_CONST_SURFACE(dim));
+
+   tc_SEND(tc, dst, tsrc_from(offset), desc, BRW_SFID_SAMPLER);
+}
+
+static void
+vs_lower_opcode_tgsi_imm(struct vs_compile_context *vcc,
+                         struct toy_dst dst, int idx)
+{
+   const uint32_t *imm;
+   int ch;
+
+   imm = toy_tgsi_get_imm(&vcc->tgsi, idx, NULL);
+
+   for (ch = 0; ch < 4; ch++) {
+      /* raw moves */
+      tc_MOV(&vcc->tc,
+            tdst_writemask(tdst_ud(dst), 1 << ch),
+            tsrc_imm_ud(imm[ch]));
+   }
+}
+
+
+static void
+vs_lower_opcode_tgsi_sv(struct vs_compile_context *vcc,
+                        struct toy_dst dst, int dim, int idx)
+{
+   struct toy_compiler *tc = &vcc->tc;
+   const struct toy_tgsi *tgsi = &vcc->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_INSTANCEID:
+   case TGSI_SEMANTIC_VERTEXID:
+      /*
+       * In 3DSTATE_VERTEX_ELEMENTS, we prepend an extra vertex element for
+       * the generated IDs, with VID in the X channel and IID in the Y
+       * channel.
+       */
+      {
+         const int grf = vcc->first_vue_grf;
+         const struct toy_src src = tsrc(TOY_FILE_GRF, grf, 0);
+         const enum toy_swizzle swizzle =
+            (tgsi->system_values[slot].semantic_name ==
+             TGSI_SEMANTIC_INSTANCEID) ? TOY_SWIZZLE_Y : TOY_SWIZZLE_X;
+
+         tc_MOV(tc, tdst_d(dst), tsrc_d(tsrc_swizzle1(src, swizzle)));
+      }
+      break;
+   case TGSI_SEMANTIC_PRIMID:
+   default:
+      tc_fail(tc, "unhandled system value");
+      tc_MOV(tc, dst, tsrc_imm_d(0));
+      break;
+   }
+}
+
+static void
+vs_lower_opcode_tgsi_direct(struct vs_compile_context *vcc,
+                            struct toy_inst *inst)
+{
+   struct toy_compiler *tc = &vcc->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:
+      vs_lower_opcode_tgsi_in(vcc, inst->dst, dim, idx);
+      break;
+   case TOY_OPCODE_TGSI_CONST:
+      if (tc->gen >= ILO_GEN(7))
+         vs_lower_opcode_tgsi_const_gen7(vcc, inst->dst, dim, inst->src[1]);
+      else
+         vs_lower_opcode_tgsi_const_gen6(vcc, inst->dst, dim, inst->src[1]);
+      break;
+   case TOY_OPCODE_TGSI_SV:
+      vs_lower_opcode_tgsi_sv(vcc, inst->dst, dim, idx);
+      break;
+   case TOY_OPCODE_TGSI_IMM:
+      assert(!dim);
+      vs_lower_opcode_tgsi_imm(vcc, inst->dst, idx);
+      break;
+   default:
+      tc_fail(tc, "unhandled TGSI fetch");
+      break;
+   }
+
+   tc_discard_inst(tc, inst);
+}
+
+static void
+vs_lower_opcode_tgsi_indirect(struct vs_compile_context *vcc,
+                              struct toy_inst *inst)
+{
+   struct toy_compiler *tc = &vcc->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);
+         }
+
+         if (tc->gen >= ILO_GEN(7))
+            vs_lower_opcode_tgsi_const_gen7(vcc, inst->dst, dim, indirect_idx);
+         else
+            vs_lower_opcode_tgsi_const_gen6(vcc, 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
+vs_add_sampler_params(struct toy_compiler *tc, int msg_type, int base_mrf,
+                      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)
+{
+   const unsigned coords_writemask = (1 << num_coords) - 1;
+   struct toy_dst m[3];
+   int num_params, i;
+
+   assert(num_coords <= 4);
+   assert(num_derivs <= 3 && num_derivs <= num_coords);
+
+   for (i = 0; i < Elements(m); i++)
+      m[i] = tdst(TOY_FILE_MRF, base_mrf + i, 0);
+
+   switch (msg_type) {
+   case GEN5_SAMPLER_MESSAGE_SAMPLE_LOD:
+      tc_MOV(tc, tdst_writemask(m[0], coords_writemask), coords);
+      tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_X), bias_or_lod);
+      num_params = 5;
+      break;
+   case GEN5_SAMPLER_MESSAGE_SAMPLE_DERIVS:
+      tc_MOV(tc, tdst_writemask(m[0], coords_writemask), coords);
+      tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_XZ),
+            tsrc_swizzle(ddx, 0, 0, 1, 1));
+      tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_YW),
+            tsrc_swizzle(ddy, 0, 0, 1, 1));
+      if (num_derivs > 2) {
+         tc_MOV(tc, tdst_writemask(m[2], TOY_WRITEMASK_X),
+               tsrc_swizzle1(ddx, 2));
+         tc_MOV(tc, tdst_writemask(m[2], TOY_WRITEMASK_Y),
+               tsrc_swizzle1(ddy, 2));
+      }
+      num_params = 4 + num_derivs * 2;
+      break;
+   case GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE:
+      tc_MOV(tc, tdst_writemask(m[0], coords_writemask), coords);
+      tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_X), ref_or_si);
+      tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_Y), bias_or_lod);
+      num_params = 6;
+      break;
+   case GEN5_SAMPLER_MESSAGE_SAMPLE_LD:
+      assert(num_coords <= 3);
+      tc_MOV(tc, tdst_writemask(tdst_d(m[0]), coords_writemask), coords);
+      tc_MOV(tc, tdst_writemask(tdst_d(m[0]), TOY_WRITEMASK_W), bias_or_lod);
+      if (tc->gen >= ILO_GEN(7)) {
+         num_params = 4;
+      }
+      else {
+         tc_MOV(tc, tdst_writemask(tdst_d(m[1]), TOY_WRITEMASK_X), ref_or_si);
+         num_params = 5;
+      }
+      break;
+   case GEN5_SAMPLER_MESSAGE_SAMPLE_RESINFO:
+      tc_MOV(tc, tdst_writemask(tdst_d(m[0]), TOY_WRITEMASK_X), bias_or_lod);
+      num_params = 1;
+      break;
+   default:
+      tc_fail(tc, "unknown sampler opcode");
+      num_params = 0;
+      break;
+   }
+
+   return (num_params + 3) / 4;
+}
+
+/**
+ * Set up message registers and return the message descriptor for sampling.
+ */
+static struct toy_src
+vs_prepare_tgsi_sampling(struct toy_compiler *tc, const struct toy_inst *inst,
+                         int base_mrf, unsigned *ret_sampler_index)
+{
+   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 = BRW_SAMPLER_SIMD_MODE_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 = toy_tgsi_get_texture_coord_dim(inst->tex.target, &ref_pos);
+
+   /* extract the parameters */
+   switch (inst->opcode) {
+   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;
+      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 = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE;
+         ref_or_si = tsrc_swizzle1(coords, ref_pos);
+      }
+      else {
+         msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD;
+      }
+
+      bias_or_lod = tsrc_swizzle1(coords, TOY_SWIZZLE_W);
+      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 = 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 = GEN5_SAMPLER_MESSAGE_SAMPLE_RESINFO;
+      num_coords = 0;
+      bias_or_lod = tsrc_swizzle1(coords, TOY_SWIZZLE_X);
+      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_TXL2:
+      if (ref_pos >= 0) {
+         assert(ref_pos < 4);
+
+         msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD_COMPARE;
+         ref_or_si = tsrc_swizzle1(coords, ref_pos);
+      }
+      else {
+         msg_type = GEN5_SAMPLER_MESSAGE_SAMPLE_LOD;
+      }
+
+      bias_or_lod = tsrc_swizzle1(inst->src[1], TOY_SWIZZLE_X);
+      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_VS_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, max;
+         struct toy_src abs_coords[3];
+         int 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], BRW_CONDITIONAL_GE);
+         tc_SEL(tc, max, tsrc_from(max), abs_coords[0], BRW_CONDITIONAL_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);
+}
+
+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(tc, 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, BRW_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);
+   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
+vs_lower_opcode_urb_write(struct toy_compiler *tc, struct toy_inst *inst)
+{
+   /* vs_write_vue() has set up the message registers */
+   toy_compiler_lower_to_send(tc, inst, false, BRW_SFID_URB);
+}
+
+static void
+vs_lower_virtual_opcodes(struct vs_compile_context *vcc)
+{
+   struct toy_compiler *tc = &vcc->tc;
+   struct toy_inst *inst;
+
+   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:
+         vs_lower_opcode_tgsi_direct(vcc, inst);
+         break;
+      case TOY_OPCODE_TGSI_INDIRECT_FETCH:
+      case TOY_OPCODE_TGSI_INDIRECT_STORE:
+         vs_lower_opcode_tgsi_indirect(vcc, 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:
+         vs_lower_opcode_tgsi_sampling(vcc, inst);
+         break;
+      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_URB_WRITE:
+         vs_lower_opcode_urb_write(tc, inst);
+         break;
+      default:
+         if (inst->opcode > 127)
+            tc_fail(tc, "unhandled virtual opcode");
+         break;
+      }
+   }
+}
+
+/**
+ * Compile the shader.
+ */
+static bool
+vs_compile(struct vs_compile_context *vcc)
+{
+   struct toy_compiler *tc = &vcc->tc;
+   struct ilo_shader *sh = vcc->shader;
+
+   vs_lower_virtual_opcodes(vcc);
+   toy_compiler_legalize_for_ra(tc);
+   toy_compiler_optimize(tc);
+   toy_compiler_allocate_registers(tc,
+         vcc->first_free_grf,
+         vcc->last_free_grf,
+         vcc->num_grf_per_vrf);
+   toy_compiler_legalize_for_asm(tc);
+
+   if (tc->fail) {
+      ilo_err("failed to legalize VS instructions: %s\n", tc->reason);
+      return false;
+   }
+
+   if (ilo_debug & ILO_DEBUG_VS) {
+      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 VS: %s\n", tc->reason);
+      return false;
+   }
+
+   if (ilo_debug & ILO_DEBUG_VS) {
+      ilo_printf("disassembly:\n");
+      toy_compiler_disassemble(tc, sh->kernel, sh->kernel_size);
+      ilo_printf("\n");
+   }
+
+   return true;
+}
+
+/**
+ * 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;
+   int 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_const_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;
+}
+
+/**
+ * Emit instructions to write the VUE.
+ */
+static void
+vs_write_vue(struct vs_compile_context *vcc)
+{
+   struct toy_compiler *tc = &vcc->tc;
+   struct toy_src outs[PIPE_MAX_SHADER_OUTPUTS];
+   struct toy_dst header;
+   struct toy_src r0;
+   struct toy_inst *inst;
+   int sent_attrs, total_attrs;
+
+   header = tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf, 0));
+   r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0));
+   inst = tc_MOV(tc, header, r0);
+   inst->mask_ctrl = BRW_MASK_DISABLE;
+
+   if (tc->gen >= ILO_GEN(7)) {
+      inst = tc_OR(tc, tdst_offset(header, 0, 5),
+            tsrc_rect(tsrc_offset(r0, 0, 5), TOY_RECT_010),
+            tsrc_rect(tsrc_imm_ud(0xff00), TOY_RECT_010));
+      inst->exec_size = BRW_EXECUTE_1;
+      inst->access_mode = BRW_ALIGN_1;
+      inst->mask_ctrl = BRW_MASK_DISABLE;
+   }
+
+   total_attrs = vs_collect_outputs(vcc, outs);
+   sent_attrs = 0;
+   while (sent_attrs < total_attrs) {
+      struct toy_src desc;
+      int mrf = vcc->first_free_mrf + 1, avail_mrf_for_attrs;
+      int num_attrs, msg_len, i;
+      bool eot;
+
+      num_attrs = total_attrs - sent_attrs;
+      eot = true;
+
+      /* see if we need another message */
+      avail_mrf_for_attrs = vcc->last_free_mrf - mrf + 1;
+      if (num_attrs > avail_mrf_for_attrs) {
+         /*
+          * From the Sandy Bridge PRM, volume 4 part 2, page 22:
+          *
+          *     "Offset. This field specifies a destination offset (in 256-bit
+          *      units) from the start of the URB entry(s), as referenced by
+          *      URB Return Handle n, at which the data (if any) will be
+          *      written."
+          *
+          * As we need to offset the following messages, we must make sure
+          * this one writes an even number of attributes.
+          */
+         num_attrs = avail_mrf_for_attrs & ~1;
+         eot = false;
+      }
+
+      if (tc->gen >= ILO_GEN(7)) {
+         /* do not forget about the header */
+         msg_len = 1 + num_attrs;
+      }
+      else {
+         /*
+          * From the Sandy Bridge PRM, volume 4 part 2, page 26:
+          *
+          *     "At least 256 bits per vertex (512 bits total, M1 & M2) must
+          *      be written.  Writing only 128 bits per vertex (256 bits
+          *      total, M1 only) results in UNDEFINED operation."
+          *
+          *     "[DevSNB] Interleave writes must be in multiples of 256 per
+          *      vertex."
+          *
+          * That is, we must write or appear to write an even number of
+          * attributes, starting from two.
+          */
+         if (num_attrs % 2 && num_attrs == avail_mrf_for_attrs) {
+            num_attrs--;
+            eot = false;
+         }
+
+         msg_len = 1 + align(num_attrs, 2);
+      }
+
+      for (i = 0; i < num_attrs; i++)
+         tc_MOV(tc, tdst(TOY_FILE_MRF, mrf++, 0), outs[sent_attrs + i]);
+
+      assert(sent_attrs % 2 == 0);
+      desc = tsrc_imm_mdesc_urb(tc, eot, msg_len, 0,
+            eot, true, false, BRW_URB_SWIZZLE_INTERLEAVE, sent_attrs / 2, 0);
+
+      tc_add2(tc, TOY_OPCODE_URB_WRITE, tdst_null(), tsrc_from(header), desc);
+
+      sent_attrs += num_attrs;
+   }
+}
+
+/**
+ * Set up shader inputs for fixed-function units.
+ */
+static void
+vs_setup_shader_in(struct ilo_shader *sh, const struct toy_tgsi *tgsi)
+{
+   int num_attrs, i;
+
+   /* vertex/instance id is the first VE if exists */
+   for (i = 0; i < tgsi->num_system_values; i++) {
+      bool found = false;
+
+      switch (tgsi->system_values[i].semantic_name) {
+      case TGSI_SEMANTIC_INSTANCEID:
+      case TGSI_SEMANTIC_VERTEXID:
+         found = true;
+         break;
+      default:
+         break;
+      }
+
+      if (found) {
+         sh->in.semantic_names[sh->in.count] =
+            tgsi->system_values[i].semantic_name;
+         sh->in.semantic_indices[sh->in.count] =
+            tgsi->system_values[i].semantic_index;
+         sh->in.interp[sh->in.count] = TGSI_INTERPOLATE_CONSTANT;
+         sh->in.centroid[sh->in.count] = false;
+
+         sh->in.count++;
+         break;
+      }
+   }
+
+   num_attrs = 0;
+   for (i = 0; i < tgsi->num_inputs; i++) {
+      assert(tgsi->inputs[i].semantic_name == TGSI_SEMANTIC_GENERIC);
+      if (tgsi->inputs[i].semantic_index >= num_attrs)
+         num_attrs = tgsi->inputs[i].semantic_index + 1;
+   }
+   assert(num_attrs <= PIPE_MAX_ATTRIBS);
+
+   /* VF cannot remap VEs.  VE[i] must be used as GENERIC[i]. */
+   for (i = 0; i < num_attrs; i++) {
+      sh->in.semantic_names[sh->in.count + i] = TGSI_SEMANTIC_GENERIC;
+      sh->in.semantic_indices[sh->in.count + i] = i;
+      sh->in.interp[sh->in.count + i] = TGSI_INTERPOLATE_CONSTANT;
+      sh->in.centroid[sh->in.count + i] = false;
+   }
+
+   sh->in.count += num_attrs;
+
+   sh->in.has_pos = false;
+   sh->in.has_linear_interp = false;
+   sh->in.barycentric_interpolation_mode = 0;
+}
+
+/**
+ * Set up shader outputs for fixed-function units.
+ */
+static void
+vs_setup_shader_out(struct ilo_shader *sh, const struct toy_tgsi *tgsi,
+                    bool output_clipdist, int *output_map)
+{
+   int psize_slot = -1, pos_slot = -1;
+   int clipdist_slot[2] = { -1, -1 };
+   int color_slot[4] = { -1, -1, -1, -1 };
+   int num_outs, i;
+
+   /* find out the slots of outputs that need special care */
+   for (i = 0; i < tgsi->num_outputs; i++) {
+      switch (tgsi->outputs[i].semantic_name) {
+      case TGSI_SEMANTIC_PSIZE:
+         psize_slot = i;
+         break;
+      case TGSI_SEMANTIC_POSITION:
+         pos_slot = i;
+         break;
+      case TGSI_SEMANTIC_CLIPDIST:
+         if (tgsi->outputs[i].semantic_index)
+            clipdist_slot[1] = i;
+         else
+            clipdist_slot[0] = i;
+         break;
+      case TGSI_SEMANTIC_COLOR:
+         if (tgsi->outputs[i].semantic_index)
+            color_slot[2] = i;
+         else
+            color_slot[0] = i;
+         break;
+      case TGSI_SEMANTIC_BCOLOR:
+         if (tgsi->outputs[i].semantic_index)
+            color_slot[3] = i;
+         else
+            color_slot[1] = i;
+         break;
+      default:
+         break;
+      }
+   }
+
+   /* the first two VUEs are always PSIZE and POSITION */
+   num_outs = 2;
+   sh->out.semantic_names[0] = TGSI_SEMANTIC_PSIZE;
+   sh->out.semantic_indices[0] = 0;
+   sh->out.semantic_names[1] = TGSI_SEMANTIC_POSITION;
+   sh->out.semantic_indices[1] = 0;
+
+   sh->out.has_pos = true;
+   output_map[0] = psize_slot;
+   output_map[1] = pos_slot;
+
+   /* followed by optional clip distances */
+   if (output_clipdist) {
+      sh->out.semantic_names[num_outs] = TGSI_SEMANTIC_CLIPDIST;
+      sh->out.semantic_indices[num_outs] = 0;
+      output_map[num_outs++] = clipdist_slot[0];
+
+      sh->out.semantic_names[num_outs] = TGSI_SEMANTIC_CLIPDIST;
+      sh->out.semantic_indices[num_outs] = 1;
+      output_map[num_outs++] = clipdist_slot[1];
+   }
+
+   /*
+    * make BCOLOR follow COLOR so that we can make use of
+    * ATTRIBUTE_SWIZZLE_INPUTATTR_FACING in 3DSTATE_SF
+    */
+   for (i = 0; i < 4; i++) {
+      const int slot = color_slot[i];
+
+      if (slot < 0)
+         continue;
+
+      sh->out.semantic_names[num_outs] = tgsi->outputs[slot].semantic_name;
+      sh->out.semantic_indices[num_outs] = tgsi->outputs[slot].semantic_index;
+
+      output_map[num_outs++] = slot;
+   }
+
+   /* add the rest of the outputs */
+   for (i = 0; i < tgsi->num_outputs; i++) {
+      switch (tgsi->outputs[i].semantic_name) {
+      case TGSI_SEMANTIC_PSIZE:
+      case TGSI_SEMANTIC_POSITION:
+      case TGSI_SEMANTIC_CLIPDIST:
+      case TGSI_SEMANTIC_COLOR:
+      case TGSI_SEMANTIC_BCOLOR:
+         break;
+      default:
+         sh->out.semantic_names[num_outs] = tgsi->outputs[i].semantic_name;
+         sh->out.semantic_indices[num_outs] = tgsi->outputs[i].semantic_index;
+         output_map[num_outs++] = i;
+         break;
+      }
+   }
+
+   sh->out.count = num_outs;
+}
+
+/**
+ * Translate the TGSI tokens.
+ */
+static bool
+vs_setup_tgsi(struct toy_compiler *tc, const struct tgsi_token *tokens,
+              struct toy_tgsi *tgsi)
+{
+   if (ilo_debug & ILO_DEBUG_VS) {
+      ilo_printf("dumping vertex shader\n");
+      ilo_printf("\n");
+
+      tgsi_dump(tokens, 0);
+      ilo_printf("\n");
+   }
+
+   toy_compiler_translate_tgsi(tc, tokens, true, tgsi);
+   if (tc->fail) {
+      ilo_err("failed to translate VS TGSI tokens: %s\n", tc->reason);
+      return false;
+   }
+
+   if (ilo_debug & ILO_DEBUG_VS) {
+      ilo_printf("TGSI translator:\n");
+      toy_tgsi_dump(tgsi);
+      ilo_printf("\n");
+      toy_compiler_dump(tc);
+      ilo_printf("\n");
+   }
+
+   return true;
+}
+
+/**
+ * Set up VS compile context.  This includes translating the TGSI tokens.
+ */
+static bool
+vs_setup(struct vs_compile_context *vcc,
+         const struct ilo_shader_state *state,
+         const struct ilo_shader_variant *variant)
+{
+   int num_consts;
+
+   memset(vcc, 0, sizeof(*vcc));
+
+   vcc->shader = CALLOC_STRUCT(ilo_shader);
+   if (!vcc->shader)
+      return false;
+
+   vcc->variant = variant;
+
+   toy_compiler_init(&vcc->tc, state->info.gen);
+   vcc->tc.templ.access_mode = BRW_ALIGN_16;
+   vcc->tc.templ.exec_size = BRW_EXECUTE_8;
+   vcc->tc.rect_linear_width = 4;
+
+   /*
+    * The classic driver uses the sampler cache (gen6) or the data cache
+    * (gen7).  Why?
+    */
+   vcc->const_cache = GEN6_SFID_DATAPORT_CONSTANT_CACHE;
+
+   if (!vs_setup_tgsi(&vcc->tc, state->info.tokens, &vcc->tgsi)) {
+      toy_compiler_cleanup(&vcc->tc);
+      FREE(vcc->shader);
+      return false;
+   }
+
+   vs_setup_shader_in(vcc->shader, &vcc->tgsi);
+   vs_setup_shader_out(vcc->shader, &vcc->tgsi,
+         (vcc->variant->u.vs.num_ucps > 0), vcc->output_map);
+
+   /* fit each pair of user clip planes into a register */
+   num_consts = (vcc->variant->u.vs.num_ucps + 1) / 2;
+
+   /* r0 is reserved for payload header */
+   vcc->first_const_grf = 1;
+   vcc->first_vue_grf = vcc->first_const_grf + num_consts;
+   vcc->first_free_grf = vcc->first_vue_grf + vcc->shader->in.count;
+   vcc->last_free_grf = 127;
+
+   /* m0 is reserved for system routines */
+   vcc->first_free_mrf = 1;
+   vcc->last_free_mrf = 15;
+
+   vcc->num_grf_per_vrf = 1;
+
+   if (vcc->tc.gen >= ILO_GEN(7)) {
+      vcc->last_free_grf -= 15;
+      vcc->first_free_mrf = vcc->last_free_grf + 1;
+      vcc->last_free_mrf = vcc->first_free_mrf + 14;
+   }
+
+   vcc->shader->in.start_grf = vcc->first_const_grf;
+   vcc->shader->pcb.clip_state_size =
+      vcc->variant->u.vs.num_ucps * (sizeof(float) * 4);
+
+   return true;
+}
+
+/**
+ * Compile the vertex shader.
+ */
+struct ilo_shader *
+ilo_shader_compile_vs(const struct ilo_shader_state *state,
+                      const struct ilo_shader_variant *variant)
+{
+   struct vs_compile_context vcc;
+   bool need_gs;
+
+   if (!vs_setup(&vcc, state, variant))
+      return NULL;
+
+   if (vcc.tc.gen >= ILO_GEN(7)) {
+      need_gs = false;
+   }
+   else {
+      need_gs = variant->u.vs.rasterizer_discard ||
+                state->info.stream_output.num_outputs;
+   }
+
+   vs_write_vue(&vcc);
+
+   if (!vs_compile(&vcc)) {
+      FREE(vcc.shader);
+      vcc.shader = NULL;
+   }
+
+   toy_tgsi_cleanup(&vcc.tgsi);
+   toy_compiler_cleanup(&vcc.tc);
+
+   if (need_gs) {
+      int so_mapping[PIPE_MAX_SHADER_OUTPUTS];
+      int i, j;
+
+      for (i = 0; i < vcc.tgsi.num_outputs; i++) {
+         int attr = 0;
+
+         for (j = 0; j < vcc.shader->out.count; j++) {
+            if (vcc.tgsi.outputs[i].semantic_name ==
+                  vcc.shader->out.semantic_names[j] &&
+                vcc.tgsi.outputs[i].semantic_index ==
+                  vcc.shader->out.semantic_indices[j]) {
+               attr = j;
+               break;
+            }
+         }
+
+         so_mapping[i] = attr;
+      }
+
+      if (!ilo_shader_compile_gs_passthrough(state, variant,
+               so_mapping, vcc.shader)) {
+         ilo_shader_destroy(vcc.shader);
+         vcc.shader = NULL;
+      }
+   }
+
+   return vcc.shader;
+}