Subversion Repositories Kolibri OS

/**************************************************************************

 *

 * Copyright 2010 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.

 *

 **************************************************************************/

/**

 * @file

 * TGSI to LLVM IR translation -- AoS.

 *

 * FIXME:

 * - No control flow support: the existing control flow code should be factored

 * out into from the SoA code into a common module and shared.

 * - No derivatives. Derivate logic should be pluggable, just like the samplers.

 *

 * @author Jose Fonseca 

 */

#include "pipe/p_config.h"

#include "pipe/p_shader_tokens.h"

#include "util/u_debug.h"

#include "util/u_math.h"

#include "util/u_memory.h"

#include "tgsi/tgsi_dump.h"

#include "tgsi/tgsi_info.h"

#include "tgsi/tgsi_parse.h"

#include "tgsi/tgsi_util.h"

#include "tgsi/tgsi_scan.h"

#include "lp_bld_type.h"

#include "lp_bld_const.h"

#include "lp_bld_arit.h"

#include "lp_bld_logic.h"

#include "lp_bld_swizzle.h"

#include "lp_bld_flow.h"

#include "lp_bld_quad.h"

#include "lp_bld_tgsi.h"

#include "lp_bld_debug.h"

#include "lp_bld_sample.h"

/**

 * Wrapper around lp_build_swizzle_aos which translates swizzles to another

 * ordering.

 */

static LLVMValueRef

swizzle_aos(struct lp_build_tgsi_context *bld_base,

            LLVMValueRef a,

            unsigned swizzle_x,

            unsigned swizzle_y,

            unsigned swizzle_z,

            unsigned swizzle_w)

{

   unsigned char swizzles[4];

   struct lp_build_tgsi_aos_context *bld = lp_aos_context(bld_base);

   assert(swizzle_x < 4);

   assert(swizzle_y < 4);

   assert(swizzle_z < 4);

   assert(swizzle_w < 4);

   swizzles[bld->inv_swizzles[0]] = bld->swizzles[swizzle_x];

   swizzles[bld->inv_swizzles[1]] = bld->swizzles[swizzle_y];

   swizzles[bld->inv_swizzles[2]] = bld->swizzles[swizzle_z];

   swizzles[bld->inv_swizzles[3]] = bld->swizzles[swizzle_w];

   return lp_build_swizzle_aos(&bld->bld_base.base, a, swizzles);

}

static LLVMValueRef

swizzle_scalar_aos(struct lp_build_tgsi_aos_context *bld,

                   LLVMValueRef a,

                   unsigned chan)

{

   chan = bld->swizzles[chan];

   return lp_build_swizzle_scalar_aos(&bld->bld_base.base, a, chan, 4);

}

static LLVMValueRef

emit_fetch_constant(

   struct lp_build_tgsi_context * bld_base,

   const struct tgsi_full_src_register * reg,

   enum tgsi_opcode_type stype,

   unsigned swizzle)

{

   struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base);

   LLVMBuilderRef builder = bld_base->base.gallivm->builder;

   struct lp_type type = bld_base->base.type;

   LLVMValueRef res;

   unsigned chan;

   assert(!reg->Register.Indirect);

   /*

    * Get the constants components

    */

   res = bld->bld_base.base.undef;

   for (chan = 0; chan < 4; ++chan) {

      LLVMValueRef index;

      LLVMValueRef scalar_ptr;

      LLVMValueRef scalar;

      LLVMValueRef swizzle;

      index = lp_build_const_int32(bld->bld_base.base.gallivm,

                                   reg->Register.Index * 4 + chan);

      scalar_ptr = LLVMBuildGEP(builder, bld->consts_ptr, &index, 1, "");

      scalar = LLVMBuildLoad(builder, scalar_ptr, "");

      lp_build_name(scalar, "const[%u].%c", reg->Register.Index, "xyzw"[chan]);

      /*

       * NOTE: constants array is always assumed to be RGBA

       */

      swizzle = lp_build_const_int32(bld->bld_base.base.gallivm,

                                     bld->swizzles[chan]);

      res = LLVMBuildInsertElement(builder, res, scalar, swizzle, "");

   }

   /*

    * Broadcast the first quaternion to all others.

    *

    * XXX: could be factored into a reusable function.

    */

   if (type.length > 4) {

      LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH];

      unsigned i;

      for (chan = 0; chan < 4; ++chan) {

         shuffles[chan] = lp_build_const_int32(bld->bld_base.base.gallivm, chan);

      }

      for (i = 4; i < type.length; ++i) {

         shuffles[i] = shuffles[i % 4];

      }

      res = LLVMBuildShuffleVector(builder,

                                   res, bld->bld_base.base.undef,

                                   LLVMConstVector(shuffles, type.length),

                                   "");

   }

   return res;

}

