xref: /third_party/mesa3d/src/gallium/drivers/i915/i915_fpc_translate.c

/**************************************************************************
 *
 * Copyright 2007 VMware, Inc.
 * All Rights Reserved.
 *
 * 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, sub license, 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 (including the
 * next paragraph) 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 NON-INFRINGEMENT.
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
 *
 **************************************************************************/

#include <stdarg.h>

#include "i915_context.h"
#include "i915_debug.h"
#include "i915_debug_private.h"
#include "i915_fpc.h"
#include "i915_reg.h"

#include "pipe/p_shader_tokens.h"
#include "tgsi/tgsi_dump.h"
#include "tgsi/tgsi_from_mesa.h"
#include "tgsi/tgsi_info.h"
#include "tgsi/tgsi_parse.h"
#include "util/log.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "util/u_string.h"

#include "draw/draw_vertex.h"

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

/**
 * Simple pass-through fragment shader to use when we don't have
 * a real shader (or it fails to compile for some reason).
 */
static unsigned passthrough_program[] = {
   _3DSTATE_PIXEL_SHADER_PROGRAM | ((1 * 3) - 1),
   /* move to output color:
    */
   (A0_MOV | (REG_TYPE_OC << A0_DEST_TYPE_SHIFT) | A0_DEST_CHANNEL_ALL |
    (REG_TYPE_R << A0_SRC0_TYPE_SHIFT) | (0 << A0_SRC0_NR_SHIFT)),
   ((SRC_ONE << A1_SRC0_CHANNEL_X_SHIFT) |
    (SRC_ZERO << A1_SRC0_CHANNEL_Y_SHIFT) |
    (SRC_ZERO << A1_SRC0_CHANNEL_Z_SHIFT) |
    (SRC_ONE << A1_SRC0_CHANNEL_W_SHIFT)),
   0};

/**
 * component-wise negation of ureg
 */
static inline int
negate(int reg, int x, int y, int z, int w)
{
   /* Another neat thing about the UREG representation */
   return reg ^ (((x & 1) << UREG_CHANNEL_X_NEGATE_SHIFT) |
                 ((y & 1) << UREG_CHANNEL_Y_NEGATE_SHIFT) |
                 ((z & 1) << UREG_CHANNEL_Z_NEGATE_SHIFT) |
                 ((w & 1) << UREG_CHANNEL_W_NEGATE_SHIFT));
}

/**
 * In the event of a translation failure, we'll generate a simple color
 * pass-through program.
 */
static void
i915_use_passthrough_shader(struct i915_fragment_shader *fs)
{
   fs->program = (uint32_t *)MALLOC(sizeof(passthrough_program));
   if (fs->program) {
      memcpy(fs->program, passthrough_program, sizeof(passthrough_program));
      fs->program_len = ARRAY_SIZE(passthrough_program);
   }
   fs->num_constants = 0;
}

void
i915_program_error(struct i915_fp_compile *p, const char *msg, ...)
{
   if (p->log_program_errors) {
      va_list args;

      va_start(args, msg);
      mesa_loge_v(msg, args);
      va_end(args);
   }

   p->error = 1;
}

static uint32_t
get_mapping(struct i915_fragment_shader *fs, enum tgsi_semantic semantic,
            int index)
{
   int i;
   for (i = 0; i < I915_TEX_UNITS; i++) {
      if (fs->texcoords[i].semantic == -1) {
         fs->texcoords[i].semantic = semantic;
         fs->texcoords[i].index = index;
         return i;
      }
      if (fs->texcoords[i].semantic == semantic &&
          fs->texcoords[i].index == index)
         return i;
   }
   debug_printf("Exceeded max generics\n");
   return 0;
}

/**
 * Construct a ureg for the given source register.  Will emit
 * constants, apply swizzling and negation as needed.
 */
static uint32_t
src_vector(struct i915_fp_compile *p,
           const struct i915_full_src_register *source,
           struct i915_fragment_shader *fs)
{
   uint32_t index = source->Register.Index;
   uint32_t src = 0, sem_name, sem_ind;

