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