static LLVMValueRef

emit_fetch_immediate(

   struct lp_build_tgsi_context * bld_base,

   const struct tgsi_full_src_register * reg,

   enum tgsi_opcode_type stype,

   unsigned swizzle)

{

   struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base);

   LLVMValueRef res = bld->immediates[reg->Register.Index];

   assert(res);

   return res;

}

static LLVMValueRef

emit_fetch_input(

   struct lp_build_tgsi_context * bld_base,

   const struct tgsi_full_src_register * reg,

   enum tgsi_opcode_type stype,

   unsigned swizzle)

{

   struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base);

   LLVMValueRef res = bld->inputs[reg->Register.Index];

   assert(!reg->Register.Indirect);

   assert(res);

   return res;

}

static LLVMValueRef

emit_fetch_temporary(

   struct lp_build_tgsi_context * bld_base,

   const struct tgsi_full_src_register * reg,

   enum tgsi_opcode_type stype,

   unsigned swizzle)

{

   struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base);

   LLVMBuilderRef builder = bld_base->base.gallivm->builder;

   LLVMValueRef temp_ptr = bld->temps[reg->Register.Index];

   LLVMValueRef res = LLVMBuildLoad(builder, temp_ptr, "");

   assert(!reg->Register.Indirect);

   if (!res)

      return bld->bld_base.base.undef;

   return res;

}

/**

 * Register store.

 */

void

lp_emit_store_aos(

   struct lp_build_tgsi_aos_context *bld,

   const struct tgsi_full_instruction *inst,

   unsigned index,

   LLVMValueRef value)

