static LLVMTypeRef llvm_type(int type)
{
switch (type) {
case SCM_FOREIGN_TYPE_FLOAT:
return LLVMFloatType();
case SCM_FOREIGN_TYPE_DOUBLE:
return LLVMDoubleType();
case SCM_FOREIGN_TYPE_BOOL:
return LLVMInt1Type();
case SCM_FOREIGN_TYPE_UINT8:
case SCM_FOREIGN_TYPE_INT8:
return LLVMInt8Type();
case SCM_FOREIGN_TYPE_UINT16:
case SCM_FOREIGN_TYPE_INT16:
return LLVMInt16Type();
case SCM_FOREIGN_TYPE_UINT32:
case SCM_FOREIGN_TYPE_INT32:
return LLVMInt32Type();
case SCM_FOREIGN_TYPE_UINT64:
case SCM_FOREIGN_TYPE_INT64:
return LLVMInt64Type();
default:
return LLVMVoidType();
};
}
/*
* Derive from the quad's upper left scalar coordinates the coordinates for
* all other quad pixels
*/
static void
generate_pos0(LLVMBuilderRef builder,
LLVMValueRef x,
LLVMValueRef y,
LLVMValueRef *x0,
LLVMValueRef *y0)
{
LLVMTypeRef int_elem_type = LLVMInt32Type();
LLVMTypeRef int_vec_type = LLVMVectorType(int_elem_type, QUAD_SIZE);
LLVMTypeRef elem_type = LLVMFloatType();
LLVMTypeRef vec_type = LLVMVectorType(elem_type, QUAD_SIZE);
LLVMValueRef x_offsets[QUAD_SIZE];
LLVMValueRef y_offsets[QUAD_SIZE];
unsigned i;
x = lp_build_broadcast(builder, int_vec_type, x);
y = lp_build_broadcast(builder, int_vec_type, y);
for(i = 0; i < QUAD_SIZE; ++i) {
x_offsets[i] = LLVMConstInt(int_elem_type, quad_offset_x[i], 0);
y_offsets[i] = LLVMConstInt(int_elem_type, quad_offset_y[i], 0);
}
x = LLVMBuildAdd(builder, x, LLVMConstVector(x_offsets, QUAD_SIZE), "");
y = LLVMBuildAdd(builder, y, LLVMConstVector(y_offsets, QUAD_SIZE), "");
*x0 = LLVMBuildSIToFP(builder, x, vec_type, "");
*y0 = LLVMBuildSIToFP(builder, y, vec_type, "");
}
static LLVMValueRef
add_test(LLVMModuleRef module, const char *name, lp_func_t lp_func)
{
LLVMTypeRef v4sf = LLVMVectorType(LLVMFloatType(), 4);
LLVMTypeRef args[1] = { v4sf };
LLVMValueRef func = LLVMAddFunction(module, name, LLVMFunctionType(v4sf, args, 1, 0));
LLVMValueRef arg1 = LLVMGetParam(func, 0);
LLVMBuilderRef builder = LLVMCreateBuilder();
LLVMBasicBlockRef block = LLVMAppendBasicBlock(func, "entry");
LLVMValueRef ret;
struct lp_build_context bld;
bld.builder = builder;
bld.type.floating = 1;
bld.type.width = 32;
bld.type.length = 4;
LLVMSetFunctionCallConv(func, LLVMCCallConv);
LLVMPositionBuilderAtEnd(builder, block);
ret = lp_func(&bld, arg1);
LLVMBuildRet(builder, ret);
LLVMDisposeBuilder(builder);
return func;
}
/**
* Do the one or two-sided stencil test comparison.
* \sa lp_build_stencil_test_single
* \param face an integer indicating front (+) or back (-) facing polygon.
* If NULL, assume front-facing.
*/
static LLVMValueRef
lp_build_stencil_test(struct lp_build_context *bld,
const struct pipe_stencil_state stencil[2],
LLVMValueRef stencilRefs[2],
LLVMValueRef stencilVals,
LLVMValueRef face)
{
LLVMValueRef res;
assert(stencil[0].enabled);
if (stencil[1].enabled && face) {
/* do two-sided test */
struct lp_build_flow_context *flow_ctx;
struct lp_build_if_state if_ctx;
LLVMValueRef front_facing;
LLVMValueRef zero = LLVMConstReal(LLVMFloatType(), 0.0);
LLVMValueRef result = bld->undef;
flow_ctx = lp_build_flow_create(bld->builder);
lp_build_flow_scope_begin(flow_ctx);
lp_build_flow_scope_declare(flow_ctx, &result);
/* front_facing = face > 0.0 */
front_facing = LLVMBuildFCmp(bld->builder, LLVMRealUGT, face, zero, "");
lp_build_if(&if_ctx, flow_ctx, bld->builder, front_facing);
{
result = lp_build_stencil_test_single(bld, &stencil[0],
stencilRefs[0], stencilVals);
}
lp_build_else(&if_ctx);
{
result = lp_build_stencil_test_single(bld, &stencil[1],
stencilRefs[1], stencilVals);
}
lp_build_endif(&if_ctx);
lp_build_flow_scope_end(flow_ctx);
lp_build_flow_destroy(flow_ctx);
res = result;
}
else {
/* do single-side test */
res = lp_build_stencil_test_single(bld, &stencil[0],
stencilRefs[0], stencilVals);
}
return res;
}
LLVMValueRef
lp_build_zero(struct lp_type type)
{
if (type.length == 1) {
if (type.floating)
return LLVMConstReal(LLVMFloatType(), 0.0);
else
return LLVMConstInt(LLVMIntType(type.width), 0, 0);
}
else {
LLVMTypeRef vec_type = lp_build_vec_type(type);
return LLVMConstNull(vec_type);
}
}
static LLVMTypeRef
get_llvm_type(int type_specifier)
{
switch (type_specifier) {
case TYPE_INT:
return LLVMInt32Type();
case TYPE_FLOAT:
return LLVMFloatType();
default:
fprintf(stderr, "Unknown type specifier: %d\n", type_specifier);
exit(EXIT_FAILURE);
}
return NULL;
}
static LLVMValueRef
translateFloatLit(ASTNode *Node) {
LLVMValueRef Container = LLVMBuildAlloca(Builder, LLVMFloatType(), "");
LLVMBuildStore(Builder, LLVMConstReal(LLVMFloatType(), *((float*)Node->Value)), Container);
return Container;
}
/**
* 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);
}
}
/* create new float type */
struct type *type_new_float() {
struct type *r = malloc(sizeof *r);
r->val = TYPE_FLOAT;
r->llvm_type = LLVMFloatType();
return r;
}
struct cl2llvm_val_t *llvm_type_cast(struct cl2llvm_val_t * original_val,
struct cl2llvmTypeWrap *totype_w_sign)
{
struct cl2llvm_val_t *llvm_val = cl2llvm_val_create();
int i;
struct cl2llvmTypeWrap *elem_type;
struct cl2llvm_val_t *cast_original_val;
LLVMValueRef index;
LLVMValueRef vector_addr;
LLVMValueRef vector;
LLVMValueRef const_elems[16];
LLVMTypeRef fromtype = cl2llvmTypeWrapGetLlvmType(original_val->type);
LLVMTypeRef totype = cl2llvmTypeWrapGetLlvmType(totype_w_sign);
int fromsign = cl2llvmTypeWrapGetSign(original_val->type);
int tosign = cl2llvmTypeWrapGetSign(totype_w_sign);
/*By default the return value is the same as the original_val*/
llvm_val->val = original_val->val;
cl2llvmTypeWrapSetLlvmType(llvm_val->type, cl2llvmTypeWrapGetLlvmType(original_val->type));
cl2llvmTypeWrapSetSign(llvm_val->type, cl2llvmTypeWrapGetSign(original_val->type));
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
/* Check that fromtype is not a vector, unless both types are identical. */
if (LLVMGetTypeKind(fromtype) == LLVMVectorTypeKind)
{
if ((LLVMGetVectorSize(fromtype) != LLVMGetVectorSize(totype)
|| LLVMGetElementType(fromtype)
!= LLVMGetElementType(totype))
|| fromsign != tosign)
{
if (LLVMGetTypeKind(totype) == LLVMVectorTypeKind)
cl2llvm_yyerror("Casts between vector types are forbidden");
cl2llvm_yyerror("A vector may not be cast to any other type.");
}
}
/* If totype is a vector, create a vector whose components are equal to
original_val */
if (LLVMGetTypeKind(totype) == LLVMVectorTypeKind
&& LLVMGetTypeKind(fromtype) != LLVMVectorTypeKind)
{
/*Go to entry block and declare vector*/
LLVMPositionBuilder(cl2llvm_builder, cl2llvm_current_function->entry_block,
cl2llvm_current_function->branch_instr);
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
vector_addr = LLVMBuildAlloca(cl2llvm_builder,
totype, temp_var_name);
LLVMPositionBuilderAtEnd(cl2llvm_builder, current_basic_block);
/* Load vector */
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
vector = LLVMBuildLoad(cl2llvm_builder, vector_addr, temp_var_name);
/* Create object to represent element type of totype */
elem_type = cl2llvmTypeWrapCreate(LLVMGetElementType(totype), tosign);
/* If original_val is constant create a constant vector */
if (LLVMIsConstant(original_val->val))
{
cast_original_val = llvm_type_cast(original_val, elem_type);
for (i = 0; i < LLVMGetVectorSize(totype); i++)
const_elems[i] = cast_original_val->val;
vector = LLVMConstVector(const_elems,
LLVMGetVectorSize(totype));
llvm_val->val = vector;
cl2llvm_val_free(cast_original_val);
}
/* If original value is not constant insert elements */
else
{
for (i = 0; i < LLVMGetVectorSize(totype); i++)
{
index = LLVMConstInt(LLVMInt32Type(), i, 0);
cast_original_val = llvm_type_cast(original_val, elem_type);
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
vector = LLVMBuildInsertElement(cl2llvm_builder,
vector, cast_original_val->val, index, temp_var_name);
cl2llvm_val_free(cast_original_val);
}
}
cl2llvmTypeWrapFree(elem_type);
llvm_val->val = vector;
}
if (fromtype == LLVMInt64Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt32Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt32Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt32Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt16Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt8Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt1Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt8Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt8Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
}
/*We now know that from type must be a floating point.*/
/*Floating point to signed integer conversions*/
else if (tosign && LLVMGetTypeKind(totype) == 8)
{
if (totype == LLVMInt64Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt64Type(), temp_var_name);
}
else if (totype == LLVMInt32Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt32Type(), temp_var_name);
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
/*Floating point to unsigned integer conversions*/
else if (!tosign)
{
if (totype == LLVMInt64Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt64Type(), temp_var_name);
}
else if (totype == LLVMInt32Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt32Type(), temp_var_name);
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMDoubleType())
{
llvm_val->val = LLVMBuildFPExt(cl2llvm_builder,
original_val->val, LLVMDoubleType(), temp_var_name);
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromtype == LLVMDoubleType())
{
llvm_val->val = LLVMBuildFPTrunc(cl2llvm_builder,
original_val->val, LLVMFloatType(), temp_var_name);
}
else if (fromtype == LLVMHalfType())
{
llvm_val->val = LLVMBuildFPExt(cl2llvm_builder,
original_val->val, LLVMFloatType(), temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
llvm_val->val = LLVMBuildFPTrunc(cl2llvm_builder,
original_val->val, LLVMHalfType(), temp_var_name);
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
cl2llvmTypeWrapSetLlvmType(llvm_val->type, totype);
cl2llvmTypeWrapSetSign(llvm_val->type, tosign);
return llvm_val;
}
