xref: /external/mesa3d/src/glsl/ir_to_llvm.cpp

/*
 * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
 * Copyright (C) 2008  VMware, Inc.   All Rights Reserved.
 * Copyright © 2010 Intel Corporation
 * Copyright © 2010 Luca Barbieri
 *
 * 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 (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 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.
 */

/**
 * \file ir_to_llvm.cpp
 *
 * Translates the IR to LLVM
 */

/* this tends to get set as part of LLVM_CFLAGS, but we definitely want asserts */
#ifdef NDEBUG
#undef NDEBUG
#endif

#include "llvm/ADT/ArrayRef.h"
#include "llvm/DerivedTypes.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/Support/IRBuilder.h"
//#include "llvm/Intrinsics.h"

#include <vector>
#include <stdio.h>
#include <map>
/*
#ifdef _MSC_VER
#include <unordered_map>
#else
#include <tr1/unordered_map>
#endif
// use C++0x/Microsoft convention
namespace std
{
using namespace tr1;
}
//*/

#include "ir.h"
#include "ir_visitor.h"
#include "glsl_types.h"
#include "src/mesa/main/mtypes.h"

// Helper function to convert array to llvm::ArrayRef
template <typename T, size_t N>
static inline llvm::ArrayRef<T> pack(T const (&array)[N]) {
   return llvm::ArrayRef<T>(array);
}

// Helper function to convert pointer + size to llvm::ArrayRef
template <typename T>
static inline llvm::ArrayRef<T> pack(T const *ptr, size_t n) {
   return llvm::ArrayRef<T>(ptr, n);
}

struct GGLState;

llvm::Value * tex2D(llvm::IRBuilder<> & builder, llvm::Value * in1, const unsigned sampler,
                     const GGLState * gglCtx);
llvm::Value * texCube(llvm::IRBuilder<> & builder, llvm::Value * in1, const unsigned sampler,
                     const GGLState * gglCtx);

class ir_to_llvm_visitor : public ir_visitor {
   ir_to_llvm_visitor();
public:


   llvm::LLVMContext& ctx;
   llvm::Module* mod;
   llvm::Function* fun;
   // could easily support more loops, but GLSL doesn't support multiloop break/continue
   std::pair<llvm::BasicBlock*, llvm::BasicBlock*> loop;
   llvm::BasicBlock* bb;
   llvm::Value* result;
   llvm::IRBuilder<> bld;

   const GGLState * gglCtx;
   const char * shaderSuffix;
   llvm::Value * inputsPtr, * outputsPtr, * constantsPtr; // internal globals to store inputs/outputs/constants pointers
   llvm::Value * inputs, * outputs, * constants;

   ir_to_llvm_visitor(llvm::Module* p_mod, const GGLState * GGLCtx, const char * suffix)
   : ctx(p_mod->getContext()), mod(p_mod), fun(0), loop(std::make_pair((llvm::BasicBlock*)0,
      (llvm::BasicBlock*)0)), bb(0), bld(ctx), gglCtx(GGLCtx), shaderSuffix(suffix),
      inputsPtr(NULL), outputsPtr(NULL), constantsPtr(NULL),
      inputs(NULL), outputs(NULL), constants(NULL)
   {
      llvm::PointerType * const floatVecPtrType = llvm::PointerType::get(llvm::VectorType::get(bld.getFloatTy(),4), 0);
      llvm::Constant * const nullFloatVecPtr = llvm::Constant::getNullValue(floatVecPtrType);
      // make input, output and consts global pointers so they can be used in
      // different LLVM functions since the shader shares these "registers" across "functions"

      inputsPtr = new llvm::GlobalVariable(*mod, floatVecPtrType, false,
         llvm::GlobalValue::InternalLinkage, nullFloatVecPtr, "gl_inputPtr");

      outputsPtr = new llvm::GlobalVariable(*mod, floatVecPtrType, false,
         llvm::GlobalValue::InternalLinkage, nullFloatVecPtr, "gl_outputsPtr");

      constantsPtr = new llvm::GlobalVariable(*mod, floatVecPtrType, false,
         llvm::GlobalValue::InternalLinkage, nullFloatVecPtr, "gl_constantsPtr");
   }

   llvm::Type* llvm_base_type(unsigned base_type)
   {
      switch(base_type)
      {
      case GLSL_TYPE_VOID:
         return llvm::Type::getVoidTy(ctx);
      case GLSL_TYPE_UINT:
      case GLSL_TYPE_INT:
         return llvm::Type::getInt32Ty(ctx);
      case GLSL_TYPE_FLOAT:
         return llvm::Type::getFloatTy(ctx);
      case GLSL_TYPE_BOOL:
         return llvm::Type::getInt1Ty(ctx);
      case GLSL_TYPE_SAMPLER:
         return llvm::PointerType::getUnqual(llvm::Type::getVoidTy(ctx));
      default:
         assert(0);
         return 0;
      }
   }

   llvm::Type* llvm_vec_type(const glsl_type* type)
   {
      if (type->is_array())
         return llvm::ArrayType::get(llvm_type(type->fields.array), type->array_size());

      if (type->is_record())
      {
         std::vector<llvm::Type*> fields;
         for (unsigned i = 0; i < type->length; i++)
            fields.push_back(llvm_type(type->fields.structure[i].type));
         return llvm::StructType::get(ctx, llvm::ArrayRef<llvm::Type*>(
             fields));
      }

      llvm::Type* base_type = llvm_base_type(type->base_type);
      if (type->vector_elements <= 1) {
         return base_type;
      } else {
         return llvm::VectorType::get(base_type, type->vector_elements);
      }
   }

   llvm::Type* llvm_type(const glsl_type* type)
   {
      llvm::Type* vec_type = llvm_vec_type(type);
      if (type->matrix_columns <= 1) {
         return vec_type;
      } else {
         return llvm::ArrayType::get(vec_type, type->matrix_columns);
      }
   }

   typedef std::map<ir_variable*, llvm::Value*> llvm_variables_t;
   //typedef std::unordered_map<ir_variable*, llvm::Value*> llvm_variables_t;
   llvm_variables_t llvm_variables;