{

   LLVMBuilderRef builder = bld->bld_base.base.gallivm->builder;

   const struct tgsi_full_dst_register *reg = &inst->Dst[index];

   LLVMValueRef mask = NULL;

   LLVMValueRef ptr;

   /*

    * Saturate the value

    */

   switch (inst->Instruction.Saturate) {

   case TGSI_SAT_NONE:

      break;

   case TGSI_SAT_ZERO_ONE:

      value = lp_build_max(&bld->bld_base.base, value, bld->bld_base.base.zero);

      value = lp_build_min(&bld->bld_base.base, value, bld->bld_base.base.one);

      break;

   case TGSI_SAT_MINUS_PLUS_ONE:

      value = lp_build_max(&bld->bld_base.base, value, lp_build_const_vec(bld->bld_base.base.gallivm, bld->bld_base.base.type, -1.0));

      value = lp_build_min(&bld->bld_base.base, value, bld->bld_base.base.one);

      break;

   default:

      assert(0);

   }

   /*

    * Translate the register file

    */

   assert(!reg->Register.Indirect);

   switch (reg->Register.File) {

   case TGSI_FILE_OUTPUT:

      ptr = bld->outputs[reg->Register.Index];

      break;

   case TGSI_FILE_TEMPORARY:

      ptr = bld->temps[reg->Register.Index];

      break;

   case TGSI_FILE_ADDRESS:

      ptr = bld->addr[reg->Indirect.Index];

      break;

   case TGSI_FILE_PREDICATE:

      ptr = bld->preds[reg->Register.Index];

      break;

   default:

      assert(0);

      return;

   }

   if (!ptr)

      return;

   /*

    * Predicate

    */

   if (inst->Instruction.Predicate) {

      LLVMValueRef pred;

      assert(inst->Predicate.Index < LP_MAX_TGSI_PREDS);

      pred = LLVMBuildLoad(builder,

                           bld->preds[inst->Predicate.Index], "");

      /*

       * Convert the value to an integer mask.

       */

      pred = lp_build_compare(bld->bld_base.base.gallivm,

                               bld->bld_base.base.type,

                               PIPE_FUNC_NOTEQUAL,

                               pred,

                               bld->bld_base.base.zero);

      if (inst->Predicate.Negate) {

         pred = LLVMBuildNot(builder, pred, "");

      }

      pred = bld->bld_base.emit_swizzle(&bld->bld_base, pred,

                         inst->Predicate.SwizzleX,

                         inst->Predicate.SwizzleY,

                         inst->Predicate.SwizzleZ,

                         inst->Predicate.SwizzleW);

      if (mask) {

         mask = LLVMBuildAnd(builder, mask, pred, "");

      } else {

         mask = pred;

      }

   }

   /*

    * Writemask

    */

   if (reg->Register.WriteMask != TGSI_WRITEMASK_XYZW) {

      LLVMValueRef writemask;

      writemask = lp_build_const_mask_aos_swizzled(bld->bld_base.base.gallivm,

                                                   bld->bld_base.base.type,

                                                   reg->Register.WriteMask,

                                                   TGSI_NUM_CHANNELS,

                                                   bld->swizzles);

      if (mask) {

         mask = LLVMBuildAnd(builder, mask, writemask, "");

      } else {

         mask = writemask;

      }

   }

   if (mask) {

      LLVMValueRef orig_value;

      orig_value = LLVMBuildLoad(builder, ptr, "");

      value = lp_build_select(&bld->bld_base.base,

                              mask, value, orig_value);

   }

   LLVMBuildStore(builder, value, ptr);

}

/**

 * High-level instruction translators.

 */

static LLVMValueRef

emit_tex(struct lp_build_tgsi_aos_context *bld,

         const struct tgsi_full_instruction *inst,

         enum lp_build_tex_modifier modifier)

{

   unsigned target;

   unsigned unit;

   LLVMValueRef coords;

   struct lp_derivatives derivs = { {NULL}, {NULL} };

   if (!bld->sampler) {

      _debug_printf("warning: found texture instruction but no sampler generator supplied\n");

      return bld->bld_base.base.undef;

   }

   target = inst->Texture.Texture;

   coords = lp_build_emit_fetch( &bld->bld_base, inst, 0 , LP_CHAN_ALL);

   if (modifier == LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV) {

      /* probably not going to work */

      derivs.ddx[0] = lp_build_emit_fetch( &bld->bld_base, inst, 1 , LP_CHAN_ALL);

      derivs.ddy[0] = lp_build_emit_fetch( &bld->bld_base, inst, 2 , LP_CHAN_ALL);

      unit = inst->Src[3].Register.Index;

   }

   else {

      unit = inst->Src[1].Register.Index;

   }

   return bld->sampler->emit_fetch_texel(bld->sampler,

                                         &bld->bld_base.base,

                                         target, unit,

                                         coords, derivs,

                                         modifier);

}

void

lp_emit_declaration_aos(

   struct lp_build_tgsi_aos_context *bld,

   const struct tgsi_full_declaration *decl)