   switch (source->Register.File) {
   case TGSI_FILE_TEMPORARY:
      if (source->Register.Index >= I915_MAX_TEMPORARY) {
         i915_program_error(p, "Exceeded max temporary reg");
         return 0;
      }
      src = UREG(REG_TYPE_R, index);
      break;
   case TGSI_FILE_INPUT:
      /* XXX: Packing COL1, FOGC into a single attribute works for
       * texenv programs, but will fail for real fragment programs
       * that use these attributes and expect them to be a full 4
       * components wide.  Could use a texcoord to pass these
       * attributes if necessary, but that won't work in the general
       * case.
       *
       * We also use a texture coordinate to pass wpos when possible.
       */

      sem_name = p->shader->info.input_semantic_name[index];
      sem_ind = p->shader->info.input_semantic_index[index];

      switch (sem_name) {
      case TGSI_SEMANTIC_GENERIC:
      case TGSI_SEMANTIC_TEXCOORD:
      case TGSI_SEMANTIC_PCOORD:
      case TGSI_SEMANTIC_POSITION: {
         if (sem_name == TGSI_SEMANTIC_PCOORD)
            fs->reads_pntc = true;

         int real_tex_unit = get_mapping(fs, sem_name, sem_ind);
         src = i915_emit_decl(p, REG_TYPE_T, T_TEX0 + real_tex_unit,
                              D0_CHANNEL_ALL);
         break;
      }
      case TGSI_SEMANTIC_COLOR:
         if (sem_ind == 0) {
            src = i915_emit_decl(p, REG_TYPE_T, T_DIFFUSE, D0_CHANNEL_ALL);
         } else {
            /* secondary color */
            assert(sem_ind == 1);
            src = i915_emit_decl(p, REG_TYPE_T, T_SPECULAR, D0_CHANNEL_XYZ);
            src = swizzle(src, X, Y, Z, ONE);
         }
         break;
      case TGSI_SEMANTIC_FOG:
         src = i915_emit_decl(p, REG_TYPE_T, T_FOG_W, D0_CHANNEL_W);
         src = swizzle(src, W, W, W, W);
         break;
      case TGSI_SEMANTIC_FACE: {
         /* for back/front faces */
         int real_tex_unit = get_mapping(fs, sem_name, sem_ind);
         src =
            i915_emit_decl(p, REG_TYPE_T, T_TEX0 + real_tex_unit, D0_CHANNEL_X);
         break;
      }
      default:
         i915_program_error(p, "Bad source->Index");
         return 0;
      }
      break;

   case TGSI_FILE_IMMEDIATE: {
      assert(index < p->num_immediates);

      uint8_t swiz[4] = {
         source->Register.SwizzleX,
         source->Register.SwizzleY,
         source->Register.SwizzleZ,
         source->Register.SwizzleW
      };

      uint8_t neg[4] = {
         source->Register.Negate,
         source->Register.Negate,
         source->Register.Negate,
         source->Register.Negate
      };

      unsigned i;

      for (i = 0; i < 4; i++) {
         if (swiz[i] == TGSI_SWIZZLE_ZERO || swiz[i] == TGSI_SWIZZLE_ONE) {
            continue;
         } else if (p->immediates[index][swiz[i]] == 0.0) {
            swiz[i] = TGSI_SWIZZLE_ZERO;
         } else if (p->immediates[index][swiz[i]] == 1.0) {
            swiz[i] = TGSI_SWIZZLE_ONE;
         } else if (p->immediates[index][swiz[i]] == -1.0) {
            swiz[i] = TGSI_SWIZZLE_ONE;
            neg[i] ^= 1;
         } else {
            break;
         }
      }

      if (i == 4) {
         return negate(swizzle(UREG(REG_TYPE_R, 0),
                               swiz[0], swiz[1], swiz[2], swiz[3]),
                       neg[0], neg[1], neg[2], neg[3]);
      }

      index = p->immediates_map[index];
      FALLTHROUGH;
   }

   case TGSI_FILE_CONSTANT:
      src = UREG(REG_TYPE_CONST, index);
      break;

   default:
      i915_program_error(p, "Bad source->File");
      return 0;
   }

   src = swizzle(src, source->Register.SwizzleX, source->Register.SwizzleY,
                 source->Register.SwizzleZ, source->Register.SwizzleW);

   /* No HW abs flag, so we have to max with the negation. */
   if (source->Register.Absolute) {
      uint32_t tmp = i915_get_utemp(p);
      i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0, src,
                      negate(src, 1, 1, 1, 1), 0);
      src = tmp;
   }

   /* There's both negate-all-components and per-component negation.
    * Try to handle both here.
    */
   {
      int n = source->Register.Negate;
      src = negate(src, n, n, n, n);
   }

   return src;
}

/**
 * Construct a ureg for a destination register.
 */
static uint32_t
get_result_vector(struct i915_fp_compile *p,
                  const struct i915_full_dst_register *dest)
{
   switch (dest->Register.File) {
   case TGSI_FILE_OUTPUT: {
      uint32_t sem_name =
         p->shader->info.output_semantic_name[dest->Register.Index];
      switch (sem_name) {
      case TGSI_SEMANTIC_POSITION:
         return UREG(REG_TYPE_OD, 0);
      case TGSI_SEMANTIC_COLOR:
         return UREG(REG_TYPE_OC, 0);
      default:
         i915_program_error(p, "Bad inst->DstReg.Index/semantics");
         return 0;
      }
   }
   case TGSI_FILE_TEMPORARY:
      return UREG(REG_TYPE_R, dest->Register.Index);
   default:
      i915_program_error(p, "Bad inst->DstReg.File");
      return 0;
   }
}

/**
 * Compute flags for saturation and writemask.
 */
