fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-03-06 16:30:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

rewrite the way we handle ir in llvm code

Browse source 
introduce intermediate step gallivm_ir before compiling it
down to the final llvm ir.
This commit is contained in:
Zack Rusin 2008-02-04 10:07:02 -05:00
parent f625c6d1d0
commit 7d69090e27
11 changed files with 1072 additions and 963 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/mesa/pipe/cell/ppu/cell_state_fs.c
View file

@ -67,7 +67,7 @@ cell_create_fs_state(struct pipe_context *pipe,
#endif
#ifdef MESA_LLVM
state->llvm_prog = gallivm_from_tgsi(state->shader.tokens, GALLIVM_FS);
state->llvm_prog = 0;
if (!gallivm_global_cpu_engine()) {
gallivm_cpu_engine_create(state->llvm_prog);
}

27
src/mesa/pipe/draw/draw_vertex_shader.c
View file

@ -113,7 +113,16 @@ run_vertex_program(struct draw_context *draw,
draw->vertex_fetch.fetch_func( draw, machine, elts, count );
/* run shader */
#if defined(__i386__) || defined(__386__)
#ifdef MESA_LLVM
if (1) {
struct gallivm_prog *prog = draw->vertex_shader->llvm_prog;
gallivm_prog_exec(prog,
machine->Inputs,
machine->Outputs,
machine->Consts,
12, 12, 12);
} else
#elif defined(__i386__) || defined(__386__)
if (draw->use_sse) {
/* SSE */
/* cast away const */
@ -212,13 +221,7 @@ draw_vertex_shader_queue_flush(struct draw_context *draw)
*/
draw_update_vertex_fetch( draw );
// debug_printf( " q(%d) ", draw->vs.queue_nr );
#ifdef MESA_LLVM
if (draw->vertex_shader->llvm_prog) {
draw_vertex_shader_queue_flush_llvm(draw);
return;
}
#endif
// fprintf(stderr, " q(%d) ", draw->vs.queue_nr );
/* run vertex shader on vertex cache entries, four per invokation */
for (i = 0; i < draw->vs.queue_nr; i += 4) {
@ -260,7 +263,13 @@ draw_create_vertex_shader(struct draw_context *draw,
vs->state = shader;
#ifdef MESA_LLVM
vs->llvm_prog = gallivm_from_tgsi(shader->tokens, GALLIVM_VS);
struct gallivm_ir *ir = gallivm_ir_new(GALLIVM_VS);
gallivm_ir_set_layout(ir, GALLIVM_SOA);
gallivm_ir_set_components(ir, 4);
gallivm_ir_fill_from_tgsi(ir, shader->tokens);
vs->llvm_prog = gallivm_ir_compile(ir);
gallivm_ir_delete(ir);
draw->engine = gallivm_global_cpu_engine();
if (!draw->engine) {
draw->engine = gallivm_cpu_engine_create(vs->llvm_prog);

1
src/mesa/pipe/llvm/Makefile
View file

@ -9,6 +9,7 @@ GALLIVM_SOURCES = \
gallivm.cpp \
instructions.cpp \
loweringpass.cpp \
tgsitollvm.cpp \
storage.cpp
INC_SOURCES = gallivm_builtins.cpp llvm_base_shader.cpp

799
src/mesa/pipe/llvm/gallivm.cpp
View file

@ -32,17 +32,17 @@
#ifdef MESA_LLVM
#include "gallivm.h"
#include "gallivm_p.h"
#include "instructions.h"
#include "loweringpass.h"
#include "storage.h"
#include "tgsitollvm.h"
#include "pipe/p_context.h"
#include "pipe/p_shader_tokens.h"
#include "pipe/tgsi/util/tgsi_parse.h"
#include "pipe/tgsi/exec/tgsi_exec.h"
#include "pipe/tgsi/util/tgsi_util.h"
#include "pipe/tgsi/util/tgsi_build.h"
#include "pipe/tgsi/util/tgsi_dump.h"
#include <llvm/Module.h>
@ -64,38 +64,23 @@
#include <llvm/Analysis/LoopPass.h>
#include <llvm/Target/TargetData.h>
#include <llvm/Bitcode/ReaderWriter.h>
#include <llvm/Transforms/Utils/Cloning.h>
#include <sstream>
#include <fstream>
#include <iostream>
struct gallivm_interpolate {
int attrib;
int chan;
int type;
};
struct gallivm_prog {
llvm::Module *module;
void *function;
int num_consts;
int id;
enum gallivm_shader_type type;
struct gallivm_interpolate interpolators[32*4]; //FIXME: this might not be enough for some shaders
int num_interp;
};
struct gallivm_cpu_engine {
llvm::ExecutionEngine *engine;
};
using namespace llvm;
#include "llvm_base_shader.cpp"
static int GLOBAL_ID = 0;
static inline void AddStandardCompilePasses(PassManager &PM) {
using namespace llvm;
static inline
void AddStandardCompilePasses(PassManager &PM)
{
PM.add(new LoweringPass());
PM.add(createVerifierPass()); // Verify that input is correct
@ -152,691 +137,16 @@ static inline void AddStandardCompilePasses(PassManager &PM) {
PM.add(createConstantMergePass()); // Merge dup global constants
}
static inline void
add_interpolator(struct gallivm_prog *prog,
struct gallivm_interpolate *interp)
{
prog->interpolators[prog->num_interp] = *interp;
++prog->num_interp;
}
static void
translate_declaration(struct gallivm_prog *prog,
llvm::Module *module,
Storage *storage,
struct tgsi_full_declaration *decl,
struct tgsi_full_declaration *fd)
{
if (decl->Declaration.File == TGSI_FILE_INPUT) {
unsigned first, last, mask;
uint interp_method;
assert(decl->Declaration.Declare == TGSI_DECLARE_RANGE);
first = decl->u.DeclarationRange.First;
last = decl->u.DeclarationRange.Last;
mask = decl->Declaration.UsageMask;
/* Do not touch WPOS.xy */
if (first == 0) {
mask &= ~TGSI_WRITEMASK_XY;
if (mask == TGSI_WRITEMASK_NONE) {
first++;
if (first > last) {
return;
}
}
}
interp_method = decl->Interpolation.Interpolate;
if (mask == TGSI_WRITEMASK_XYZW) {
unsigned i, j;
for (i = first; i <= last; i++) {
for (j = 0; j < NUM_CHANNELS; j++) {
//interp( mach, i, j );
struct gallivm_interpolate interp;
interp.type = interp_method;
interp.attrib = i;
interp.chan = j;
add_interpolator(prog, &interp);
}
}
} else {
unsigned i, j;
for( j = 0; j < NUM_CHANNELS; j++ ) {
if( mask & (1 << j) ) {
for( i = first; i <= last; i++ ) {
struct gallivm_interpolate interp;
interp.type = interp_method;
interp.attrib = i;
interp.chan = j;
add_interpolator(prog, &interp);
}
}
}
}
}
}
static void
translate_immediate(Storage *storage,
struct tgsi_full_immediate *imm)
{
float vec[4];
int i;
for (i = 0; i < imm->Immediate.Size - 1; ++i) {
switch( imm->Immediate.DataType ) {
case TGSI_IMM_FLOAT32:
vec[i] = imm->u.ImmediateFloat32[i].Float;
break;
default:
assert( 0 );
}
}
storage->addImmediate(vec);
}
static inline llvm::Value *
swizzleVector(llvm::Value *val, struct tgsi_full_src_register *src,
Storage *storage)
{
int swizzle = 0;
int start = 1000;
const int NO_SWIZZLE = TGSI_SWIZZLE_X * 1000 + TGSI_SWIZZLE_Y * 100 +
TGSI_SWIZZLE_Z * 10 + TGSI_SWIZZLE_W;
for (int k = 0; k < 4; ++k) {
swizzle += tgsi_util_get_full_src_register_extswizzle(src, k) * start;
start /= 10;
}
if (swizzle != NO_SWIZZLE) {
/*fprintf(stderr, "XXXXXXXX swizzle = %d\n", swizzle);*/
val = storage->shuffleVector(val, swizzle);
}
return val;
}
static void
translate_instruction(llvm::Module *module,
Storage *storage,
Instructions *instr,
struct tgsi_full_instruction *inst,
struct tgsi_full_instruction *fi,
unsigned instno)
{
llvm::Value *inputs[4];
inputs[0] = 0;
inputs[1] = 0;
inputs[2] = 0;
inputs[3] = 0;
for (int i = 0; i < inst->Instruction.NumSrcRegs; ++i) {
struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
llvm::Value *val = 0;
llvm::Value *indIdx = 0;
if (src->SrcRegister.Indirect) {
indIdx = storage->addrElement(src->SrcRegisterInd.Index);
indIdx = storage->extractIndex(indIdx);
}
if (src->SrcRegister.File == TGSI_FILE_CONSTANT) {
val = storage->constElement(src->SrcRegister.Index, indIdx);
} else if (src->SrcRegister.File == TGSI_FILE_INPUT) {
val = storage->inputElement(src->SrcRegister.Index, indIdx);
} else if (src->SrcRegister.File == TGSI_FILE_TEMPORARY) {
val = storage->tempElement(src->SrcRegister.Index);
} else if (src->SrcRegister.File == TGSI_FILE_OUTPUT) {
val = storage->outputElement(src->SrcRegister.Index, indIdx);
} else if (src->SrcRegister.File == TGSI_FILE_IMMEDIATE) {
val = storage->immediateElement(src->SrcRegister.Index);
} else {
fprintf(stderr, "ERROR: not supported llvm source %d\n", src->SrcRegister.File);
return;
}
inputs[i] = swizzleVector(val, src, storage);
}
/*if (inputs[0])
instr->printVector(inputs[0]);
if (inputs[1])
instr->printVector(inputs[1]);*/
llvm::Value *out = 0;
switch (inst->Instruction.Opcode) {
case TGSI_OPCODE_ARL: {
out = instr->arl(inputs[0]);
}
break;
case TGSI_OPCODE_MOV: {
out = inputs[0];
}
break;
case TGSI_OPCODE_LIT: {
out = instr->lit(inputs[0]);
}
break;
case TGSI_OPCODE_RCP: {
out = instr->rcp(inputs[0]);
}
break;
case TGSI_OPCODE_RSQ: {
out = instr->rsq(inputs[0]);
}
break;
case TGSI_OPCODE_EXP:
break;
case TGSI_OPCODE_LOG:
break;
case TGSI_OPCODE_MUL: {
out = instr->mul(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_ADD: {
out = instr->add(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_DP3: {
out = instr->dp3(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_DP4: {
out = instr->dp4(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_DST: {
out = instr->dst(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MIN: {
out = instr->min(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MAX: {
out = instr->max(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_SLT: {
out = instr->slt(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_SGE: {
out = instr->sge(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MAD: {
out = instr->madd(inputs[0], inputs[1], inputs[2]);
}
break;
case TGSI_OPCODE_SUB: {
out = instr->sub(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_LERP: {
out = instr->lerp(inputs[0], inputs[1], inputs[2]);
}
break;
case TGSI_OPCODE_CND:
break;
case TGSI_OPCODE_CND0:
break;
case TGSI_OPCODE_DOT2ADD:
break;
case TGSI_OPCODE_INDEX:
break;
case TGSI_OPCODE_NEGATE:
break;
case TGSI_OPCODE_FRAC: {
out = instr->frc(inputs[0]);
}
break;
case TGSI_OPCODE_CLAMP:
break;
case TGSI_OPCODE_FLOOR: {
out = instr->floor(inputs[0]);
}
break;
case TGSI_OPCODE_ROUND:
break;
case TGSI_OPCODE_EXPBASE2: {
out = instr->ex2(inputs[0]);
}
break;
case TGSI_OPCODE_LOGBASE2: {
out = instr->lg2(inputs[0]);
}
break;
case TGSI_OPCODE_POWER: {
out = instr->pow(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_CROSSPRODUCT: {
out = instr->cross(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MULTIPLYMATRIX:
break;
case TGSI_OPCODE_ABS: {
out = instr->abs(inputs[0]);
}
break;
case TGSI_OPCODE_RCC:
break;
case TGSI_OPCODE_DPH: {
out = instr->dph(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_COS: {
out = instr->cos(inputs[0]);
}
break;
case TGSI_OPCODE_DDX:
break;
case TGSI_OPCODE_DDY:
break;
case TGSI_OPCODE_KILP: {
out = instr->kilp(inputs[0]);
storage->setKilElement(out);
return;
}
break;
case TGSI_OPCODE_PK2H:
break;
case TGSI_OPCODE_PK2US:
break;
case TGSI_OPCODE_PK4B:
break;
case TGSI_OPCODE_PK4UB:
break;
case TGSI_OPCODE_RFL:
break;
case TGSI_OPCODE_SEQ:
break;
case TGSI_OPCODE_SFL:
break;
case TGSI_OPCODE_SGT: {
out = instr->sgt(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_SIN: {
out = instr->sin(inputs[0]);
}
break;
case TGSI_OPCODE_SLE:
break;
case TGSI_OPCODE_SNE:
break;
case TGSI_OPCODE_STR:
break;
case TGSI_OPCODE_TEX:
break;
case TGSI_OPCODE_TXD:
break;
case TGSI_OPCODE_UP2H:
break;
case TGSI_OPCODE_UP2US:
break;
case TGSI_OPCODE_UP4B:
break;
case TGSI_OPCODE_UP4UB:
break;
case TGSI_OPCODE_X2D:
break;
case TGSI_OPCODE_ARA:
break;
case TGSI_OPCODE_ARR:
break;
case TGSI_OPCODE_BRA:
break;
case TGSI_OPCODE_CAL: {
instr->cal(inst->InstructionExtLabel.Label, storage->inputPtr());
return;
}
break;
case TGSI_OPCODE_RET: {
instr->end();
return;
}
break;
case TGSI_OPCODE_SSG:
break;
case TGSI_OPCODE_CMP: {
out = instr->cmp(inputs[0], inputs[1], inputs[2]);
}
break;
case TGSI_OPCODE_SCS: {
out = instr->scs(inputs[0]);
}
break;
case TGSI_OPCODE_TXB:
break;
case TGSI_OPCODE_NRM:
break;
case TGSI_OPCODE_DIV:
break;
case TGSI_OPCODE_DP2:
break;
case TGSI_OPCODE_TXL:
break;
case TGSI_OPCODE_BRK: {
instr->brk();
return;
}
break;
case TGSI_OPCODE_IF: {
instr->ifop(inputs[0]);
storage->setCurrentBlock(instr->currentBlock());
return; //just update the state
}
break;
case TGSI_OPCODE_LOOP:
break;
case TGSI_OPCODE_REP:
break;
case TGSI_OPCODE_ELSE: {
instr->elseop();
storage->setCurrentBlock(instr->currentBlock());
return; //only state update
}
break;
case TGSI_OPCODE_ENDIF: {
instr->endif();
storage->setCurrentBlock(instr->currentBlock());
return; //just update the state
}
break;
case TGSI_OPCODE_ENDLOOP:
break;
case TGSI_OPCODE_ENDREP:
break;
case TGSI_OPCODE_PUSHA:
break;
case TGSI_OPCODE_POPA:
break;
case TGSI_OPCODE_CEIL:
break;
case TGSI_OPCODE_I2F:
break;
case TGSI_OPCODE_NOT:
break;
case TGSI_OPCODE_TRUNC: {
out = instr->trunc(inputs[0]);
}
break;
case TGSI_OPCODE_SHL:
break;
case TGSI_OPCODE_SHR:
break;
case TGSI_OPCODE_AND:
break;
case TGSI_OPCODE_OR:
break;
case TGSI_OPCODE_MOD:
break;
case TGSI_OPCODE_XOR:
break;
case TGSI_OPCODE_SAD:
break;
case TGSI_OPCODE_TXF:
break;
case TGSI_OPCODE_TXQ:
break;
case TGSI_OPCODE_CONT:
break;
case TGSI_OPCODE_EMIT:
break;
case TGSI_OPCODE_ENDPRIM:
break;
case TGSI_OPCODE_BGNLOOP2: {
instr->beginLoop();
storage->setCurrentBlock(instr->currentBlock());
return;
}
break;
case TGSI_OPCODE_BGNSUB: {
instr->bgnSub(instno);
storage->setCurrentBlock(instr->currentBlock());
storage->pushTemps();
return;
}
break;
case TGSI_OPCODE_ENDLOOP2: {
instr->endLoop();
storage->setCurrentBlock(instr->currentBlock());
return;
}
break;
case TGSI_OPCODE_ENDSUB: {
instr->endSub();
storage->setCurrentBlock(instr->currentBlock());
storage->popArguments();
storage->popTemps();
return;
}
break;
case TGSI_OPCODE_NOISE1:
break;
case TGSI_OPCODE_NOISE2:
break;
case TGSI_OPCODE_NOISE3:
break;
case TGSI_OPCODE_NOISE4:
break;
case TGSI_OPCODE_NOP:
break;
case TGSI_OPCODE_TEXBEM:
break;
case TGSI_OPCODE_TEXBEML:
break;
case TGSI_OPCODE_TEXREG2AR:
break;
case TGSI_OPCODE_TEXM3X2PAD:
break;
case TGSI_OPCODE_TEXM3X2TEX:
break;
case TGSI_OPCODE_TEXM3X3PAD:
break;
case TGSI_OPCODE_TEXM3X3TEX:
break;
case TGSI_OPCODE_TEXM3X3SPEC:
break;
case TGSI_OPCODE_TEXM3X3VSPEC:
break;
case TGSI_OPCODE_TEXREG2GB:
break;
case TGSI_OPCODE_TEXREG2RGB:
break;
case TGSI_OPCODE_TEXDP3TEX:
break;
case TGSI_OPCODE_TEXDP3:
break;
case TGSI_OPCODE_TEXM3X3:
break;
case TGSI_OPCODE_TEXM3X2DEPTH:
break;
case TGSI_OPCODE_TEXDEPTH:
break;
case TGSI_OPCODE_BEM:
break;
case TGSI_OPCODE_M4X3:
break;
case TGSI_OPCODE_M3X4:
break;
case TGSI_OPCODE_M3X3:
break;
case TGSI_OPCODE_M3X2:
break;
case TGSI_OPCODE_NRM4:
break;
case TGSI_OPCODE_CALLNZ:
break;
case TGSI_OPCODE_IFC:
break;
case TGSI_OPCODE_BREAKC:
break;
case TGSI_OPCODE_KIL:
break;
case TGSI_OPCODE_END:
instr->end();
return;
break;
default:
fprintf(stderr, "ERROR: Unknown opcode %d\n",
inst->Instruction.Opcode);
assert(0);
break;
}
if (!out) {
fprintf(stderr, "ERROR: unsupported opcode %d\n",
inst->Instruction.Opcode);
assert(!"Unsupported opcode");
}
/* # not sure if we need this */
switch( inst->Instruction.Saturate ) {
case TGSI_SAT_NONE:
break;
case TGSI_SAT_ZERO_ONE:
/*TXT( "_SAT" );*/
break;
case TGSI_SAT_MINUS_PLUS_ONE:
/*TXT( "_SAT[-1,1]" );*/
break;
default:
assert( 0 );
}
/* store results */
for (int i = 0; i < inst->Instruction.NumDstRegs; ++i) {
struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
if (dst->DstRegister.File == TGSI_FILE_OUTPUT) {
storage->setOutputElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
} else if (dst->DstRegister.File == TGSI_FILE_TEMPORARY) {
storage->setTempElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
} else if (dst->DstRegister.File == TGSI_FILE_ADDRESS) {
storage->setAddrElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
} else {
fprintf(stderr, "ERROR: unsupported LLVM destination!");
assert(!"wrong destination");
}
}
}
static llvm::Module *
tgsi_to_llvm(struct gallivm_prog *prog, const struct tgsi_token *tokens)
{
llvm::Module *mod = createBaseShader();
struct tgsi_parse_context parse;
struct tgsi_full_instruction fi;
struct tgsi_full_declaration fd;
unsigned instno = 0;
Function* shader = mod->getFunction("execute_shader");
std::ostringstream stream;
if (prog->type == GALLIVM_VS) {
stream << "vs_shader";
} else {
stream << "fs_shader";
}
stream << prog->id;
std::string func_name = stream.str();
shader->setName(func_name.c_str());
Function::arg_iterator args = shader->arg_begin();
Value *ptr_INPUT = args++;
ptr_INPUT->setName("input");
BasicBlock *label_entry = new BasicBlock("entry", shader, 0);
tgsi_parse_init(&parse, tokens);
fi = tgsi_default_full_instruction();
fd = tgsi_default_full_declaration();
Storage storage(label_entry, ptr_INPUT);
Instructions instr(mod, shader, label_entry, &storage);
while(!tgsi_parse_end_of_tokens(&parse)) {
tgsi_parse_token(&parse);
switch (parse.FullToken.Token.Type) {
case TGSI_TOKEN_TYPE_DECLARATION:
translate_declaration(prog, mod, &storage,
&parse.FullToken.FullDeclaration,
&fd);
break;
case TGSI_TOKEN_TYPE_IMMEDIATE:
translate_immediate(&storage,
&parse.FullToken.FullImmediate);
break;
case TGSI_TOKEN_TYPE_INSTRUCTION:
translate_instruction(mod, &storage, &instr,
&parse.FullToken.FullInstruction,
&fi, instno);
++instno;
break;
default:
assert(0);
}
}
tgsi_parse_free(&parse);
prog->num_consts = storage.numConsts();
return mod;
}
/*!
Translates the TGSI tokens into LLVM format. Translated representation
is stored in the gallivm_prog and returned.
After calling this function the gallivm_prog can either be used with a custom
code generator to generate machine code for the GPU which the code generator
addresses or it can be jit compiled with gallivm_cpu_jit_compile and executed
with gallivm_prog_exec to run the module on the CPU.
*/
struct gallivm_prog *
gallivm_from_tgsi(const struct tgsi_token *tokens, enum gallivm_shader_type type)
{
std::cout << "Creating llvm from: " <<std::endl;
++GLOBAL_ID;
struct gallivm_prog *gallivm =
(struct gallivm_prog *)calloc(1, sizeof(struct gallivm_prog));
gallivm->id = GLOBAL_ID;
gallivm->type = type;
tgsi_dump(tokens, 0);
llvm::Module *mod = tgsi_to_llvm(gallivm, tokens);
gallivm->module = mod;
gallivm_prog_dump(gallivm, 0);
/* Run optimization passes over it */
PassManager passes;
passes.add(new TargetData(mod));
AddStandardCompilePasses(passes);
passes.run(*mod);
gallivm->module = mod;
gallivm_prog_dump(gallivm, 0);
return gallivm;
}
void gallivm_prog_delete(struct gallivm_prog *prog)
{
llvm::Module *mod = static_cast<llvm::Module*>(prog->module);
delete mod;
delete prog->module;
prog->module = 0;
prog->function = 0;
free(prog);
}
typedef void (*vertex_shader_runner)(float (*ainputs)[PIPE_MAX_SHADER_INPUTS][4],
float (*dests)[PIPE_MAX_SHADER_INPUTS][4],
typedef void (*vertex_shader_runner)(void *ainputs,
void *dests,
float (*aconsts)[4],
int num_vertices,
int num_inputs,
@ -850,8 +160,8 @@ typedef void (*vertex_shader_runner)(float (*ainputs)[PIPE_MAX_SHADER_INPUTS][4]
function.
*/
int gallivm_prog_exec(struct gallivm_prog *prog,
float (*inputs)[PIPE_MAX_SHADER_INPUTS][4],
float (*dests)[PIPE_MAX_SHADER_INPUTS][4],
struct tgsi_exec_vector *inputs,
struct tgsi_exec_vector *dests,
float (*consts)[4],
int num_vertices,
int num_inputs,
@ -943,18 +253,15 @@ int gallivm_fragment_shader_exec(struct gallivm_prog *prog,
samplers);
}
void gallivm_prog_dump(struct gallivm_prog *prog, const char *file_prefix)
void gallivm_ir_dump(struct gallivm_ir *ir, const char *file_prefix)
{
llvm::Module *mod;
if (!prog || !prog->module)
if (!ir || !ir->module)
return;
mod = static_cast<llvm::Module*>(prog->module);
if (file_prefix) {
std::ostringstream stream;
stream << file_prefix;
stream << prog->id;
stream << ir->id;
stream << ".ll";
std::string name = stream.str();
std::ofstream out(name.c_str());
@ -962,12 +269,12 @@ void gallivm_prog_dump(struct gallivm_prog *prog, const char *file_prefix)
std::cerr<<"Can't open file : "<<stream.str()<<std::endl;;
return;
}
out << (*mod);
out << (*ir->module);
out.close();
} else {
const llvm::Module::FunctionListType &funcs = mod->getFunctionList();
const llvm::Module::FunctionListType &funcs = ir->module->getFunctionList();
llvm::Module::FunctionListType::const_iterator itr;
std::cout<<"; ---------- Start shader "<<prog->id<<std::endl;
std::cout<<"; ---------- Start shader "<<ir->id<<std::endl;
for (itr = funcs.begin(); itr != funcs.end(); ++itr) {
const llvm::Function &func = (*itr);
std::string name = func.getName();
@ -980,7 +287,7 @@ void gallivm_prog_dump(struct gallivm_prog *prog, const char *file_prefix)
std::cout<<*found<<std::endl;
}
}
std::cout<<"; ---------- End shader "<<prog->id<<std::endl;
std::cout<<"; ---------- End shader "<<ir->id<<std::endl;
}
}
@ -1086,9 +393,63 @@ void gallivm_prog_inputs_interpolate(struct gallivm_prog *prog,
}
}
struct gallivm_ir * gallivm_ir_new(enum gallivm_shader_type type)
{
struct gallivm_ir *ir =
(struct gallivm_ir *)calloc(1, sizeof(struct gallivm_ir));
++GLOBAL_ID;
ir->id = GLOBAL_ID;
ir->type = type;
return ir;
}
void gallivm_ir_set_layout(struct gallivm_ir *ir,
enum gallivm_vector_layout layout)
{
ir->layout = layout;
}
void gallivm_ir_set_components(struct gallivm_ir *ir, int num)
{
ir->num_components = num;
}
void gallivm_ir_fill_from_tgsi(struct gallivm_ir *ir,
const struct tgsi_token *tokens)
{
std::cout << "Creating llvm from: " <<std::endl;
tgsi_dump(tokens, 0);
llvm::Module *mod = tgsi_to_llvm(ir, tokens);
ir->module = mod;
gallivm_ir_dump(ir, 0);
}
void gallivm_ir_delete(struct gallivm_ir *ir)
{
delete ir->module;
free(ir);
}
struct gallivm_prog * gallivm_ir_compile(struct gallivm_ir *ir)
{
struct gallivm_prog *prog =
(struct gallivm_prog *)calloc(1, sizeof(struct gallivm_prog));
llvm::Module *mod = llvm::CloneModule(ir->module);
prog->num_consts = ir->num_consts;
memcpy(prog->interpolators, ir->interpolators, sizeof(prog->interpolators));
prog->num_interp = ir->num_interp;
/* Run optimization passes over it */
PassManager passes;
passes.add(new TargetData(mod));
AddStandardCompilePasses(passes);
passes.run(*mod);
prog->module = mod;
return prog;
}
#endif /* MESA_LLVM */

23
src/mesa/pipe/llvm/gallivm.h
View file

@ -43,21 +43,36 @@ extern "C" {
struct tgsi_token;
struct gallivm_ir;
struct gallivm_prog;
struct gallivm_cpu_engine;
struct tgsi_interp_coef;
struct tgsi_sampler;
struct tgsi_exec_vector;
enum gallivm_shader_type {
GALLIVM_VS,
GALLIVM_FS
};
struct gallivm_prog *gallivm_from_tgsi(const struct tgsi_token *tokens, enum gallivm_shader_type type);
void gallivm_prog_delete(struct gallivm_prog *prog);
enum gallivm_vector_layout {
GALLIVM_AOS,
GALLIVM_SOA
};
struct gallivm_ir *gallivm_ir_new(enum gallivm_shader_type type);
void gallivm_ir_set_layout(struct gallivm_ir *prog,
enum gallivm_vector_layout layout);
void gallivm_ir_set_components(struct gallivm_ir *prog, int num);
void gallivm_ir_fill_from_tgsi(struct gallivm_ir *prog,
const struct tgsi_token *tokens);
void gallivm_ir_delete(struct gallivm_ir *prog);
struct gallivm_prog *gallivm_ir_compile(struct gallivm_ir *ir);
int gallivm_prog_exec(struct gallivm_prog *prog,
float (*inputs)[PIPE_MAX_SHADER_INPUTS][4],
float (*dests)[PIPE_MAX_SHADER_INPUTS][4],
struct tgsi_exec_vector *inputs,
struct tgsi_exec_vector *dests,
float (*consts)[4],
int num_vertices,
int num_inputs,

56
src/mesa/pipe/llvm/gallivm_p.h Normal file
View file

@ -0,0 +1,56 @@
#ifndef GALLIVM_P_H
#define GALLIVM_P_H
#ifdef MESA_LLVM
namespace llvm {
class Module;
}
#if defined __cplusplus
extern "C" {
#endif
enum gallivm_shader_type;
enum gallivm_vector_layout;
struct gallivm_interpolate {
int attrib;
int chan;
int type;
};
struct gallivm_ir {
llvm::Module *module;
int id;
enum gallivm_shader_type type;
enum gallivm_vector_layout layout;
int num_components;
int num_consts;
//FIXME: this might not be enough for some shaders
struct gallivm_interpolate interpolators[32*4];
int num_interp;
};
struct gallivm_prog {
llvm::Module *module;
void *function;
int id;
enum gallivm_shader_type type;
int num_consts;
//FIXME: this might not be enough for some shaders
struct gallivm_interpolate interpolators[32*4];
int num_interp;
};
#endif /* MESA_LLVM */
#if defined __cplusplus
} // extern "C"
#endif
#endif

413
src/mesa/pipe/llvm/llvm_base_shader.cpp
View file

@ -104,8 +104,8 @@ Module* createBaseShader() {
/*isVarArg=*/false);
std::vector<const Type*>FuncTy_18_args;
FuncTy_18_args.push_back(PointerTy_12);
FuncTy_18_args.push_back(PointerTy_12);
FuncTy_18_args.push_back(PointerTy_9);
FuncTy_18_args.push_back(PointerTy_9);
FuncTy_18_args.push_back(PointerTy_7);
FuncTy_18_args.push_back(IntegerType::get(32));
FuncTy_18_args.push_back(IntegerType::get(32));
@ -526,14 +526,23 @@ Module* createBaseShader() {
BasicBlock* label_forbody_preheader_i = new BasicBlock("forbody.preheader.i",func_run_vertex_shader,0);
BasicBlock* label_forbody_i = new BasicBlock("forbody.i",func_run_vertex_shader,0);
BasicBlock* label_from_consts_exit = new BasicBlock("from_consts.exit",func_run_vertex_shader,0);
BasicBlock* label_forbody_preheader_91 = new BasicBlock("forbody.preheader",func_run_vertex_shader,0);
BasicBlock* label_forbody_92 = new BasicBlock("forbody",func_run_vertex_shader,0);
BasicBlock* label_afterfor_93 = new BasicBlock("afterfor",func_run_vertex_shader,0);
// Block entry (label_entry_90)
AllocaInst* ptr_consts = new AllocaInst(ArrayTy_20, "consts", label_entry_90);
AllocaInst* ptr_temps = new AllocaInst(ArrayTy_22, "temps", label_entry_90);
AllocaInst* ptr_args = new AllocaInst(StructTy_struct_ShaderInput, "args", label_entry_90);
std::vector<Value*> ptr_tmp_indices;
ptr_tmp_indices.push_back(const_int32_29);
ptr_tmp_indices.push_back(const_int32_29);
Instruction* ptr_tmp = new GetElementPtrInst(ptr_args, ptr_tmp_indices.begin(), ptr_tmp_indices.end(), "tmp", label_entry_90);
CastInst* ptr_conv = new BitCastInst(ptr_results, PointerTy_0, "conv", label_entry_90);
StoreInst* void_91 = new StoreInst(ptr_conv, ptr_tmp, false, label_entry_90);
std::vector<Value*> ptr_tmp2_indices;
ptr_tmp2_indices.push_back(const_int32_29);
ptr_tmp2_indices.push_back(const_int32_31);
Instruction* ptr_tmp2 = new GetElementPtrInst(ptr_args, ptr_tmp2_indices.begin(), ptr_tmp2_indices.end(), "tmp2", label_entry_90);
CastInst* ptr_conv4 = new BitCastInst(ptr_inputs, PointerTy_0, "conv4", label_entry_90);
StoreInst* void_92 = new StoreInst(ptr_conv4, ptr_tmp2, false, label_entry_90);
ICmpInst* int1_cmp_i = new ICmpInst(ICmpInst::ICMP_SGT, int32_num_consts, const_int32_29, "cmp.i", label_entry_90);
new BranchInst(label_forbody_preheader_i, label_from_consts_exit, int1_cmp_i, label_entry_90);
@ -544,17 +553,17 @@ Module* createBaseShader() {
new BranchInst(label_forbody_i, label_forbody_preheader_i);
// Block forbody.i (label_forbody_i)
Argument* fwdref_96 = new Argument(IntegerType::get(32));
Argument* fwdref_95 = new Argument(IntegerType::get(32));
PHINode* int32_i_0_reg2mem_0_i = new PHINode(IntegerType::get(32), "i.0.reg2mem.0.i", label_forbody_i);
int32_i_0_reg2mem_0_i->reserveOperandSpace(2);
int32_i_0_reg2mem_0_i->addIncoming(const_int32_29, label_forbody_preheader_i);
int32_i_0_reg2mem_0_i->addIncoming(fwdref_96, label_forbody_i);
int32_i_0_reg2mem_0_i->addIncoming(fwdref_95, label_forbody_i);
Argument* fwdref_97 = new Argument(VectorTy_1);
Argument* fwdref_96 = new Argument(VectorTy_1);
PHINode* packed_vec_0_reg2mem_0_i = new PHINode(VectorTy_1, "vec.0.reg2mem.0.i", label_forbody_i);
packed_vec_0_reg2mem_0_i->reserveOperandSpace(2);
packed_vec_0_reg2mem_0_i->addIncoming(const_packed_32, label_forbody_preheader_i);
packed_vec_0_reg2mem_0_i->addIncoming(fwdref_97, label_forbody_i);
packed_vec_0_reg2mem_0_i->addIncoming(fwdref_96, label_forbody_i);
std::vector<Value*> ptr_arraydecay_i_indices;
ptr_arraydecay_i_indices.push_back(int32_i_0_reg2mem_0_i);
@ -584,80 +593,40 @@ Module* createBaseShader() {
ptr_arrayidx34_i_indices.push_back(const_int32_29);
ptr_arrayidx34_i_indices.push_back(int32_i_0_reg2mem_0_i);
Instruction* ptr_arrayidx34_i = new GetElementPtrInst(ptr_consts, ptr_arrayidx34_i_indices.begin(), ptr_arrayidx34_i_indices.end(), "arrayidx34.i", label_forbody_i);
StoreInst* void_98 = new StoreInst(packed_tmp31_i, ptr_arrayidx34_i, false, label_forbody_i);
BinaryOperator* int32_indvar_next8 = BinaryOperator::create(Instruction::Add, int32_i_0_reg2mem_0_i, const_int32_31, "indvar.next8", label_forbody_i);
ICmpInst* int1_exitcond9 = new ICmpInst(ICmpInst::ICMP_EQ, int32_indvar_next8, int32_tmp10_i, "exitcond9", label_forbody_i);
new BranchInst(label_from_consts_exit, label_forbody_i, int1_exitcond9, label_forbody_i);
StoreInst* void_97 = new StoreInst(packed_tmp31_i, ptr_arrayidx34_i, false, label_forbody_i);
BinaryOperator* int32_indvar_next_98 = BinaryOperator::create(Instruction::Add, int32_i_0_reg2mem_0_i, const_int32_31, "indvar.next", label_forbody_i);
ICmpInst* int1_exitcond_99 = new ICmpInst(ICmpInst::ICMP_EQ, int32_indvar_next_98, int32_tmp10_i, "exitcond", label_forbody_i);
new BranchInst(label_from_consts_exit, label_forbody_i, int1_exitcond_99, label_forbody_i);
// Block from_consts.exit (label_from_consts_exit)
std::vector<Value*> ptr_tmp2_indices;
ptr_tmp2_indices.push_back(const_int32_29);
ptr_tmp2_indices.push_back(const_int32_34);
Instruction* ptr_tmp2 = new GetElementPtrInst(ptr_args, ptr_tmp2_indices.begin(), ptr_tmp2_indices.end(), "tmp2", label_from_consts_exit);
std::vector<Value*> ptr_arraydecay3_indices;
ptr_arraydecay3_indices.push_back(const_int32_29);
ptr_arraydecay3_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay3 = new GetElementPtrInst(ptr_consts, ptr_arraydecay3_indices.begin(), ptr_arraydecay3_indices.end(), "arraydecay3", label_from_consts_exit);
StoreInst* void_100 = new StoreInst(ptr_arraydecay3, ptr_tmp2, false, label_from_consts_exit);
std::vector<Value*> ptr_tmp4_indices;
ptr_tmp4_indices.push_back(const_int32_29);
ptr_tmp4_indices.push_back(const_int32_33);
Instruction* ptr_tmp4 = new GetElementPtrInst(ptr_args, ptr_tmp4_indices.begin(), ptr_tmp4_indices.end(), "tmp4", label_from_consts_exit);
std::vector<Value*> ptr_arraydecay5_indices;
ptr_arraydecay5_indices.push_back(const_int32_29);
ptr_arraydecay5_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay5 = new GetElementPtrInst(ptr_temps, ptr_arraydecay5_indices.begin(), ptr_arraydecay5_indices.end(), "arraydecay5", label_from_consts_exit);
StoreInst* void_101 = new StoreInst(ptr_arraydecay5, ptr_tmp4, false, label_from_consts_exit);
ICmpInst* int1_cmp_102 = new ICmpInst(ICmpInst::ICMP_SGT, int32_num_vertices, const_int32_29, "cmp", label_from_consts_exit);
new BranchInst(label_forbody_preheader_91, label_afterfor_93, int1_cmp_102, label_from_consts_exit);
std::vector<Value*> ptr_tmp7_indices;
ptr_tmp7_indices.push_back(const_int32_29);
ptr_tmp7_indices.push_back(const_int32_34);
Instruction* ptr_tmp7 = new GetElementPtrInst(ptr_args, ptr_tmp7_indices.begin(), ptr_tmp7_indices.end(), "tmp7", label_from_consts_exit);
std::vector<Value*> ptr_arraydecay8_indices;
ptr_arraydecay8_indices.push_back(const_int32_29);
ptr_arraydecay8_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay8 = new GetElementPtrInst(ptr_consts, ptr_arraydecay8_indices.begin(), ptr_arraydecay8_indices.end(), "arraydecay8", label_from_consts_exit);
StoreInst* void_101 = new StoreInst(ptr_arraydecay8, ptr_tmp7, false, label_from_consts_exit);
std::vector<Value*> ptr_tmp9_indices;
ptr_tmp9_indices.push_back(const_int32_29);
ptr_tmp9_indices.push_back(const_int32_33);
Instruction* ptr_tmp9 = new GetElementPtrInst(ptr_args, ptr_tmp9_indices.begin(), ptr_tmp9_indices.end(), "tmp9", label_from_consts_exit);
std::vector<Value*> ptr_arraydecay10_indices;
ptr_arraydecay10_indices.push_back(const_int32_29);
ptr_arraydecay10_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay10 = new GetElementPtrInst(ptr_temps, ptr_arraydecay10_indices.begin(), ptr_arraydecay10_indices.end(), "arraydecay10", label_from_consts_exit);
StoreInst* void_102 = new StoreInst(ptr_arraydecay10, ptr_tmp9, false, label_from_consts_exit);
CallInst* void_103 = new CallInst(func_execute_shader, ptr_args, "", label_from_consts_exit);
void_103->setCallingConv(CallingConv::C);
void_103->setTailCall(false);const ParamAttrsList *void_103_PAL = 0;
void_103->setParamAttrs(void_103_PAL);
// Block forbody.preheader (label_forbody_preheader_91)
std::vector<Value*> ptr_tmp8_indices;
ptr_tmp8_indices.push_back(const_int32_29);
ptr_tmp8_indices.push_back(const_int32_29);
Instruction* ptr_tmp8 = new GetElementPtrInst(ptr_args, ptr_tmp8_indices.begin(), ptr_tmp8_indices.end(), "tmp8", label_forbody_preheader_91);
std::vector<Value*> ptr_tmp12_indices;
ptr_tmp12_indices.push_back(const_int32_29);
ptr_tmp12_indices.push_back(const_int32_31);
Instruction* ptr_tmp12 = new GetElementPtrInst(ptr_args, ptr_tmp12_indices.begin(), ptr_tmp12_indices.end(), "tmp12", label_forbody_preheader_91);
BinaryOperator* int32_tmp_104 = BinaryOperator::create(Instruction::Add, int32_num_vertices, const_int32_30, "tmp", label_forbody_preheader_91);
ICmpInst* int1_tmp6 = new ICmpInst(ICmpInst::ICMP_SLT, int32_tmp_104, const_int32_29, "tmp6", label_forbody_preheader_91);
SelectInst* int32_tmp7 = new SelectInst(int1_tmp6, const_int32_31, int32_num_vertices, "tmp7", label_forbody_preheader_91);
new BranchInst(label_forbody_92, label_forbody_preheader_91);
// Block forbody (label_forbody_92)
Argument* fwdref_107 = new Argument(IntegerType::get(32));
PHINode* int32_i_0_reg2mem_0_106 = new PHINode(IntegerType::get(32), "i.0.reg2mem.0", label_forbody_92);
int32_i_0_reg2mem_0_106->reserveOperandSpace(2);
int32_i_0_reg2mem_0_106->addIncoming(const_int32_29, label_forbody_preheader_91);
int32_i_0_reg2mem_0_106->addIncoming(fwdref_107, label_forbody_92);
std::vector<Value*> ptr_arraydecay11_108_indices;
ptr_arraydecay11_108_indices.push_back(int32_i_0_reg2mem_0_106);
ptr_arraydecay11_108_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay11_108 = new GetElementPtrInst(ptr_results, ptr_arraydecay11_108_indices.begin(), ptr_arraydecay11_108_indices.end(), "arraydecay11", label_forbody_92);
StoreInst* void_109 = new StoreInst(ptr_arraydecay11_108, ptr_tmp8, false, label_forbody_92);
std::vector<Value*> ptr_arraydecay16_indices;
ptr_arraydecay16_indices.push_back(int32_i_0_reg2mem_0_106);
ptr_arraydecay16_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay16 = new GetElementPtrInst(ptr_inputs, ptr_arraydecay16_indices.begin(), ptr_arraydecay16_indices.end(), "arraydecay16", label_forbody_92);
StoreInst* void_110 = new StoreInst(ptr_arraydecay16, ptr_tmp12, false, label_forbody_92);
CallInst* void_111 = new CallInst(func_execute_shader, ptr_args, "", label_forbody_92);
void_111->setCallingConv(CallingConv::C);
void_111->setTailCall(false);const ParamAttrsList *void_111_PAL = 0;
void_111->setParamAttrs(void_111_PAL);
BinaryOperator* int32_indvar_next_112 = BinaryOperator::create(Instruction::Add, int32_i_0_reg2mem_0_106, const_int32_31, "indvar.next", label_forbody_92);
ICmpInst* int1_exitcond_113 = new ICmpInst(ICmpInst::ICMP_EQ, int32_indvar_next_112, int32_tmp7, "exitcond", label_forbody_92);
new BranchInst(label_afterfor_93, label_forbody_92, int1_exitcond_113, label_forbody_92);
// Block afterfor (label_afterfor_93)
new ReturnInst(label_afterfor_93);
new ReturnInst(label_from_consts_exit);
// Resolve Forward References
fwdref_107->replaceAllUsesWith(int32_indvar_next_112); delete fwdref_107;
fwdref_97->replaceAllUsesWith(packed_tmp31_i); delete fwdref_97;
fwdref_96->replaceAllUsesWith(int32_indvar_next8); delete fwdref_96;
fwdref_96->replaceAllUsesWith(packed_tmp31_i); delete fwdref_96;
fwdref_95->replaceAllUsesWith(int32_indvar_next_98); delete fwdref_95;
}
@ -668,195 +637,195 @@ Module* createBaseShader() {
float_x->setName("x");
Value* float_y = args++;
float_y->setName("y");
Value* ptr_results_116 = args++;
ptr_results_116->setName("results");
Value* ptr_inputs_117 = args++;
ptr_inputs_117->setName("inputs");
Value* int32_num_inputs_118 = args++;
int32_num_inputs_118->setName("num_inputs");
Value* ptr_aconsts_119 = args++;
ptr_aconsts_119->setName("aconsts");
Value* int32_num_consts_120 = args++;
int32_num_consts_120->setName("num_consts");
Value* ptr_results_105 = args++;
ptr_results_105->setName("results");
Value* ptr_inputs_106 = args++;
ptr_inputs_106->setName("inputs");
Value* int32_num_inputs_107 = args++;
int32_num_inputs_107->setName("num_inputs");
Value* ptr_aconsts_108 = args++;
ptr_aconsts_108->setName("aconsts");
Value* int32_num_consts_109 = args++;
int32_num_consts_109->setName("num_consts");
Value* ptr_samplers = args++;
ptr_samplers->setName("samplers");
BasicBlock* label_entry_121 = new BasicBlock("entry",func_run_fragment_shader,0);
BasicBlock* label_forbody_preheader_i_122 = new BasicBlock("forbody.preheader.i",func_run_fragment_shader,0);
BasicBlock* label_forbody_i_123 = new BasicBlock("forbody.i",func_run_fragment_shader,0);
BasicBlock* label_from_consts_exit_124 = new BasicBlock("from_consts.exit",func_run_fragment_shader,0);
BasicBlock* label_entry_110 = new BasicBlock("entry",func_run_fragment_shader,0);
BasicBlock* label_forbody_preheader_i_111 = new BasicBlock("forbody.preheader.i",func_run_fragment_shader,0);
BasicBlock* label_forbody_i_112 = new BasicBlock("forbody.i",func_run_fragment_shader,0);
BasicBlock* label_from_consts_exit_113 = new BasicBlock("from_consts.exit",func_run_fragment_shader,0);
// Block entry (label_entry_121)
AllocaInst* ptr_consts_125 = new AllocaInst(ArrayTy_20, "consts", label_entry_121);
AllocaInst* ptr_temps_126 = new AllocaInst(ArrayTy_22, "temps", label_entry_121);
AllocaInst* ptr_args_127 = new AllocaInst(StructTy_struct_ShaderInput, "args", label_entry_121);
std::vector<Value*> ptr_tmp_indices;
ptr_tmp_indices.push_back(const_int32_29);
ptr_tmp_indices.push_back(const_int32_35);
Instruction* ptr_tmp = new GetElementPtrInst(ptr_args_127, ptr_tmp_indices.begin(), ptr_tmp_indices.end(), "tmp", label_entry_121);
StoreInst* void_128 = new StoreInst(const_int32_29, ptr_tmp, false, label_entry_121);
ICmpInst* int1_cmp_i_129 = new ICmpInst(ICmpInst::ICMP_SGT, int32_num_consts_120, const_int32_29, "cmp.i", label_entry_121);
new BranchInst(label_forbody_preheader_i_122, label_from_consts_exit_124, int1_cmp_i_129, label_entry_121);
// Block entry (label_entry_110)
AllocaInst* ptr_consts_114 = new AllocaInst(ArrayTy_20, "consts", label_entry_110);
AllocaInst* ptr_temps_115 = new AllocaInst(ArrayTy_22, "temps", label_entry_110);
AllocaInst* ptr_args_116 = new AllocaInst(StructTy_struct_ShaderInput, "args", label_entry_110);
std::vector<Value*> ptr_tmp_117_indices;
ptr_tmp_117_indices.push_back(const_int32_29);
ptr_tmp_117_indices.push_back(const_int32_35);
Instruction* ptr_tmp_117 = new GetElementPtrInst(ptr_args_116, ptr_tmp_117_indices.begin(), ptr_tmp_117_indices.end(), "tmp", label_entry_110);
StoreInst* void_118 = new StoreInst(const_int32_29, ptr_tmp_117, false, label_entry_110);
ICmpInst* int1_cmp_i_119 = new ICmpInst(ICmpInst::ICMP_SGT, int32_num_consts_109, const_int32_29, "cmp.i", label_entry_110);
new BranchInst(label_forbody_preheader_i_111, label_from_consts_exit_113, int1_cmp_i_119, label_entry_110);
// Block forbody.preheader.i (label_forbody_preheader_i_122)
BinaryOperator* int32_tmp_i_131 = BinaryOperator::create(Instruction::Add, int32_num_consts_120, const_int32_30, "tmp.i", label_forbody_preheader_i_122);
ICmpInst* int1_tmp9_i_132 = new ICmpInst(ICmpInst::ICMP_SLT, int32_tmp_i_131, const_int32_29, "tmp9.i", label_forbody_preheader_i_122);
SelectInst* int32_tmp10_i_133 = new SelectInst(int1_tmp9_i_132, const_int32_31, int32_num_consts_120, "tmp10.i", label_forbody_preheader_i_122);
new BranchInst(label_forbody_i_123, label_forbody_preheader_i_122);
// Block forbody.preheader.i (label_forbody_preheader_i_111)
BinaryOperator* int32_tmp_i_121 = BinaryOperator::create(Instruction::Add, int32_num_consts_109, const_int32_30, "tmp.i", label_forbody_preheader_i_111);
ICmpInst* int1_tmp9_i_122 = new ICmpInst(ICmpInst::ICMP_SLT, int32_tmp_i_121, const_int32_29, "tmp9.i", label_forbody_preheader_i_111);
SelectInst* int32_tmp10_i_123 = new SelectInst(int1_tmp9_i_122, const_int32_31, int32_num_consts_109, "tmp10.i", label_forbody_preheader_i_111);
new BranchInst(label_forbody_i_112, label_forbody_preheader_i_111);
// Block forbody.i (label_forbody_i_123)
Argument* fwdref_136 = new Argument(IntegerType::get(32));
PHINode* int32_i_0_reg2mem_0_i_135 = new PHINode(IntegerType::get(32), "i.0.reg2mem.0.i", label_forbody_i_123);
int32_i_0_reg2mem_0_i_135->reserveOperandSpace(2);
int32_i_0_reg2mem_0_i_135->addIncoming(const_int32_29, label_forbody_preheader_i_122);
int32_i_0_reg2mem_0_i_135->addIncoming(fwdref_136, label_forbody_i_123);
// Block forbody.i (label_forbody_i_112)
Argument* fwdref_126 = new Argument(IntegerType::get(32));
PHINode* int32_i_0_reg2mem_0_i_125 = new PHINode(IntegerType::get(32), "i.0.reg2mem.0.i", label_forbody_i_112);
int32_i_0_reg2mem_0_i_125->reserveOperandSpace(2);
int32_i_0_reg2mem_0_i_125->addIncoming(const_int32_29, label_forbody_preheader_i_111);
int32_i_0_reg2mem_0_i_125->addIncoming(fwdref_126, label_forbody_i_112);
Argument* fwdref_138 = new Argument(VectorTy_1);
PHINode* packed_vec_0_reg2mem_0_i_137 = new PHINode(VectorTy_1, "vec.0.reg2mem.0.i", label_forbody_i_123);
packed_vec_0_reg2mem_0_i_137->reserveOperandSpace(2);
packed_vec_0_reg2mem_0_i_137->addIncoming(const_packed_32, label_forbody_preheader_i_122);
packed_vec_0_reg2mem_0_i_137->addIncoming(fwdref_138, label_forbody_i_123);
Argument* fwdref_128 = new Argument(VectorTy_1);
PHINode* packed_vec_0_reg2mem_0_i_127 = new PHINode(VectorTy_1, "vec.0.reg2mem.0.i", label_forbody_i_112);
packed_vec_0_reg2mem_0_i_127->reserveOperandSpace(2);
packed_vec_0_reg2mem_0_i_127->addIncoming(const_packed_32, label_forbody_preheader_i_111);
packed_vec_0_reg2mem_0_i_127->addIncoming(fwdref_128, label_forbody_i_112);
std::vector<Value*> ptr_arraydecay_i_139_indices;
ptr_arraydecay_i_139_indices.push_back(int32_i_0_reg2mem_0_i_135);
ptr_arraydecay_i_139_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay_i_139 = new GetElementPtrInst(ptr_aconsts_119, ptr_arraydecay_i_139_indices.begin(), ptr_arraydecay_i_139_indices.end(), "arraydecay.i", label_forbody_i_123);
LoadInst* float_tmp5_i_140 = new LoadInst(ptr_arraydecay_i_139, "tmp5.i", false, label_forbody_i_123);
InsertElementInst* packed_tmp7_i_141 = new InsertElementInst(packed_vec_0_reg2mem_0_i_137, float_tmp5_i_140, const_int32_29, "tmp7.i", label_forbody_i_123);
std::vector<Value*> ptr_arrayidx12_i_142_indices;
ptr_arrayidx12_i_142_indices.push_back(int32_i_0_reg2mem_0_i_135);
ptr_arrayidx12_i_142_indices.push_back(const_int32_31);
Instruction* ptr_arrayidx12_i_142 = new GetElementPtrInst(ptr_aconsts_119, ptr_arrayidx12_i_142_indices.begin(), ptr_arrayidx12_i_142_indices.end(), "arrayidx12.i", label_forbody_i_123);
LoadInst* float_tmp13_i_143 = new LoadInst(ptr_arrayidx12_i_142, "tmp13.i", false, label_forbody_i_123);
InsertElementInst* packed_tmp15_i_144 = new InsertElementInst(packed_tmp7_i_141, float_tmp13_i_143, const_int32_31, "tmp15.i", label_forbody_i_123);
std::vector<Value*> ptr_arrayidx20_i_145_indices;
ptr_arrayidx20_i_145_indices.push_back(int32_i_0_reg2mem_0_i_135);
ptr_arrayidx20_i_145_indices.push_back(const_int32_33);
Instruction* ptr_arrayidx20_i_145 = new GetElementPtrInst(ptr_aconsts_119, ptr_arrayidx20_i_145_indices.begin(), ptr_arrayidx20_i_145_indices.end(), "arrayidx20.i", label_forbody_i_123);
LoadInst* float_tmp21_i_146 = new LoadInst(ptr_arrayidx20_i_145, "tmp21.i", false, label_forbody_i_123);
InsertElementInst* packed_tmp23_i_147 = new InsertElementInst(packed_tmp15_i_144, float_tmp21_i_146, const_int32_33, "tmp23.i", label_forbody_i_123);
std::vector<Value*> ptr_arrayidx28_i_148_indices;
ptr_arrayidx28_i_148_indices.push_back(int32_i_0_reg2mem_0_i_135);
ptr_arrayidx28_i_148_indices.push_back(const_int32_34);
Instruction* ptr_arrayidx28_i_148 = new GetElementPtrInst(ptr_aconsts_119, ptr_arrayidx28_i_148_indices.begin(), ptr_arrayidx28_i_148_indices.end(), "arrayidx28.i", label_forbody_i_123);
LoadInst* float_tmp29_i_149 = new LoadInst(ptr_arrayidx28_i_148, "tmp29.i", false, label_forbody_i_123);
InsertElementInst* packed_tmp31_i_150 = new InsertElementInst(packed_tmp23_i_147, float_tmp29_i_149, const_int32_34, "tmp31.i", label_forbody_i_123);
std::vector<Value*> ptr_arrayidx34_i_151_indices;
ptr_arrayidx34_i_151_indices.push_back(const_int32_29);
ptr_arrayidx34_i_151_indices.push_back(int32_i_0_reg2mem_0_i_135);
Instruction* ptr_arrayidx34_i_151 = new GetElementPtrInst(ptr_consts_125, ptr_arrayidx34_i_151_indices.begin(), ptr_arrayidx34_i_151_indices.end(), "arrayidx34.i", label_forbody_i_123);
StoreInst* void_152 = new StoreInst(packed_tmp31_i_150, ptr_arrayidx34_i_151, false, label_forbody_i_123);
BinaryOperator* int32_indvar_next7 = BinaryOperator::create(Instruction::Add, int32_i_0_reg2mem_0_i_135, const_int32_31, "indvar.next7", label_forbody_i_123);
ICmpInst* int1_exitcond8 = new ICmpInst(ICmpInst::ICMP_EQ, int32_indvar_next7, int32_tmp10_i_133, "exitcond8", label_forbody_i_123);
new BranchInst(label_from_consts_exit_124, label_forbody_i_123, int1_exitcond8, label_forbody_i_123);
std::vector<Value*> ptr_arraydecay_i_129_indices;
ptr_arraydecay_i_129_indices.push_back(int32_i_0_reg2mem_0_i_125);
ptr_arraydecay_i_129_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay_i_129 = new GetElementPtrInst(ptr_aconsts_108, ptr_arraydecay_i_129_indices.begin(), ptr_arraydecay_i_129_indices.end(), "arraydecay.i", label_forbody_i_112);
LoadInst* float_tmp5_i_130 = new LoadInst(ptr_arraydecay_i_129, "tmp5.i", false, label_forbody_i_112);
InsertElementInst* packed_tmp7_i_131 = new InsertElementInst(packed_vec_0_reg2mem_0_i_127, float_tmp5_i_130, const_int32_29, "tmp7.i", label_forbody_i_112);
std::vector<Value*> ptr_arrayidx12_i_132_indices;
ptr_arrayidx12_i_132_indices.push_back(int32_i_0_reg2mem_0_i_125);
ptr_arrayidx12_i_132_indices.push_back(const_int32_31);
Instruction* ptr_arrayidx12_i_132 = new GetElementPtrInst(ptr_aconsts_108, ptr_arrayidx12_i_132_indices.begin(), ptr_arrayidx12_i_132_indices.end(), "arrayidx12.i", label_forbody_i_112);
LoadInst* float_tmp13_i_133 = new LoadInst(ptr_arrayidx12_i_132, "tmp13.i", false, label_forbody_i_112);
InsertElementInst* packed_tmp15_i_134 = new InsertElementInst(packed_tmp7_i_131, float_tmp13_i_133, const_int32_31, "tmp15.i", label_forbody_i_112);
std::vector<Value*> ptr_arrayidx20_i_135_indices;
ptr_arrayidx20_i_135_indices.push_back(int32_i_0_reg2mem_0_i_125);
ptr_arrayidx20_i_135_indices.push_back(const_int32_33);
Instruction* ptr_arrayidx20_i_135 = new GetElementPtrInst(ptr_aconsts_108, ptr_arrayidx20_i_135_indices.begin(), ptr_arrayidx20_i_135_indices.end(), "arrayidx20.i", label_forbody_i_112);
LoadInst* float_tmp21_i_136 = new LoadInst(ptr_arrayidx20_i_135, "tmp21.i", false, label_forbody_i_112);
InsertElementInst* packed_tmp23_i_137 = new InsertElementInst(packed_tmp15_i_134, float_tmp21_i_136, const_int32_33, "tmp23.i", label_forbody_i_112);
std::vector<Value*> ptr_arrayidx28_i_138_indices;
ptr_arrayidx28_i_138_indices.push_back(int32_i_0_reg2mem_0_i_125);
ptr_arrayidx28_i_138_indices.push_back(const_int32_34);
Instruction* ptr_arrayidx28_i_138 = new GetElementPtrInst(ptr_aconsts_108, ptr_arrayidx28_i_138_indices.begin(), ptr_arrayidx28_i_138_indices.end(), "arrayidx28.i", label_forbody_i_112);
LoadInst* float_tmp29_i_139 = new LoadInst(ptr_arrayidx28_i_138, "tmp29.i", false, label_forbody_i_112);
InsertElementInst* packed_tmp31_i_140 = new InsertElementInst(packed_tmp23_i_137, float_tmp29_i_139, const_int32_34, "tmp31.i", label_forbody_i_112);
std::vector<Value*> ptr_arrayidx34_i_141_indices;
ptr_arrayidx34_i_141_indices.push_back(const_int32_29);
ptr_arrayidx34_i_141_indices.push_back(int32_i_0_reg2mem_0_i_125);
Instruction* ptr_arrayidx34_i_141 = new GetElementPtrInst(ptr_consts_114, ptr_arrayidx34_i_141_indices.begin(), ptr_arrayidx34_i_141_indices.end(), "arrayidx34.i", label_forbody_i_112);
StoreInst* void_142 = new StoreInst(packed_tmp31_i_140, ptr_arrayidx34_i_141, false, label_forbody_i_112);
BinaryOperator* int32_indvar_next7 = BinaryOperator::create(Instruction::Add, int32_i_0_reg2mem_0_i_125, const_int32_31, "indvar.next7", label_forbody_i_112);
ICmpInst* int1_exitcond8 = new ICmpInst(ICmpInst::ICMP_EQ, int32_indvar_next7, int32_tmp10_i_123, "exitcond8", label_forbody_i_112);
new BranchInst(label_from_consts_exit_113, label_forbody_i_112, int1_exitcond8, label_forbody_i_112);
// Block from_consts.exit (label_from_consts_exit_124)
// Block from_consts.exit (label_from_consts_exit_113)
std::vector<Value*> ptr_tmp3_indices;
ptr_tmp3_indices.push_back(const_int32_29);
ptr_tmp3_indices.push_back(const_int32_34);
Instruction* ptr_tmp3 = new GetElementPtrInst(ptr_args_127, ptr_tmp3_indices.begin(), ptr_tmp3_indices.end(), "tmp3", label_from_consts_exit_124);
Instruction* ptr_tmp3 = new GetElementPtrInst(ptr_args_116, ptr_tmp3_indices.begin(), ptr_tmp3_indices.end(), "tmp3", label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay4_indices;
ptr_arraydecay4_indices.push_back(const_int32_29);
ptr_arraydecay4_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay4 = new GetElementPtrInst(ptr_consts_125, ptr_arraydecay4_indices.begin(), ptr_arraydecay4_indices.end(), "arraydecay4", label_from_consts_exit_124);
StoreInst* void_154 = new StoreInst(ptr_arraydecay4, ptr_tmp3, false, label_from_consts_exit_124);
Instruction* ptr_arraydecay4 = new GetElementPtrInst(ptr_consts_114, ptr_arraydecay4_indices.begin(), ptr_arraydecay4_indices.end(), "arraydecay4", label_from_consts_exit_113);
StoreInst* void_144 = new StoreInst(ptr_arraydecay4, ptr_tmp3, false, label_from_consts_exit_113);
std::vector<Value*> ptr_tmp5_indices;
ptr_tmp5_indices.push_back(const_int32_29);
ptr_tmp5_indices.push_back(const_int32_33);
Instruction* ptr_tmp5 = new GetElementPtrInst(ptr_args_127, ptr_tmp5_indices.begin(), ptr_tmp5_indices.end(), "tmp5", label_from_consts_exit_124);
Instruction* ptr_tmp5 = new GetElementPtrInst(ptr_args_116, ptr_tmp5_indices.begin(), ptr_tmp5_indices.end(), "tmp5", label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay6_indices;
ptr_arraydecay6_indices.push_back(const_int32_29);
ptr_arraydecay6_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay6 = new GetElementPtrInst(ptr_temps_126, ptr_arraydecay6_indices.begin(), ptr_arraydecay6_indices.end(), "arraydecay6", label_from_consts_exit_124);
StoreInst* void_155 = new StoreInst(ptr_arraydecay6, ptr_tmp5, false, label_from_consts_exit_124);
std::vector<Value*> ptr_tmp8_156_indices;
ptr_tmp8_156_indices.push_back(const_int32_29);
ptr_tmp8_156_indices.push_back(const_int32_31);
Instruction* ptr_tmp8_156 = new GetElementPtrInst(ptr_args_127, ptr_tmp8_156_indices.begin(), ptr_tmp8_156_indices.end(), "tmp8", label_from_consts_exit_124);
std::vector<Value*> ptr_tmp12_157_indices;
ptr_tmp12_157_indices.push_back(const_int32_29);
ptr_tmp12_157_indices.push_back(const_int32_29);
Instruction* ptr_tmp12_157 = new GetElementPtrInst(ptr_args_127, ptr_tmp12_157_indices.begin(), ptr_tmp12_157_indices.end(), "tmp12", label_from_consts_exit_124);
std::vector<Value*> ptr_arraydecay11_158_indices;
ptr_arraydecay11_158_indices.push_back(const_int32_29);
ptr_arraydecay11_158_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay11_158 = new GetElementPtrInst(ptr_inputs_117, ptr_arraydecay11_158_indices.begin(), ptr_arraydecay11_158_indices.end(), "arraydecay11", label_from_consts_exit_124);
StoreInst* void_159 = new StoreInst(ptr_arraydecay11_158, ptr_tmp8_156, false, label_from_consts_exit_124);
std::vector<Value*> ptr_arraydecay16_160_indices;
ptr_arraydecay16_160_indices.push_back(const_int32_29);
ptr_arraydecay16_160_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay16_160 = new GetElementPtrInst(ptr_results_116, ptr_arraydecay16_160_indices.begin(), ptr_arraydecay16_160_indices.end(), "arraydecay16", label_from_consts_exit_124);
StoreInst* void_161 = new StoreInst(ptr_arraydecay16_160, ptr_tmp12_157, false, label_from_consts_exit_124);
StoreInst* void_162 = new StoreInst(const_int32_29, ptr_tmp, false, label_from_consts_exit_124);
CallInst* void_163 = new CallInst(func_execute_shader, ptr_args_127, "", label_from_consts_exit_124);
void_163->setCallingConv(CallingConv::C);
void_163->setTailCall(false);const ParamAttrsList *void_163_PAL = 0;
void_163->setParamAttrs(void_163_PAL);
Instruction* ptr_arraydecay6 = new GetElementPtrInst(ptr_temps_115, ptr_arraydecay6_indices.begin(), ptr_arraydecay6_indices.end(), "arraydecay6", label_from_consts_exit_113);
StoreInst* void_145 = new StoreInst(ptr_arraydecay6, ptr_tmp5, false, label_from_consts_exit_113);
std::vector<Value*> ptr_tmp8_indices;
ptr_tmp8_indices.push_back(const_int32_29);
ptr_tmp8_indices.push_back(const_int32_31);
Instruction* ptr_tmp8 = new GetElementPtrInst(ptr_args_116, ptr_tmp8_indices.begin(), ptr_tmp8_indices.end(), "tmp8", label_from_consts_exit_113);
std::vector<Value*> ptr_tmp12_indices;
ptr_tmp12_indices.push_back(const_int32_29);
ptr_tmp12_indices.push_back(const_int32_29);
Instruction* ptr_tmp12 = new GetElementPtrInst(ptr_args_116, ptr_tmp12_indices.begin(), ptr_tmp12_indices.end(), "tmp12", label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay11_146_indices;
ptr_arraydecay11_146_indices.push_back(const_int32_29);
ptr_arraydecay11_146_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay11_146 = new GetElementPtrInst(ptr_inputs_106, ptr_arraydecay11_146_indices.begin(), ptr_arraydecay11_146_indices.end(), "arraydecay11", label_from_consts_exit_113);
StoreInst* void_147 = new StoreInst(ptr_arraydecay11_146, ptr_tmp8, false, label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay16_indices;
ptr_arraydecay16_indices.push_back(const_int32_29);
ptr_arraydecay16_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay16 = new GetElementPtrInst(ptr_results_105, ptr_arraydecay16_indices.begin(), ptr_arraydecay16_indices.end(), "arraydecay16", label_from_consts_exit_113);
StoreInst* void_148 = new StoreInst(ptr_arraydecay16, ptr_tmp12, false, label_from_consts_exit_113);
StoreInst* void_149 = new StoreInst(const_int32_29, ptr_tmp_117, false, label_from_consts_exit_113);
CallInst* void_150 = new CallInst(func_execute_shader, ptr_args_116, "", label_from_consts_exit_113);
void_150->setCallingConv(CallingConv::C);
void_150->setTailCall(false);const ParamAttrsList *void_150_PAL = 0;
void_150->setParamAttrs(void_150_PAL);
LoadInst* int32_tmp23 = new LoadInst(ptr_tmp, "tmp23", false, label_from_consts_exit_124);
LoadInst* int32_tmp23 = new LoadInst(ptr_tmp_117, "tmp23", false, label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay11_1_indices;
ptr_arraydecay11_1_indices.push_back(const_int32_31);
ptr_arraydecay11_1_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay11_1 = new GetElementPtrInst(ptr_inputs_117, ptr_arraydecay11_1_indices.begin(), ptr_arraydecay11_1_indices.end(), "arraydecay11.1", label_from_consts_exit_124);
StoreInst* void_164 = new StoreInst(ptr_arraydecay11_1, ptr_tmp8_156, false, label_from_consts_exit_124);
Instruction* ptr_arraydecay11_1 = new GetElementPtrInst(ptr_inputs_106, ptr_arraydecay11_1_indices.begin(), ptr_arraydecay11_1_indices.end(), "arraydecay11.1", label_from_consts_exit_113);
StoreInst* void_151 = new StoreInst(ptr_arraydecay11_1, ptr_tmp8, false, label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay16_1_indices;
ptr_arraydecay16_1_indices.push_back(const_int32_31);
ptr_arraydecay16_1_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay16_1 = new GetElementPtrInst(ptr_results_116, ptr_arraydecay16_1_indices.begin(), ptr_arraydecay16_1_indices.end(), "arraydecay16.1", label_from_consts_exit_124);
StoreInst* void_165 = new StoreInst(ptr_arraydecay16_1, ptr_tmp12_157, false, label_from_consts_exit_124);
StoreInst* void_166 = new StoreInst(const_int32_29, ptr_tmp, false, label_from_consts_exit_124);
CallInst* void_167 = new CallInst(func_execute_shader, ptr_args_127, "", label_from_consts_exit_124);
void_167->setCallingConv(CallingConv::C);
void_167->setTailCall(false);const ParamAttrsList *void_167_PAL = 0;
void_167->setParamAttrs(void_167_PAL);
Instruction* ptr_arraydecay16_1 = new GetElementPtrInst(ptr_results_105, ptr_arraydecay16_1_indices.begin(), ptr_arraydecay16_1_indices.end(), "arraydecay16.1", label_from_consts_exit_113);
StoreInst* void_152 = new StoreInst(ptr_arraydecay16_1, ptr_tmp12, false, label_from_consts_exit_113);
StoreInst* void_153 = new StoreInst(const_int32_29, ptr_tmp_117, false, label_from_consts_exit_113);
CallInst* void_154 = new CallInst(func_execute_shader, ptr_args_116, "", label_from_consts_exit_113);
void_154->setCallingConv(CallingConv::C);
void_154->setTailCall(false);const ParamAttrsList *void_154_PAL = 0;
void_154->setParamAttrs(void_154_PAL);
LoadInst* int32_tmp23_1 = new LoadInst(ptr_tmp, "tmp23.1", false, label_from_consts_exit_124);
BinaryOperator* int32_shl_1 = BinaryOperator::create(Instruction::Shl, int32_tmp23_1, const_int32_31, "shl.1", label_from_consts_exit_124);
BinaryOperator* int32_or_1 = BinaryOperator::create(Instruction::Or, int32_shl_1, int32_tmp23, "or.1", label_from_consts_exit_124);
LoadInst* int32_tmp23_1 = new LoadInst(ptr_tmp_117, "tmp23.1", false, label_from_consts_exit_113);
BinaryOperator* int32_shl_1 = BinaryOperator::create(Instruction::Shl, int32_tmp23_1, const_int32_31, "shl.1", label_from_consts_exit_113);
BinaryOperator* int32_or_1 = BinaryOperator::create(Instruction::Or, int32_shl_1, int32_tmp23, "or.1", label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay11_2_indices;
ptr_arraydecay11_2_indices.push_back(const_int32_33);
ptr_arraydecay11_2_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay11_2 = new GetElementPtrInst(ptr_inputs_117, ptr_arraydecay11_2_indices.begin(), ptr_arraydecay11_2_indices.end(), "arraydecay11.2", label_from_consts_exit_124);
StoreInst* void_168 = new StoreInst(ptr_arraydecay11_2, ptr_tmp8_156, false, label_from_consts_exit_124);
Instruction* ptr_arraydecay11_2 = new GetElementPtrInst(ptr_inputs_106, ptr_arraydecay11_2_indices.begin(), ptr_arraydecay11_2_indices.end(), "arraydecay11.2", label_from_consts_exit_113);
StoreInst* void_155 = new StoreInst(ptr_arraydecay11_2, ptr_tmp8, false, label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay16_2_indices;
ptr_arraydecay16_2_indices.push_back(const_int32_33);
ptr_arraydecay16_2_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay16_2 = new GetElementPtrInst(ptr_results_116, ptr_arraydecay16_2_indices.begin(), ptr_arraydecay16_2_indices.end(), "arraydecay16.2", label_from_consts_exit_124);
StoreInst* void_169 = new StoreInst(ptr_arraydecay16_2, ptr_tmp12_157, false, label_from_consts_exit_124);
StoreInst* void_170 = new StoreInst(const_int32_29, ptr_tmp, false, label_from_consts_exit_124);
CallInst* void_171 = new CallInst(func_execute_shader, ptr_args_127, "", label_from_consts_exit_124);
void_171->setCallingConv(CallingConv::C);
void_171->setTailCall(false);const ParamAttrsList *void_171_PAL = 0;
void_171->setParamAttrs(void_171_PAL);
Instruction* ptr_arraydecay16_2 = new GetElementPtrInst(ptr_results_105, ptr_arraydecay16_2_indices.begin(), ptr_arraydecay16_2_indices.end(), "arraydecay16.2", label_from_consts_exit_113);
StoreInst* void_156 = new StoreInst(ptr_arraydecay16_2, ptr_tmp12, false, label_from_consts_exit_113);
StoreInst* void_157 = new StoreInst(const_int32_29, ptr_tmp_117, false, label_from_consts_exit_113);
CallInst* void_158 = new CallInst(func_execute_shader, ptr_args_116, "", label_from_consts_exit_113);
void_158->setCallingConv(CallingConv::C);
void_158->setTailCall(false);const ParamAttrsList *void_158_PAL = 0;
void_158->setParamAttrs(void_158_PAL);
LoadInst* int32_tmp23_2 = new LoadInst(ptr_tmp, "tmp23.2", false, label_from_consts_exit_124);
BinaryOperator* int32_shl_2 = BinaryOperator::create(Instruction::Shl, int32_tmp23_2, const_int32_33, "shl.2", label_from_consts_exit_124);
BinaryOperator* int32_or_2 = BinaryOperator::create(Instruction::Or, int32_shl_2, int32_or_1, "or.2", label_from_consts_exit_124);
LoadInst* int32_tmp23_2 = new LoadInst(ptr_tmp_117, "tmp23.2", false, label_from_consts_exit_113);
BinaryOperator* int32_shl_2 = BinaryOperator::create(Instruction::Shl, int32_tmp23_2, const_int32_33, "shl.2", label_from_consts_exit_113);
BinaryOperator* int32_or_2 = BinaryOperator::create(Instruction::Or, int32_shl_2, int32_or_1, "or.2", label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay11_3_indices;
ptr_arraydecay11_3_indices.push_back(const_int32_34);
ptr_arraydecay11_3_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay11_3 = new GetElementPtrInst(ptr_inputs_117, ptr_arraydecay11_3_indices.begin(), ptr_arraydecay11_3_indices.end(), "arraydecay11.3", label_from_consts_exit_124);
StoreInst* void_172 = new StoreInst(ptr_arraydecay11_3, ptr_tmp8_156, false, label_from_consts_exit_124);
Instruction* ptr_arraydecay11_3 = new GetElementPtrInst(ptr_inputs_106, ptr_arraydecay11_3_indices.begin(), ptr_arraydecay11_3_indices.end(), "arraydecay11.3", label_from_consts_exit_113);
StoreInst* void_159 = new StoreInst(ptr_arraydecay11_3, ptr_tmp8, false, label_from_consts_exit_113);
std::vector<Value*> ptr_arraydecay16_3_indices;
ptr_arraydecay16_3_indices.push_back(const_int32_34);
ptr_arraydecay16_3_indices.push_back(const_int32_29);
Instruction* ptr_arraydecay16_3 = new GetElementPtrInst(ptr_results_116, ptr_arraydecay16_3_indices.begin(), ptr_arraydecay16_3_indices.end(), "arraydecay16.3", label_from_consts_exit_124);
StoreInst* void_173 = new StoreInst(ptr_arraydecay16_3, ptr_tmp12_157, false, label_from_consts_exit_124);
StoreInst* void_174 = new StoreInst(const_int32_29, ptr_tmp, false, label_from_consts_exit_124);
CallInst* void_175 = new CallInst(func_execute_shader, ptr_args_127, "", label_from_consts_exit_124);
void_175->setCallingConv(CallingConv::C);
void_175->setTailCall(false);const ParamAttrsList *void_175_PAL = 0;
void_175->setParamAttrs(void_175_PAL);
Instruction* ptr_arraydecay16_3 = new GetElementPtrInst(ptr_results_105, ptr_arraydecay16_3_indices.begin(), ptr_arraydecay16_3_indices.end(), "arraydecay16.3", label_from_consts_exit_113);
StoreInst* void_160 = new StoreInst(ptr_arraydecay16_3, ptr_tmp12, false, label_from_consts_exit_113);
StoreInst* void_161 = new StoreInst(const_int32_29, ptr_tmp_117, false, label_from_consts_exit_113);
CallInst* void_162 = new CallInst(func_execute_shader, ptr_args_116, "", label_from_consts_exit_113);
void_162->setCallingConv(CallingConv::C);
void_162->setTailCall(false);const ParamAttrsList *void_162_PAL = 0;
void_162->setParamAttrs(void_162_PAL);
LoadInst* int32_tmp23_3 = new LoadInst(ptr_tmp, "tmp23.3", false, label_from_consts_exit_124);
BinaryOperator* int32_shl_3 = BinaryOperator::create(Instruction::Shl, int32_tmp23_3, const_int32_34, "shl.3", label_from_consts_exit_124);
BinaryOperator* int32_or_3 = BinaryOperator::create(Instruction::Or, int32_shl_3, int32_or_2, "or.3", label_from_consts_exit_124);
BinaryOperator* int32_neg = BinaryOperator::create(Instruction::Xor, int32_or_3, const_int32_30, "neg", label_from_consts_exit_124);
new ReturnInst(int32_neg, label_from_consts_exit_124);
LoadInst* int32_tmp23_3 = new LoadInst(ptr_tmp_117, "tmp23.3", false, label_from_consts_exit_113);
BinaryOperator* int32_shl_3 = BinaryOperator::create(Instruction::Shl, int32_tmp23_3, const_int32_34, "shl.3", label_from_consts_exit_113);
BinaryOperator* int32_or_3 = BinaryOperator::create(Instruction::Or, int32_shl_3, int32_or_2, "or.3", label_from_consts_exit_113);
BinaryOperator* int32_neg = BinaryOperator::create(Instruction::Xor, int32_or_3, const_int32_30, "neg", label_from_consts_exit_113);
new ReturnInst(int32_neg, label_from_consts_exit_113);
// Resolve Forward References
fwdref_138->replaceAllUsesWith(packed_tmp31_i_150); delete fwdref_138;
fwdref_136->replaceAllUsesWith(int32_indvar_next7); delete fwdref_136;
fwdref_128->replaceAllUsesWith(packed_tmp31_i_140); delete fwdref_128;
fwdref_126->replaceAllUsesWith(int32_indvar_next7); delete fwdref_126;
}

14
src/mesa/pipe/llvm/llvm_entry.c
View file

@ -86,8 +86,8 @@ struct ShaderInput
extern void execute_shader(struct ShaderInput *input);
void run_vertex_shader(float4 (*inputs)[16],
float4 (*results)[16],
void run_vertex_shader(void *inputs,
void *results,
float (*aconsts)[4],
int num_vertices,
int num_inputs,
@ -98,16 +98,16 @@ void run_vertex_shader(float4 (*inputs)[16],
float4 temps[128];//MAX_PROGRAM_TEMPS
struct ShaderInput args;
args.dests = results;
args.inputs = inputs;
/*printf("XXX LLVM run_vertex_shader vertices = %d, inputs = %d, attribs = %d, consts = %d\n",
num_vertices, num_inputs, num_attribs, num_consts);*/
from_consts(consts, aconsts, num_consts);
args.consts = consts;
args.temps = temps;
for (int i = 0; i < num_vertices; ++i) {
args.dests = results[i];
args.inputs = inputs[i];
execute_shader(&args);
}
execute_shader(&args);
}

682
src/mesa/pipe/llvm/tgsitollvm.cpp Normal file
View file

@ -0,0 +1,682 @@
#include "tgsitollvm.h"
#include "gallivm.h"
#include "gallivm_p.h"
#include "storage.h"
#include "instructions.h"
#include "pipe/p_shader_tokens.h"
#include "pipe/tgsi/util/tgsi_parse.h"
#include "pipe/tgsi/exec/tgsi_exec.h"
#include "pipe/tgsi/util/tgsi_util.h"
#include "pipe/tgsi/util/tgsi_build.h"
#include "pipe/tgsi/util/tgsi_dump.h"
#include <llvm/Module.h>
#include <llvm/CallingConv.h>
#include <llvm/Constants.h>
#include <llvm/DerivedTypes.h>
#include <llvm/Instructions.h>
#include <llvm/ModuleProvider.h>
#include <llvm/Pass.h>
#include <llvm/PassManager.h>
#include <llvm/ParameterAttributes.h>
#include <llvm/Support/PatternMatch.h>
#include <llvm/ExecutionEngine/JIT.h>
#include <llvm/ExecutionEngine/Interpreter.h>
#include <llvm/ExecutionEngine/GenericValue.h>
#include <llvm/Support/MemoryBuffer.h>
#include <llvm/LinkAllPasses.h>
#include <llvm/Analysis/Verifier.h>
#include <llvm/Analysis/LoopPass.h>
#include <llvm/Target/TargetData.h>
#include <llvm/Bitcode/ReaderWriter.h>
#include <llvm/Transforms/Utils/Cloning.h>
#include <sstream>
#include <fstream>
#include <iostream>
using namespace llvm;
#include "llvm_base_shader.cpp"
static inline void
add_interpolator(struct gallivm_ir *ir,
struct gallivm_interpolate *interp)
{
ir->interpolators[ir->num_interp] = *interp;
++ir->num_interp;
}
static void
translate_declaration(struct gallivm_ir *prog,
llvm::Module *module,
Storage *storage,
struct tgsi_full_declaration *decl,
struct tgsi_full_declaration *fd)
{
if (decl->Declaration.File == TGSI_FILE_INPUT) {
unsigned first, last, mask;
uint interp_method;
assert(decl->Declaration.Declare == TGSI_DECLARE_RANGE);
first = decl->u.DeclarationRange.First;
last = decl->u.DeclarationRange.Last;
mask = decl->Declaration.UsageMask;
/* Do not touch WPOS.xy */
if (first == 0) {
mask &= ~TGSI_WRITEMASK_XY;
if (mask == TGSI_WRITEMASK_NONE) {
first++;
if (first > last) {
return;
}
}
}
interp_method = decl->Interpolation.Interpolate;
if (mask == TGSI_WRITEMASK_XYZW) {
unsigned i, j;
for (i = first; i <= last; i++) {
for (j = 0; j < NUM_CHANNELS; j++) {
//interp( mach, i, j );
struct gallivm_interpolate interp;
interp.type = interp_method;
interp.attrib = i;
interp.chan = j;
add_interpolator(prog, &interp);
}
}
} else {
unsigned i, j;
for( j = 0; j < NUM_CHANNELS; j++ ) {
if( mask & (1 << j) ) {
for( i = first; i <= last; i++ ) {
struct gallivm_interpolate interp;
interp.type = interp_method;
interp.attrib = i;
interp.chan = j;
add_interpolator(prog, &interp);
}
}
}
}
}
}
static void
translate_immediate(Storage *storage,
struct tgsi_full_immediate *imm)
{
float vec[4];
int i;
for (i = 0; i < imm->Immediate.Size - 1; ++i) {
switch( imm->Immediate.DataType ) {
case TGSI_IMM_FLOAT32:
vec[i] = imm->u.ImmediateFloat32[i].Float;
break;
default:
assert( 0 );
}
}
storage->addImmediate(vec);
}
static inline llvm::Value *
swizzleVector(llvm::Value *val, struct tgsi_full_src_register *src,
Storage *storage)
{
int swizzle = 0;
int start = 1000;
const int NO_SWIZZLE = TGSI_SWIZZLE_X * 1000 + TGSI_SWIZZLE_Y * 100 +
TGSI_SWIZZLE_Z * 10 + TGSI_SWIZZLE_W;
for (int k = 0; k < 4; ++k) {
swizzle += tgsi_util_get_full_src_register_extswizzle(src, k) * start;
start /= 10;
}
if (swizzle != NO_SWIZZLE) {
/*fprintf(stderr, "XXXXXXXX swizzle = %d\n", swizzle);*/
val = storage->shuffleVector(val, swizzle);
}
return val;
}
static void
translate_instruction(llvm::Module *module,
Storage *storage,
Instructions *instr,
struct tgsi_full_instruction *inst,
struct tgsi_full_instruction *fi,
unsigned instno)
{
llvm::Value *inputs[4];
inputs[0] = 0;
inputs[1] = 0;
inputs[2] = 0;
inputs[3] = 0;
for (int i = 0; i < inst->Instruction.NumSrcRegs; ++i) {
struct tgsi_full_src_register *src = &inst->FullSrcRegisters[i];
llvm::Value *val = 0;
llvm::Value *indIdx = 0;
if (src->SrcRegister.Indirect) {
indIdx = storage->addrElement(src->SrcRegisterInd.Index);
indIdx = storage->extractIndex(indIdx);
}
if (src->SrcRegister.File == TGSI_FILE_CONSTANT) {
val = storage->constElement(src->SrcRegister.Index, indIdx);
} else if (src->SrcRegister.File == TGSI_FILE_INPUT) {
val = storage->inputElement(src->SrcRegister.Index, indIdx);
} else if (src->SrcRegister.File == TGSI_FILE_TEMPORARY) {
val = storage->tempElement(src->SrcRegister.Index);
} else if (src->SrcRegister.File == TGSI_FILE_OUTPUT) {
val = storage->outputElement(src->SrcRegister.Index, indIdx);
} else if (src->SrcRegister.File == TGSI_FILE_IMMEDIATE) {
val = storage->immediateElement(src->SrcRegister.Index);
} else {
fprintf(stderr, "ERROR: not supported llvm source %d\n", src->SrcRegister.File);
return;
}
inputs[i] = swizzleVector(val, src, storage);
}
/*if (inputs[0])
instr->printVector(inputs[0]);
if (inputs[1])
instr->printVector(inputs[1]);*/
llvm::Value *out = 0;
switch (inst->Instruction.Opcode) {
case TGSI_OPCODE_ARL: {
out = instr->arl(inputs[0]);
}
break;
case TGSI_OPCODE_MOV: {
out = inputs[0];
}
break;
case TGSI_OPCODE_LIT: {
out = instr->lit(inputs[0]);
}
break;
case TGSI_OPCODE_RCP: {
out = instr->rcp(inputs[0]);
}
break;
case TGSI_OPCODE_RSQ: {
out = instr->rsq(inputs[0]);
}
break;
case TGSI_OPCODE_EXP:
break;
case TGSI_OPCODE_LOG:
break;
case TGSI_OPCODE_MUL: {
out = instr->mul(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_ADD: {
out = instr->add(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_DP3: {
out = instr->dp3(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_DP4: {
out = instr->dp4(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_DST: {
out = instr->dst(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MIN: {
out = instr->min(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MAX: {
out = instr->max(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_SLT: {
out = instr->slt(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_SGE: {
out = instr->sge(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MAD: {
out = instr->madd(inputs[0], inputs[1], inputs[2]);
}
break;
case TGSI_OPCODE_SUB: {
out = instr->sub(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_LERP: {
out = instr->lerp(inputs[0], inputs[1], inputs[2]);
}
break;
case TGSI_OPCODE_CND:
break;
case TGSI_OPCODE_CND0:
break;
case TGSI_OPCODE_DOT2ADD:
break;
case TGSI_OPCODE_INDEX:
break;
case TGSI_OPCODE_NEGATE:
break;
case TGSI_OPCODE_FRAC: {
out = instr->frc(inputs[0]);
}
break;
case TGSI_OPCODE_CLAMP:
break;
case TGSI_OPCODE_FLOOR: {
out = instr->floor(inputs[0]);
}
break;
case TGSI_OPCODE_ROUND:
break;
case TGSI_OPCODE_EXPBASE2: {
out = instr->ex2(inputs[0]);
}
break;
case TGSI_OPCODE_LOGBASE2: {
out = instr->lg2(inputs[0]);
}
break;
case TGSI_OPCODE_POWER: {
out = instr->pow(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_CROSSPRODUCT: {
out = instr->cross(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_MULTIPLYMATRIX:
break;
case TGSI_OPCODE_ABS: {
out = instr->abs(inputs[0]);
}
break;
case TGSI_OPCODE_RCC:
break;
case TGSI_OPCODE_DPH: {
out = instr->dph(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_COS: {
out = instr->cos(inputs[0]);
}
break;
case TGSI_OPCODE_DDX:
break;
case TGSI_OPCODE_DDY:
break;
case TGSI_OPCODE_KILP: {
out = instr->kilp(inputs[0]);
storage->setKilElement(out);
return;
}
break;
case TGSI_OPCODE_PK2H:
break;
case TGSI_OPCODE_PK2US:
break;
case TGSI_OPCODE_PK4B:
break;
case TGSI_OPCODE_PK4UB:
break;
case TGSI_OPCODE_RFL:
break;
case TGSI_OPCODE_SEQ:
break;
case TGSI_OPCODE_SFL:
break;
case TGSI_OPCODE_SGT: {
out = instr->sgt(inputs[0], inputs[1]);
}
break;
case TGSI_OPCODE_SIN: {
out = instr->sin(inputs[0]);
}
break;
case TGSI_OPCODE_SLE:
break;
case TGSI_OPCODE_SNE:
break;
case TGSI_OPCODE_STR:
break;
case TGSI_OPCODE_TEX:
break;
case TGSI_OPCODE_TXD:
break;
case TGSI_OPCODE_UP2H:
break;
case TGSI_OPCODE_UP2US:
break;
case TGSI_OPCODE_UP4B:
break;
case TGSI_OPCODE_UP4UB:
break;
case TGSI_OPCODE_X2D:
break;
case TGSI_OPCODE_ARA:
break;
case TGSI_OPCODE_ARR:
break;
case TGSI_OPCODE_BRA:
break;
case TGSI_OPCODE_CAL: {
instr->cal(inst->InstructionExtLabel.Label, storage->inputPtr());
return;
}
break;
case TGSI_OPCODE_RET: {
instr->end();
return;
}
break;
case TGSI_OPCODE_SSG:
break;
case TGSI_OPCODE_CMP: {
out = instr->cmp(inputs[0], inputs[1], inputs[2]);
}
break;
case TGSI_OPCODE_SCS: {
out = instr->scs(inputs[0]);
}
break;
case TGSI_OPCODE_TXB:
break;
case TGSI_OPCODE_NRM:
break;
case TGSI_OPCODE_DIV:
break;
case TGSI_OPCODE_DP2:
break;
case TGSI_OPCODE_TXL:
break;
case TGSI_OPCODE_BRK: {
instr->brk();
return;
}
break;
case TGSI_OPCODE_IF: {
instr->ifop(inputs[0]);
storage->setCurrentBlock(instr->currentBlock());
return; //just update the state
}
break;
case TGSI_OPCODE_LOOP:
break;
case TGSI_OPCODE_REP:
break;
case TGSI_OPCODE_ELSE: {
instr->elseop();
storage->setCurrentBlock(instr->currentBlock());
return; //only state update
}
break;
case TGSI_OPCODE_ENDIF: {
instr->endif();
storage->setCurrentBlock(instr->currentBlock());
return; //just update the state
}
break;
case TGSI_OPCODE_ENDLOOP:
break;
case TGSI_OPCODE_ENDREP:
break;
case TGSI_OPCODE_PUSHA:
break;
case TGSI_OPCODE_POPA:
break;
case TGSI_OPCODE_CEIL:
break;
case TGSI_OPCODE_I2F:
break;
case TGSI_OPCODE_NOT:
break;
case TGSI_OPCODE_TRUNC: {
out = instr->trunc(inputs[0]);
}
break;
case TGSI_OPCODE_SHL:
break;
case TGSI_OPCODE_SHR:
break;
case TGSI_OPCODE_AND:
break;
case TGSI_OPCODE_OR:
break;
case TGSI_OPCODE_MOD:
break;
case TGSI_OPCODE_XOR:
break;
case TGSI_OPCODE_SAD:
break;
case TGSI_OPCODE_TXF:
break;
case TGSI_OPCODE_TXQ:
break;
case TGSI_OPCODE_CONT:
break;
case TGSI_OPCODE_EMIT:
break;
case TGSI_OPCODE_ENDPRIM:
break;
case TGSI_OPCODE_BGNLOOP2: {
instr->beginLoop();
storage->setCurrentBlock(instr->currentBlock());
return;
}
break;
case TGSI_OPCODE_BGNSUB: {
instr->bgnSub(instno);
storage->setCurrentBlock(instr->currentBlock());
storage->pushTemps();
return;
}
break;
case TGSI_OPCODE_ENDLOOP2: {
instr->endLoop();
storage->setCurrentBlock(instr->currentBlock());
return;
}
break;
case TGSI_OPCODE_ENDSUB: {
instr->endSub();
storage->setCurrentBlock(instr->currentBlock());
storage->popArguments();
storage->popTemps();
return;
}
break;
case TGSI_OPCODE_NOISE1:
break;
case TGSI_OPCODE_NOISE2:
break;
case TGSI_OPCODE_NOISE3:
break;
case TGSI_OPCODE_NOISE4:
break;
case TGSI_OPCODE_NOP:
break;
case TGSI_OPCODE_TEXBEM:
break;
case TGSI_OPCODE_TEXBEML:
break;
case TGSI_OPCODE_TEXREG2AR:
break;
case TGSI_OPCODE_TEXM3X2PAD:
break;
case TGSI_OPCODE_TEXM3X2TEX:
break;
case TGSI_OPCODE_TEXM3X3PAD:
break;
case TGSI_OPCODE_TEXM3X3TEX:
break;
case TGSI_OPCODE_TEXM3X3SPEC:
break;
case TGSI_OPCODE_TEXM3X3VSPEC:
break;
case TGSI_OPCODE_TEXREG2GB:
break;
case TGSI_OPCODE_TEXREG2RGB:
break;
case TGSI_OPCODE_TEXDP3TEX:
break;
case TGSI_OPCODE_TEXDP3:
break;
case TGSI_OPCODE_TEXM3X3:
break;
case TGSI_OPCODE_TEXM3X2DEPTH:
break;
case TGSI_OPCODE_TEXDEPTH:
break;
case TGSI_OPCODE_BEM:
break;
case TGSI_OPCODE_M4X3:
break;
case TGSI_OPCODE_M3X4:
break;
case TGSI_OPCODE_M3X3:
break;
case TGSI_OPCODE_M3X2:
break;
case TGSI_OPCODE_NRM4:
break;
case TGSI_OPCODE_CALLNZ:
break;
case TGSI_OPCODE_IFC:
break;
case TGSI_OPCODE_BREAKC:
break;
case TGSI_OPCODE_KIL:
break;
case TGSI_OPCODE_END:
instr->end();
return;
break;
default:
fprintf(stderr, "ERROR: Unknown opcode %d\n",
inst->Instruction.Opcode);
assert(0);
break;
}
if (!out) {
fprintf(stderr, "ERROR: unsupported opcode %d\n",
inst->Instruction.Opcode);
assert(!"Unsupported opcode");
}
/* # not sure if we need this */
switch( inst->Instruction.Saturate ) {
case TGSI_SAT_NONE:
break;
case TGSI_SAT_ZERO_ONE:
/*TXT( "_SAT" );*/
break;
case TGSI_SAT_MINUS_PLUS_ONE:
/*TXT( "_SAT[-1,1]" );*/
break;
default:
assert( 0 );
}
/* store results */
for (int i = 0; i < inst->Instruction.NumDstRegs; ++i) {
struct tgsi_full_dst_register *dst = &inst->FullDstRegisters[i];
if (dst->DstRegister.File == TGSI_FILE_OUTPUT) {
storage->setOutputElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
} else if (dst->DstRegister.File == TGSI_FILE_TEMPORARY) {
storage->setTempElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
} else if (dst->DstRegister.File == TGSI_FILE_ADDRESS) {
storage->setAddrElement(dst->DstRegister.Index, out, dst->DstRegister.WriteMask);
} else {
fprintf(stderr, "ERROR: unsupported LLVM destination!");
assert(!"wrong destination");
}
}
}
llvm::Module *
tgsi_to_llvm(struct gallivm_ir *ir, const struct tgsi_token *tokens)
{
llvm::Module *mod = createBaseShader();
struct tgsi_parse_context parse;
struct tgsi_full_instruction fi;
struct tgsi_full_declaration fd;
unsigned instno = 0;
Function* shader = mod->getFunction("execute_shader");
std::ostringstream stream;
if (ir->type == GALLIVM_VS) {
stream << "vs_shader";
} else {
stream << "fs_shader";
}
stream << ir->id;
std::string func_name = stream.str();
shader->setName(func_name.c_str());
Function::arg_iterator args = shader->arg_begin();
Value *ptr_INPUT = args++;
ptr_INPUT->setName("input");
BasicBlock *label_entry = new BasicBlock("entry", shader, 0);
tgsi_parse_init(&parse, tokens);
fi = tgsi_default_full_instruction();
fd = tgsi_default_full_declaration();
Storage storage(label_entry, ptr_INPUT);
Instructions instr(mod, shader, label_entry, &storage);
while(!tgsi_parse_end_of_tokens(&parse)) {
tgsi_parse_token(&parse);
switch (parse.FullToken.Token.Type) {
case TGSI_TOKEN_TYPE_DECLARATION:
translate_declaration(ir, mod, &storage,
&parse.FullToken.FullDeclaration,
&fd);
break;
case TGSI_TOKEN_TYPE_IMMEDIATE:
translate_immediate(&storage,
&parse.FullToken.FullImmediate);
break;
case TGSI_TOKEN_TYPE_INSTRUCTION:
translate_instruction(mod, &storage, &instr,
&parse.FullToken.FullInstruction,
&fi, instno);
++instno;
break;
default:
assert(0);
}
}
tgsi_parse_free(&parse);
ir->num_consts = storage.numConsts();
return mod;
}

16
src/mesa/pipe/llvm/tgsitollvm.h Normal file
View file

@ -0,0 +1,16 @@
#ifndef TGSITOLLVM_H
#define TGSITOLLVM_H
namespace llvm {
class Module;
}
struct gallivm_ir;
struct tgsi_token;
llvm::Module * tgsi_to_llvm(struct gallivm_ir *ir,
const struct tgsi_token *tokens);
#endif

2
src/mesa/pipe/softpipe/sp_state_fs.c
View file

@ -61,7 +61,7 @@ softpipe_create_fs_state(struct pipe_context *pipe,
}
#ifdef MESA_LLVM
state->llvm_prog = gallivm_from_tgsi(state->shader.tokens, GALLIVM_FS);
state->llvm_prog = 0;
if (!gallivm_global_cpu_engine()) {
gallivm_cpu_engine_create(state->llvm_prog);
}