{

   struct gallivm_state *gallivm = bld->bld_base.base.gallivm;

   LLVMTypeRef vec_type = lp_build_vec_type(bld->bld_base.base.gallivm, bld->bld_base.base.type);

   unsigned first = decl->Range.First;

   unsigned last = decl->Range.Last;

   unsigned idx;

   for (idx = first; idx <= last; ++idx) {

      switch (decl->Declaration.File) {

      case TGSI_FILE_TEMPORARY:

         assert(idx < LP_MAX_TGSI_TEMPS);

         if (bld->indirect_files & (1 << TGSI_FILE_TEMPORARY)) {

            LLVMValueRef array_size = lp_build_const_int32(gallivm, last + 1);

            bld->temps_array = lp_build_array_alloca(bld->bld_base.base.gallivm,

                                                     vec_type, array_size, "");

         } else {

            bld->temps[idx] = lp_build_alloca(gallivm, vec_type, "");

         }

         break;

      case TGSI_FILE_OUTPUT:

         bld->outputs[idx] = lp_build_alloca(gallivm, vec_type, "");

         break;

      case TGSI_FILE_ADDRESS:

         assert(idx < LP_MAX_TGSI_ADDRS);

         bld->addr[idx] = lp_build_alloca(gallivm, vec_type, "");

         break;

      case TGSI_FILE_PREDICATE:

         assert(idx < LP_MAX_TGSI_PREDS);

         bld->preds[idx] = lp_build_alloca(gallivm, vec_type, "");

         break;

      default:

         /* don't need to declare other vars */

         break;

      }

   }

}

/**

 * Emit LLVM for one TGSI instruction.

 * \param return TRUE for success, FALSE otherwise

 */

boolean

lp_emit_instruction_aos(

   struct lp_build_tgsi_aos_context *bld,

   const struct tgsi_full_instruction *inst,

   const struct tgsi_opcode_info *info,

   int *pc)