static uint32_t
get_result_flags(const struct i915_full_instruction *inst)
{
   const uint32_t writeMask = inst->Dst[0].Register.WriteMask;
   uint32_t flags = 0x0;

   if (inst->Instruction.Saturate)
      flags |= A0_DEST_SATURATE;

   if (writeMask & TGSI_WRITEMASK_X)
      flags |= A0_DEST_CHANNEL_X;
   if (writeMask & TGSI_WRITEMASK_Y)
      flags |= A0_DEST_CHANNEL_Y;
   if (writeMask & TGSI_WRITEMASK_Z)
      flags |= A0_DEST_CHANNEL_Z;
   if (writeMask & TGSI_WRITEMASK_W)
      flags |= A0_DEST_CHANNEL_W;

   return flags;
}

/**
 * Convert TGSI_TEXTURE_x token to DO_SAMPLE_TYPE_x token
 */
static uint32_t
translate_tex_src_target(struct i915_fp_compile *p, uint32_t tex)
{
   switch (tex) {
   case TGSI_TEXTURE_SHADOW1D:
      FALLTHROUGH;
   case TGSI_TEXTURE_1D:
      return D0_SAMPLE_TYPE_2D;

   case TGSI_TEXTURE_SHADOW2D:
      FALLTHROUGH;
   case TGSI_TEXTURE_2D:
      return D0_SAMPLE_TYPE_2D;

   case TGSI_TEXTURE_SHADOWRECT:
      FALLTHROUGH;
   case TGSI_TEXTURE_RECT:
      return D0_SAMPLE_TYPE_2D;

   case TGSI_TEXTURE_3D:
      return D0_SAMPLE_TYPE_VOLUME;

   case TGSI_TEXTURE_CUBE:
      return D0_SAMPLE_TYPE_CUBE;

   default:
      i915_program_error(p, "TexSrc type");
      return 0;
   }
}

/**
 * Return the number of coords needed to access a given TGSI_TEXTURE_*
 */
uint32_t
i915_coord_mask(enum tgsi_opcode opcode, enum tgsi_texture_type tex)
{
   uint32_t coord_mask = 0;

   if (opcode == TGSI_OPCODE_TXP || opcode == TGSI_OPCODE_TXB)
      coord_mask |= TGSI_WRITEMASK_W;

   switch (tex) {
   case TGSI_TEXTURE_1D: /* See the 1D coord swizzle below. */
   case TGSI_TEXTURE_2D:
   case TGSI_TEXTURE_RECT:
      return coord_mask | TGSI_WRITEMASK_XY;

   case TGSI_TEXTURE_SHADOW1D:
   case TGSI_TEXTURE_SHADOW2D:
   case TGSI_TEXTURE_SHADOWRECT:
   case TGSI_TEXTURE_3D:
   case TGSI_TEXTURE_CUBE:
      return coord_mask | TGSI_WRITEMASK_XYZ;

   default:
      unreachable("bad texture target");
   }
}

/**
 * Generate texel lookup instruction.
 */
static void
emit_tex(struct i915_fp_compile *p, const struct i915_full_instruction *inst,
         uint32_t opcode, struct i915_fragment_shader *fs)
{
   uint32_t texture = inst->Texture.Texture;
   uint32_t unit = inst->Src[1].Register.Index;
   uint32_t tex = translate_tex_src_target(p, texture);
   uint32_t sampler = i915_emit_decl(p, REG_TYPE_S, unit, tex);
   uint32_t coord = src_vector(p, &inst->Src[0], fs);

   /* For 1D textures, set the Y coord to the same as X.  Otherwise, we could
    * select the wrong LOD based on the uninitialized Y coord when we sample our
    * 1D textures as 2D.
    */
   if (texture == TGSI_TEXTURE_1D || texture == TGSI_TEXTURE_SHADOW1D)
      coord = swizzle(coord, X, X, Z, W);

   i915_emit_texld(p, get_result_vector(p, &inst->Dst[0]),
                   get_result_flags(inst), sampler, coord, opcode,
                   i915_coord_mask(inst->Instruction.Opcode, texture));
}

/**
 * Generate a simple arithmetic instruction
 * \param opcode  the i915 opcode
 * \param numArgs  the number of input/src arguments
 */
static void
emit_simple_arith(struct i915_fp_compile *p,
                  const struct i915_full_instruction *inst, uint32_t opcode,
                  uint32_t numArgs, struct i915_fragment_shader *fs)
{
   uint32_t arg1, arg2, arg3;

   assert(numArgs <= 3);

   arg1 = (numArgs < 1) ? 0 : src_vector(p, &inst->Src[0], fs);
   arg2 = (numArgs < 2) ? 0 : src_vector(p, &inst->Src[1], fs);
   arg3 = (numArgs < 3) ? 0 : src_vector(p, &inst->Src[2], fs);

   i915_emit_arith(p, opcode, get_result_vector(p, &inst->Dst[0]),
                   get_result_flags(inst), 0, arg1, arg2, arg3);
}

/** As above, but swap the first two src regs */
static void
emit_simple_arith_swap2(struct i915_fp_compile *p,
                        const struct i915_full_instruction *inst,
                        uint32_t opcode, uint32_t numArgs,
                        struct i915_fragment_shader *fs)
{
   struct i915_full_instruction inst2;

