util_dl_proc
util_dl_get_proc_address(struct util_dl_library *library,
const char *procname)
{
#if defined(PIPE_OS_UNIX)
return (util_dl_proc) pointer_to_func(dlsym((void *)library, procname));
#elif defined(PIPE_OS_WINDOWS)
return (util_dl_proc)GetProcAddress((HMODULE)library, procname);
#else
return (util_dl_proc)NULL;
#endif
}
void (*ppc_get_func(struct ppc_function *p))(void)
{
#if 0
DUMP_END();
if (DISASSEM && p->store)
debug_printf("disassemble %p %p\n", p->store, p->csr);
if (p->store == p->error_overflow)
return (void (*)(void)) NULL;
else
#endif
return (void (*)(void)) pointer_to_func(p->store);
}
func_pointer
gallivm_jit_function(struct gallivm_state *gallivm,
LLVMValueRef func)
{
void *code;
func_pointer jit_func;
assert(gallivm->compiled);
assert(gallivm->engine);
code = LLVMGetPointerToGlobal(gallivm->engine, func);
assert(code);
jit_func = pointer_to_func(code);
if (gallivm_debug & GALLIVM_DEBUG_ASM) {
lp_disassemble(code);
}
/* Free the function body to save memory */
lp_func_delete_body(func);
return jit_func;
}
PIPE_ALIGN_STACK
static boolean
test_round(unsigned verbose, FILE *fp)
{
LLVMModuleRef module = NULL;
LLVMValueRef test_round = NULL, test_trunc, test_floor, test_ceil;
LLVMExecutionEngineRef engine = lp_build_engine;
LLVMPassManagerRef pass = NULL;
char *error = NULL;
test_round_t round_func, trunc_func, floor_func, ceil_func;
float unpacked[4];
unsigned packed;
boolean success = TRUE;
int i;
module = LLVMModuleCreateWithName("test");
test_round = add_test(module, "round", lp_build_round);
test_trunc = add_test(module, "trunc", lp_build_trunc);
test_floor = add_test(module, "floor", lp_build_floor);
test_ceil = add_test(module, "ceil", lp_build_ceil);
if(LLVMVerifyModule(module, LLVMPrintMessageAction, &error)) {
printf("LLVMVerifyModule: %s\n", error);
LLVMDumpModule(module);
abort();
}
LLVMDisposeMessage(error);
#if 0
pass = LLVMCreatePassManager();
LLVMAddTargetData(LLVMGetExecutionEngineTargetData(engine), pass);
/* These are the passes currently listed in llvm-c/Transforms/Scalar.h,
* but there are more on SVN. */
LLVMAddConstantPropagationPass(pass);
LLVMAddInstructionCombiningPass(pass);
LLVMAddPromoteMemoryToRegisterPass(pass);
LLVMAddGVNPass(pass);
LLVMAddCFGSimplificationPass(pass);
LLVMRunPassManager(pass, module);
#else
(void)pass;
#endif
round_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_round));
trunc_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_trunc));
floor_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_floor));
ceil_func = (test_round_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_ceil));
memset(unpacked, 0, sizeof unpacked);
packed = 0;
if (0)
LLVMDumpModule(module);
for (i = 0; i < 3; i++) {
v4sf xvals[3] = {
{-10.0, -1, 0, 12.0},
{-1.5, -0.25, 1.25, 2.5},
{-0.99, -0.01, 0.01, 0.99}
};
v4sf x = xvals[i];
v4sf y, ref;
float *xp = (float *) &x;
float *refp = (float *) &ref;
printf("\n");
printv("x ", x);
refp[0] = round(xp[0]);
refp[1] = round(xp[1]);
refp[2] = round(xp[2]);
refp[3] = round(xp[3]);
y = round_func(x);
printv("C round(x) ", ref);
printv("LLVM round(x)", y);
compare(ref, y);
refp[0] = trunc(xp[0]);
refp[1] = trunc(xp[1]);
refp[2] = trunc(xp[2]);
refp[3] = trunc(xp[3]);
y = trunc_func(x);
printv("C trunc(x) ", ref);
printv("LLVM trunc(x)", y);
compare(ref, y);
refp[0] = floor(xp[0]);
refp[1] = floor(xp[1]);
refp[2] = floor(xp[2]);
refp[3] = floor(xp[3]);
y = floor_func(x);
printv("C floor(x) ", ref);
printv("LLVM floor(x)", y);
compare(ref, y);
refp[0] = ceil(xp[0]);
refp[1] = ceil(xp[1]);
refp[2] = ceil(xp[2]);
refp[3] = ceil(xp[3]);
y = ceil_func(x);
printv("C ceil(x) ", ref);
printv("LLVM ceil(x) ", y);
compare(ref, y);
}
LLVMFreeMachineCodeForFunction(engine, test_round);
LLVMFreeMachineCodeForFunction(engine, test_trunc);
LLVMFreeMachineCodeForFunction(engine, test_floor);
LLVMFreeMachineCodeForFunction(engine, test_ceil);
LLVMDisposeExecutionEngine(engine);
if(pass)
LLVMDisposePassManager(pass);
return success;
}
/**
* Generate the runtime callable function for the whole fragment pipeline.
* Note that the function which we generate operates on a block of 16
* pixels at at time. The block contains 2x2 quads. Each quad contains
* 2x2 pixels.
*/
static void
generate_fragment(struct llvmpipe_context *lp,
struct lp_fragment_shader *shader,
struct lp_fragment_shader_variant *variant,
unsigned partial_mask)
{
struct llvmpipe_screen *screen = llvmpipe_screen(lp->pipe.screen);
const struct lp_fragment_shader_variant_key *key = &variant->key;
char func_name[256];
struct lp_type fs_type;
struct lp_type blend_type;
LLVMTypeRef fs_elem_type;
LLVMTypeRef fs_int_vec_type;
LLVMTypeRef blend_vec_type;
LLVMTypeRef arg_types[11];
LLVMTypeRef func_type;
LLVMValueRef context_ptr;
LLVMValueRef x;
LLVMValueRef y;
LLVMValueRef a0_ptr;
LLVMValueRef dadx_ptr;
LLVMValueRef dady_ptr;
LLVMValueRef color_ptr_ptr;
LLVMValueRef depth_ptr;
LLVMValueRef mask_input;
LLVMValueRef counter = NULL;
LLVMBasicBlockRef block;
LLVMBuilderRef builder;
struct lp_build_sampler_soa *sampler;
struct lp_build_interp_soa_context interp;
LLVMValueRef fs_mask[LP_MAX_VECTOR_LENGTH];
LLVMValueRef fs_out_color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS][LP_MAX_VECTOR_LENGTH];
LLVMValueRef blend_mask;
LLVMValueRef function;
LLVMValueRef facing;
unsigned num_fs;
unsigned i;
unsigned chan;
unsigned cbuf;
/* TODO: actually pick these based on the fs and color buffer
* characteristics. */
memset(&fs_type, 0, sizeof fs_type);
fs_type.floating = TRUE; /* floating point values */
fs_type.sign = TRUE; /* values are signed */
fs_type.norm = FALSE; /* values are not limited to [0,1] or [-1,1] */
fs_type.width = 32; /* 32-bit float */
fs_type.length = 4; /* 4 elements per vector */
num_fs = 4; /* number of quads per block */
memset(&blend_type, 0, sizeof blend_type);
blend_type.floating = FALSE; /* values are integers */
blend_type.sign = FALSE; /* values are unsigned */
blend_type.norm = TRUE; /* values are in [0,1] or [-1,1] */
blend_type.width = 8; /* 8-bit ubyte values */
blend_type.length = 16; /* 16 elements per vector */
/*
* Generate the function prototype. Any change here must be reflected in
* lp_jit.h's lp_jit_frag_func function pointer type, and vice-versa.
*/
fs_elem_type = lp_build_elem_type(fs_type);
fs_int_vec_type = lp_build_int_vec_type(fs_type);
blend_vec_type = lp_build_vec_type(blend_type);
util_snprintf(func_name, sizeof(func_name), "fs%u_variant%u_%s",
shader->no, variant->no, partial_mask ? "partial" : "whole");
arg_types[0] = screen->context_ptr_type; /* context */
arg_types[1] = LLVMInt32Type(); /* x */
arg_types[2] = LLVMInt32Type(); /* y */
arg_types[3] = LLVMFloatType(); /* facing */
arg_types[4] = LLVMPointerType(fs_elem_type, 0); /* a0 */
arg_types[5] = LLVMPointerType(fs_elem_type, 0); /* dadx */
arg_types[6] = LLVMPointerType(fs_elem_type, 0); /* dady */
arg_types[7] = LLVMPointerType(LLVMPointerType(blend_vec_type, 0), 0); /* color */
arg_types[8] = LLVMPointerType(fs_int_vec_type, 0); /* depth */
arg_types[9] = LLVMInt32Type(); /* mask_input */
arg_types[10] = LLVMPointerType(LLVMInt32Type(), 0);/* counter */
func_type = LLVMFunctionType(LLVMVoidType(), arg_types, Elements(arg_types), 0);
function = LLVMAddFunction(screen->module, func_name, func_type);
LLVMSetFunctionCallConv(function, LLVMCCallConv);
variant->function[partial_mask] = function;
/* XXX: need to propagate noalias down into color param now we are
* passing a pointer-to-pointer?
*/
for(i = 0; i < Elements(arg_types); ++i)
if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
LLVMAddAttribute(LLVMGetParam(function, i), LLVMNoAliasAttribute);
context_ptr = LLVMGetParam(function, 0);
x = LLVMGetParam(function, 1);
y = LLVMGetParam(function, 2);
facing = LLVMGetParam(function, 3);
a0_ptr = LLVMGetParam(function, 4);
dadx_ptr = LLVMGetParam(function, 5);
dady_ptr = LLVMGetParam(function, 6);
color_ptr_ptr = LLVMGetParam(function, 7);
depth_ptr = LLVMGetParam(function, 8);
mask_input = LLVMGetParam(function, 9);
lp_build_name(context_ptr, "context");
lp_build_name(x, "x");
lp_build_name(y, "y");
lp_build_name(a0_ptr, "a0");
lp_build_name(dadx_ptr, "dadx");
lp_build_name(dady_ptr, "dady");
lp_build_name(color_ptr_ptr, "color_ptr_ptr");
lp_build_name(depth_ptr, "depth");
lp_build_name(mask_input, "mask_input");
if (key->occlusion_count) {
counter = LLVMGetParam(function, 10);
lp_build_name(counter, "counter");
}
/*
* Function body
*/
block = LLVMAppendBasicBlock(function, "entry");
builder = LLVMCreateBuilder();
LLVMPositionBuilderAtEnd(builder, block);
/*
* The shader input interpolation info is not explicitely baked in the
* shader key, but everything it derives from (TGSI, and flatshade) is
* already included in the shader key.
*/
lp_build_interp_soa_init(&interp,
lp->num_inputs,
lp->inputs,
builder, fs_type,
a0_ptr, dadx_ptr, dady_ptr,
x, y);
/* code generated texture sampling */
sampler = lp_llvm_sampler_soa_create(key->sampler, context_ptr);
/* loop over quads in the block */
for(i = 0; i < num_fs; ++i) {
LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
LLVMValueRef out_color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS];
LLVMValueRef depth_ptr_i;
if(i != 0)
lp_build_interp_soa_update(&interp, i);
depth_ptr_i = LLVMBuildGEP(builder, depth_ptr, &index, 1, "");
generate_fs(lp, shader, key,
builder,
fs_type,
context_ptr,
i,
&interp,
sampler,
&fs_mask[i], /* output */
out_color,
depth_ptr_i,
facing,
partial_mask,
mask_input,
counter);
for(cbuf = 0; cbuf < key->nr_cbufs; cbuf++)
for(chan = 0; chan < NUM_CHANNELS; ++chan)
fs_out_color[cbuf][chan][i] = out_color[cbuf][chan];
}
sampler->destroy(sampler);
/* Loop over color outputs / color buffers to do blending.
*/
for(cbuf = 0; cbuf < key->nr_cbufs; cbuf++) {
LLVMValueRef color_ptr;
LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), cbuf, 0);
LLVMValueRef blend_in_color[NUM_CHANNELS];
unsigned rt;
/*
* Convert the fs's output color and mask to fit to the blending type.
*/
for(chan = 0; chan < NUM_CHANNELS; ++chan) {
lp_build_conv(builder, fs_type, blend_type,
fs_out_color[cbuf][chan], num_fs,
&blend_in_color[chan], 1);
lp_build_name(blend_in_color[chan], "color%d.%c", cbuf, "rgba"[chan]);
}
if (partial_mask || !variant->opaque) {
lp_build_conv_mask(builder, fs_type, blend_type,
fs_mask, num_fs,
&blend_mask, 1);
} else {
blend_mask = lp_build_const_int_vec(blend_type, ~0);
}
color_ptr = LLVMBuildLoad(builder,
LLVMBuildGEP(builder, color_ptr_ptr, &index, 1, ""),
"");
lp_build_name(color_ptr, "color_ptr%d", cbuf);
/* which blend/colormask state to use */
rt = key->blend.independent_blend_enable ? cbuf : 0;
/*
* Blending.
*/
generate_blend(&key->blend,
rt,
builder,
blend_type,
context_ptr,
blend_mask,
blend_in_color,
color_ptr);
}
#ifdef PIPE_ARCH_X86
/* Avoid corrupting the FPU stack on 32bit OSes. */
lp_build_intrinsic(builder, "llvm.x86.mmx.emms", LLVMVoidType(), NULL, 0);
#endif
LLVMBuildRetVoid(builder);
LLVMDisposeBuilder(builder);
/* Verify the LLVM IR. If invalid, dump and abort */
#ifdef DEBUG
if(LLVMVerifyFunction(function, LLVMPrintMessageAction)) {
if (1)
lp_debug_dump_value(function);
abort();
}
#endif
/* Apply optimizations to LLVM IR */
LLVMRunFunctionPassManager(screen->pass, function);
if (gallivm_debug & GALLIVM_DEBUG_IR) {
/* Print the LLVM IR to stderr */
lp_debug_dump_value(function);
debug_printf("\n");
}
/*
* Translate the LLVM IR into machine code.
*/
{
void *f = LLVMGetPointerToGlobal(screen->engine, function);
variant->jit_function[partial_mask] = (lp_jit_frag_func)pointer_to_func(f);
if (gallivm_debug & GALLIVM_DEBUG_ASM) {
lp_disassemble(f);
}
lp_func_delete_body(function);
}
}
