static void handle_line(char **tokens, int ntokens) {
char *name = tokens[0];
LLVMValueRef param;
LLVMValueRef res;
LLVMModuleRef M = LLVMModuleCreateWithName(name);
LLVMTypeRef I64ty = LLVMInt64Type();
LLVMTypeRef I64Ptrty = LLVMPointerType(I64ty, 0);
LLVMTypeRef Fty = LLVMFunctionType(I64ty, &I64Ptrty, 1, 0);
LLVMValueRef F = LLVMAddFunction(M, name, Fty);
LLVMBuilderRef builder = LLVMCreateBuilder();
LLVMPositionBuilderAtEnd(builder, LLVMAppendBasicBlock(F, "entry"));
LLVMGetParams(F, ¶m);
LLVMSetValueName(param, "in");
res = build_from_tokens(tokens + 1, ntokens - 1, builder, param);
if (res) {
char *irstr = LLVMPrintModuleToString(M);
puts(irstr);
LLVMDisposeMessage(irstr);
}
LLVMDisposeBuilder(builder);
LLVMDisposeModule(M);
}
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();
};
}
static LLVMValueRef
add_blend_test(LLVMModuleRef module,
const struct pipe_blend_state *blend,
enum vector_mode mode,
struct lp_type type)
{
LLVMTypeRef ret_type;
LLVMTypeRef vec_type;
LLVMTypeRef args[4];
LLVMValueRef func;
LLVMValueRef src_ptr;
LLVMValueRef dst_ptr;
LLVMValueRef const_ptr;
LLVMValueRef res_ptr;
LLVMBasicBlockRef block;
LLVMBuilderRef builder;
ret_type = LLVMInt64Type();
vec_type = lp_build_vec_type(type);
args[3] = args[2] = args[1] = args[0] = LLVMPointerType(vec_type, 0);
func = LLVMAddFunction(module, "test", LLVMFunctionType(LLVMVoidType(), args, 4, 0));
LLVMSetFunctionCallConv(func, LLVMCCallConv);
src_ptr = LLVMGetParam(func, 0);
dst_ptr = LLVMGetParam(func, 1);
const_ptr = LLVMGetParam(func, 2);
res_ptr = LLVMGetParam(func, 3);
block = LLVMAppendBasicBlock(func, "entry");
builder = LLVMCreateBuilder();
LLVMPositionBuilderAtEnd(builder, block);
if (mode == AoS) {
LLVMValueRef src;
LLVMValueRef dst;
LLVMValueRef con;
LLVMValueRef res;
src = LLVMBuildLoad(builder, src_ptr, "src");
dst = LLVMBuildLoad(builder, dst_ptr, "dst");
con = LLVMBuildLoad(builder, const_ptr, "const");
res = lp_build_blend_aos(builder, blend, type, src, dst, con, 3);
lp_build_name(res, "res");
LLVMBuildStore(builder, res, res_ptr);
}
if (mode == SoA) {
LLVMValueRef src[4];
LLVMValueRef dst[4];
LLVMValueRef con[4];
LLVMValueRef res[4];
unsigned i;
for(i = 0; i < 4; ++i) {
LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
src[i] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, src_ptr, &index, 1, ""), "");
dst[i] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, dst_ptr, &index, 1, ""), "");
con[i] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, const_ptr, &index, 1, ""), "");
lp_build_name(src[i], "src.%c", "rgba"[i]);
lp_build_name(con[i], "con.%c", "rgba"[i]);
lp_build_name(dst[i], "dst.%c", "rgba"[i]);
}
lp_build_blend_soa(builder, blend, type, src, dst, con, res);
for(i = 0; i < 4; ++i) {
LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
lp_build_name(res[i], "res.%c", "rgba"[i]);
LLVMBuildStore(builder, res[i], LLVMBuildGEP(builder, res_ptr, &index, 1, ""));
}
}
LLVMBuildRetVoid(builder);;
LLVMDisposeBuilder(builder);
return func;
}
static LLVMValueRef build_from_tokens(char **tokens, int ntokens,
LLVMBuilderRef builder,
LLVMValueRef param) {
LLVMValueRef stack[MAX_DEPTH];
int depth = 0;
int i;
for (i = 0; i < ntokens; i++) {
char tok = tokens[i][0];
switch (tok) {
case '+':
case '-':
case '*':
case '/':
case '&':
case '|':
case '^':
if (depth < 2) {
printf("stack underflow\n");
return NULL;
}
stack[depth - 2] = LLVMBuildBinOp(builder, op_to_opcode(tok),
stack[depth - 1], stack[depth - 2], "");
depth--;
break;
case '@': {
LLVMValueRef off;
if (depth < 1) {
printf("stack underflow\n");
return NULL;
}
off = LLVMBuildGEP(builder, param, &stack[depth - 1], 1, "");
stack[depth - 1] = LLVMBuildLoad(builder, off, "");
break;
}
default: {
char *end;
long val = strtol(tokens[i], &end, 0);
if (end[0] != '\0') {
printf("error parsing number\n");
return NULL;
}
if (depth >= MAX_DEPTH) {
printf("stack overflow\n");
return NULL;
}
stack[depth++] = LLVMConstInt(LLVMInt64Type(), val, 1);
break;
}
}
}
if (depth < 1) {
printf("stack underflow at return\n");
return NULL;
}
LLVMBuildRet(builder, stack[depth - 1]);
return stack[depth - 1];
}
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;
}
/* This function will take a bool and sign extend it to a specified bitwidth.
It will also perform i1 to floating point conversions if necessary. All vector
components that are equal to 1 will be converted to -1 in accordance with the
OpenCL standard. */
struct cl2llvm_val_t *cl2llvm_bool_ext(struct cl2llvm_val_t *bool_val,
struct cl2llvmTypeWrap *type)
{
struct cl2llvm_val_t *value;
struct cl2llvmTypeWrap *switch_type;
LLVMTypeRef totype;
int vec_length;
switch_type = cl2llvmTypeWrapCreate(cl2llvmTypeWrapGetLlvmType(type), cl2llvmTypeWrapGetSign(type));
if (LLVMGetTypeKind(cl2llvmTypeWrapGetLlvmType(type)) == LLVMVectorTypeKind)
cl2llvmTypeWrapSetLlvmType(switch_type, LLVMGetElementType(cl2llvmTypeWrapGetLlvmType(type)));
if (LLVMGetTypeKind(cl2llvmTypeWrapGetLlvmType(type)) == LLVMVectorTypeKind)
{
vec_length = LLVMGetVectorSize(cl2llvmTypeWrapGetLlvmType(type));
switch (LLVMGetTypeKind(cl2llvmTypeWrapGetLlvmType(switch_type)))
{
case LLVMIntegerTypeKind:
totype = cl2llvmTypeWrapGetLlvmType(type);
break;
case LLVMFloatTypeKind:
totype = LLVMVectorType(LLVMInt32Type(), vec_length);
break;
case LLVMDoubleTypeKind:
totype = LLVMVectorType(LLVMInt64Type(), vec_length);
break;
case LLVMHalfTypeKind:
totype = LLVMVectorType(LLVMInt16Type(), vec_length);
break;
default:
cl2llvm_yyerror("unreachable code reached");
break;
}
}
else
totype = LLVMInt32Type();
value = cl2llvm_val_create();
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
/* Build sign extension */
value->val = LLVMBuildSExt(cl2llvm_builder,
bool_val->val, totype, temp_var_name);
cl2llvmTypeWrapSetLlvmType(value->type, totype);
cl2llvmTypeWrapSetSign(value->type, 1);
/* if value is a vector, change 1's to -1's */
if (LLVMGetTypeKind(cl2llvmTypeWrapGetLlvmType(type)) == LLVMVectorTypeKind)
{
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
value->val = LLVMBuildNeg(cl2llvm_builder,
value->val, temp_var_name);
}
cl2llvmTypeWrapFree(switch_type);
return value;
}
/* This function takes cl2llvm_type and an empty string. The string is
then filled with the type of the cl2llvm_type */
void cl2llvm_type_to_string(struct cl2llvmTypeWrap *type, char *type_string)
{
int sign;
int i, j;
int vec_size;
int ptr_count;
int array_count;
int array_size[50];
char type_string_cpy[50];
LLVMTypeRef bit_type;
bit_type = cl2llvmTypeWrapGetLlvmType(type);
sign = cl2llvmTypeWrapGetSign(type);
array_count = 0;
ptr_count = 0;
vec_size = 0;
/* Get array information */
if (LLVMGetTypeKind(bit_type) == LLVMArrayTypeKind)
{
for (array_count = 0; LLVMGetTypeKind(bit_type)
== LLVMArrayTypeKind; array_count++)
{
array_size[array_count] = LLVMGetArrayLength(bit_type);
bit_type = LLVMGetElementType(bit_type);
}
}
/* Get pointer information */
if (LLVMGetTypeKind(bit_type) == LLVMPointerTypeKind)
{
for (ptr_count = 0; LLVMGetTypeKind(bit_type)
== LLVMPointerTypeKind; ptr_count++)
{
bit_type = LLVMGetElementType(bit_type);
}
}
/* Get vector information */
if (LLVMGetTypeKind(bit_type) == LLVMVectorTypeKind)
{
vec_size = LLVMGetVectorSize(bit_type);
bit_type = LLVMGetElementType(bit_type);
}
if (LLVMGetTypeKind(bit_type) == LLVMDoubleTypeKind)
strcpy(type_string, "double");
else if (LLVMGetTypeKind(bit_type) == LLVMFloatTypeKind)
strcpy(type_string, "float");
else if (LLVMGetTypeKind(bit_type) == LLVMHalfTypeKind)
strcpy(type_string, "half");
else if (LLVMGetTypeKind(bit_type) == LLVMIntegerTypeKind)
{
if (bit_type == LLVMInt64Type())
{
if (sign)
strcpy(type_string, "long long");
else
strcpy(type_string, "unsigned long long");
}
else if (bit_type == LLVMInt32Type())
{
if (sign)
strcpy(type_string, "int");
else
strcpy(type_string, "uint");
}
else if (bit_type == LLVMInt16Type())
{
if (sign)
strcpy(type_string, "short");
else
strcpy(type_string, "ushort");
}
else if (bit_type == LLVMInt8Type())
{
if (sign)
strcpy(type_string, "char");
else
strcpy(type_string, "uchar");
}
else if (bit_type == LLVMInt1Type())
strcpy(type_string, "bool");
}
if (vec_size)
{
i = 0;
while (type_string[i] != '\00')
i++;
switch (vec_size)
{
case 2:
type_string[i] = '2';
break;
case 3:
type_string[i] = '3';
break;
case 4:
type_string[i] = '4';
break;
case 8:
type_string[i] = '8';
break;
case 16:
type_string[i] = '1';
type_string[++i] = '6';
break;
}
i++;
type_string[i] = '\00';
}
if (ptr_count)
{
i = 0;
while (type_string[i] != '\00')
i++;
type_string[i++] = ' ';
for (j = 0; j < ptr_count; j++)
type_string[i++] = '*';
type_string[i] = '\00';
}
if (array_count == 1)
{
i = 0;
while (type_string[i] != '\00')
i++;
type_string[i] = '*';
i++;
type_string[i] = '\00';
}
else if (array_count)
{
i = 0;
while (type_string[i] != '\00')
i++;
type_string[i++] = '(';
type_string[i++] = '*';
type_string[i++] = ')';
type_string[i] = '\00';
for (j = 1; j < array_count; j++)
{
strcpy(type_string_cpy, type_string);
snprintf(type_string, sizeof(char) * 40,
"%s[%d]", type_string_cpy, array_size[j]);
}
}
}