   assert(numArgs == 2);

   /* transpose first two registers */
   inst2 = *inst;
   inst2.Src[0] = inst->Src[1];
   inst2.Src[1] = inst->Src[0];

   emit_simple_arith(p, &inst2, opcode, numArgs, fs);
}

/*
 * Translate TGSI instruction to i915 instruction.
 *
 * Possible concerns:
 *
 * DDX, DDY -- return 0
 * SIN, COS -- could use another taylor step?
 * LIT      -- results seem a little different to sw mesa
 * LOG      -- different to mesa on negative numbers, but this is conformant.
 */
static void
i915_translate_instruction(struct i915_fp_compile *p,
                           const struct i915_full_instruction *inst,
                           struct i915_fragment_shader *fs)
{
   uint32_t src0, src1, src2, flags;
   uint32_t tmp = 0;

   switch (inst->Instruction.Opcode) {
   case TGSI_OPCODE_ADD:
      emit_simple_arith(p, inst, A0_ADD, 2, fs);
      break;

   case TGSI_OPCODE_CEIL:
      src0 = src_vector(p, &inst->Src[0], fs);
      tmp = i915_get_utemp(p);
      flags = get_result_flags(inst);
      i915_emit_arith(p, A0_FLR, tmp, flags & A0_DEST_CHANNEL_ALL, 0,
                      negate(src0, 1, 1, 1, 1), 0, 0);
      i915_emit_arith(p, A0_MOV, get_result_vector(p, &inst->Dst[0]), flags, 0,
                      negate(tmp, 1, 1, 1, 1), 0, 0);
      break;

   case TGSI_OPCODE_CMP:
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);
      src2 = src_vector(p, &inst->Src[2], fs);
      i915_emit_arith(p, A0_CMP, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0, src0, src2,
                      src1); /* NOTE: order of src2, src1 */
      break;

   case TGSI_OPCODE_DDX:
   case TGSI_OPCODE_DDY:
      /* XXX We just output 0 here */
      debug_printf("Punting DDX/DDY\n");
      src0 = get_result_vector(p, &inst->Dst[0]);
      i915_emit_arith(p, A0_MOV, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0,
                      swizzle(src0, ZERO, ZERO, ZERO, ZERO), 0, 0);
      break;