{

   LLVMValueRef src0, src1, src2;

   LLVMValueRef tmp0, tmp1;

   LLVMValueRef dst0 = NULL;

   /*

    * Stores and write masks are handled in a general fashion after the long

    * instruction opcode switch statement.

    *

    * Although not stricitly necessary, we avoid generating instructions for

    * channels which won't be stored, in cases where's that easy. For some

    * complex instructions, like texture sampling, it is more convenient to

    * assume a full writemask and then let LLVM optimization passes eliminate

    * redundant code.

    */

   (*pc)++;

   assert(info->num_dst <= 1);

   if (info->num_dst) {

      dst0 = bld->bld_base.base.undef;

   }

   switch (inst->Instruction.Opcode) {

   case TGSI_OPCODE_ARL:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_floor(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_MOV:

      dst0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      break;

   case TGSI_OPCODE_LIT:

      return FALSE;

   case TGSI_OPCODE_RCP:

   /* TGSI_OPCODE_RECIP */

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_rcp(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_RSQ:

   /* TGSI_OPCODE_RECIPSQRT */

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      tmp0 = lp_build_emit_llvm_unary(&bld->bld_base, TGSI_OPCODE_ABS, src0);

      dst0 = lp_build_rsqrt(&bld->bld_base.base, tmp0);

      break;

   case TGSI_OPCODE_EXP:

      return FALSE;

   case TGSI_OPCODE_LOG:

      return FALSE;

   case TGSI_OPCODE_MUL:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      dst0 = lp_build_mul(&bld->bld_base.base, src0, src1);

      break;

   case TGSI_OPCODE_ADD:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      dst0 = lp_build_add(&bld->bld_base.base, src0, src1);

      break;

   case TGSI_OPCODE_DP3:

   /* TGSI_OPCODE_DOT3 */

      return FALSE;

   case TGSI_OPCODE_DP4:

   /* TGSI_OPCODE_DOT4 */

      return FALSE;

   case TGSI_OPCODE_DST:

      return FALSE;

   case TGSI_OPCODE_MIN:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      dst0 = lp_build_min(&bld->bld_base.base, src0, src1);

      break;

   case TGSI_OPCODE_MAX:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      dst0 = lp_build_max(&bld->bld_base.base, src0, src1);

      break;

   case TGSI_OPCODE_SLT:

   /* TGSI_OPCODE_SETLT */

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_LESS, src0, src1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero);

      break;

   case TGSI_OPCODE_SGE:

   /* TGSI_OPCODE_SETGE */

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_GEQUAL, src0, src1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero);

      break;

   case TGSI_OPCODE_MAD:

   /* TGSI_OPCODE_MADD */

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL);

      tmp0 = lp_build_mul(&bld->bld_base.base, src0, src1);

      dst0 = lp_build_add(&bld->bld_base.base, tmp0, src2);

      break;

   case TGSI_OPCODE_SUB:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      dst0 = lp_build_sub(&bld->bld_base.base, src0, src1);

      break;

   case TGSI_OPCODE_LRP:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL);

      tmp0 = lp_build_sub(&bld->bld_base.base, src1, src2);

      tmp0 = lp_build_mul(&bld->bld_base.base, src0, tmp0);

      dst0 = lp_build_add(&bld->bld_base.base, tmp0, src2);

      break;

   case TGSI_OPCODE_CND:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL);

      tmp1 = lp_build_const_vec(bld->bld_base.base.gallivm, bld->bld_base.base.type, 0.5);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_GREATER, src2, tmp1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, src0, src1);

      break;

   case TGSI_OPCODE_DP2A:

      return FALSE;

   case TGSI_OPCODE_FRC:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      tmp0 = lp_build_floor(&bld->bld_base.base, src0);

      dst0 = lp_build_sub(&bld->bld_base.base, src0, tmp0);

      break;

   case TGSI_OPCODE_CLAMP:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL);

      tmp0 = lp_build_max(&bld->bld_base.base, src0, src1);

      dst0 = lp_build_min(&bld->bld_base.base, tmp0, src2);

      break;

   case TGSI_OPCODE_FLR:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_floor(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_ROUND:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_round(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_EX2:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      tmp0 = lp_build_swizzle_scalar_aos(&bld->bld_base.base, src0, TGSI_SWIZZLE_X, TGSI_NUM_CHANNELS);

      dst0 = lp_build_exp2(&bld->bld_base.base, tmp0);

      break;

   case TGSI_OPCODE_LG2:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      tmp0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X);

      dst0 = lp_build_log2(&bld->bld_base.base, tmp0);

      break;

   case TGSI_OPCODE_POW:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      src1 = swizzle_scalar_aos(bld, src1, TGSI_SWIZZLE_X);

      dst0 = lp_build_pow(&bld->bld_base.base, src0, src1);

      break;

   case TGSI_OPCODE_XPD:

      return FALSE;

   case TGSI_OPCODE_RCC:

      /* deprecated? */

      assert(0);

      return FALSE;

   case TGSI_OPCODE_DPH:

      return FALSE;

   case TGSI_OPCODE_COS:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      tmp0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X);

      dst0 = lp_build_cos(&bld->bld_base.base, tmp0);

      break;

   case TGSI_OPCODE_DDX:

      return FALSE;

   case TGSI_OPCODE_DDY:

      return FALSE;

   case TGSI_OPCODE_KILL:

      return FALSE;

   case TGSI_OPCODE_KILL_IF:

      return FALSE;

   case TGSI_OPCODE_PK2H:

      return FALSE;

      break;

   case TGSI_OPCODE_PK2US:

      return FALSE;

      break;

   case TGSI_OPCODE_PK4B:

      return FALSE;

      break;

   case TGSI_OPCODE_PK4UB:

      return FALSE;

   case TGSI_OPCODE_RFL:

      return FALSE;

   case TGSI_OPCODE_SEQ:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_EQUAL, src0, src1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero);

      break;

   case TGSI_OPCODE_SFL:

      dst0 = bld->bld_base.base.zero;

      break;

   case TGSI_OPCODE_SGT:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_GREATER, src0, src1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero);

      break;

   case TGSI_OPCODE_SIN:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      tmp0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X);

      dst0 = lp_build_sin(&bld->bld_base.base, tmp0);

      break;

   case TGSI_OPCODE_SLE:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_LEQUAL, src0, src1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero);

      break;

   case TGSI_OPCODE_SNE:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_NOTEQUAL, src0, src1);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero);

      break;

   case TGSI_OPCODE_STR:

      dst0 = bld->bld_base.base.one;

      break;

   case TGSI_OPCODE_TEX:

      dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_NONE);

      break;

   case TGSI_OPCODE_TXD:

      dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV);

      break;

   case TGSI_OPCODE_UP2H:

      /* deprecated */

      assert (0);

      return FALSE;

      break;

   case TGSI_OPCODE_UP2US:

      /* deprecated */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_UP4B:

      /* deprecated */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_UP4UB:

      /* deprecated */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_X2D:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_ARA:

      /* deprecated */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_ARR:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_round(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_BRA:

      /* deprecated */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_CAL:

      return FALSE;

   case TGSI_OPCODE_RET:

      return FALSE;

   case TGSI_OPCODE_END:

      *pc = -1;

      break;

   case TGSI_OPCODE_SSG:

   /* TGSI_OPCODE_SGN */

      tmp0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_sgn(&bld->bld_base.base, tmp0);

      break;

   case TGSI_OPCODE_CMP:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL);

      src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL);

      tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_LESS, src0, bld->bld_base.base.zero);

      dst0 = lp_build_select(&bld->bld_base.base, tmp0, src1, src2);

      break;

   case TGSI_OPCODE_SCS:

      return FALSE;

   case TGSI_OPCODE_TXB:

      dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_LOD_BIAS);

      break;

   case TGSI_OPCODE_NRM:

      /* fall-through */

   case TGSI_OPCODE_NRM4:

      return FALSE;

   case TGSI_OPCODE_DIV:

      /* deprecated */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_DP2:

      return FALSE;

   case TGSI_OPCODE_TXL:

      dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_EXPLICIT_LOD);

      break;

   case TGSI_OPCODE_TXP:

      dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_PROJECTED);

      break;

   case TGSI_OPCODE_BRK:

      return FALSE;

   case TGSI_OPCODE_IF:

   case TGSI_OPCODE_UIF:

      return FALSE;

   case TGSI_OPCODE_BGNLOOP:

      return FALSE;

   case TGSI_OPCODE_BGNSUB:

      return FALSE;

   case TGSI_OPCODE_ELSE:

      return FALSE;

   case TGSI_OPCODE_ENDIF:

      return FALSE;

   case TGSI_OPCODE_ENDLOOP:

      return FALSE;

   case TGSI_OPCODE_ENDSUB:

      return FALSE;

   case TGSI_OPCODE_PUSHA:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_POPA:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_CEIL:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_ceil(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_I2F:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_NOT:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_TRUNC:

      src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL);

      dst0 = lp_build_trunc(&bld->bld_base.base, src0);

      break;

   case TGSI_OPCODE_SHL:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_ISHR:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_AND:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_OR:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_MOD:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_XOR:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_SAD:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_TXF:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_TXQ:

      /* deprecated? */

      assert(0);

      return FALSE;

      break;

   case TGSI_OPCODE_CONT:

      return FALSE;

   case TGSI_OPCODE_EMIT:

      return FALSE;

      break;

   case TGSI_OPCODE_ENDPRIM:

      return FALSE;

      break;

   case TGSI_OPCODE_NOP:

      break;

   default:

      return FALSE;

   }

   if (info->num_dst) {

      lp_emit_store_aos(bld, inst, 0, dst0);

   }

   return TRUE;

}