   llvm::Value* llvm_variable(class ir_variable* var)
   {
      llvm_variables_t::iterator vari = llvm_variables.find(var);
      if (vari != llvm_variables.end()) {
         return vari->second;
      } else {
         llvm::Type* type = llvm_type(var->type);

         llvm::Value* v = NULL;
         if(fun) {
            if (ir_var_in == var->mode)
            {
               assert(var->location >= 0);
               v = bld.CreateConstGEP1_32(inputs, var->location);
               v = bld.CreateBitCast(v, llvm::PointerType::get(llvm_type(var->type), 0), var->name);
            }
            else if (ir_var_out == var->mode)
            {
               assert(var->location >= 0);
               v = bld.CreateConstGEP1_32(outputs, var->location);
               v = bld.CreateBitCast(v, llvm::PointerType::get(llvm_type(var->type), 0), var->name);
            }
            else if (ir_var_uniform == var->mode)
            {
               assert(var->location >= 0);
               v = bld.CreateConstGEP1_32(constants, var->location);
               v = bld.CreateBitCast(v, llvm::PointerType::get(llvm_type(var->type), 0), var->name);
            }
            else
            {
               if(bb == &fun->getEntryBlock())
                  v = bld.CreateAlloca(type, 0, var->name);
               else
                  v = new llvm::AllocaInst(type, 0, var->name, fun->getEntryBlock().getTerminator());
            }
         } else {
           // TODO: can anything global be non-constant in GLSL?; fix linkage
            //printf("var '%s' mode=%d location=%d \n", var->name, var->mode, var->location);
            switch(var->mode)
            {
               case ir_var_auto: // fall through
               case ir_var_temporary:
               {
                  llvm::Constant * init = llvm::UndefValue::get(llvm_type(var->type));
                  if(var->constant_value)
                     init = llvm_constant(var->constant_value);
                  v = new llvm::GlobalVariable(*mod, type, var->read_only, llvm::GlobalValue::InternalLinkage, init, var->name);
                  break;
               }
               case ir_var_in: // fall through
               case ir_var_out: // fall through
               case ir_var_uniform: // fall through
                  assert(var->location >= 0);
                  return NULL; // variable outside of function means declaration
               default:
                  assert(0);
            }

//            llvm::Function::LinkageTypes linkage;
//            if(var->mode == ir_var_auto || var->mode == ir_var_temporary)
//               linkage = llvm::GlobalValue::InternalLinkage;
//            else
//               linkage = llvm::GlobalValue::ExternalLinkage;
//            llvm::Constant* init = 0;
//            if(var->constant_value)
//            {
//               init = llvm_constant(var->constant_value);
//               // this constants need to be external (ie. written to output)
//               if (llvm::GlobalValue::ExternalLinkage == linkage)
//                  linkage = llvm::GlobalValue::AvailableExternallyLinkage;
//            }
//            else if(linkage == llvm::GlobalValue::InternalLinkage)
//               init = llvm::UndefValue::get(llvm_type(var->type));
//            v = new llvm::GlobalVariable(*mod, type, var->read_only, linkage, init, var->name);
         }
         assert(v);
         llvm_variables[var] = v;
         return v;
      }
   }

   //typedef std::map<ir_function_signature*, llvm::Function*> llvm_functions_t;
   //typedef std::unordered_map<ir_function_signature*, llvm::Function*> llvm_functions_t;
   //llvm_functions_t llvm_functions;

   llvm::Function* llvm_function(class ir_function_signature* sig)
   {
      const char* name = sig->function_name();
      char * functionName = (char *)malloc(strlen(name) + strlen(shaderSuffix) + 1);
      strcpy(functionName, name);
      strcat(functionName, shaderSuffix);
      llvm::Function * function = mod->getFunction(functionName);
      if (function)
      {
         free(functionName);
         return function;
      }
      else
      {
         llvm::Function::LinkageTypes linkage;
         std::vector<llvm::Type*> params;
         foreach_iter(exec_list_iterator, iter, sig->parameters) {
            ir_variable* arg = (ir_variable*)iter.get();
            params.push_back(llvm_type(arg->type));
         }

         if(!strcmp(name, "main") || !sig->is_defined)
         {
            linkage = llvm::Function::ExternalLinkage;
            llvm::PointerType * vecPtrTy = llvm::PointerType::get(llvm::VectorType::get(bld.getFloatTy(), 4), 0);
            assert(0 == params.size());
            params.push_back(vecPtrTy); // inputs
            params.push_back(vecPtrTy); // outputs
            params.push_back(vecPtrTy); // constants
         }
         else {
            linkage = llvm::Function::InternalLinkage;
         }
         llvm::FunctionType* ft = llvm::FunctionType::get(llvm_type(sig->return_type),
                                                          llvm::ArrayRef<llvm::Type*>(params),
                                                          false);
         function = llvm::Function::Create(ft, linkage, functionName, mod);
         free(functionName);
         return function;
      }
   }

   llvm::Value* llvm_value(class ir_instruction* ir)
   {
      result = 0;
      ir->accept(this);
      return result;
   }

   llvm::Constant* llvm_constant(class ir_instruction* ir)
   {
      return (llvm::Constant *)llvm_value(ir);
      //return &dynamic_cast<llvm::Constant&>(*llvm_value(ir));
   }

   llvm::Constant* llvm_int(unsigned v)
   {
      return llvm::ConstantInt::get(llvm::Type::getInt32Ty(ctx), v);
   }

   llvm::Value* llvm_pointer(class ir_rvalue* ir)
   {
      if(ir_dereference_variable* deref = ir->as_dereference_variable())
         return llvm_variable(deref->variable_referenced());
      else if(ir_dereference_array* deref = ir->as_dereference_array())
      {
         llvm::Value* gep[2] = {llvm_int(0), llvm_value(deref->array_index)};
         return bld.CreateInBoundsGEP(llvm_pointer(deref->array), gep);
         }
      else if(ir->as_dereference())
      {
         ir_dereference_record* deref = (ir_dereference_record*)ir;
         int idx = deref->record->type->field_index(deref->field);
         assert(idx >= 0);
         return bld.CreateConstInBoundsGEP2_32(llvm_pointer(deref->record), 0, idx);
      }
      else
      {
         assert(0);
         return 0;
      }
   }

//   llvm::Value* llvm_intrinsic(llvm::Intrinsic::ID id, llvm::Value* a)
//   {
//      llvm::Type* types[1] = {a->getType()};
//      return bld.CreateCall(llvm::Intrinsic::getDeclaration(mod, id, types, 1), a);
//   }
//
//   llvm::Value* llvm_intrinsic(llvm::Intrinsic::ID id, llvm::Value* a, llvm::Value* b)
//   {
//      llvm::Type* types[2] = {a->getType(), b->getType()};
//      /* only one type suffix is usually needed, so pass 1 here */
//      return bld.CreateCall2(llvm::Intrinsic::getDeclaration(mod, id, types, 1), a, b);
//   }