   case TGSI_OPCODE_DP2:
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);

      i915_emit_arith(p, A0_DP3, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0,
                      swizzle(src0, X, Y, ZERO, ZERO), src1, 0);
      break;

   case TGSI_OPCODE_DP3:
      emit_simple_arith(p, inst, A0_DP3, 2, fs);
      break;

   case TGSI_OPCODE_DP4:
      emit_simple_arith(p, inst, A0_DP4, 2, fs);
      break;

   case TGSI_OPCODE_DST:
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);

      /* result[0] = 1    * 1;
       * result[1] = a[1] * b[1];
       * result[2] = a[2] * 1;
       * result[3] = 1    * b[3];
       */
      i915_emit_arith(p, A0_MUL, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0, swizzle(src0, ONE, Y, Z, ONE),
                      swizzle(src1, ONE, Y, ONE, W), 0);
      break;

   case TGSI_OPCODE_END:
      /* no-op */
      break;

   case TGSI_OPCODE_EX2:
      src0 = src_vector(p, &inst->Src[0], fs);

      i915_emit_arith(p, A0_EXP, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0, swizzle(src0, X, X, X, X), 0,
                      0);
      break;

   case TGSI_OPCODE_FLR:
      emit_simple_arith(p, inst, A0_FLR, 1, fs);
      break;

   case TGSI_OPCODE_FRC:
      emit_simple_arith(p, inst, A0_FRC, 1, fs);
      break;

   case TGSI_OPCODE_KILL_IF:
      /* kill if src[0].x < 0 || src[0].y < 0 ... */
      src0 = src_vector(p, &inst->Src[0], fs);
      tmp = i915_get_utemp(p);

      i915_emit_texld(p, tmp,              /* dest reg: a dummy reg */
                      A0_DEST_CHANNEL_ALL, /* dest writemask */
                      0,                   /* sampler */
                      src0,                /* coord*/
                      T0_TEXKILL,          /* opcode */
                      TGSI_WRITEMASK_XYZW);/* coord_mask */
      break;

   case TGSI_OPCODE_KILL:
      /* unconditional kill */
      tmp = i915_get_utemp(p);

      i915_emit_texld(p, tmp,              /* dest reg: a dummy reg */
                      A0_DEST_CHANNEL_ALL, /* dest writemask */
                      0,                   /* sampler */
                      negate(swizzle(UREG(REG_TYPE_R, 0), ONE, ONE, ONE, ONE),
                             1, 1, 1, 1), /* coord */
                      T0_TEXKILL,         /* opcode */
                      TGSI_WRITEMASK_X);  /* coord_mask */
      break;

   case TGSI_OPCODE_LG2:
      src0 = src_vector(p, &inst->Src[0], fs);

      i915_emit_arith(p, A0_LOG, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0, swizzle(src0, X, X, X, X), 0,
                      0);
      break;

   case TGSI_OPCODE_LIT:
      src0 = src_vector(p, &inst->Src[0], fs);
      tmp = i915_get_utemp(p);

      /* tmp = max( a.xyzw, a.00zw )
       * XXX: Clamp tmp.w to -128..128
       * tmp.y = log(tmp.y)
       * tmp.y = tmp.w * tmp.y
       * tmp.y = exp(tmp.y)
       * result = cmp (a.11-x1, a.1x01, a.1xy1 )
       */
      i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0, src0,
                      swizzle(src0, ZERO, ZERO, Z, W), 0);

      i915_emit_arith(p, A0_LOG, tmp, A0_DEST_CHANNEL_Y, 0,
                      swizzle(tmp, Y, Y, Y, Y), 0, 0);

      i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_Y, 0,
                      swizzle(tmp, ZERO, Y, ZERO, ZERO),
                      swizzle(tmp, ZERO, W, ZERO, ZERO), 0);

      i915_emit_arith(p, A0_EXP, tmp, A0_DEST_CHANNEL_Y, 0,
                      swizzle(tmp, Y, Y, Y, Y), 0, 0);

      i915_emit_arith(
         p, A0_CMP, get_result_vector(p, &inst->Dst[0]), get_result_flags(inst),
         0, negate(swizzle(tmp, ONE, ONE, X, ONE), 0, 0, 1, 0),
         swizzle(tmp, ONE, X, ZERO, ONE), swizzle(tmp, ONE, X, Y, ONE));

      break;

   case TGSI_OPCODE_LRP:
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);
      src2 = src_vector(p, &inst->Src[2], fs);
      flags = get_result_flags(inst);
      tmp = i915_get_utemp(p);

      /* b*a + c*(1-a)
       *
       * b*a + c - ca
       *
       * tmp = b*a + c,
       * result = (-c)*a + tmp
       */
      i915_emit_arith(p, A0_MAD, tmp, flags & A0_DEST_CHANNEL_ALL, 0, src1,
                      src0, src2);

      i915_emit_arith(p, A0_MAD, get_result_vector(p, &inst->Dst[0]), flags, 0,
                      negate(src2, 1, 1, 1, 1), src0, tmp);
      break;

   case TGSI_OPCODE_MAD:
      emit_simple_arith(p, inst, A0_MAD, 3, fs);
      break;

   case TGSI_OPCODE_MAX:
      emit_simple_arith(p, inst, A0_MAX, 2, fs);
      break;

   case TGSI_OPCODE_MIN:
      emit_simple_arith(p, inst, A0_MIN, 2, fs);
      break;

   case TGSI_OPCODE_MOV:
      emit_simple_arith(p, inst, A0_MOV, 1, fs);
      break;

   case TGSI_OPCODE_MUL:
      emit_simple_arith(p, inst, A0_MUL, 2, fs);
      break;

   case TGSI_OPCODE_NOP:
      break;

   case TGSI_OPCODE_POW:
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);
      tmp = i915_get_utemp(p);
      flags = get_result_flags(inst);

      /* XXX: masking on intermediate values, here and elsewhere.
       */
      i915_emit_arith(p, A0_LOG, tmp, A0_DEST_CHANNEL_X, 0,
                      swizzle(src0, X, X, X, X), 0, 0);

      i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_X, 0, tmp, src1, 0);

      i915_emit_arith(p, A0_EXP, get_result_vector(p, &inst->Dst[0]), flags, 0,
                      swizzle(tmp, X, X, X, X), 0, 0);
      break;

   case TGSI_OPCODE_RET:
      /* XXX: no-op? */
      break;

   case TGSI_OPCODE_RCP:
      src0 = src_vector(p, &inst->Src[0], fs);

      i915_emit_arith(p, A0_RCP, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0, swizzle(src0, X, X, X, X), 0,
                      0);
      break;

   case TGSI_OPCODE_RSQ:
      src0 = src_vector(p, &inst->Src[0], fs);

      i915_emit_arith(p, A0_RSQ, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0, swizzle(src0, X, X, X, X), 0,
                      0);
      break;

   case TGSI_OPCODE_SEQ: {
      const uint32_t zero = swizzle(UREG(REG_TYPE_R, 0),
                                    SRC_ZERO, SRC_ZERO, SRC_ZERO, SRC_ZERO);

      /* if we're both >= and <= then we're == */
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);
      tmp = i915_get_utemp(p);

      if (src0 == zero || src1 == zero) {
         if (src0 == zero)
            src0 = src1;

         /* x == 0 is equivalent to -abs(x) >= 0, but the latter requires only
          * two instructions instead of three.
          */
         i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0, src0,
                         negate(src0, 1, 1, 1, 1), 0);
         i915_emit_arith(p, A0_SGE, get_result_vector(p, &inst->Dst[0]),
                         get_result_flags(inst), 0,
                         negate(tmp, 1, 1, 1, 1), zero, 0);
      } else {
         i915_emit_arith(p, A0_SGE, tmp, A0_DEST_CHANNEL_ALL, 0, src0, src1, 0);

         i915_emit_arith(p, A0_SGE, get_result_vector(p, &inst->Dst[0]),
                         get_result_flags(inst), 0, src1, src0, 0);

         i915_emit_arith(p, A0_MUL, get_result_vector(p, &inst->Dst[0]),
                         get_result_flags(inst), 0,
                         get_result_vector(p, &inst->Dst[0]), tmp, 0);
      }

      break;
   }

   case TGSI_OPCODE_SGE:
      emit_simple_arith(p, inst, A0_SGE, 2, fs);
      break;

   case TGSI_OPCODE_SLE:
      /* like SGE, but swap reg0, reg1 */
      emit_simple_arith_swap2(p, inst, A0_SGE, 2, fs);
      break;

   case TGSI_OPCODE_SLT:
      emit_simple_arith(p, inst, A0_SLT, 2, fs);
      break;

   case TGSI_OPCODE_SGT:
      /* like SLT, but swap reg0, reg1 */
      emit_simple_arith_swap2(p, inst, A0_SLT, 2, fs);
      break;

   case TGSI_OPCODE_SNE: {
      const uint32_t zero = swizzle(UREG(REG_TYPE_R, 0),
                                    SRC_ZERO, SRC_ZERO, SRC_ZERO, SRC_ZERO);

      /* if we're < or > then we're != */
      src0 = src_vector(p, &inst->Src[0], fs);
      src1 = src_vector(p, &inst->Src[1], fs);
      tmp = i915_get_utemp(p);

      if (src0 == zero || src1 == zero) {
         if (src0 == zero)
            src0 = src1;

         /* x != 0 is equivalent to -abs(x) < 0, but the latter requires only
          * two instructions instead of three.
          */
         i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0, src0,
                         negate(src0, 1, 1, 1, 1), 0);
         i915_emit_arith(p, A0_SLT, get_result_vector(p, &inst->Dst[0]),
                         get_result_flags(inst), 0,
                         negate(tmp, 1, 1, 1, 1), zero, 0);
      } else {
         i915_emit_arith(p, A0_SLT, tmp, A0_DEST_CHANNEL_ALL, 0, src0, src1, 0);

         i915_emit_arith(p, A0_SLT, get_result_vector(p, &inst->Dst[0]),
                         get_result_flags(inst), 0, src1, src0, 0);

         i915_emit_arith(p, A0_ADD, get_result_vector(p, &inst->Dst[0]),
                         get_result_flags(inst), 0,
                         get_result_vector(p, &inst->Dst[0]), tmp, 0);
      }
      break;
   }

   case TGSI_OPCODE_SSG:
      /* compute (src>0) - (src<0) */
      src0 = src_vector(p, &inst->Src[0], fs);
      tmp = i915_get_utemp(p);

      i915_emit_arith(p, A0_SLT, tmp, A0_DEST_CHANNEL_ALL, 0, src0,
                      swizzle(src0, ZERO, ZERO, ZERO, ZERO), 0);

      i915_emit_arith(p, A0_SLT, get_result_vector(p, &inst->Dst[0]),
                      get_result_flags(inst), 0,
                      swizzle(src0, ZERO, ZERO, ZERO, ZERO), src0, 0);

      i915_emit_arith(
         p, A0_ADD, get_result_vector(p, &inst->Dst[0]), get_result_flags(inst),
         0, get_result_vector(p, &inst->Dst[0]), negate(tmp, 1, 1, 1, 1), 0);
      break;

   case TGSI_OPCODE_TEX:
      emit_tex(p, inst, T0_TEXLD, fs);
      break;

   case TGSI_OPCODE_TRUNC:
      emit_simple_arith(p, inst, A0_TRC, 1, fs);
      break;

   case TGSI_OPCODE_TXB:
      emit_tex(p, inst, T0_TEXLDB, fs);
      break;

   case TGSI_OPCODE_TXP:
      emit_tex(p, inst, T0_TEXLDP, fs);
      break;

   default:
      i915_program_error(p, "bad opcode %s (%d)",
                         tgsi_get_opcode_name(inst->Instruction.Opcode),
                         inst->Instruction.Opcode);
      return;
   }

   i915_release_utemps(p);
}

