src/gallium/aux/llvm/tgsitollvm.cpp

   1 #include "tgsitollvm.h"
   2
   3 #include "gallivm.h"
   4 #include "gallivm_p.h"
   5
   6 #include "storage.h"
   7 #include "instructions.h"
   8 #include "storagesoa.h"
   9 #include "instructionssoa.h"
  10
  11 #include "pipe/p_shader_tokens.h"
  12
  13 #include "tgsi/util/tgsi_parse.h"
  14 #include "tgsi/exec/tgsi_exec.h"
  15 #include "tgsi/util/tgsi_util.h"
  16 #include "tgsi/util/tgsi_build.h"
  17 #include "tgsi/util/tgsi_dump.h"
  18
  19
  20 #include <llvm/Module.h>
  21 #include <llvm/CallingConv.h>
  22 #include <llvm/Constants.h>
  23 #include <llvm/DerivedTypes.h>
  24 #include <llvm/Instructions.h>
  25 #include <llvm/ModuleProvider.h>
  26 #include <llvm/Pass.h>
  27 #include <llvm/PassManager.h>
  28 #include <llvm/ParameterAttributes.h>
  29 #include <llvm/Support/PatternMatch.h>
  30 #include <llvm/ExecutionEngine/JIT.h>
  31 #include <llvm/ExecutionEngine/Interpreter.h>
  32 #include <llvm/ExecutionEngine/GenericValue.h>
  33 #include <llvm/Support/MemoryBuffer.h>
  34 #include <llvm/LinkAllPasses.h>
  35 #include <llvm/Analysis/Verifier.h>
  36 #include <llvm/Analysis/LoopPass.h>
  37 #include <llvm/Target/TargetData.h>
  38 #include <llvm/Bitcode/ReaderWriter.h>
  39 #include <llvm/Transforms/Utils/Cloning.h>
  40
  41
  42 #include <sstream>
  43 #include <fstream>
  44 #include <iostream>
  45
  46 using namespace llvm;
  47
  48 static inline FunctionType *vertexShaderFunctionType()
  49 {
  50    //Function takes three arguments,
  51    // the calling code has to make sure the types it will
  52    // pass are castable to the following:
  53    // [4 x <4 x float>] inputs,
  54    // [4 x <4 x float>] output,
  55    // [4 x [4 x float]] consts,
  56    // [4 x <4 x float>] temps
  57
  58    std::vector<const Type*> funcArgs;
  59    VectorType *vectorType = VectorType::get(Type::FloatTy, 4);
  60    ArrayType *vectorArray = ArrayType::get(vectorType, 4);
  61    PointerType *vectorArrayPtr = PointerType::get(vectorArray, 0);
  62
  63    ArrayType   *floatArray     = ArrayType::get(Type::FloatTy, 4);
  64    ArrayType   *constsArray    = ArrayType::get(floatArray, 4);
  65    PointerType *constsArrayPtr = PointerType::get(constsArray, 0);
  66
  67    funcArgs.push_back(vectorArrayPtr);//inputs
  68    funcArgs.push_back(vectorArrayPtr);//output
  69    funcArgs.push_back(constsArrayPtr);//consts
  70    funcArgs.push_back(vectorArrayPtr);//temps
  71
  72    FunctionType *functionType = FunctionType::get(
  73       /*Result=*/Type::VoidTy,
  74       /*Params=*/funcArgs,
  75       /*isVarArg=*/false);
  76
  77    return functionType;
  78 }
  79
  80 static inline void
  81 add_interpolator(struct gallivm_ir *ir,
  82                  struct gallivm_interpolate *interp)
  83 {
  84    ir->interpolators[ir->num_interp] = *interp;
  85    ++ir->num_interp;
  86 }
  87
  88 static void
  89 translate_declaration(struct gallivm_ir *prog,
  90                       llvm::Module *module,
  91                       Storage *storage,
  92                       struct tgsi_full_declaration *decl,
  93                       struct tgsi_full_declaration *fd)
  94 {
  95    if (decl->Declaration.File == TGSI_FILE_INPUT) {
  96       unsigned first, last, mask;
  97       uint interp_method;
  98
  99       assert(decl->Declaration.Declare == TGSI_DECLARE_RANGE);
 100
 101       first = decl->u.DeclarationRange.First;
 102       last = decl->u.DeclarationRange.Last;
 103       mask = decl->Declaration.UsageMask;
 104
 105       /* Do not touch WPOS.xy */
 106       if (first == 0) {
 107          mask &= ~TGSI_WRITEMASK_XY;
 108          if (mask == TGSI_WRITEMASK_NONE) {
 109             first++;
 110             if (first > last) {
 111                return;
 112             }
 113          }
 114       }
 115
 116       interp_method = decl->Interpolation.Interpolate;
 117
 118       if (mask == TGSI_WRITEMASK_XYZW) {
 119          unsigned i, j;
 120
 121          for (i = first; i <= last; i++) {
 122             for (j = 0; j < NUM_CHANNELS; j++) {
 123                //interp( mach, i, j );
 124                struct gallivm_interpolate interp;
 125                interp.type = interp_method;
 126                interp.attrib = i;
 127                interp.chan = j;
 128                add_interpolator(prog, &interp);
 129             }
 130          }
 131       } else {
 132          unsigned i, j;
 133          for( j = 0; j < NUM_CHANNELS; j++ ) {
 134             if( mask & (1 << j) ) {
 135                for( i = first; i <= last; i++ ) {
 136                   struct gallivm_interpolate interp;
 137                   interp.type = interp_method;
 138                   interp.attrib = i;
 139                   interp.chan = j;
 140                   add_interpolator(prog, &interp);
 141                }
 142             }
 143          }
 144       }
 145    }
 146 }
 147
 148 static void
 149 translate_declarationir(struct gallivm_ir *,
 150                       llvm::Module *,
 151                       StorageSoa *storage,
 152                       struct tgsi_full_declaration *decl,
 153                       struct tgsi_full_declaration *)
 154 {
 155    if (decl->Declaration.File == TGSI_FILE_ADDRESS) {
 156       int idx = decl->u.DeclarationRange.First;
 157       storage->addAddress(idx);
 158    }
 159 }
 160
 161 static void
 162 translate_immediate(Storage *storage,
 163                     struct tgsi_full_immediate *imm)
 164 {
 165    float vec[4];
 166    int i;
 167    for (i = 0; i < imm->Immediate.Size - 1; ++i) {
 168       switch (imm->Immediate.DataType) {
 169       case TGSI_IMM_FLOAT32:
 170          vec[i] = imm->u.ImmediateFloat32[i].Float;
 171          break;
 172       default:
 173          assert(0);
 174       }
 175    }
 176    storage->addImmediate(vec);
 177 }
 178
 179
 180 static void
 181 translate_immediateir(StorageSoa *storage,
 182                       struct tgsi_full_immediate *imm)
 183 {
 184    float vec[4];
 185    int i;
 186    for (i = 0; i < imm->Immediate.Size - 1; ++i) {
 187       switch (imm->Immediate.DataType) {
 188       case TGSI_IMM_FLOAT32:
 189          vec[i] = imm->u.ImmediateFloat32[i].Float;
 190          break;
 191       default:
 192          assert(0);
 193       }
 194    }
 195    storage->addImmediate(vec);
 196 }
 197
 198 static inline int
 199 swizzleInt(struct tgsi_full_src_register *src)
 200 {
 201    int swizzle = 0;
 202    int start = 1000;
 203
 204    for (int k = 0; k < 4; ++k) {
 205       swizzle += tgsi_util_get_full_src_register_extswizzle(src, k) * start;
 206       start /= 10;
 207    }
 208    return swizzle;
 209 }
 210
 211 static inline llvm::Value *
 212 swizzleVector(llvm::Value *val, struct tgsi_full_src_register *src,
 213               Storage *storage)
 214 {
 215    int swizzle = swizzleInt(src);
 216
 217    if (gallivm_is_swizzle(swizzle)) {
 218       /*fprintf(stderr, "XXXXXXXX swizzle = %d\n", swizzle);*/
 219       val = storage->shuffleVector(val, swizzle);
 220    }
 221    return val;
 222 }
 223
 224 static void
 225 translate_instruction(llvm::Module *module,
 226                       Storage *storage,
 227                       Instructions *instr,
 228                       struct tgsi_full_instruction *inst,
 229                       struct tgsi_full_instruction *fi,
 230                       unsigned instno)
 231 {
 232    llvm::Value *inputs[4];
 233    inputs[0] = 0;
 234    inputs[1] = 0;
 235    inputs[2] = 0;
 236    inputs[3] = 0;
 237
 238    for (int i = 0; i < inst->Instruction.NumSrcRegs; ++i) {
 239       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
 240       llvm::Value *val = 0;
 241       llvm::Value *indIdx = 0;
 242
 243       if (src->SrcRegister.Indirect) {
 244          indIdx = storage->addrElement(src->SrcRegisterInd.Index);
 245          indIdx = storage->extractIndex(indIdx);
 246       }
 247       if (src->SrcRegister.File == TGSI_FILE_CONSTANT) {
 248          val = storage->constElement(src->SrcRegister.Index, indIdx);
 249       } else if (src->SrcRegister.File == TGSI_FILE_INPUT) {
 250          val = storage->inputElement(src->SrcRegister.Index, indIdx);
 251       } else if (src->SrcRegister.File == TGSI_FILE_TEMPORARY) {
 252          val = storage->tempElement(src->SrcRegister.Index);
 253       } else if (src->SrcRegister.File == TGSI_FILE_OUTPUT) {
 254          val = storage->outputElement(src->SrcRegister.Index, indIdx);
 255       } else if (src->SrcRegister.File == TGSI_FILE_IMMEDIATE) {
 256          val = storage->immediateElement(src->SrcRegister.Index);
 257       } else {
 258          fprintf(stderr, "ERROR: not supported llvm source %d\n", src->SrcRegister.File);
 259          return;
 260       }
 261
 262       inputs[i] = swizzleVector(val, src, storage);
 263    }
 264
 265    /*if (inputs[0])
 266      instr->printVector(inputs[0]);
 267      if (inputs[1])
 268      instr->printVector(inputs[1]);*/
 269    llvm::Value *out = 0;
 270    switch (inst->Instruction.Opcode) {
 271    case TGSI_OPCODE_ARL: {
 272       out = instr->arl(inputs[0]);
 273    }
 274       break;
 275    case TGSI_OPCODE_MOV: {
 276       out = inputs[0];
 277    }
 278       break;
 279    case TGSI_OPCODE_LIT: {
 280       out = instr->lit(inputs[0]);
 281    }
 282       break;
 283    case TGSI_OPCODE_RCP: {
 284       out = instr->rcp(inputs[0]);
 285    }
 286       break;
 287    case TGSI_OPCODE_RSQ: {
 288       out = instr->rsq(inputs[0]);
 289    }
 290       break;
 291    case TGSI_OPCODE_EXP:
 292       break;
 293    case TGSI_OPCODE_LOG:
 294       break;
 295    case TGSI_OPCODE_MUL: {
 296       out = instr->mul(inputs[0], inputs[1]);
 297    }
 298       break;
 299    case TGSI_OPCODE_ADD: {
 300       out = instr->add(inputs[0], inputs[1]);
 301    }
 302       break;
 303    case TGSI_OPCODE_DP3: {
 304       out = instr->dp3(inputs[0], inputs[1]);
 305    }
 306       break;
 307    case TGSI_OPCODE_DP4: {
 308       out = instr->dp4(inputs[0], inputs[1]);
 309    }
 310       break;
 311    case TGSI_OPCODE_DST: {
 312       out = instr->dst(inputs[0], inputs[1]);
 313    }
 314       break;
 315    case TGSI_OPCODE_MIN: {
 316       out = instr->min(inputs[0], inputs[1]);
 317    }
 318       break;
 319    case TGSI_OPCODE_MAX: {
 320       out = instr->max(inputs[0], inputs[1]);
 321    }
 322       break;
 323    case TGSI_OPCODE_SLT: {
 324       out = instr->slt(inputs[0], inputs[1]);
 325    }
 326       break;
 327    case TGSI_OPCODE_SGE: {
 328       out = instr->sge(inputs[0], inputs[1]);
 329    }
 330       break;
 331    case TGSI_OPCODE_MAD: {
 332       out = instr->madd(inputs[0], inputs[1], inputs[2]);
 333    }
 334       break;
 335    case TGSI_OPCODE_SUB: {
 336       out = instr->sub(inputs[0], inputs[1]);
 337    }
 338       break;
 339    case TGSI_OPCODE_LERP: {
 340       out = instr->lerp(inputs[0], inputs[1], inputs[2]);
 341    }
 342       break;
 343    case TGSI_OPCODE_CND:
 344       break;
 345    case TGSI_OPCODE_CND0:
 346       break;
 347    case TGSI_OPCODE_DOT2ADD:
 348       break;
 349    case TGSI_OPCODE_INDEX:
 350       break;
 351    case TGSI_OPCODE_NEGATE:
 352       break;
 353    case TGSI_OPCODE_FRAC: {
 354       out = instr->frc(inputs[0]);
 355    }
 356       break;
 357    case TGSI_OPCODE_CLAMP:
 358       break;
 359    case TGSI_OPCODE_FLOOR: {
 360       out = instr->floor(inputs[0]);
 361    }
 362       break;
 363    case TGSI_OPCODE_ROUND:
 364       break;
 365    case TGSI_OPCODE_EXPBASE2: {
 366       out = instr->ex2(inputs[0]);
 367    }
 368       break;
 369    case TGSI_OPCODE_LOGBASE2: {
 370       out = instr->lg2(inputs[0]);
 371    }
 372       break;
 373    case TGSI_OPCODE_POWER: {
 374       out = instr->pow(inputs[0], inputs[1]);
 375    }
 376       break;
 377    case TGSI_OPCODE_CROSSPRODUCT: {
 378       out = instr->cross(inputs[0], inputs[1]);
 379    }
 380       break;
 381    case TGSI_OPCODE_MULTIPLYMATRIX:
 382       break;
 383    case TGSI_OPCODE_ABS: {
 384       out = instr->abs(inputs[0]);
 385    }
 386       break;
 387    case TGSI_OPCODE_RCC:
 388       break;
 389    case TGSI_OPCODE_DPH: {
 390       out = instr->dph(inputs[0], inputs[1]);
 391    }
 392       break;
 393    case TGSI_OPCODE_COS: {
 394       out = instr->cos(inputs[0]);
 395    }
 396       break;
 397    case TGSI_OPCODE_DDX:
 398       break;
 399    case TGSI_OPCODE_DDY:
 400       break;
 401    case TGSI_OPCODE_KILP: {
 402       out = instr->kilp(inputs[0]);
 403       storage->setKilElement(out);
 404       return;
 405    }
 406       break;
 407    case TGSI_OPCODE_PK2H:
 408       break;
 409    case TGSI_OPCODE_PK2US:
 410       break;
 411    case TGSI_OPCODE_PK4B:
 412       break;
 413    case TGSI_OPCODE_PK4UB:
 414       break;
 415    case TGSI_OPCODE_RFL:
 416       break;
 417    case TGSI_OPCODE_SEQ:
 418       break;
 419    case TGSI_OPCODE_SFL:
 420       break;
 421    case TGSI_OPCODE_SGT: {
 422       out = instr->sgt(inputs[0], inputs[1]);
 423    }
 424       break;
 425    case TGSI_OPCODE_SIN: {
 426       out = instr->sin(inputs[0]);
 427    }
 428       break;
 429    case TGSI_OPCODE_SLE:
 430       break;
 431    case TGSI_OPCODE_SNE:
 432       break;
 433    case TGSI_OPCODE_STR:
 434       break;
 435    case TGSI_OPCODE_TEX:
 436       break;
 437    case TGSI_OPCODE_TXD:
 438       break;
 439    case TGSI_OPCODE_UP2H:
 440       break;
 441    case TGSI_OPCODE_UP2US:
 442       break;
 443    case TGSI_OPCODE_UP4B:
 444       break;
 445    case TGSI_OPCODE_UP4UB:
 446       break;
 447    case TGSI_OPCODE_X2D:
 448       break;
 449    case TGSI_OPCODE_ARA:
 450       break;
 451    case TGSI_OPCODE_ARR:
 452       break;
 453    case TGSI_OPCODE_BRA:
 454       break;
 455    case TGSI_OPCODE_CAL: {
 456       instr->cal(inst->InstructionExtLabel.Label, storage->inputPtr());
 457       return;
 458    }
 459       break;
 460    case TGSI_OPCODE_RET: {
 461       instr->end();
 462       return;
 463    }
 464       break;
 465    case TGSI_OPCODE_SSG:
 466       break;
 467    case TGSI_OPCODE_CMP: {
 468       out = instr->cmp(inputs[0], inputs[1], inputs[2]);
 469    }
 470       break;
 471    case TGSI_OPCODE_SCS: {
 472       out = instr->scs(inputs[0]);
 473    }
 474       break;
 475    case TGSI_OPCODE_TXB:
 476       break;
 477    case TGSI_OPCODE_NRM:
 478       break;
 479    case TGSI_OPCODE_DIV:
 480       break;
 481    case TGSI_OPCODE_DP2:
 482       break;
 483    case TGSI_OPCODE_TXL:
 484       break;
 485    case TGSI_OPCODE_BRK: {
 486       instr->brk();
 487       return;
 488    }
 489       break;
 490    case TGSI_OPCODE_IF: {
 491       instr->ifop(inputs[0]);
 492       storage->setCurrentBlock(instr->currentBlock());
 493       return;  //just update the state
 494    }
 495       break;
 496    case TGSI_OPCODE_LOOP:
 497       break;
 498    case TGSI_OPCODE_REP:
 499       break;
 500    case TGSI_OPCODE_ELSE: {
 501       instr->elseop();
 502       storage->setCurrentBlock(instr->currentBlock());
 503       return; //only state update
 504    }
 505       break;
 506    case TGSI_OPCODE_ENDIF: {
 507       instr->endif();
 508       storage->setCurrentBlock(instr->currentBlock());
 509       return; //just update the state
 510    }
 511       break;
 512    case TGSI_OPCODE_ENDLOOP:
 513       break;
 514    case TGSI_OPCODE_ENDREP:
 515       break;
 516    case TGSI_OPCODE_PUSHA:
 517       break;
 518    case TGSI_OPCODE_POPA:
 519       break;
 520    case TGSI_OPCODE_CEIL:
 521       break;
 522    case TGSI_OPCODE_I2F:
 523       break;
 524    case TGSI_OPCODE_NOT:
 525       break;
 526    case TGSI_OPCODE_TRUNC: {
 527       out = instr->trunc(inputs[0]);
 528    }
 529       break;
 530    case TGSI_OPCODE_SHL:
 531       break;
 532    case TGSI_OPCODE_SHR:
 533       break;
 534    case TGSI_OPCODE_AND:
 535       break;
 536    case TGSI_OPCODE_OR:
 537       break;
 538    case TGSI_OPCODE_MOD:
 539       break;
 540    case TGSI_OPCODE_XOR:
 541       break;
 542    case TGSI_OPCODE_SAD:
 543       break;
 544    case TGSI_OPCODE_TXF:
 545       break;
 546    case TGSI_OPCODE_TXQ:
 547       break;
 548    case TGSI_OPCODE_CONT:
 549       break;
 550    case TGSI_OPCODE_EMIT:
 551       break;
 552    case TGSI_OPCODE_ENDPRIM:
 553       break;
 554    case TGSI_OPCODE_BGNLOOP2: {
 555       instr->beginLoop();
 556       storage->setCurrentBlock(instr->currentBlock());
 557       return;
 558    }
 559       break;
 560    case TGSI_OPCODE_BGNSUB: {
 561       instr->bgnSub(instno);
 562       storage->setCurrentBlock(instr->currentBlock());
 563       storage->pushTemps();
 564       return;
 565    }
 566       break;
 567    case TGSI_OPCODE_ENDLOOP2: {
 568       instr->endLoop();
 569       storage->setCurrentBlock(instr->currentBlock());
 570       return;
 571    }
 572       break;
 573    case TGSI_OPCODE_ENDSUB: {
 574       instr->endSub();
 575       storage->setCurrentBlock(instr->currentBlock());
 576       storage->popArguments();
 577       storage->popTemps();
 578       return;
 579    }
 580       break;
 581    case TGSI_OPCODE_NOISE1:
 582       break;
 583    case TGSI_OPCODE_NOISE2:
 584       break;
 585    case TGSI_OPCODE_NOISE3:
 586       break;
 587    case TGSI_OPCODE_NOISE4:
 588       break;
 589    case TGSI_OPCODE_NOP:
 590       break;
 591    case TGSI_OPCODE_TEXBEM:
 592       break;
 593    case TGSI_OPCODE_TEXBEML:
 594       break;
 595    case TGSI_OPCODE_TEXREG2AR:
 596       break;
 597    case TGSI_OPCODE_TEXM3X2PAD:
 598       break;
 599    case TGSI_OPCODE_TEXM3X2TEX:
 600       break;
 601    case TGSI_OPCODE_TEXM3X3PAD:
 602       break;
 603    case TGSI_OPCODE_TEXM3X3TEX:
 604       break;
 605    case TGSI_OPCODE_TEXM3X3SPEC:
 606       break;
 607    case TGSI_OPCODE_TEXM3X3VSPEC:
 608       break;
 609    case TGSI_OPCODE_TEXREG2GB:
 610       break;
 611    case TGSI_OPCODE_TEXREG2RGB:
 612       break;
 613    case TGSI_OPCODE_TEXDP3TEX:
 614       break;
 615    case TGSI_OPCODE_TEXDP3:
 616       break;
 617    case TGSI_OPCODE_TEXM3X3:
 618       break;
 619    case TGSI_OPCODE_TEXM3X2DEPTH:
 620       break;
 621    case TGSI_OPCODE_TEXDEPTH:
 622       break;
 623    case TGSI_OPCODE_BEM:
 624       break;
 625    case TGSI_OPCODE_M4X3:
 626       break;
 627    case TGSI_OPCODE_M3X4:
 628       break;
 629    case TGSI_OPCODE_M3X3:
 630       break;
 631    case TGSI_OPCODE_M3X2:
 632       break;
 633    case TGSI_OPCODE_NRM4:
 634       break;
 635    case TGSI_OPCODE_CALLNZ:
 636       break;
 637    case TGSI_OPCODE_IFC:
 638       break;
 639    case TGSI_OPCODE_BREAKC:
 640       break;
 641    case TGSI_OPCODE_KIL:
 642       break;
 643    case TGSI_OPCODE_END:
 644       instr->end();
 645       return;
 646       break;
 647    default:
 648       fprintf(stderr, "ERROR: Unknown opcode %d\n",
 649               inst->Instruction.Opcode);
 650       assert(0);
 651       break;
 652    }
 653
 654    if (!out) {
 655       fprintf(stderr, "ERROR: unsupported opcode %d\n",
 656               inst->Instruction.Opcode);
 657       assert(!"Unsupported opcode");
 658    }
 659
 660    /* # not sure if we need this */
 661    switch( inst->Instruction.Saturate ) {
 662    case TGSI_SAT_NONE:
 663       break;
 664    case TGSI_SAT_ZERO_ONE:
 665       /*TXT( "_SAT" );*/
 666       break;
 667    case TGSI_SAT_MINUS_PLUS_ONE:
 668       /*TXT( "_SAT[-1,1]" );*/
 669       break;
 670    default:
 671       assert( 0 );
 672    }
 673
 674    /* store results  */
 675    for (int i = 0; i < inst->Instruction.NumDstRegs; ++i) {
 676       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
 677
 678       if (dst->DstRegister.File == TGSI_FILE_OUTPUT) {
 679          storage->setOutputElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
 680       } else if (dst->DstRegister.File == TGSI_FILE_TEMPORARY) {
 681          storage->setTempElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
 682       } else if (dst->DstRegister.File == TGSI_FILE_ADDRESS) {
 683          storage->setAddrElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
 684       } else {
 685          fprintf(stderr, "ERROR: unsupported LLVM destination!");
 686          assert(!"wrong destination");
 687       }
 688    }
 689 }
 690
 691
 692 static void
 693 translate_instructionir(llvm::Module *module,
 694                         StorageSoa *storage,
 695                         InstructionsSoa *instr,
 696                         struct tgsi_full_instruction *inst,
 697                         struct tgsi_full_instruction *fi,
 698                         unsigned instno)
 699 {
 700    std::vector< std::vector<llvm::Value*> > inputs(inst->Instruction.NumSrcRegs);
 701
 702    for (int i = 0; i < inst->Instruction.NumSrcRegs; ++i) {
 703       struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
 704       std::vector<llvm::Value*> val;
 705       llvm::Value *indIdx = 0;
 706       int swizzle = swizzleInt(src);
 707
 708       if (src->SrcRegister.Indirect) {
 709          indIdx = storage->addrElement(src->SrcRegisterInd.Index);
 710       }
 711       if (src->SrcRegister.File == TGSI_FILE_CONSTANT) {
 712          val = storage->load(StorageSoa::Const,
 713                              src->SrcRegister.Index, swizzle, indIdx);
 714       } else if (src->SrcRegister.File == TGSI_FILE_INPUT) {
 715          val = storage->load(StorageSoa::Input,
 716                              src->SrcRegister.Index, swizzle, indIdx);
 717       } else if (src->SrcRegister.File == TGSI_FILE_TEMPORARY) {
 718          val = storage->load(StorageSoa::Temp,
 719                              src->SrcRegister.Index, swizzle, indIdx);
 720       } else if (src->SrcRegister.File == TGSI_FILE_OUTPUT) {
 721          val = storage->load(StorageSoa::Output,
 722                              src->SrcRegister.Index, swizzle, indIdx);
 723       } else if (src->SrcRegister.File == TGSI_FILE_IMMEDIATE) {
 724          val = storage->load(StorageSoa::Immediate,
 725                              src->SrcRegister.Index, swizzle, indIdx);
 726       } else {
 727          fprintf(stderr, "ERROR: not supported llvm source %d\n", src->SrcRegister.File);
 728          return;
 729       }
 730
 731       inputs[i] = val;
 732    }
 733
 734    std::vector<llvm::Value*> out(4);
 735    switch (inst->Instruction.Opcode) {
 736    case TGSI_OPCODE_ARL: {
 737       out = instr->arl(inputs[0]);
 738    }
 739       break;
 740    case TGSI_OPCODE_MOV: {
 741       out = inputs[0];
 742    }
 743       break;
 744    case TGSI_OPCODE_LIT: {
 745    }
 746       break;
 747    case TGSI_OPCODE_RCP: {
 748    }
 749       break;
 750    case TGSI_OPCODE_RSQ: {
 751    }
 752       break;
 753    case TGSI_OPCODE_EXP:
 754       break;
 755    case TGSI_OPCODE_LOG:
 756       break;
 757    case TGSI_OPCODE_MUL: {
 758       out = instr->mul(inputs[0], inputs[1]);
 759    }
 760       break;
 761    case TGSI_OPCODE_ADD: {
 762       out = instr->add(inputs[0], inputs[1]);
 763    }
 764       break;
 765    case TGSI_OPCODE_DP3: {
 766    }
 767       break;
 768    case TGSI_OPCODE_DP4: {
 769    }
 770       break;
 771    case TGSI_OPCODE_DST: {
 772    }
 773       break;
 774    case TGSI_OPCODE_MIN: {
 775    }
 776       break;
 777    case TGSI_OPCODE_MAX: {
 778    }
 779       break;
 780    case TGSI_OPCODE_SLT: {
 781    }
 782       break;
 783    case TGSI_OPCODE_SGE: {
 784    }
 785       break;
 786    case TGSI_OPCODE_MAD: {
 787       out = instr->madd(inputs[0], inputs[1], inputs[2]);
 788    }
 789       break;
 790    case TGSI_OPCODE_SUB: {
 791    }
 792       break;
 793    case TGSI_OPCODE_LERP: {
 794    }
 795       break;
 796    case TGSI_OPCODE_CND:
 797       break;
 798    case TGSI_OPCODE_CND0:
 799       break;
 800    case TGSI_OPCODE_DOT2ADD:
 801       break;
 802    case TGSI_OPCODE_INDEX:
 803       break;
 804    case TGSI_OPCODE_NEGATE:
 805       break;
 806    case TGSI_OPCODE_FRAC: {
 807    }
 808       break;
 809    case TGSI_OPCODE_CLAMP:
 810       break;
 811    case TGSI_OPCODE_FLOOR: {
 812    }
 813       break;
 814    case TGSI_OPCODE_ROUND:
 815       break;
 816    case TGSI_OPCODE_EXPBASE2: {
 817    }
 818       break;
 819    case TGSI_OPCODE_LOGBASE2: {
 820    }
 821       break;
 822    case TGSI_OPCODE_POWER: {
 823    }
 824       break;
 825    case TGSI_OPCODE_CROSSPRODUCT: {
 826    }
 827       break;
 828    case TGSI_OPCODE_MULTIPLYMATRIX:
 829       break;
 830    case TGSI_OPCODE_ABS: {
 831    }
 832       break;
 833    case TGSI_OPCODE_RCC:
 834       break;
 835    case TGSI_OPCODE_DPH: {
 836    }
 837       break;
 838    case TGSI_OPCODE_COS: {
 839    }
 840       break;
 841    case TGSI_OPCODE_DDX:
 842       break;
 843    case TGSI_OPCODE_DDY:
 844       break;
 845    case TGSI_OPCODE_KILP: {
 846    }
 847       break;
 848    case TGSI_OPCODE_PK2H:
 849       break;
 850    case TGSI_OPCODE_PK2US:
 851       break;
 852    case TGSI_OPCODE_PK4B:
 853       break;
 854    case TGSI_OPCODE_PK4UB:
 855       break;
 856    case TGSI_OPCODE_RFL:
 857       break;
 858    case TGSI_OPCODE_SEQ:
 859       break;
 860    case TGSI_OPCODE_SFL:
 861       break;
 862    case TGSI_OPCODE_SGT: {
 863    }
 864       break;
 865    case TGSI_OPCODE_SIN: {
 866    }
 867       break;
 868    case TGSI_OPCODE_SLE:
 869       break;
 870    case TGSI_OPCODE_SNE:
 871       break;
 872    case TGSI_OPCODE_STR:
 873       break;
 874    case TGSI_OPCODE_TEX:
 875       break;
 876    case TGSI_OPCODE_TXD:
 877       break;
 878    case TGSI_OPCODE_UP2H:
 879       break;
 880    case TGSI_OPCODE_UP2US:
 881       break;
 882    case TGSI_OPCODE_UP4B:
 883       break;
 884    case TGSI_OPCODE_UP4UB:
 885       break;
 886    case TGSI_OPCODE_X2D:
 887       break;
 888    case TGSI_OPCODE_ARA:
 889       break;
 890    case TGSI_OPCODE_ARR:
 891       break;
 892    case TGSI_OPCODE_BRA:
 893       break;
 894    case TGSI_OPCODE_CAL: {
 895    }
 896       break;
 897    case TGSI_OPCODE_RET: {
 898    }
 899       break;
 900    case TGSI_OPCODE_SSG:
 901       break;
 902    case TGSI_OPCODE_CMP: {
 903    }
 904       break;
 905    case TGSI_OPCODE_SCS: {
 906    }
 907       break;
 908    case TGSI_OPCODE_TXB:
 909       break;
 910    case TGSI_OPCODE_NRM:
 911       break;
 912    case TGSI_OPCODE_DIV:
 913       break;
 914    case TGSI_OPCODE_DP2:
 915       break;
 916    case TGSI_OPCODE_TXL:
 917       break;
 918    case TGSI_OPCODE_BRK: {
 919    }
 920       break;
 921    case TGSI_OPCODE_IF: {
 922    }
 923       break;
 924    case TGSI_OPCODE_LOOP:
 925       break;
 926    case TGSI_OPCODE_REP:
 927       break;
 928    case TGSI_OPCODE_ELSE: {
 929    }
 930       break;
 931    case TGSI_OPCODE_ENDIF: {
 932    }
 933       break;
 934    case TGSI_OPCODE_ENDLOOP:
 935       break;
 936    case TGSI_OPCODE_ENDREP:
 937       break;
 938    case TGSI_OPCODE_PUSHA:
 939       break;
 940    case TGSI_OPCODE_POPA:
 941       break;
 942    case TGSI_OPCODE_CEIL:
 943       break;
 944    case TGSI_OPCODE_I2F:
 945       break;
 946    case TGSI_OPCODE_NOT:
 947       break;
 948    case TGSI_OPCODE_TRUNC: {
 949    }
 950       break;
 951    case TGSI_OPCODE_SHL:
 952       break;
 953    case TGSI_OPCODE_SHR:
 954       break;
 955    case TGSI_OPCODE_AND:
 956       break;
 957    case TGSI_OPCODE_OR:
 958       break;
 959    case TGSI_OPCODE_MOD:
 960       break;
 961    case TGSI_OPCODE_XOR:
 962       break;
 963    case TGSI_OPCODE_SAD:
 964       break;
 965    case TGSI_OPCODE_TXF:
 966       break;
 967    case TGSI_OPCODE_TXQ:
 968       break;
 969    case TGSI_OPCODE_CONT:
 970       break;
 971    case TGSI_OPCODE_EMIT:
 972       break;
 973    case TGSI_OPCODE_ENDPRIM:
 974       break;
 975    case TGSI_OPCODE_BGNLOOP2: {
 976    }
 977       break;
 978    case TGSI_OPCODE_BGNSUB: {
 979    }
 980       break;
 981    case TGSI_OPCODE_ENDLOOP2: {
 982    }
 983       break;
 984    case TGSI_OPCODE_ENDSUB: {
 985    }
 986       break;
 987    case TGSI_OPCODE_NOISE1:
 988       break;
 989    case TGSI_OPCODE_NOISE2:
 990       break;
 991    case TGSI_OPCODE_NOISE3:
 992       break;
 993    case TGSI_OPCODE_NOISE4:
 994       break;
 995    case TGSI_OPCODE_NOP:
 996       break;
 997    case TGSI_OPCODE_TEXBEM:
 998       break;
 999    case TGSI_OPCODE_TEXBEML:
1000       break;
1001    case TGSI_OPCODE_TEXREG2AR:
1002       break;
1003    case TGSI_OPCODE_TEXM3X2PAD:
1004       break;
1005    case TGSI_OPCODE_TEXM3X2TEX:
1006       break;
1007    case TGSI_OPCODE_TEXM3X3PAD:
1008       break;
1009    case TGSI_OPCODE_TEXM3X3TEX:
1010       break;
1011    case TGSI_OPCODE_TEXM3X3SPEC:
1012       break;
1013    case TGSI_OPCODE_TEXM3X3VSPEC:
1014       break;
1015    case TGSI_OPCODE_TEXREG2GB:
1016       break;
1017    case TGSI_OPCODE_TEXREG2RGB:
1018       break;
1019    case TGSI_OPCODE_TEXDP3TEX:
1020       break;
1021    case TGSI_OPCODE_TEXDP3:
1022       break;
1023    case TGSI_OPCODE_TEXM3X3:
1024       break;
1025    case TGSI_OPCODE_TEXM3X2DEPTH:
1026       break;
1027    case TGSI_OPCODE_TEXDEPTH:
1028       break;
1029    case TGSI_OPCODE_BEM:
1030       break;
1031    case TGSI_OPCODE_M4X3:
1032       break;
1033    case TGSI_OPCODE_M3X4:
1034       break;
1035    case TGSI_OPCODE_M3X3:
1036       break;
1037    case TGSI_OPCODE_M3X2:
1038       break;
1039    case TGSI_OPCODE_NRM4:
1040       break;
1041    case TGSI_OPCODE_CALLNZ:
1042       break;
1043    case TGSI_OPCODE_IFC:
1044       break;
1045    case TGSI_OPCODE_BREAKC:
1046       break;
1047    case TGSI_OPCODE_KIL:
1048       break;
1049    case TGSI_OPCODE_END:
1050       instr->end();
1051       return;
1052       break;
1053    default:
1054       fprintf(stderr, "ERROR: Unknown opcode %d\n",
1055               inst->Instruction.Opcode);
1056       assert(0);
1057       break;
1058    }
1059
1060    if (!out[0]) {
1061       fprintf(stderr, "ERROR: unsupported opcode %d\n",
1062               inst->Instruction.Opcode);
1063       assert(!"Unsupported opcode");
1064    }
1065
1066    /* store results  */
1067    for (int i = 0; i < inst->Instruction.NumDstRegs; ++i) {
1068       struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
1069
1070       if (dst->DstRegister.File == TGSI_FILE_OUTPUT) {
1071          storage->store(StorageSoa::Output,
1072                         dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
1073       } else if (dst->DstRegister.File == TGSI_FILE_TEMPORARY) {
1074          storage->store(StorageSoa::Temp,
1075                         dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
1076       } else if (dst->DstRegister.File == TGSI_FILE_ADDRESS) {
1077          storage->store(StorageSoa::Address,
1078                         dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
1079       } else {
1080          fprintf(stderr, "ERROR: unsupported LLVM destination!");
1081          assert(!"wrong destination");
1082       }
1083    }
1084 }
1085
1086 llvm::Module *
1087 tgsi_to_llvm(struct gallivm_ir *ir, const struct tgsi_token *tokens)
1088 {
1089    llvm::Module *mod = new Module("shader");
1090    struct tgsi_parse_context parse;
1091    struct tgsi_full_instruction fi;
1092    struct tgsi_full_declaration fd;
1093    unsigned instno = 0;
1094    Function* shader = mod->getFunction("execute_shader");
1095    std::ostringstream stream;
1096    if (ir->type == GALLIVM_VS) {
1097       stream << "vs_shader";
1098    } else {
1099       stream << "fs_shader";
1100    }
1101    stream << ir->id;
1102    std::string func_name = stream.str();
1103    shader->setName(func_name.c_str());
1104
1105    Function::arg_iterator args = shader->arg_begin();
1106    Value *ptr_INPUT = args++;
1107    ptr_INPUT->setName("input");
1108
1109    BasicBlock *label_entry = new BasicBlock("entry", shader, 0);
1110
1111    tgsi_parse_init(&parse, tokens);
1112
1113    fi = tgsi_default_full_instruction();
1114    fd = tgsi_default_full_declaration();
1115    Storage storage(label_entry, ptr_INPUT);
1116    Instructions instr(mod, shader, label_entry, &storage);
1117    while(!tgsi_parse_end_of_tokens(&parse)) {
1118       tgsi_parse_token(&parse);
1119
1120       switch (parse.FullToken.Token.Type) {
1121       case TGSI_TOKEN_TYPE_DECLARATION:
1122          translate_declaration(ir, mod, &storage,
1123                                &parse.FullToken.FullDeclaration,
1124                                &fd);
1125          break;
1126
1127       case TGSI_TOKEN_TYPE_IMMEDIATE:
1128          translate_immediate(&storage,
1129                              &parse.FullToken.FullImmediate);
1130          break;
1131
1132       case TGSI_TOKEN_TYPE_INSTRUCTION:
1133          translate_instruction(mod, &storage, &instr,
1134                                &parse.FullToken.FullInstruction,
1135                                &fi, instno);
1136          ++instno;
1137          break;
1138
1139       default:
1140          assert(0);
1141       }
1142    }
1143
1144    tgsi_parse_free(&parse);
1145
1146    ir->num_consts = storage.numConsts();
1147    return mod;
1148 }
1149
1150 llvm::Module * tgsi_to_llvmir(struct gallivm_ir *ir,
1151                               const struct tgsi_token *tokens)
1152 {
1153    llvm::Module *mod = new Module("shader");
1154    struct tgsi_parse_context parse;
1155    struct tgsi_full_instruction fi;
1156    struct tgsi_full_declaration fd;
1157    unsigned instno = 0;
1158    std::ostringstream stream;
1159    if (ir->type == GALLIVM_VS) {
1160       stream << "vs_shader";
1161    } else {
1162       stream << "fs_shader";
1163    }
1164    //stream << ir->id;
1165    std::string func_name = stream.str();
1166    Function *shader = llvm::cast<Function>(mod->getOrInsertFunction(
1167                                               func_name.c_str(),
1168                                               vertexShaderFunctionType()));
1169
1170    Function::arg_iterator args = shader->arg_begin();
1171    Value *input = args++;
1172    input->setName("inputs");
1173    Value *output = args++;
1174    output->setName("outputs");
1175    Value *consts = args++;
1176    consts->setName("consts");
1177    Value *temps = args++;
1178    temps->setName("temps");
1179
1180    BasicBlock *label_entry = new BasicBlock("entry", shader, 0);
1181
1182    tgsi_parse_init(&parse, tokens);
1183
1184    fi = tgsi_default_full_instruction();
1185    fd = tgsi_default_full_declaration();
1186
1187    StorageSoa storage(label_entry, input, output, consts, temps);
1188    InstructionsSoa instr(mod, shader, label_entry, &storage);
1189
1190    while(!tgsi_parse_end_of_tokens(&parse)) {
1191       tgsi_parse_token(&parse);
1192
1193       switch (parse.FullToken.Token.Type) {
1194       case TGSI_TOKEN_TYPE_DECLARATION:
1195          translate_declarationir(ir, mod, &storage,
1196                                  &parse.FullToken.FullDeclaration,
1197                                  &fd);
1198          break;
1199
1200       case TGSI_TOKEN_TYPE_IMMEDIATE:
1201          translate_immediateir(&storage,
1202                              &parse.FullToken.FullImmediate);
1203          break;
1204
1205       case TGSI_TOKEN_TYPE_INSTRUCTION:
1206          storage.declareImmediates();
1207          translate_instructionir(mod, &storage, &instr,
1208                                  &parse.FullToken.FullInstruction,
1209                                  &fi, instno);
1210          ++instno;
1211          break;
1212
1213       default:
1214          assert(0);
1215       }
1216    }
1217
1218    tgsi_parse_free(&parse);
1219
1220    return mod;
1221 }