void

lp_build_tgsi_aos(struct gallivm_state *gallivm,

                  const struct tgsi_token *tokens,

                  struct lp_type type,

                  const unsigned char swizzles[4],

                  LLVMValueRef consts_ptr,

                  const LLVMValueRef *inputs,

                  LLVMValueRef *outputs,

                  struct lp_build_sampler_aos *sampler,

                  const struct tgsi_shader_info *info)

{

   struct lp_build_tgsi_aos_context bld;

   struct tgsi_parse_context parse;

   uint num_immediates = 0;

   unsigned chan;

   int pc = 0;

   /* Setup build context */

   memset(&bld, 0, sizeof bld);

   lp_build_context_init(&bld.bld_base.base, gallivm, type);

   lp_build_context_init(&bld.bld_base.uint_bld, gallivm, lp_uint_type(type));

   lp_build_context_init(&bld.bld_base.int_bld, gallivm, lp_int_type(type));

   lp_build_context_init(&bld.int_bld, gallivm, lp_int_type(type));

   for (chan = 0; chan < 4; ++chan) {

      bld.swizzles[chan] = swizzles[chan];

      bld.inv_swizzles[swizzles[chan]] = chan;

   }

   bld.inputs = inputs;

   bld.outputs = outputs;

   bld.consts_ptr = consts_ptr;

   bld.sampler = sampler;

   bld.indirect_files = info->indirect_files;

   bld.bld_base.emit_swizzle = swizzle_aos;

   bld.bld_base.info = info;

   bld.bld_base.emit_fetch_funcs[TGSI_FILE_CONSTANT] = emit_fetch_constant;

   bld.bld_base.emit_fetch_funcs[TGSI_FILE_IMMEDIATE] = emit_fetch_immediate;

   bld.bld_base.emit_fetch_funcs[TGSI_FILE_INPUT] = emit_fetch_input;

   bld.bld_base.emit_fetch_funcs[TGSI_FILE_TEMPORARY] = emit_fetch_temporary;

   /* Set opcode actions */

   lp_set_default_actions_cpu(&bld.bld_base);

   if (!lp_bld_tgsi_list_init(&bld.bld_base)) {

      return;

   }

   tgsi_parse_init(&parse, tokens);

   while (!tgsi_parse_end_of_tokens(&parse)) {

      tgsi_parse_token(&parse);

      switch(parse.FullToken.Token.Type) {

      case TGSI_TOKEN_TYPE_DECLARATION:

         /* Inputs already interpolated */

         lp_emit_declaration_aos(&bld, &parse.FullToken.FullDeclaration);

         break;

      case TGSI_TOKEN_TYPE_INSTRUCTION:

         /* save expanded instruction */

         lp_bld_tgsi_add_instruction(&bld.bld_base,

                                     &parse.FullToken.FullInstruction);

         break;

      case TGSI_TOKEN_TYPE_IMMEDIATE:

         /* simply copy the immediate values into the next immediates[] slot */

         {

            const uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;

            float imm[4];

            assert(size <= 4);

            assert(num_immediates < LP_MAX_TGSI_IMMEDIATES);

            for (chan = 0; chan < 4; ++chan) {

               imm[chan] = 0.0f;

            }

            for (chan = 0; chan < size; ++chan) {

               unsigned swizzle = bld.swizzles[chan];

               imm[swizzle] = parse.FullToken.FullImmediate.u[chan].Float;

            }

            bld.immediates[num_immediates] =

                     lp_build_const_aos(gallivm, type,

                                        imm[0], imm[1], imm[2], imm[3],

                                        NULL);

            num_immediates++;

         }

         break;

      case TGSI_TOKEN_TYPE_PROPERTY:

         break;

      default:

         assert(0);

      }

   }

   while (pc != -1) {

      struct tgsi_full_instruction *instr = bld.bld_base.instructions + pc;

      const struct tgsi_opcode_info *opcode_info =

         tgsi_get_opcode_info(instr->Instruction.Opcode);

      if (!lp_emit_instruction_aos(&bld, instr, opcode_info, &pc))

         _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",

                       opcode_info->mnemonic);

   }

   if (0) {

      LLVMBasicBlockRef block = LLVMGetInsertBlock(gallivm->builder);

      LLVMValueRef function = LLVMGetBasicBlockParent(block);

      debug_printf("11111111111111111111111111111 \n");

      tgsi_dump(tokens, 0);

      lp_debug_dump_value(function);

      debug_printf("2222222222222222222222222222 \n");

   }

   tgsi_parse_free(&parse);

   FREE(bld.bld_base.instructions);

   if (0) {

      LLVMModuleRef module = LLVMGetGlobalParent(

         LLVMGetBasicBlockParent(LLVMGetInsertBlock(gallivm->builder)));

      LLVMDumpModule(module);

   }

}