static void
i915_translate_token(struct i915_fp_compile *p,
                     const union i915_full_token *token,
                     struct i915_fragment_shader *fs)
{
   struct i915_fragment_shader *ifs = p->shader;
   switch (token->Token.Type) {
   case TGSI_TOKEN_TYPE_PROPERTY:
      /* Ignore properties where we only support one value. */
      assert(token->FullProperty.Property.PropertyName ==
                TGSI_PROPERTY_FS_COORD_ORIGIN ||
             token->FullProperty.Property.PropertyName ==
                TGSI_PROPERTY_FS_COORD_PIXEL_CENTER ||
             token->FullProperty.Property.PropertyName ==
                TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS ||
             token->FullProperty.Property.PropertyName ==
                TGSI_PROPERTY_SEPARABLE_PROGRAM);
      break;

   case TGSI_TOKEN_TYPE_DECLARATION:
      if (token->FullDeclaration.Declaration.File == TGSI_FILE_CONSTANT) {
         if (token->FullDeclaration.Range.Last >= I915_MAX_CONSTANT) {
            i915_program_error(p, "Exceeded %d max uniforms",
                               I915_MAX_CONSTANT);
         } else {
            uint32_t i;
            for (i = token->FullDeclaration.Range.First;
                 i <= token->FullDeclaration.Range.Last; i++) {
               ifs->constant_flags[i] = I915_CONSTFLAG_USER;
               ifs->num_constants = MAX2(ifs->num_constants, i + 1);
            }
         }
      } else if (token->FullDeclaration.Declaration.File ==
                 TGSI_FILE_TEMPORARY) {
         if (token->FullDeclaration.Range.Last >= I915_MAX_TEMPORARY) {
            i915_program_error(p, "Exceeded %d max TGSI temps",
                               I915_MAX_TEMPORARY);
         } else {
            uint32_t i;
            for (i = token->FullDeclaration.Range.First;
                 i <= token->FullDeclaration.Range.Last; i++) {
               /* XXX just use shader->info->file_mask[TGSI_FILE_TEMPORARY] */
               p->temp_flag |= (1 << i); /* mark temp as used */
            }
         }
      }
      break;

   case TGSI_TOKEN_TYPE_IMMEDIATE: {
      const struct tgsi_full_immediate *imm = &token->FullImmediate;
      const uint32_t pos = p->num_immediates++;
      uint32_t j;
      assert(imm->Immediate.NrTokens <= 4 + 1);
      for (j = 0; j < imm->Immediate.NrTokens - 1; j++) {
         p->immediates[pos][j] = imm->u[j].Float;
      }
   } break;

   case TGSI_TOKEN_TYPE_INSTRUCTION:
      if (p->first_instruction) {
         /* resolve location of immediates */
         uint32_t i, j;
         for (i = 0; i < p->num_immediates; i++) {
            /* find constant slot for this immediate */
            for (j = 0; j < I915_MAX_CONSTANT; j++) {
               if (ifs->constant_flags[j] == 0x0) {
                  memcpy(ifs->constants[j], p->immediates[i],
                         4 * sizeof(float));
                  /*printf("immediate %d maps to const %d\n", i, j);*/
                  ifs->constant_flags[j] = 0xf; /* all four comps used */
                  p->immediates_map[i] = j;
                  ifs->num_constants = MAX2(ifs->num_constants, j + 1);
                  break;
               }
            }
            if (j == I915_MAX_CONSTANT) {
               i915_program_error(p, "Exceeded %d max uniforms and immediates.",
                                  I915_MAX_CONSTANT);
            }
         }

         p->first_instruction = false;
      }

      i915_translate_instruction(p, &token->FullInstruction, fs);
      break;

   default:
      assert(0);
   }
}