   llvm::Value* llvm_intrinsic_unop(ir_expression_operation op, llvm::Value * op0)
   {
      llvm::Type * floatType = llvm::Type::getFloatTy(ctx);
      const char * name = NULL;
      switch (op) {
      case ir_unop_sin:
         name = "sinf";
         break;
      case ir_unop_cos:
         name = "cosf";
         break;
      default:
         assert(0);
      }

      llvm::Function * function = mod->getFunction(name);
      if (!function) {
         // predeclare the intrinsic
         std::vector<llvm::Type*> args;
         args.push_back(floatType);
         llvm::FunctionType* type = llvm::FunctionType::get(floatType,
                                                            llvm::ArrayRef<llvm::Type*>(args),
                                                            false);
         function = llvm::Function::Create(type, llvm::Function::ExternalLinkage, name, mod);
         function->setCallingConv(llvm::CallingConv::C);
      }

      return bld.CreateCall(function, op0);
   }

   llvm::Value* llvm_intrinsic_binop(ir_expression_operation op, llvm::Value * op0, llvm::Value * op1)
   {
      llvm::Type * floatType = llvm::Type::getFloatTy(ctx);
      const char * name = NULL;
      switch (op) {
      case ir_binop_pow:
         name = "powf";
         break;
      default:
         assert(0);
      }

      llvm::Function * function = mod->getFunction(name);
      if (!function) {
         // predeclare the intrinsic
         std::vector<llvm::Type*> args;
         args.push_back(floatType);
         args.push_back(floatType);
         llvm::FunctionType* type = llvm::FunctionType::get(floatType,
                                                            llvm::ArrayRef<llvm::Type*>(args),
                                                            false);
         function = llvm::Function::Create(type, llvm::Function::ExternalLinkage, name, mod);
         function->setCallingConv(llvm::CallingConv::C);
      }

      return bld.CreateCall2(function, op0, op1);
   }

   llvm::Constant* llvm_imm(llvm::Type* type, double v)
   {
      if(type->isVectorTy())
      {
         std::vector<llvm::Constant*> values;
         values.push_back(llvm_imm(((llvm::VectorType*)type)->getElementType(), v));
         for(unsigned i = 1; i < ((llvm::VectorType*)type)->getNumElements(); ++i)
            values.push_back(values[0]);
         return llvm::ConstantVector::get(values);
      }
      else if(type->isIntegerTy())
         return llvm::ConstantInt::get(type, v);
      else if(type->isFloatingPointTy())
         return llvm::ConstantFP::get(type, v);
      else
      {
         assert(0);
         return 0;
      }
   }

   static llvm::Value* create_shuffle3(llvm::IRBuilder<>& bld, llvm::Value* v, unsigned a, unsigned b, unsigned c, const llvm::Twine& name = "")
   {
      llvm::Type* int_ty = llvm::Type::getInt32Ty(v->getContext());
      llvm::Constant* vals[3] = {llvm::ConstantInt::get(int_ty, a), llvm::ConstantInt::get(int_ty, b), llvm::ConstantInt::get(int_ty, c)};
      return bld.CreateShuffleVector(v, llvm::UndefValue::get(v->getType()), llvm::ConstantVector::get(pack(vals)), name);
   }

   llvm::Value* create_select(unsigned width, llvm::Value * cond, llvm::Value * tru, llvm::Value * fal, const char * name = "")
   {
      if (1 == width)
         return bld.CreateSelect(cond, tru, fal, name);

      llvm::Type * vectorType = tru->getType();
      llvm::Value * vector = llvm::Constant::getNullValue(vectorType);
      for (unsigned int i = 0; i < width; i++) {
         llvm::Value * c = bld.CreateExtractElement(cond, llvm_int(i));
         llvm::Value * t = bld.CreateExtractElement(tru, llvm_int(i));
         llvm::Value * f = bld.CreateExtractElement(fal, llvm_int(i));
         llvm::Value * v = bld.CreateSelect(c, t, f, name);
         vector = bld.CreateInsertElement(vector, v, llvm_int(i), "vslct");
      }
      return vector;
   }

   llvm::Value* create_dot_product(llvm::Value* ops0, llvm::Value* ops1, glsl_base_type type, unsigned width)
   {
      llvm::Value* prod;
      switch (type) {
      case GLSL_TYPE_UINT:
      case GLSL_TYPE_INT:
         prod = bld.CreateMul(ops0, ops1, "dot.mul");
         break;
      case GLSL_TYPE_FLOAT:
         prod = bld.CreateFMul(ops0, ops1, "dot.mul");
         break;
      default:
         assert(0);
      }

      if (width<= 1)
         return prod;

      llvm::Value* sum = 0;
      for (unsigned i = 0; i < width; ++i) {
         llvm::Value* elem = bld.CreateExtractElement(prod, llvm_int(i), "dot.elem");
         if (sum) {
            if (type == GLSL_TYPE_FLOAT)
               sum = bld.CreateFAdd(sum, elem, "dot.add");
            else
               sum = bld.CreateAdd(sum, elem, "dot.add");
         }
         else
            sum = elem;
      }
      return sum;
   }

