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