/**
 * Translate TGSI fragment shader into i915 hardware instructions.
 * \param p  the translation state
 * \param tokens  the TGSI token array
 */
static void
i915_translate_instructions(struct i915_fp_compile *p,
                            const struct i915_token_list *tokens,
                            struct i915_fragment_shader *fs)
{
   int i;
   for (i = 0; i < tokens->NumTokens && !p->error; i++) {
      i915_translate_token(p, &tokens->Tokens[i], fs);
   }
}

static struct i915_fp_compile *
i915_init_compile(struct i915_context *i915, struct i915_fragment_shader *ifs)
{
   struct i915_fp_compile *p = CALLOC_STRUCT(i915_fp_compile);
   int i;

   p->shader = ifs;

   /* Put new constants at end of const buffer, growing downward.
    * The problem is we don't know how many user-defined constants might
    * be specified with pipe->set_constant_buffer().
    * Should pre-scan the user's program to determine the highest-numbered
    * constant referenced.
    */
   ifs->num_constants = 0;
   memset(ifs->constant_flags, 0, sizeof(ifs->constant_flags));

   memset(&p->register_phases, 0, sizeof(p->register_phases));

   for (i = 0; i < I915_TEX_UNITS; i++)
      ifs->texcoords[i].semantic = -1;

   p->log_program_errors = !i915->no_log_program_errors;

   p->first_instruction = true;

   p->nr_tex_indirect = 1; /* correct? */
   p->nr_tex_insn = 0;
   p->nr_alu_insn = 0;
   p->nr_decl_insn = 0;

   p->csr = p->program;
   p->decl = p->declarations;
   p->decl_s = 0;
   p->decl_t = 0;
   p->temp_flag = ~0x0U << I915_MAX_TEMPORARY;
   p->utemp_flag = ~0x7;

   /* initialize the first program word */
   *(p->decl++) = _3DSTATE_PIXEL_SHADER_PROGRAM;

   return p;
}