   llvm::Value* llvm_expression(ir_expression* ir)
   {
      llvm::Value* ops[2];
      for(unsigned i = 0; i < ir->get_num_operands(); ++i)
         ops[i] = llvm_value(ir->operands[i]);

      if(ir->get_num_operands() == 2)
      {
         int vecidx = -1;
         int scaidx = -1;
         if(ir->operands[0]->type->vector_elements <= 1 && ir->operands[1]->type->vector_elements > 1)
         {
            scaidx = 0;
            vecidx = 1;
         }
         else if(ir->operands[0]->type->vector_elements > 1 && ir->operands[1]->type->vector_elements <= 1)
         {
            scaidx = 1;
            vecidx = 0;
         }
         else
            assert(ir->operands[0]->type->vector_elements == ir->operands[1]->type->vector_elements);

         if(scaidx >= 0)
         {
            llvm::Value* vec;
            vec = llvm::UndefValue::get(ops[vecidx]->getType());
            for(unsigned i = 0; i < ir->operands[vecidx]->type->vector_elements; ++i)
               vec = bld.CreateInsertElement(vec,  ops[scaidx], llvm_int(i), "sca2vec");
            ops[scaidx] = vec;
         }
      }

      switch (ir->operation) {
      case ir_unop_logic_not:
         return bld.CreateNot(ops[0]);
      case ir_unop_neg:
         switch (ir->operands[0]->type->base_type) {
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_INT:
            return bld.CreateNeg(ops[0]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFNeg(ops[0]);
         default:
            assert(0);
         }
      case ir_unop_abs:
         switch (ir->operands[0]->type->base_type) {
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_BOOL:
            return ops[0];
         case GLSL_TYPE_INT:
            return create_select(ir->operands[0]->type->vector_elements,
                                 bld.CreateICmpSGE(ops[0], llvm_imm(ops[0]->getType(), 0), "sabs.ge"),
                                 ops[0], bld.CreateNeg(ops[0], "sabs.neg"), "sabs.select");
         case GLSL_TYPE_FLOAT:
            return create_select(ir->operands[0]->type->vector_elements,
                                 bld.CreateFCmpUGE(ops[0], llvm_imm(ops[0]->getType(), 0), "fabs.ge"),
                                 ops[0], bld.CreateFNeg(ops[0], "fabs.neg"), "fabs.select");
         default:
            assert(0);
         }
      case ir_unop_sign:
         switch (ir->operands[0]->type->base_type) {
         case GLSL_TYPE_BOOL:
            return ops[0];
         case GLSL_TYPE_UINT:
            return bld.CreateZExt(bld.CreateICmpNE(ops[0], llvm_imm(ops[0]->getType(), 0), "usign.ne"), ops[0]->getType(), "usign.zext");
         case GLSL_TYPE_INT:
            return bld.CreateSelect(bld.CreateICmpNE(ops[0], llvm_imm(ops[0]->getType(), 0), "ssign.ne"),
                                    bld.CreateSelect(bld.CreateICmpSGE(ops[0], llvm_imm(ops[0]->getType(), 0), "ssign.ge"), llvm_imm(ops[0]->getType(), 1), llvm_imm(ops[0]->getType(), -1), "sabs.selects"),
                                    llvm_imm(ops[0]->getType(), 0), "sabs.select0");
         case GLSL_TYPE_FLOAT:
            return bld.CreateSelect(bld.CreateFCmpONE(ops[0], llvm_imm(ops[0]->getType(), 0), "fsign.ne"),
                                    bld.CreateSelect(bld.CreateFCmpUGE(ops[0], llvm_imm(ops[0]->getType(), 0), "fsign.ge"), llvm_imm(ops[0]->getType(), 1), llvm_imm(ops[0]->getType(), -1), "fabs.selects"),
                                    llvm_imm(ops[0]->getType(), 0), "fabs.select0");
         default:
            assert(0);
         }
      case ir_unop_rcp:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
         return bld.CreateFDiv(llvm_imm(ops[0]->getType(), 1), ops[0]);
      case ir_unop_exp: // fall through
      case ir_unop_exp2: // fall through
      case ir_unop_log: // fall through
      case ir_unop_log2: // fall through
      case ir_unop_sin: // fall through
      case ir_unop_cos:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
         return llvm_intrinsic_unop(ir->operation, ops[0]);
         // TODO: implement these somehow
      case ir_unop_dFdx:
         assert(0);
         //return llvm_intrinsic(llvm::Intrinsic::ddx, ops[0]);
      case ir_unop_dFdy:
         assert(0);
         //return llvm_intrinsic(llvm::Intrinsic::ddy, ops[0]);
      case ir_binop_add:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            return bld.CreateAdd(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFAdd(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_sub:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            return bld.CreateSub(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFSub(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_mul:
         if (ir->operands[0]->type->is_matrix() && ir->operands[1]->type->is_vector())
            assert(0);
         else if (ir->operands[0]->type->is_vector() && ir->operands[1]->type->is_matrix()) {
            assert(0); // matrix multiplication should have been lowered to vector ops
			llvm::VectorType * vectorType = llvm::VectorType::get(llvm_base_type(ir->operands[1]->type->base_type), ir->operands[1]->type->matrix_columns);
            llvm::Value * vector = llvm::Constant::getNullValue(vectorType);
            for (unsigned int i = 0; i < ir->operands[1]->type->matrix_columns; i++) {
               llvm::Value * value = bld.CreateExtractValue(ops[1], i, "vec*mat_col");
               value = create_dot_product(value, ops[0], ir->operands[1]->type->base_type, ir->operands[1]->type->vector_elements);
               vector = bld.CreateInsertElement(vector, value, llvm_int(i), "vec*mat_res");
            }
            return vector;
         }
         else if (ir->operands[0]->type->is_matrix() && ir->operands[1]->type->is_matrix())
            assert(0);

         switch (ir->operands[0]->type->base_type) {
         case GLSL_TYPE_BOOL:
            return bld.CreateAnd(ops[0], ops[1]);
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            return bld.CreateMul(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFMul(ops[0], ops[1]);
         default:
            assert(0);
         }
         case ir_binop_div:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateUDiv(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateSDiv(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFDiv(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_mod:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateURem(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateSRem(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFRem(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_less:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateICmpULT(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateICmpSLT(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFCmpOLT(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_greater:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateICmpUGT(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateICmpSGT(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFCmpOGT(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_lequal:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateICmpULE(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateICmpSLE(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFCmpOLE(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_gequal:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateICmpUGE(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateICmpSGE(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFCmpOGE(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_equal: // fall through
      case ir_binop_all_equal: // TODO: check op same as ir_binop_equal
         switch (ir->operands[0]->type->base_type) {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            return bld.CreateICmpEQ(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFCmpOEQ(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_nequal:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            return bld.CreateICmpNE(ops[0], ops[1]);
         case GLSL_TYPE_FLOAT:
            return bld.CreateFCmpONE(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_logic_xor:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
         return bld.CreateICmpNE(ops[0], ops[1]);
      case ir_binop_logic_or:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
         return bld.CreateOr(ops[0], ops[1]);
      case ir_binop_logic_and:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
         return bld.CreateAnd(ops[0], ops[1]);
      case ir_binop_dot:
         return create_dot_product(ops[0], ops[1], ir->operands[0]->type->base_type, ir->operands[0]->type->vector_elements);
//      case ir_binop_cross: this op does not exist in ir.h
//         assert(ir->operands[0]->type->vector_elements == 3);
//         switch(ir->operands[0]->type->base_type)
//         {
//         case GLSL_TYPE_UINT:
//         case GLSL_TYPE_INT:
//            return bld.CreateSub(
//                  bld.CreateMul(create_shuffle3(bld, ops[0], 1, 2, 0, "cross.a120"), create_shuffle3(bld, ops[1], 2, 0, 1, "cross.a201"), "cross.ab"),
//                  bld.CreateMul(create_shuffle3(bld, ops[1], 1, 2, 0, "cross.b120"), create_shuffle3(bld, ops[0], 2, 0, 1, "cross.b201"), "cross.ba"),
//                  "cross.sub");
//         case GLSL_TYPE_FLOAT:
//            return bld.CreateFSub(
//                  bld.CreateFMul(create_shuffle3(bld, ops[0], 1, 2, 0, "cross.a120"), create_shuffle3(bld, ops[1], 2, 0, 1, "cross.a201"), "cross.ab"),
//                  bld.CreateFMul(create_shuffle3(bld, ops[1], 1, 2, 0, "cross.b120"), create_shuffle3(bld, ops[0], 2, 0, 1, "cross.b201"), "cross.ba"),
//                  "cross.sub");
//         default:
//            assert(0);
//         }
      case ir_unop_sqrt:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
         return llvm_intrinsic_unop(ir->operation, ops[0]);
      case ir_unop_rsq:
         assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
         return bld.CreateFDiv(llvm_imm(ops[0]->getType(), 1), llvm_intrinsic_unop(ir_unop_sqrt, ops[0]), "rsqrt.rcp");
      case ir_unop_i2f:
         return bld.CreateSIToFP(ops[0], llvm_type(ir->type));
      case ir_unop_u2f:
      case ir_unop_b2f:
         return bld.CreateUIToFP(ops[0], llvm_type(ir->type));
      case ir_unop_b2i:
         return bld.CreateZExt(ops[0], llvm_type(ir->type));
      case ir_unop_f2i:
         return bld.CreateFPToSI(ops[0], llvm_type(ir->type));
      case ir_unop_f2b:
         return bld.CreateFCmpONE(ops[0], llvm_imm(ops[0]->getType(), 0));
      case ir_unop_i2b:
         return bld.CreateICmpNE(ops[0], llvm_imm(ops[0]->getType(), 0));
      case ir_unop_trunc:
      {
         if(ir->operands[0]->type->base_type != GLSL_TYPE_FLOAT)
            return ops[0];
         glsl_type int_type = *ir->operands[0]->type;
         int_type.base_type = GLSL_TYPE_INT;
         return bld.CreateSIToFP(bld.CreateFPToSI(ops[0], llvm_type(&int_type), "trunc.fptosi"),ops[0]->getType(), "trunc.sitofp");
      }
      case ir_unop_floor:
      {
         if(ir->operands[0]->type->base_type != GLSL_TYPE_FLOAT)
            return ops[0];
         llvm::Value* one = llvm_imm(ops[0]->getType(), 1);
         return bld.CreateFSub(ops[0], bld.CreateFRem(ops[0], one));
      }
      case ir_unop_ceil:
      {
         if(ir->operands[0]->type->base_type != GLSL_TYPE_FLOAT)
            return ops[0];
         llvm::Value* one = llvm_imm(ops[0]->getType(), 1);
         return bld.CreateFAdd(bld.CreateFSub(ops[0], bld.CreateFRem(ops[0], one)), one);
      }
      case ir_unop_fract:
      {
         if(ir->operands[0]->type->base_type != GLSL_TYPE_FLOAT)
            return llvm_imm(ops[0]->getType(), 0);
         llvm::Value* one = llvm_imm(ops[0]->getType(), 1);
         return bld.CreateFRem(ops[0], one);
      }
      // TODO: NaNs might be wrong in min/max, not sure how to fix it
      case ir_binop_min:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
            return bld.CreateAnd(ops[0], ops[1], "bmin");
         case GLSL_TYPE_UINT:
            return bld.CreateSelect(bld.CreateICmpULE(ops[0], ops[1], "umin.le"), ops[0], ops[1], "umin.select");
         case GLSL_TYPE_INT:
            return bld.CreateSelect(bld.CreateICmpSLE(ops[0], ops[1], "smin.le"), ops[0], ops[1], "smin.select");
         case GLSL_TYPE_FLOAT:
            return bld.CreateSelect(bld.CreateFCmpULE(ops[0], ops[1], "fmin.le"), ops[0], ops[1], "fmin.select");
         default:
            assert(0);
         }
      case ir_binop_max:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
            return bld.CreateOr(ops[0], ops[1], "bmax");
         case GLSL_TYPE_UINT:
            return bld.CreateSelect(bld.CreateICmpUGE(ops[0], ops[1], "umax.ge"), ops[0], ops[1], "umax.select");
         case GLSL_TYPE_INT:
            return bld.CreateSelect(bld.CreateICmpSGE(ops[0], ops[1], "smax.ge"), ops[0], ops[1], "smax.select");
         case GLSL_TYPE_FLOAT:
            return bld.CreateSelect(bld.CreateFCmpUGE(ops[0], ops[1], "fmax.ge"), ops[0], ops[1], "fmax.select");
         default:
            assert(0);
         }
      case ir_binop_pow:
         assert(GLSL_TYPE_FLOAT == ir->operands[0]->type->base_type);
         assert(GLSL_TYPE_FLOAT == ir->operands[1]->type->base_type);
         return llvm_intrinsic_binop(ir_binop_pow, ops[0], ops[1]);
      case ir_unop_bit_not:
         return bld.CreateNot(ops[0]);
      case ir_binop_bit_and:
         return bld.CreateAnd(ops[0], ops[1]);
      case ir_binop_bit_xor:
         return bld.CreateXor(ops[0], ops[1]);
      case ir_binop_bit_or:
         return bld.CreateOr(ops[0], ops[1]);
      case ir_binop_lshift:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            return bld.CreateLShr(ops[0], ops[1]);
         default:
            assert(0);
         }
      case ir_binop_rshift:
         switch(ir->operands[0]->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            return bld.CreateLShr(ops[0], ops[1]);
         case GLSL_TYPE_INT:
            return bld.CreateAShr(ops[0], ops[1]);
         default:
            assert(0);
            return 0;
         }
      default:
         printf("ir->operation=%d \n", ir->operation);
         assert(0);
         return 0;
      }
   }

   virtual void visit(class ir_expression * ir)
   {
      result = llvm_expression(ir);
   }

   virtual void visit(class ir_dereference_array *ir)
   {
      result = bld.CreateLoad(llvm_pointer(ir));
   }

   virtual void visit(class ir_dereference_record *ir)
   {
      result = bld.CreateLoad(llvm_pointer(ir));
   }

   virtual void visit(class ir_dereference_variable *ir)
   {
      result = bld.CreateLoad(llvm_pointer(ir), ir->variable_referenced()->name);
   }

   virtual void visit(class ir_texture * ir)
   {
      llvm::Value * coordinate = llvm_value(ir->coordinate);
      if (ir->projector)
      {
         llvm::Value * proj = llvm_value(ir->projector);
         unsigned width = ((llvm::VectorType*)coordinate->getType())->getNumElements();
         llvm::Value * div = llvm::Constant::getNullValue(coordinate->getType());
         for (unsigned i = 0; i < width; i++)
            div = bld.CreateInsertElement(div, proj, bld.getInt32(i), "texProjDup");
         coordinate = bld.CreateFDiv(coordinate, div, "texProj");
      }

      ir_variable * sampler = NULL;
      if(ir_dereference_variable* deref = ir->sampler->as_dereference_variable())
         sampler = deref->variable_referenced();
      else if(ir_dereference_array* deref = ir->sampler->as_dereference_array())
      {
         assert(0); // not implemented
         return;
         deref->array_index;
         deref->array;
      }
      else if(ir->sampler->as_dereference())
      {
         assert(0); // not implemented
         ir_dereference_record* deref = (ir_dereference_record*)ir->sampler;
         int idx = deref->record->type->field_index(deref->field);
         assert(idx >= 0);
      }
      else
         assert(0);

      assert(sampler->location >= 0 && sampler->location < 64); // TODO: proper limit

      // ESSL texture LOD is only for 2D texture in vert shader, and it's explicit
      // bias used only in frag shader, and added to computed LOD
      assert(ir_tex == ir->op);

      assert(GLSL_TYPE_FLOAT == sampler->type->sampler_type);
      printf("sampler '%s' location=%d dim=%d type=%d proj=%d lod=%d \n", sampler->name, sampler->location,
         sampler->type->sampler_dimensionality, sampler->type->sampler_type,
         ir->projector ? 1 : 0, ir->lod_info.lod ? 1 : 0);
      if (GLSL_SAMPLER_DIM_CUBE == sampler->type->sampler_dimensionality)
         result = texCube(bld, coordinate, sampler->location, gglCtx);
      else if (GLSL_SAMPLER_DIM_2D == sampler->type->sampler_dimensionality)
         result = tex2D(bld, coordinate, sampler->location, gglCtx);
      else
         assert(0);
   }

   virtual void visit(class ir_discard * ir)
   {
      llvm::BasicBlock* discard = llvm::BasicBlock::Create(ctx, "discard", fun);
      llvm::BasicBlock* after;
      if(ir->condition)
      {
         after = llvm::BasicBlock::Create(ctx, "discard.survived", fun);
         bld.CreateCondBr(llvm_value(ir->condition), discard, after);
      }
      else
      {
         after = llvm::BasicBlock::Create(ctx, "dead_code.discard", fun);
         bld.CreateBr(discard);
      }

      bld.SetInsertPoint(discard);

      // FIXME: According to the LLVM mailing list, UnwindInst should not
      // be used by the frontend since LLVM 3.0, and 'CreateUnwind'
      // method has been removed from the IRBuilder.  Here's the
      // temporary workaround.  But it would be better to remove
      // this in the future.
      //
      // A solution after LLVM 3.0: To add a global boolean in the shader to
      // store whether it was discarded or not and just continue on normally,
      // and handle the discard outside the shader, in the scanline function.
      // The discard instruction is not used frequently, so it should be okay
      // performance wise.
      new llvm::UnwindInst(ctx, discard); /// Deprecated

      bb = after;
      bld.SetInsertPoint(bb);
   }

   virtual void visit(class ir_loop_jump *ir)
   {
      llvm::BasicBlock* target;
      if(ir->mode == ir_loop_jump::jump_continue)
         target = loop.first;
      else if(ir->mode == ir_loop_jump::jump_break)
         target = loop.second;
      assert(target);

      bld.CreateBr(target);

      bb = llvm::BasicBlock::Create(ctx, "dead_code.jump", fun);
      bld.SetInsertPoint(bb);
   }

   virtual void visit(class ir_loop * ir)
   {
      llvm::BasicBlock* body = llvm::BasicBlock::Create(ctx, "loop", fun);
      llvm::BasicBlock* header = body;
      llvm::BasicBlock* after = llvm::BasicBlock::Create(ctx, "loop.after", fun);
      llvm::Value* ctr;

      if(ir->counter)
      {
         ctr = llvm_variable(ir->counter);
         if(ir->from)
            bld.CreateStore(llvm_value(ir->from), ctr);
         if(ir->to)
            header = llvm::BasicBlock::Create(ctx, "loop.header", fun);
      }

      bld.CreateBr(header);

      if(ir->counter && ir->to)
      {
         bld.SetInsertPoint(header);
         llvm::Value* cond;
         llvm::Value* load = bld.CreateLoad(ctr);
         llvm::Value* to = llvm_value(ir->to);
         switch(ir->counter->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
            cond = bld.CreateICmpULT(load, to);
            break;
         case GLSL_TYPE_INT:
            cond = bld.CreateICmpSLT(load, to);
            break;
         case GLSL_TYPE_FLOAT:
            cond = bld.CreateFCmpOLT(load, to);
            break;
         }
         bld.CreateCondBr(cond, body, after);
      }

      bld.SetInsertPoint(body);

      std::pair<llvm::BasicBlock*, llvm::BasicBlock*> saved_loop = loop;
      loop = std::make_pair(header, after);
      visit_exec_list(&ir->body_instructions, this);
      loop = saved_loop;

      if(ir->counter && ir->increment)
      {
         switch(ir->counter->type->base_type)
         {
         case GLSL_TYPE_BOOL:
         case GLSL_TYPE_UINT:
         case GLSL_TYPE_INT:
            bld.CreateStore(bld.CreateAdd(bld.CreateLoad(ctr), llvm_value(ir->increment)), ctr);
            break;
         case GLSL_TYPE_FLOAT:
            bld.CreateStore(bld.CreateFAdd(bld.CreateLoad(ctr), llvm_value(ir->increment)), ctr);
            break;
         }
      }
      bld.CreateBr(header);

      bb = after;
      bld.SetInsertPoint(bb);
   }

   virtual void visit(class ir_if *ir)
   {
      llvm::BasicBlock* bbt = llvm::BasicBlock::Create(ctx, "if", fun);
      llvm::BasicBlock* bbf = llvm::BasicBlock::Create(ctx, "else", fun);
      llvm::BasicBlock* bbe = llvm::BasicBlock::Create(ctx, "endif", fun);
      bld.CreateCondBr(llvm_value(ir->condition), bbt, bbf);

      bld.SetInsertPoint(bbt);
      visit_exec_list(&ir->then_instructions, this);
      bld.CreateBr(bbe);

      bld.SetInsertPoint(bbf);
      visit_exec_list(&ir->else_instructions, this);
      bld.CreateBr(bbe);

      bb = bbe;
      bld.SetInsertPoint(bb);
   }

   virtual void visit(class ir_return * ir)
   {
      if(!ir->value)
         bld.CreateRetVoid();
      else
         bld.CreateRet(llvm_value(ir->value));

      bb = llvm::BasicBlock::Create(ctx, "dead_code.return", fun);
      bld.SetInsertPoint(bb);
   }

   virtual void visit(class ir_call * ir)
   {
      std::vector<llvm::Value*> args;

      foreach_iter(exec_list_iterator, iter, *ir)
      {
         ir_rvalue *arg = (ir_constant *)iter.get();
         args.push_back(llvm_value(arg));
      }

      result = bld.CreateCall(llvm_function(ir->get_callee()), llvm::ArrayRef<llvm::Value*>(args));

      llvm::AttrListPtr attr;
      ((llvm::CallInst*)result)->setAttributes(attr);
   }

   virtual void visit(class ir_constant * ir)
   {
      if (ir->type->base_type == GLSL_TYPE_STRUCT) {
         std::vector<llvm::Constant*> fields;
         foreach_iter(exec_list_iterator, iter, ir->components) {
            ir_constant *field = (ir_constant *)iter.get();
            fields.push_back(llvm_constant(field));
         }
         result = llvm::ConstantStruct::get((llvm::StructType*)llvm_type(ir->type), fields);
      }
      else if (ir->type->base_type == GLSL_TYPE_ARRAY) {
         std::vector<llvm::Constant*> elems;
         for (unsigned i = 0; i < ir->type->length; i++)
            elems.push_back(llvm_constant(ir->array_elements[i]));
         result = llvm::ConstantArray::get((llvm::ArrayType*)llvm_type(ir->type), elems);
      }
      else
      {
         llvm::Type* base_type = llvm_base_type(ir->type->base_type);
         llvm::Type* vec_type = llvm_vec_type(ir->type);
         llvm::Type* type = llvm_type(ir->type);

         std::vector<llvm::Constant*> vecs;
         unsigned idx = 0;
         for (unsigned i = 0; i < ir->type->matrix_columns; ++i) {
            std::vector<llvm::Constant*> elems;
            for (unsigned j = 0; j < ir->type->vector_elements; ++j) {
               llvm::Constant* elem;
               switch(ir->type->base_type)
               {
               case GLSL_TYPE_FLOAT:
                  elem = llvm::ConstantFP::get(base_type, ir->value.f[idx]);
                  break;
               case GLSL_TYPE_UINT:
                  elem = llvm::ConstantInt::get(base_type, ir->value.u[idx]);
                  break;
               case GLSL_TYPE_INT:
                  elem = llvm::ConstantInt::get(base_type, ir->value.i[idx]);
                  break;
               case GLSL_TYPE_BOOL:
                  elem = llvm::ConstantInt::get(base_type, ir->value.b[idx]);
                  break;
               }
               elems.push_back(elem);
               ++idx;
            }

            llvm::Constant* vec;
            if(ir->type->vector_elements > 1) {
               llvm::ArrayRef<llvm::Constant*> ConstantArray(elems);
               vec = llvm::ConstantVector::get(ConstantArray);
            } else {
               vec = elems[0];
            }
            vecs.push_back(vec);
         }

         if(ir->type->matrix_columns > 1)
            result = llvm::ConstantArray::get((llvm::ArrayType*)type, vecs);
         else
            result = vecs[0];
      }
   }

   llvm::Value* llvm_shuffle(llvm::Value* val, int* shuffle_mask, unsigned res_width, const llvm::Twine &name = "")
   {
      llvm::Type* elem_type = val->getType();
      llvm::Type* res_type = elem_type;;
      unsigned val_width = 1;
      if(val->getType()->isVectorTy())
      {
         val_width = ((llvm::VectorType*)val->getType())->getNumElements();
         elem_type = ((llvm::VectorType*)val->getType())->getElementType();
      }
      if(res_width > 1)
         res_type = llvm::VectorType::get(elem_type, res_width);

      llvm::Constant* shuffle_mask_values[4];
      assert(res_width <= 4);
      bool any_def = false;
      for(unsigned i = 0; i < res_width; ++i)
      {
         if(shuffle_mask[i] < 0)
            shuffle_mask_values[i] = llvm::UndefValue::get(llvm::Type::getInt32Ty(ctx));
         else
         {
            any_def = true;
            shuffle_mask_values[i] = llvm_int(shuffle_mask[i]);
         }
      }

      llvm::Value* undef = llvm::UndefValue::get(res_type);
      if(!any_def)
         return undef;

      if(val_width > 1)
      {
         if(res_width > 1)
         {
            if(val_width == res_width)
            {
               bool nontrivial = false;
               for(unsigned i = 0; i < val_width; ++i)
               {
                  if(shuffle_mask[i] != (int)i)
                     nontrivial = true;
               }
               if(!nontrivial)
                  return val;
            }

            return bld.CreateShuffleVector(val, llvm::UndefValue::get(val->getType()), llvm::ConstantVector::get(pack(shuffle_mask_values, res_width)), name);
         }
         else
            return bld.CreateExtractElement(val, llvm_int(shuffle_mask[0]), name);
      }
      else
      {
         if(res_width > 1)
         {
            llvm::Value* tmp = undef;
            for(unsigned i = 0; i < res_width; ++i)
            {
               if(shuffle_mask[i] >= 0)
               tmp = bld.CreateInsertElement(tmp, val, llvm_int(i), name);
            }
            return tmp;
         }
         else if(shuffle_mask[0] >= 0)
            return val;
         else
            return undef;
      }
   }


   virtual void visit(class ir_swizzle * swz)
   {
      llvm::Value* val = llvm_value(swz->val);
      int mask[4] = {swz->mask.x, swz->mask.y, swz->mask.z, swz->mask.w};
      result = llvm_shuffle(val, mask, swz->mask.num_components, "swizzle");
   }

   virtual void visit(class ir_assignment * ir)
   {
      llvm::Value* lhs = llvm_pointer(ir->lhs);
      llvm::Value* rhs = llvm_value(ir->rhs);
      unsigned width = ir->lhs->type->vector_elements;
      unsigned mask = (1 << width) - 1;
      assert(rhs);

      // TODO: masking for matrix assignment
      if (ir->rhs->type->is_matrix()) {
         bld.CreateStore(rhs, lhs, "mat_str");
         return;
      }

      if (!(ir->write_mask & mask))
         return;

      if (ir->rhs->type->vector_elements < width) {
         int expand_mask[4] = {-1, -1, -1, -1};
         for (unsigned i = 0; i < ir->lhs->type->vector_elements; ++i)
            expand_mask[i] = i;
//         printf("ve: %u w %u issw: %i\n", ir->rhs->type->vector_elements, width, !!ir->rhs->as_swizzle());
         rhs = llvm_shuffle(rhs, expand_mask, width, "assign.expand");
      }

      if (width > 1 && (ir->write_mask & mask) != mask) {
         llvm::Constant* blend_mask[4];
         // refer to ir.h: ir_assignment::write_mask
         // A partially-set write mask means that each enabled channel gets
         // the value from a consecutive channel of the rhs.
         unsigned rhsChannel = 0;
         for (unsigned i = 0; i < width; ++i) {
            if (ir->write_mask & (1 << i))
               blend_mask[i] = llvm_int(width + rhsChannel++);
            else
               blend_mask[i] = llvm_int(i);
         }
         rhs = bld.CreateShuffleVector(bld.CreateLoad(lhs), rhs, llvm::ConstantVector::get(pack(blend_mask, width)), "assign.writemask");
      }

      if(ir->condition)
         rhs = bld.CreateSelect(llvm_value(ir->condition), rhs, bld.CreateLoad(lhs), "assign.conditional");

      bld.CreateStore(rhs, lhs);
   }

   virtual void visit(class ir_variable * var)
   {
      llvm_variable(var);
   }

   virtual void visit(ir_function_signature *sig)
   {
      if(!sig->is_defined)
         return;

      assert(!fun);
      fun = llvm_function(sig);

      bb = llvm::BasicBlock::Create(ctx, "entry", fun);
      bld.SetInsertPoint(bb);

      llvm::Function::arg_iterator ai = fun->arg_begin();
      if (!strcmp("main",sig->function_name()))
      {
         assert(3 == fun->arg_size());
         bld.CreateStore(ai, inputsPtr);
         inputs = ai;
         ai++;
         bld.CreateStore(ai, outputsPtr);
         outputs = ai;
         ai++;
         bld.CreateStore(ai, constantsPtr);
         constants = ai;
         ai++;
      }
      else
      {
         foreach_iter(exec_list_iterator, iter, sig->parameters) {
            ir_variable* arg = (ir_variable*)iter.get();
            ai->setName(arg->name);
            bld.CreateStore(ai, llvm_variable(arg));
            ++ai;
         }
         inputs = bld.CreateLoad(inputsPtr);
         outputs = bld.CreateLoad(outputsPtr);
         constants = bld.CreateLoad(constantsPtr);
      }
      inputs->setName("gl_inputs");
      outputs->setName("gl_outputs");
      constants->setName("gl_constants");



      foreach_iter(exec_list_iterator, iter, sig->body) {
         ir_instruction *ir = (ir_instruction *)iter.get();

         ir->accept(this);
      }

      if(fun->getReturnType()->isVoidTy())
         bld.CreateRetVoid();
      else
         bld.CreateRet(llvm::UndefValue::get(fun->getReturnType()));

      bb = NULL;
      fun = NULL;
   }

   virtual void visit(class ir_function * funs)
   {
      foreach_iter(exec_list_iterator, iter, *funs)
      {
         ir_function_signature* sig = (ir_function_signature*)iter.get();
         sig->accept(this);
      }
   }
};

struct llvm::Module *
glsl_ir_to_llvm_module(struct exec_list *ir, llvm::Module * mod,
                        const struct GGLState * gglCtx, const char * shaderSuffix)
{
   ir_to_llvm_visitor v(mod, gglCtx, shaderSuffix);

   visit_exec_list(ir, &v);

//   mod->dump();
   if(llvm::verifyModule(*mod, llvm::PrintMessageAction, 0))
   {
      puts("**\n module verification failed **\n");
      mod->dump();
      assert(0);
      return NULL;
   }

   return mod;
   //v.ir_to_llvm_emit_op1(NULL, OPCODE_END, ir_to_llvm_undef_dst, ir_to_llvm_undef);
}