/* Copy compile results to the fragment program struct and destroy the
 * compilation context.
 */
static void
i915_fini_compile(struct i915_context *i915, struct i915_fp_compile *p)
{
   struct i915_fragment_shader *ifs = p->shader;
   unsigned long program_size = (unsigned long)(p->csr - p->program);
   unsigned long decl_size = (unsigned long)(p->decl - p->declarations);

   if (p->nr_tex_indirect > I915_MAX_TEX_INDIRECT)
      debug_printf("Exceeded max nr indirect texture lookups\n");

   if (p->nr_tex_insn > I915_MAX_TEX_INSN)
      i915_program_error(p, "Exceeded max TEX instructions");

   if (p->nr_alu_insn > I915_MAX_ALU_INSN)
      i915_program_error(p, "Exceeded max ALU instructions");

   if (p->nr_decl_insn > I915_MAX_DECL_INSN)
      i915_program_error(p, "Exceeded max DECL instructions");

   /* hw doesn't seem to like empty frag programs (num_instructions == 1 is just
    * TGSI_END), even when the depth write fixup gets emitted below - maybe that
    * one is fishy, too?
    */
   if (ifs->info.num_instructions == 1)
      i915_program_error(p, "Empty fragment shader");

   if (p->error) {
      p->NumNativeInstructions = 0;
      p->NumNativeAluInstructions = 0;
      p->NumNativeTexInstructions = 0;
      p->NumNativeTexIndirections = 0;

      i915_use_passthrough_shader(ifs);
   } else {
      p->NumNativeInstructions =
         p->nr_alu_insn + p->nr_tex_insn + p->nr_decl_insn;
      p->NumNativeAluInstructions = p->nr_alu_insn;
      p->NumNativeTexInstructions = p->nr_tex_insn;
      p->NumNativeTexIndirections = p->nr_tex_indirect;

      /* patch in the program length */
      p->declarations[0] |= program_size + decl_size - 2;

      /* Copy compilation results to fragment program struct:
       */
      assert(!ifs->program);

      ifs->program_len = decl_size + program_size;
      ifs->program = (uint32_t *)MALLOC(ifs->program_len * sizeof(uint32_t));
      memcpy(ifs->program, p->declarations, decl_size * sizeof(uint32_t));
      memcpy(&ifs->program[decl_size], p->program,
             program_size * sizeof(uint32_t));

      util_debug_message(
         &i915->debug, SHADER_INFO,
         "%s shader: %d inst, %d tex, %d tex_indirect, %d temps, %d const",
         _mesa_shader_stage_to_abbrev(MESA_SHADER_FRAGMENT), (int)program_size,
         p->nr_tex_insn, p->nr_tex_indirect,
         p->shader->info.file_max[TGSI_FILE_TEMPORARY] + 1,
         ifs->num_constants);
   }

   /* Release the compilation struct:
    */
   FREE(p);
}

/**
 * Rather than trying to intercept and jiggle depth writes during
 * emit, just move the value into its correct position at the end of
 * the program:
 */
static void
i915_fixup_depth_write(struct i915_fp_compile *p)
{
   for (int i = 0; i < p->shader->info.num_outputs; i++) {
      if (p->shader->info.output_semantic_name[i] != TGSI_SEMANTIC_POSITION)
         continue;

      const uint32_t depth = UREG(REG_TYPE_OD, 0);

      i915_emit_arith(p, A0_MOV,                  /* opcode */
                      depth,                      /* dest reg */
                      A0_DEST_CHANNEL_W,          /* write mask */
                      0,                          /* saturate? */
                      swizzle(depth, X, Y, Z, Z), /* src0 */
                      0, 0 /* src1, src2 */);
   }
}

void
i915_translate_fragment_program(struct i915_context *i915,
                                struct i915_fragment_shader *fs)
{
   struct i915_fp_compile *p;
   const struct tgsi_token *tokens = fs->state.tokens;
   struct i915_token_list *i_tokens;

   if (I915_DBG_ON(DBG_FS)) {
      mesa_logi("TGSI fragment shader:");
      tgsi_dump(tokens, 0);
   }

   p = i915_init_compile(i915, fs);

   i_tokens = i915_optimize(tokens);
   i915_translate_instructions(p, i_tokens, fs);
   i915_fixup_depth_write(p);

   i915_fini_compile(i915, p);
   i915_optimize_free(i_tokens);

   if (I915_DBG_ON(DBG_FS)) {
      mesa_logi("i915 fragment shader with %d constants%s", fs->num_constants,
                fs->num_constants ? ":" : "");

      for (int i = 0; i < I915_MAX_CONSTANT; i++) {
         if (fs->constant_flags[i] &&
             fs->constant_flags[i] != I915_CONSTFLAG_USER) {
            mesa_logi("\t\tC[%d] = { %f, %f, %f, %f }", i, fs->constants[i][0],
                      fs->constants[i][1], fs->constants[i][2],
                      fs->constants[i][3]);
         }
      }
      i915_disassemble_program(fs->program, fs->program_len);
   }
}