Print this page
new smatch
*** 19,102 ****
#include "linearize.h"
#include "flow.h"
struct function {
LLVMBuilderRef builder;
- LLVMTypeRef type;
LLVMValueRef fn;
LLVMModuleRef module;
};
! static inline bool symbol_is_fp_type(struct symbol *sym)
! {
! if (!sym)
! return false;
! return sym->ctype.base_type == &fp_type;
! }
!
! static LLVMTypeRef symbol_type(LLVMModuleRef module, struct symbol *sym);
!
! static LLVMTypeRef func_return_type(LLVMModuleRef module, struct symbol *sym)
{
! return symbol_type(module, sym->ctype.base_type);
}
! static LLVMTypeRef sym_func_type(LLVMModuleRef module, struct symbol *sym)
{
! LLVMTypeRef *arg_type;
! LLVMTypeRef func_type;
! LLVMTypeRef ret_type;
struct symbol *arg;
! int n_arg = 0;
- /* to avoid strangeness with varargs [for now], we build
- * the function and type anew, for each call. This
- * is probably wrong. We should look up the
- * symbol declaration info.
- */
-
- ret_type = func_return_type(module, sym);
-
- /* count args, build argument type information */
FOR_EACH_PTR(sym->arguments, arg) {
- n_arg++;
- } END_FOR_EACH_PTR(arg);
-
- arg_type = calloc(n_arg, sizeof(LLVMTypeRef));
-
- int idx = 0;
- FOR_EACH_PTR(sym->arguments, arg) {
struct symbol *arg_sym = arg->ctype.base_type;
! arg_type[idx++] = symbol_type(module, arg_sym);
} END_FOR_EACH_PTR(arg);
- func_type = LLVMFunctionType(ret_type, arg_type, n_arg,
- sym->variadic);
! return func_type;
}
! static LLVMTypeRef sym_array_type(LLVMModuleRef module, struct symbol *sym)
{
LLVMTypeRef elem_type;
struct symbol *base_type;
base_type = sym->ctype.base_type;
/* empty struct is undefined [6.7.2.1(8)] */
assert(base_type->bit_size > 0);
! elem_type = symbol_type(module, base_type);
if (!elem_type)
return NULL;
return LLVMArrayType(elem_type, sym->bit_size / base_type->bit_size);
}
#define MAX_STRUCT_MEMBERS 64
! static LLVMTypeRef sym_struct_type(LLVMModuleRef module, struct symbol *sym)
{
LLVMTypeRef elem_types[MAX_STRUCT_MEMBERS];
struct symbol *member;
char buffer[256];
LLVMTypeRef ret;
--- 19,75 ----
#include "linearize.h"
#include "flow.h"
struct function {
LLVMBuilderRef builder;
LLVMValueRef fn;
LLVMModuleRef module;
};
! static LLVMTypeRef symbol_type(struct symbol *sym);
! static LLVMTypeRef func_return_type(struct symbol *sym)
{
! return symbol_type(sym->ctype.base_type);
}
! static LLVMTypeRef sym_func_type(struct symbol *sym)
{
! int n_arg = symbol_list_size(sym->arguments);
! LLVMTypeRef *arg_type = calloc(n_arg, sizeof(LLVMTypeRef));
! LLVMTypeRef ret_type = func_return_type(sym);
struct symbol *arg;
! int idx = 0;
FOR_EACH_PTR(sym->arguments, arg) {
struct symbol *arg_sym = arg->ctype.base_type;
! arg_type[idx++] = symbol_type(arg_sym);
} END_FOR_EACH_PTR(arg);
! return LLVMFunctionType(ret_type, arg_type, n_arg, sym->variadic);
}
! static LLVMTypeRef sym_array_type(struct symbol *sym)
{
LLVMTypeRef elem_type;
struct symbol *base_type;
base_type = sym->ctype.base_type;
/* empty struct is undefined [6.7.2.1(8)] */
assert(base_type->bit_size > 0);
! elem_type = symbol_type(base_type);
if (!elem_type)
return NULL;
return LLVMArrayType(elem_type, sym->bit_size / base_type->bit_size);
}
#define MAX_STRUCT_MEMBERS 64
! static LLVMTypeRef sym_struct_type(struct symbol *sym)
{
LLVMTypeRef elem_types[MAX_STRUCT_MEMBERS];
struct symbol *member;
char buffer[256];
LLVMTypeRef ret;
*** 110,129 ****
FOR_EACH_PTR(sym->symbol_list, member) {
LLVMTypeRef member_type;
assert(nr < MAX_STRUCT_MEMBERS);
! member_type = symbol_type(module, member);
elem_types[nr++] = member_type;
} END_FOR_EACH_PTR(member);
LLVMStructSetBody(ret, elem_types, nr, 0 /* packed? */);
return ret;
}
! static LLVMTypeRef sym_union_type(LLVMModuleRef module, struct symbol *sym)
{
LLVMTypeRef elements;
unsigned union_size;
/*
--- 83,102 ----
FOR_EACH_PTR(sym->symbol_list, member) {
LLVMTypeRef member_type;
assert(nr < MAX_STRUCT_MEMBERS);
! member_type = symbol_type(member);
elem_types[nr++] = member_type;
} END_FOR_EACH_PTR(member);
LLVMStructSetBody(ret, elem_types, nr, 0 /* packed? */);
return ret;
}
! static LLVMTypeRef sym_union_type(struct symbol *sym)
{
LLVMTypeRef elements;
unsigned union_size;
/*
*** 136,163 ****
elements = LLVMArrayType(LLVMInt8Type(), union_size);
return LLVMStructType(&elements, 1, 0 /* packed? */);
}
! static LLVMTypeRef sym_ptr_type(LLVMModuleRef module, struct symbol *sym)
{
LLVMTypeRef type;
/* 'void *' is treated like 'char *' */
if (is_void_type(sym->ctype.base_type))
type = LLVMInt8Type();
else
! type = symbol_type(module, sym->ctype.base_type);
return LLVMPointerType(type, 0);
}
static LLVMTypeRef sym_basetype_type(struct symbol *sym)
{
LLVMTypeRef ret = NULL;
! if (symbol_is_fp_type(sym)) {
switch (sym->bit_size) {
case 32:
ret = LLVMFloatType();
break;
case 64:
--- 109,136 ----
elements = LLVMArrayType(LLVMInt8Type(), union_size);
return LLVMStructType(&elements, 1, 0 /* packed? */);
}
! static LLVMTypeRef sym_ptr_type(struct symbol *sym)
{
LLVMTypeRef type;
/* 'void *' is treated like 'char *' */
if (is_void_type(sym->ctype.base_type))
type = LLVMInt8Type();
else
! type = symbol_type(sym->ctype.base_type);
return LLVMPointerType(type, 0);
}
static LLVMTypeRef sym_basetype_type(struct symbol *sym)
{
LLVMTypeRef ret = NULL;
! if (is_float_type(sym)) {
switch (sym->bit_size) {
case 32:
ret = LLVMFloatType();
break;
case 64:
*** 197,239 ****
}
return ret;
}
! static LLVMTypeRef symbol_type(LLVMModuleRef module, struct symbol *sym)
{
LLVMTypeRef ret = NULL;
/* don't cache the result for SYM_NODE */
if (sym->type == SYM_NODE)
! return symbol_type(module, sym->ctype.base_type);
if (sym->aux)
return sym->aux;
switch (sym->type) {
case SYM_BITFIELD:
case SYM_ENUM:
! ret = symbol_type(module, sym->ctype.base_type);
break;
case SYM_BASETYPE:
ret = sym_basetype_type(sym);
break;
case SYM_PTR:
! ret = sym_ptr_type(module, sym);
break;
case SYM_UNION:
! ret = sym_union_type(module, sym);
break;
case SYM_STRUCT:
! ret = sym_struct_type(module, sym);
break;
case SYM_ARRAY:
! ret = sym_array_type(module, sym);
break;
case SYM_FN:
! ret = sym_func_type(module, sym);
break;
default:
assert(0);
}
--- 170,215 ----
}
return ret;
}
! static LLVMTypeRef symbol_type(struct symbol *sym)
{
LLVMTypeRef ret = NULL;
/* don't cache the result for SYM_NODE */
if (sym->type == SYM_NODE)
! return symbol_type(sym->ctype.base_type);
if (sym->aux)
return sym->aux;
switch (sym->type) {
case SYM_BITFIELD:
+ ret = LLVMIntType(sym->bit_size);
+ break;
+ case SYM_RESTRICT:
case SYM_ENUM:
! ret = symbol_type(sym->ctype.base_type);
break;
case SYM_BASETYPE:
ret = sym_basetype_type(sym);
break;
case SYM_PTR:
! ret = sym_ptr_type(sym);
break;
case SYM_UNION:
! ret = sym_union_type(sym);
break;
case SYM_STRUCT:
! ret = sym_struct_type(sym);
break;
case SYM_ARRAY:
! ret = sym_array_type(sym);
break;
case SYM_FN:
! ret = sym_func_type(sym);
break;
default:
assert(0);
}
*** 240,273 ****
/* cache the result */
sym->aux = ret;
return ret;
}
! static LLVMTypeRef int_type_by_size(int size)
{
! switch (size) {
! case 1: return LLVMInt1Type();
case 8: return LLVMInt8Type();
case 16: return LLVMInt16Type();
case 32: return LLVMInt32Type();
case 64: return LLVMInt64Type();
default:
! die("invalid bit size %d", size);
break;
}
return NULL; /* not reached */
}
- static LLVMTypeRef insn_symbol_type(LLVMModuleRef module, struct instruction *insn)
- {
- if (insn->type)
- return symbol_type(module, insn->type);
-
- return int_type_by_size(insn->size);
- }
-
static LLVMLinkage data_linkage(struct symbol *sym)
{
if (sym->ctype.modifiers & MOD_STATIC)
return LLVMPrivateLinkage;
--- 216,244 ----
/* cache the result */
sym->aux = ret;
return ret;
}
! static LLVMTypeRef insn_symbol_type(struct instruction *insn)
{
! if (insn->type)
! return symbol_type(insn->type);
!
! switch (insn->size) {
case 8: return LLVMInt8Type();
case 16: return LLVMInt16Type();
case 32: return LLVMInt32Type();
case 64: return LLVMInt64Type();
default:
! die("invalid bit size %d", insn->size);
break;
}
+
return NULL; /* not reached */
}
static LLVMLinkage data_linkage(struct symbol *sym)
{
if (sym->ctype.modifiers & MOD_STATIC)
return LLVMPrivateLinkage;
*** 282,373 ****
return LLVMExternalLinkage;
}
#define MAX_PSEUDO_NAME 64
! static void pseudo_name(pseudo_t pseudo, char *buf)
{
switch (pseudo->type) {
case PSEUDO_REG:
! snprintf(buf, MAX_PSEUDO_NAME, "R%d", pseudo->nr);
break;
! case PSEUDO_SYM:
! assert(0);
break;
case PSEUDO_VAL:
! assert(0);
break;
! case PSEUDO_ARG: {
assert(0);
break;
- }
- case PSEUDO_PHI:
- snprintf(buf, MAX_PSEUDO_NAME, "PHI%d", pseudo->nr);
- break;
default:
assert(0);
}
}
! static LLVMValueRef pseudo_to_value(struct function *fn, struct instruction *insn, pseudo_t pseudo)
{
LLVMValueRef result = NULL;
-
- switch (pseudo->type) {
- case PSEUDO_REG:
- result = pseudo->priv;
- break;
- case PSEUDO_SYM: {
- struct symbol *sym = pseudo->sym;
struct expression *expr;
assert(sym->bb_target == NULL);
expr = sym->initializer;
! if (expr) {
switch (expr->type) {
case EXPR_STRING: {
const char *s = expr->string->data;
LLVMValueRef indices[] = { LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt64Type(), 0, 0) };
LLVMValueRef data;
! data = LLVMAddGlobal(fn->module, LLVMArrayType(LLVMInt8Type(), strlen(s) + 1), ".str");
LLVMSetLinkage(data, LLVMPrivateLinkage);
LLVMSetGlobalConstant(data, 1);
LLVMSetInitializer(data, LLVMConstString(strdup(s), strlen(s) + 1, true));
result = LLVMConstGEP(data, indices, ARRAY_SIZE(indices));
! break;
}
! case EXPR_SYMBOL: {
! struct symbol *sym = expr->symbol;
!
! result = LLVMGetNamedGlobal(fn->module, show_ident(sym->ident));
! assert(result != NULL);
break;
}
- default:
- assert(0);
}
- } else {
- const char *name = show_ident(sym->ident);
- LLVMTypeRef type = symbol_type(fn->module, sym);
if (LLVMGetTypeKind(type) == LLVMFunctionTypeKind) {
! result = LLVMGetNamedFunction(fn->module, name);
if (!result)
! result = LLVMAddFunction(fn->module, name, type);
} else {
! result = LLVMGetNamedGlobal(fn->module, name);
if (!result)
! result = LLVMAddGlobal(fn->module, type, name);
}
}
break;
}
case PSEUDO_VAL:
! result = LLVMConstInt(int_type_by_size(pseudo->size), pseudo->value, 1);
break;
case PSEUDO_ARG: {
result = LLVMGetParam(fn->fn, pseudo->nr - 1);
break;
}
--- 253,386 ----
return LLVMExternalLinkage;
}
#define MAX_PSEUDO_NAME 64
! static const char *pseudo_name(pseudo_t pseudo, char *buf)
{
switch (pseudo->type) {
case PSEUDO_REG:
! snprintf(buf, MAX_PSEUDO_NAME, "R%d.", pseudo->nr);
break;
! case PSEUDO_PHI:
! snprintf(buf, MAX_PSEUDO_NAME, "PHI%d.", pseudo->nr);
break;
+ case PSEUDO_SYM:
case PSEUDO_VAL:
! case PSEUDO_ARG:
! case PSEUDO_VOID:
! buf[0] = '\0';
break;
! case PSEUDO_UNDEF:
assert(0);
break;
default:
assert(0);
}
+
+ return buf;
}
! static LLVMValueRef get_sym_value(LLVMModuleRef module, struct symbol *sym)
{
+ const char *name = show_ident(sym->ident);
+ LLVMTypeRef type = symbol_type(sym);
LLVMValueRef result = NULL;
struct expression *expr;
assert(sym->bb_target == NULL);
expr = sym->initializer;
! if (expr && !sym->ident) {
switch (expr->type) {
case EXPR_STRING: {
const char *s = expr->string->data;
LLVMValueRef indices[] = { LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt64Type(), 0, 0) };
LLVMValueRef data;
! data = LLVMAddGlobal(module, LLVMArrayType(LLVMInt8Type(), strlen(s) + 1), ".str");
LLVMSetLinkage(data, LLVMPrivateLinkage);
LLVMSetGlobalConstant(data, 1);
LLVMSetInitializer(data, LLVMConstString(strdup(s), strlen(s) + 1, true));
result = LLVMConstGEP(data, indices, ARRAY_SIZE(indices));
! return result;
}
! default:
break;
}
}
if (LLVMGetTypeKind(type) == LLVMFunctionTypeKind) {
! result = LLVMGetNamedFunction(module, name);
if (!result)
! result = LLVMAddFunction(module, name, type);
} else {
! result = LLVMGetNamedGlobal(module, name);
if (!result)
! result = LLVMAddGlobal(module, type, name);
}
+
+ return result;
+ }
+
+ static LLVMValueRef constant_value(unsigned long long val, LLVMTypeRef dtype)
+ {
+ LLVMValueRef result;
+
+ switch (LLVMGetTypeKind(dtype)) {
+ case LLVMPointerTypeKind:
+ if (val != 0) { // for example: ... = (void*) 0x123;
+ LLVMTypeRef itype = LLVMIntType(bits_in_pointer);
+ result = LLVMConstInt(itype, val, 1);
+ result = LLVMConstIntToPtr(result, dtype);
+ } else {
+ result = LLVMConstPointerNull(dtype);
}
break;
+ case LLVMIntegerTypeKind:
+ result = LLVMConstInt(dtype, val, 1);
+ break;
+ case LLVMArrayTypeKind:
+ case LLVMStructTypeKind:
+ if (val != 0)
+ return NULL;
+ result = LLVMConstNull(dtype);
+ break;
+ default:
+ return NULL;
}
+ return result;
+ }
+
+ static LLVMValueRef val_to_value(unsigned long long val, struct symbol *ctype)
+ {
+ LLVMValueRef result;
+ LLVMTypeRef dtype;
+
+ assert(ctype);
+ dtype = symbol_type(ctype);
+ result = constant_value(val, dtype);
+ if (result)
+ return result;
+ sparse_error(ctype->pos, "no value possible for %s", show_typename(ctype));
+ return LLVMGetUndef(symbol_type(ctype));
+ }
+
+ static LLVMValueRef pseudo_to_value(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
+ {
+ LLVMValueRef result = NULL;
+
+ switch (pseudo->type) {
+ case PSEUDO_REG:
+ result = pseudo->priv;
+ break;
+ case PSEUDO_SYM:
+ result = get_sym_value(fn->module, pseudo->sym);
+ break;
case PSEUDO_VAL:
! result = val_to_value(pseudo->value, ctype);
break;
case PSEUDO_ARG: {
result = LLVMGetParam(fn->fn, pseudo->nr - 1);
break;
}
*** 375,421 ****
result = pseudo->priv;
break;
case PSEUDO_VOID:
result = NULL;
break;
default:
assert(0);
}
return result;
}
static LLVMValueRef calc_gep(LLVMBuilderRef builder, LLVMValueRef base, LLVMValueRef off)
{
LLVMTypeRef type = LLVMTypeOf(base);
unsigned int as = LLVMGetPointerAddressSpace(type);
LLVMTypeRef bytep = LLVMPointerType(LLVMInt8Type(), as);
LLVMValueRef addr;
/* convert base to char* type */
! base = LLVMBuildPointerCast(builder, base, bytep, "");
/* addr = base + off */
! addr = LLVMBuildInBoundsGEP(builder, base, &off, 1, "");
/* convert back to the actual pointer type */
! addr = LLVMBuildPointerCast(builder, addr, type, "");
return addr;
}
static LLVMRealPredicate translate_fop(int opcode)
{
static const LLVMRealPredicate trans_tbl[] = {
! [OP_SET_EQ] = LLVMRealOEQ,
! [OP_SET_NE] = LLVMRealUNE,
! [OP_SET_LE] = LLVMRealOLE,
! [OP_SET_GE] = LLVMRealOGE,
! [OP_SET_LT] = LLVMRealOLT,
! [OP_SET_GT] = LLVMRealOGT,
! /* Are these used with FP? */
! [OP_SET_B] = LLVMRealOLT,
! [OP_SET_A] = LLVMRealOGT,
! [OP_SET_BE] = LLVMRealOLE,
! [OP_SET_AE] = LLVMRealOGE,
};
return trans_tbl[opcode];
}
--- 388,515 ----
result = pseudo->priv;
break;
case PSEUDO_VOID:
result = NULL;
break;
+ case PSEUDO_UNDEF:
+ result = LLVMGetUndef(symbol_type(ctype));
+ break;
default:
assert(0);
}
return result;
}
+ static LLVMValueRef pseudo_to_rvalue(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
+ {
+ LLVMValueRef val = pseudo_to_value(fn, ctype, pseudo);
+ LLVMTypeRef dtype = symbol_type(ctype);
+ char name[MAX_PSEUDO_NAME];
+
+ pseudo_name(pseudo, name);
+ return LLVMBuildBitCast(fn->builder, val, dtype, name);
+ }
+
+ static LLVMValueRef value_to_ivalue(struct function *fn, struct symbol *ctype, LLVMValueRef val)
+ {
+ const char *name = LLVMGetValueName(val);
+ LLVMTypeRef dtype = symbol_type(ctype);
+
+ if (LLVMGetTypeKind(LLVMTypeOf(val)) == LLVMPointerTypeKind) {
+ LLVMTypeRef dtype = LLVMIntType(bits_in_pointer);
+ val = LLVMBuildPtrToInt(fn->builder, val, dtype, name);
+ }
+ if (ctype && is_int_type(ctype)) {
+ val = LLVMBuildIntCast(fn->builder, val, dtype, name);
+ }
+ return val;
+ }
+
+ static LLVMValueRef value_to_pvalue(struct function *fn, struct symbol *ctype, LLVMValueRef val)
+ {
+ const char *name = LLVMGetValueName(val);
+ LLVMTypeRef dtype = symbol_type(ctype);
+
+ assert(is_ptr_type(ctype));
+ switch (LLVMGetTypeKind(LLVMTypeOf(val))) {
+ case LLVMIntegerTypeKind:
+ val = LLVMBuildIntToPtr(fn->builder, val, dtype, name);
+ break;
+ case LLVMPointerTypeKind:
+ val = LLVMBuildBitCast(fn->builder, val, dtype, name);
+ break;
+ default:
+ break;
+ }
+ return val;
+ }
+
+ static LLVMValueRef adjust_type(struct function *fn, struct symbol *ctype, LLVMValueRef val)
+ {
+ if (is_int_type(ctype))
+ return value_to_ivalue(fn, ctype, val);
+ if (is_ptr_type(ctype))
+ return value_to_pvalue(fn, ctype, val);
+ return val;
+ }
+
+ /*
+ * Get the LLVMValue corresponding to the pseudo
+ * and force the type corresponding to ctype.
+ */
+ static LLVMValueRef get_operand(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
+ {
+ LLVMValueRef target = pseudo_to_value(fn, ctype, pseudo);
+ return adjust_type(fn, ctype, target);
+ }
+
+ /*
+ * Get the LLVMValue corresponding to the pseudo
+ * and force the type corresponding to ctype but
+ * map all pointers to intptr_t.
+ */
+ static LLVMValueRef get_ioperand(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
+ {
+ LLVMValueRef target = pseudo_to_value(fn, ctype, pseudo);
+ return value_to_ivalue(fn, ctype, target);
+ }
+
static LLVMValueRef calc_gep(LLVMBuilderRef builder, LLVMValueRef base, LLVMValueRef off)
{
LLVMTypeRef type = LLVMTypeOf(base);
unsigned int as = LLVMGetPointerAddressSpace(type);
LLVMTypeRef bytep = LLVMPointerType(LLVMInt8Type(), as);
LLVMValueRef addr;
+ const char *name = LLVMGetValueName(off);
/* convert base to char* type */
! base = LLVMBuildPointerCast(builder, base, bytep, name);
/* addr = base + off */
! addr = LLVMBuildInBoundsGEP(builder, base, &off, 1, name);
/* convert back to the actual pointer type */
! addr = LLVMBuildPointerCast(builder, addr, type, name);
return addr;
}
static LLVMRealPredicate translate_fop(int opcode)
{
static const LLVMRealPredicate trans_tbl[] = {
! [OP_FCMP_ORD] = LLVMRealORD,
! [OP_FCMP_OEQ] = LLVMRealOEQ,
! [OP_FCMP_ONE] = LLVMRealONE,
! [OP_FCMP_OLE] = LLVMRealOLE,
! [OP_FCMP_OGE] = LLVMRealOGE,
! [OP_FCMP_OLT] = LLVMRealOLT,
! [OP_FCMP_OGT] = LLVMRealOGT,
! [OP_FCMP_UEQ] = LLVMRealUEQ,
! [OP_FCMP_UNE] = LLVMRealUNE,
! [OP_FCMP_ULE] = LLVMRealULE,
! [OP_FCMP_UGE] = LLVMRealUGE,
! [OP_FCMP_ULT] = LLVMRealULT,
! [OP_FCMP_UGT] = LLVMRealUGT,
! [OP_FCMP_UNO] = LLVMRealUNO,
};
return trans_tbl[opcode];
}
*** 440,580 ****
static void output_op_binary(struct function *fn, struct instruction *insn)
{
LLVMValueRef lhs, rhs, target;
char target_name[64];
! lhs = pseudo_to_value(fn, insn, insn->src1);
- rhs = pseudo_to_value(fn, insn, insn->src2);
-
pseudo_name(insn->target, target_name);
switch (insn->opcode) {
/* Binary */
case OP_ADD:
- if (symbol_is_fp_type(insn->type))
- target = LLVMBuildFAdd(fn->builder, lhs, rhs, target_name);
- else
target = LLVMBuildAdd(fn->builder, lhs, rhs, target_name);
break;
case OP_SUB:
- if (symbol_is_fp_type(insn->type))
- target = LLVMBuildFSub(fn->builder, lhs, rhs, target_name);
- else
target = LLVMBuildSub(fn->builder, lhs, rhs, target_name);
break;
! case OP_MULU:
! if (symbol_is_fp_type(insn->type))
! target = LLVMBuildFMul(fn->builder, lhs, rhs, target_name);
! else
target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
break;
- case OP_MULS:
- assert(!symbol_is_fp_type(insn->type));
- target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
- break;
case OP_DIVU:
- if (symbol_is_fp_type(insn->type))
- target = LLVMBuildFDiv(fn->builder, lhs, rhs, target_name);
- else
target = LLVMBuildUDiv(fn->builder, lhs, rhs, target_name);
break;
case OP_DIVS:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildSDiv(fn->builder, lhs, rhs, target_name);
break;
case OP_MODU:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildURem(fn->builder, lhs, rhs, target_name);
break;
case OP_MODS:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildSRem(fn->builder, lhs, rhs, target_name);
break;
case OP_SHL:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildShl(fn->builder, lhs, rhs, target_name);
break;
case OP_LSR:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildLShr(fn->builder, lhs, rhs, target_name);
break;
case OP_ASR:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildAShr(fn->builder, lhs, rhs, target_name);
break;
/* Logical */
case OP_AND:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildAnd(fn->builder, lhs, rhs, target_name);
break;
case OP_OR:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildOr(fn->builder, lhs, rhs, target_name);
break;
case OP_XOR:
! assert(!symbol_is_fp_type(insn->type));
target = LLVMBuildXor(fn->builder, lhs, rhs, target_name);
break;
- case OP_AND_BOOL: {
- LLVMValueRef lhs_nz, rhs_nz;
- LLVMTypeRef dst_type;
-
- lhs_nz = LLVMBuildIsNotNull(fn->builder, lhs, "");
- rhs_nz = LLVMBuildIsNotNull(fn->builder, rhs, "");
- target = LLVMBuildAnd(fn->builder, lhs_nz, rhs_nz, target_name);
-
- dst_type = insn_symbol_type(fn->module, insn);
- target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
- break;
- }
- case OP_OR_BOOL: {
- LLVMValueRef lhs_nz, rhs_nz;
- LLVMTypeRef dst_type;
-
- lhs_nz = LLVMBuildIsNotNull(fn->builder, lhs, "");
- rhs_nz = LLVMBuildIsNotNull(fn->builder, rhs, "");
- target = LLVMBuildOr(fn->builder, lhs_nz, rhs_nz, target_name);
-
- dst_type = insn_symbol_type(fn->module, insn);
- target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
- break;
- }
default:
assert(0);
break;
}
insn->target->priv = target;
}
static void output_op_compare(struct function *fn, struct instruction *insn)
{
LLVMValueRef lhs, rhs, target;
char target_name[64];
! lhs = pseudo_to_value(fn, insn, insn->src1);
!
if (insn->src2->type == PSEUDO_VAL)
! rhs = LLVMConstInt(LLVMTypeOf(lhs), insn->src2->value, 1);
else
! rhs = pseudo_to_value(fn, insn, insn->src2);
pseudo_name(insn->target, target_name);
! LLVMTypeRef dst_type = insn_symbol_type(fn->module, insn);
! if (LLVMGetTypeKind(LLVMTypeOf(lhs)) == LLVMIntegerTypeKind) {
LLVMIntPredicate op = translate_op(insn->opcode);
target = LLVMBuildICmp(fn->builder, op, lhs, rhs, target_name);
! } else {
LLVMRealPredicate op = translate_fop(insn->opcode);
target = LLVMBuildFCmp(fn->builder, op, lhs, rhs, target_name);
}
target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
insn->target->priv = target;
}
--- 534,670 ----
static void output_op_binary(struct function *fn, struct instruction *insn)
{
LLVMValueRef lhs, rhs, target;
char target_name[64];
! lhs = get_ioperand(fn, insn->type, insn->src1);
! rhs = get_ioperand(fn, insn->type, insn->src2);
pseudo_name(insn->target, target_name);
switch (insn->opcode) {
/* Binary */
case OP_ADD:
target = LLVMBuildAdd(fn->builder, lhs, rhs, target_name);
break;
case OP_SUB:
target = LLVMBuildSub(fn->builder, lhs, rhs, target_name);
break;
! case OP_MUL:
target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
break;
case OP_DIVU:
target = LLVMBuildUDiv(fn->builder, lhs, rhs, target_name);
break;
case OP_DIVS:
! assert(!is_float_type(insn->type));
target = LLVMBuildSDiv(fn->builder, lhs, rhs, target_name);
break;
case OP_MODU:
! assert(!is_float_type(insn->type));
target = LLVMBuildURem(fn->builder, lhs, rhs, target_name);
break;
case OP_MODS:
! assert(!is_float_type(insn->type));
target = LLVMBuildSRem(fn->builder, lhs, rhs, target_name);
break;
case OP_SHL:
! assert(!is_float_type(insn->type));
target = LLVMBuildShl(fn->builder, lhs, rhs, target_name);
break;
case OP_LSR:
! assert(!is_float_type(insn->type));
target = LLVMBuildLShr(fn->builder, lhs, rhs, target_name);
break;
case OP_ASR:
! assert(!is_float_type(insn->type));
target = LLVMBuildAShr(fn->builder, lhs, rhs, target_name);
break;
+ /* floating-point */
+ case OP_FADD:
+ target = LLVMBuildFAdd(fn->builder, lhs, rhs, target_name);
+ break;
+ case OP_FSUB:
+ target = LLVMBuildFSub(fn->builder, lhs, rhs, target_name);
+ break;
+ case OP_FMUL:
+ target = LLVMBuildFMul(fn->builder, lhs, rhs, target_name);
+ break;
+ case OP_FDIV:
+ target = LLVMBuildFDiv(fn->builder, lhs, rhs, target_name);
+ break;
+
/* Logical */
case OP_AND:
! assert(!is_float_type(insn->type));
target = LLVMBuildAnd(fn->builder, lhs, rhs, target_name);
break;
case OP_OR:
! assert(!is_float_type(insn->type));
target = LLVMBuildOr(fn->builder, lhs, rhs, target_name);
break;
case OP_XOR:
! assert(!is_float_type(insn->type));
target = LLVMBuildXor(fn->builder, lhs, rhs, target_name);
break;
default:
assert(0);
break;
}
+ target = adjust_type(fn, insn->type, target);
insn->target->priv = target;
}
static void output_op_compare(struct function *fn, struct instruction *insn)
{
LLVMValueRef lhs, rhs, target;
char target_name[64];
! lhs = pseudo_to_value(fn, NULL, insn->src1);
if (insn->src2->type == PSEUDO_VAL)
! rhs = constant_value(insn->src2->value, LLVMTypeOf(lhs));
else
! rhs = pseudo_to_value(fn, NULL, insn->src2);
! if (!rhs)
! rhs = LLVMGetUndef(symbol_type(insn->type));
pseudo_name(insn->target, target_name);
! LLVMTypeRef dst_type = insn_symbol_type(insn);
! switch (LLVMGetTypeKind(LLVMTypeOf(lhs))) {
! case LLVMPointerTypeKind:
! lhs = value_to_pvalue(fn, &ptr_ctype, lhs);
! rhs = value_to_pvalue(fn, &ptr_ctype, rhs);
! /* fall through */
!
! case LLVMIntegerTypeKind: {
LLVMIntPredicate op = translate_op(insn->opcode);
+ if (LLVMGetTypeKind(LLVMTypeOf(rhs)) == LLVMPointerTypeKind) {
+ LLVMTypeRef ltype = LLVMTypeOf(lhs);
+ rhs = LLVMBuildPtrToInt(fn->builder, rhs, ltype, "");
+ }
target = LLVMBuildICmp(fn->builder, op, lhs, rhs, target_name);
! break;
! }
! case LLVMHalfTypeKind:
! case LLVMFloatTypeKind:
! case LLVMDoubleTypeKind:
! case LLVMX86_FP80TypeKind:
! case LLVMFP128TypeKind:
! case LLVMPPC_FP128TypeKind: {
LLVMRealPredicate op = translate_fop(insn->opcode);
target = LLVMBuildFCmp(fn->builder, op, lhs, rhs, target_name);
+ break;
}
+ default:
+ assert(0);
+ }
target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
insn->target->priv = target;
}
*** 582,593 ****
static void output_op_ret(struct function *fn, struct instruction *insn)
{
pseudo_t pseudo = insn->src;
if (pseudo && pseudo != VOID) {
! LLVMValueRef result = pseudo_to_value(fn, insn, pseudo);
!
LLVMBuildRet(fn->builder, result);
} else
LLVMBuildRetVoid(fn->builder);
}
--- 672,682 ----
static void output_op_ret(struct function *fn, struct instruction *insn)
{
pseudo_t pseudo = insn->src;
if (pseudo && pseudo != VOID) {
! LLVMValueRef result = get_operand(fn, insn->type, pseudo);
LLVMBuildRet(fn->builder, result);
} else
LLVMBuildRetVoid(fn->builder);
}
*** 600,613 ****
/* int type large enough to hold a pointer */
int_type = LLVMIntType(bits_in_pointer);
off = LLVMConstInt(int_type, insn->offset, 0);
/* convert src to the effective pointer type */
! src = pseudo_to_value(fn, insn, insn->src);
as = LLVMGetPointerAddressSpace(LLVMTypeOf(src));
! addr_type = LLVMPointerType(insn_symbol_type(fn->module, insn), as);
! src = LLVMBuildPointerCast(fn->builder, src, addr_type, "");
/* addr = src + off */
addr = calc_gep(fn->builder, src, off);
return addr;
}
--- 689,702 ----
/* int type large enough to hold a pointer */
int_type = LLVMIntType(bits_in_pointer);
off = LLVMConstInt(int_type, insn->offset, 0);
/* convert src to the effective pointer type */
! src = pseudo_to_value(fn, insn->type, insn->src);
as = LLVMGetPointerAddressSpace(LLVMTypeOf(src));
! addr_type = LLVMPointerType(insn_symbol_type(insn), as);
! src = LLVMBuildPointerCast(fn->builder, src, addr_type, LLVMGetValueName(src));
/* addr = src + off */
addr = calc_gep(fn->builder, src, off);
return addr;
}
*** 614,658 ****
static void output_op_load(struct function *fn, struct instruction *insn)
{
LLVMValueRef addr, target;
addr = calc_memop_addr(fn, insn);
/* perform load */
! target = LLVMBuildLoad(fn->builder, addr, "load_target");
insn->target->priv = target;
}
static void output_op_store(struct function *fn, struct instruction *insn)
{
! LLVMValueRef addr, target, target_in;
addr = calc_memop_addr(fn, insn);
! target_in = pseudo_to_value(fn, insn, insn->target);
/* perform store */
! target = LLVMBuildStore(fn->builder, target_in, addr);
!
! insn->target->priv = target;
}
static LLVMValueRef bool_value(struct function *fn, LLVMValueRef value)
{
if (LLVMTypeOf(value) != LLVMInt1Type())
! value = LLVMBuildIsNotNull(fn->builder, value, "cond");
return value;
}
static void output_op_cbr(struct function *fn, struct instruction *br)
{
LLVMValueRef cond = bool_value(fn,
! pseudo_to_value(fn, br, br->cond));
LLVMBuildCondBr(fn->builder, cond,
br->bb_true->priv,
br->bb_false->priv);
}
--- 703,747 ----
static void output_op_load(struct function *fn, struct instruction *insn)
{
LLVMValueRef addr, target;
+ char name[MAX_PSEUDO_NAME];
addr = calc_memop_addr(fn, insn);
/* perform load */
! pseudo_name(insn->target, name);
! target = LLVMBuildLoad(fn->builder, addr, name);
insn->target->priv = target;
}
static void output_op_store(struct function *fn, struct instruction *insn)
{
! LLVMValueRef addr, target_in;
addr = calc_memop_addr(fn, insn);
! target_in = pseudo_to_rvalue(fn, insn->type, insn->target);
/* perform store */
! LLVMBuildStore(fn->builder, target_in, addr);
}
static LLVMValueRef bool_value(struct function *fn, LLVMValueRef value)
{
if (LLVMTypeOf(value) != LLVMInt1Type())
! value = LLVMBuildIsNotNull(fn->builder, value, LLVMGetValueName(value));
return value;
}
static void output_op_cbr(struct function *fn, struct instruction *br)
{
LLVMValueRef cond = bool_value(fn,
! pseudo_to_value(fn, NULL, br->cond));
LLVMBuildCondBr(fn->builder, cond,
br->bb_true->priv,
br->bb_false->priv);
}
*** 663,680 ****
}
static void output_op_sel(struct function *fn, struct instruction *insn)
{
LLVMValueRef target, src1, src2, src3;
! src1 = bool_value(fn, pseudo_to_value(fn, insn, insn->src1));
! src2 = pseudo_to_value(fn, insn, insn->src2);
! src3 = pseudo_to_value(fn, insn, insn->src3);
! target = LLVMBuildSelect(fn->builder, src1, src2, src3, "select");
! insn->target->priv = target;
}
static void output_op_switch(struct function *fn, struct instruction *insn)
{
LLVMValueRef sw_val, target;
--- 752,771 ----
}
static void output_op_sel(struct function *fn, struct instruction *insn)
{
LLVMValueRef target, src1, src2, src3;
+ char name[MAX_PSEUDO_NAME];
! src1 = bool_value(fn, pseudo_to_value(fn, NULL, insn->src1));
! src2 = get_operand(fn, insn->type, insn->src2);
! src3 = get_operand(fn, insn->type, insn->src3);
! pseudo_name(insn->target, name);
! target = LLVMBuildSelect(fn->builder, src1, src2, src3, name);
! insn->target->priv = adjust_type(fn, insn->type, target);
}
static void output_op_switch(struct function *fn, struct instruction *insn)
{
LLVMValueRef sw_val, target;
*** 681,735 ****
struct basic_block *def = NULL;
struct multijmp *jmp;
int n_jmp = 0;
FOR_EACH_PTR(insn->multijmp_list, jmp) {
! if (jmp->begin == jmp->end) { /* case N */
! n_jmp++;
! } else if (jmp->begin < jmp->end) { /* case M..N */
! assert(0);
} else /* default case */
def = jmp->target;
} END_FOR_EACH_PTR(jmp);
! sw_val = pseudo_to_value(fn, insn, insn->target);
target = LLVMBuildSwitch(fn->builder, sw_val,
def ? def->priv : NULL, n_jmp);
FOR_EACH_PTR(insn->multijmp_list, jmp) {
! if (jmp->begin == jmp->end) { /* case N */
! LLVMAddCase(target,
! LLVMConstInt(LLVMInt32Type(), jmp->begin, 0),
! jmp->target->priv);
! } else if (jmp->begin < jmp->end) { /* case M..N */
! assert(0);
}
} END_FOR_EACH_PTR(jmp);
-
- insn->target->priv = target;
}
static void output_op_call(struct function *fn, struct instruction *insn)
{
LLVMValueRef target, func;
int n_arg = 0, i;
struct pseudo *arg;
LLVMValueRef *args;
! FOR_EACH_PTR(insn->arguments, arg) {
! n_arg++;
! } END_FOR_EACH_PTR(arg);
!
args = calloc(n_arg, sizeof(LLVMValueRef));
i = 0;
FOR_EACH_PTR(insn->arguments, arg) {
! args[i++] = pseudo_to_value(fn, insn, arg);
} END_FOR_EACH_PTR(arg);
! func = pseudo_to_value(fn, insn, insn->func);
! target = LLVMBuildCall(fn->builder, func, args, n_arg, "");
insn->target->priv = target;
}
static void output_op_phisrc(struct function *fn, struct instruction *insn)
--- 772,827 ----
struct basic_block *def = NULL;
struct multijmp *jmp;
int n_jmp = 0;
FOR_EACH_PTR(insn->multijmp_list, jmp) {
! if (jmp->begin <= jmp->end) {
! n_jmp += (jmp->end - jmp->begin) + 1;
} else /* default case */
def = jmp->target;
} END_FOR_EACH_PTR(jmp);
! sw_val = get_ioperand(fn, insn->type, insn->cond);
target = LLVMBuildSwitch(fn->builder, sw_val,
def ? def->priv : NULL, n_jmp);
FOR_EACH_PTR(insn->multijmp_list, jmp) {
! long long val;
!
! for (val = jmp->begin; val <= jmp->end; val++) {
! LLVMValueRef Val = val_to_value(val, insn->type);
! LLVMAddCase(target, Val, jmp->target->priv);
}
} END_FOR_EACH_PTR(jmp);
}
static void output_op_call(struct function *fn, struct instruction *insn)
{
LLVMValueRef target, func;
+ struct symbol *ctype;
int n_arg = 0, i;
struct pseudo *arg;
LLVMValueRef *args;
+ char name[64];
! n_arg = pseudo_list_size(insn->arguments);
args = calloc(n_arg, sizeof(LLVMValueRef));
+ PREPARE_PTR_LIST(insn->fntypes, ctype);
+ if (insn->func->type == PSEUDO_REG || insn->func->type == PSEUDO_PHI)
+ func = get_operand(fn, ctype, insn->func);
+ else
+ func = pseudo_to_value(fn, ctype, insn->func);
i = 0;
FOR_EACH_PTR(insn->arguments, arg) {
! NEXT_PTR_LIST(ctype);
! args[i++] = pseudo_to_rvalue(fn, ctype, arg);
} END_FOR_EACH_PTR(arg);
+ FINISH_PTR_LIST(ctype);
! pseudo_name(insn->target, name);
! target = LLVMBuildCall(fn->builder, func, args, n_arg, name);
insn->target->priv = target;
}
static void output_op_phisrc(struct function *fn, struct instruction *insn)
*** 738,748 ****
struct instruction *phi;
assert(insn->target->priv == NULL);
/* target = src */
! v = pseudo_to_value(fn, insn, insn->phi_src);
FOR_EACH_PTR(insn->phi_users, phi) {
LLVMValueRef load, ptr;
assert(phi->opcode == OP_PHI);
--- 830,840 ----
struct instruction *phi;
assert(insn->target->priv == NULL);
/* target = src */
! v = get_operand(fn, insn->type, insn->phi_src);
FOR_EACH_PTR(insn->phi_users, phi) {
LLVMValueRef load, ptr;
assert(phi->opcode == OP_PHI);
*** 768,813 ****
}
static void output_op_ptrcast(struct function *fn, struct instruction *insn)
{
LLVMValueRef src, target;
char target_name[64];
! src = insn->src->priv;
! if (!src)
! src = pseudo_to_value(fn, insn, insn->src);
!
pseudo_name(insn->target, target_name);
! assert(!symbol_is_fp_type(insn->type));
! target = LLVMBuildBitCast(fn->builder, src, insn_symbol_type(fn->module, insn), target_name);
!
insn->target->priv = target;
}
static void output_op_cast(struct function *fn, struct instruction *insn, LLVMOpcode op)
{
LLVMValueRef src, target;
char target_name[64];
! src = insn->src->priv;
! if (!src)
! src = pseudo_to_value(fn, insn, insn->src);
pseudo_name(insn->target, target_name);
! assert(!symbol_is_fp_type(insn->type));
! if (insn->size < LLVMGetIntTypeWidth(LLVMTypeOf(src)))
! target = LLVMBuildTrunc(fn->builder, src, insn_symbol_type(fn->module, insn), target_name);
! else
! target = LLVMBuildCast(fn->builder, op, src, insn_symbol_type(fn->module, insn), target_name);
insn->target->priv = target;
}
static void output_insn(struct function *fn, struct instruction *insn)
{
switch (insn->opcode) {
case OP_RET:
output_op_ret(fn, insn);
--- 860,990 ----
}
static void output_op_ptrcast(struct function *fn, struct instruction *insn)
{
LLVMValueRef src, target;
+ LLVMTypeRef dtype;
+ struct symbol *otype = insn->orig_type;
+ LLVMOpcode op;
char target_name[64];
! src = get_operand(fn, otype, insn->src);
pseudo_name(insn->target, target_name);
! dtype = symbol_type(insn->type);
! switch (insn->opcode) {
! case OP_UTPTR:
! case OP_SEXT: // FIXME
! assert(is_int_type(otype));
! assert(is_ptr_type(insn->type));
! op = LLVMIntToPtr;
! break;
! case OP_PTRTU:
! assert(is_ptr_type(otype));
! assert(is_int_type(insn->type));
! op = LLVMPtrToInt;
! break;
! case OP_PTRCAST:
! case OP_ZEXT: // FIXME
! assert(is_ptr_type(otype));
! assert(is_ptr_type(insn->type));
! op = LLVMBitCast;
! break;
! default:
! assert(0);
! }
! target = LLVMBuildCast(fn->builder, op, src, dtype, target_name);
insn->target->priv = target;
}
static void output_op_cast(struct function *fn, struct instruction *insn, LLVMOpcode op)
{
LLVMValueRef src, target;
+ LLVMTypeRef dtype;
+ struct symbol *otype = insn->orig_type;
char target_name[64];
! if (is_ptr_type(insn->type)) // cast to void* is OP_CAST ...
! return output_op_ptrcast(fn, insn);
+ assert(is_int_type(insn->type));
+
+ src = get_operand(fn, otype, insn->src);
pseudo_name(insn->target, target_name);
! dtype = symbol_type(insn->type);
! if (is_ptr_type(otype)) {
! op = LLVMPtrToInt;
! } else if (is_float_type(otype)) {
! assert(op == LLVMFPToUI || op == LLVMFPToSI);
! } else if (is_int_type(otype)) {
! unsigned int width = otype->bit_size;
! if (insn->size < width)
! op = LLVMTrunc;
! else if (insn->size == width)
! op = LLVMBitCast;
! } else {
! assert(0);
! }
! target = LLVMBuildCast(fn->builder, op, src, dtype, target_name);
! insn->target->priv = target;
! }
+ static void output_op_fpcast(struct function *fn, struct instruction *insn)
+ {
+ LLVMTypeRef dtype = symbol_type(insn->type);
+ LLVMValueRef src, target;
+ struct symbol *otype = insn->orig_type;
+ char name[64];
+
+ assert(is_float_type(insn->type));
+
+ pseudo_name(insn->target, name);
+ src = get_operand(fn, otype, insn->src);
+ switch (insn->opcode) {
+ case OP_FCVTF:
+ target = LLVMBuildFPCast(fn->builder, src, dtype, name);
+ break;
+ case OP_SCVTF:
+ target = LLVMBuildSIToFP(fn->builder, src, dtype, name);
+ break;
+ case OP_UCVTF:
+ target = LLVMBuildUIToFP(fn->builder, src, dtype, name);
+ break;
+ default:
+ assert(0);
+ }
insn->target->priv = target;
}
+ static void output_op_setval(struct function *fn, struct instruction *insn)
+ {
+ struct expression *val = insn->val;
+ LLVMValueRef target;
+
+ switch (val->type) {
+ case EXPR_LABEL:
+ target = LLVMBlockAddress(fn->fn, val->symbol->bb_target->priv);
+ break;
+ default:
+ assert(0);
+ }
+
+ insn->target->priv = target;
+ }
+
+ static void output_op_setfval(struct function *fn, struct instruction *insn)
+ {
+ LLVMTypeRef dtype = symbol_type(insn->type);
+ LLVMValueRef target;
+
+ target = LLVMConstReal(dtype, insn->fvalue);
+ insn->target->priv = target;
+ }
+
static void output_insn(struct function *fn, struct instruction *insn)
{
switch (insn->opcode) {
case OP_RET:
output_op_ret(fn, insn);
*** 820,831 ****
break;
case OP_SYMADDR:
assert(0);
break;
case OP_SETVAL:
! assert(0);
break;
case OP_SWITCH:
output_op_switch(fn, insn);
break;
case OP_COMPUTEDGOTO:
assert(0);
--- 997,1011 ----
break;
case OP_SYMADDR:
assert(0);
break;
case OP_SETVAL:
! output_op_setval(fn, insn);
break;
+ case OP_SETFVAL:
+ output_op_setfval(fn, insn);
+ break;
case OP_SWITCH:
output_op_switch(fn, insn);
break;
case OP_COMPUTEDGOTO:
assert(0);
*** 837,877 ****
output_op_phi(fn, insn);
break;
case OP_LOAD:
output_op_load(fn, insn);
break;
- case OP_LNOP:
- assert(0);
- break;
case OP_STORE:
output_op_store(fn, insn);
break;
- case OP_SNOP:
- assert(0);
- break;
case OP_INLINED_CALL:
- assert(0);
break;
case OP_CALL:
output_op_call(fn, insn);
break;
! case OP_CAST:
output_op_cast(fn, insn, LLVMZExt);
break;
! case OP_SCAST:
output_op_cast(fn, insn, LLVMSExt);
break;
! case OP_FPCAST:
! assert(0);
break;
case OP_PTRCAST:
output_op_ptrcast(fn, insn);
break;
case OP_BINARY ... OP_BINARY_END:
output_op_binary(fn, insn);
break;
! case OP_BINCMP ... OP_BINCMP_END:
output_op_compare(fn, insn);
break;
case OP_SEL:
output_op_sel(fn, insn);
break;
--- 1017,1062 ----
output_op_phi(fn, insn);
break;
case OP_LOAD:
output_op_load(fn, insn);
break;
case OP_STORE:
output_op_store(fn, insn);
break;
case OP_INLINED_CALL:
break;
case OP_CALL:
output_op_call(fn, insn);
break;
! case OP_ZEXT:
output_op_cast(fn, insn, LLVMZExt);
break;
! case OP_SEXT:
output_op_cast(fn, insn, LLVMSExt);
break;
! case OP_TRUNC:
! output_op_cast(fn, insn, LLVMTrunc);
break;
+ case OP_FCVTU:
+ output_op_cast(fn, insn, LLVMFPToUI);
+ break;
+ case OP_FCVTS:
+ output_op_cast(fn, insn, LLVMFPToSI);
+ break;
+ case OP_UCVTF: case OP_SCVTF:
+ case OP_FCVTF:
+ output_op_fpcast(fn, insn);
+ break;
+ case OP_UTPTR:
+ case OP_PTRTU:
case OP_PTRCAST:
output_op_ptrcast(fn, insn);
break;
case OP_BINARY ... OP_BINARY_END:
output_op_binary(fn, insn);
break;
! case OP_FPCMP ... OP_BINCMP_END:
output_op_compare(fn, insn);
break;
case OP_SEL:
output_op_sel(fn, insn);
break;
*** 880,901 ****
break;
case OP_NOT: {
LLVMValueRef src, target;
char target_name[64];
! src = pseudo_to_value(fn, insn, insn->src);
pseudo_name(insn->target, target_name);
target = LLVMBuildNot(fn->builder, src, target_name);
insn->target->priv = target;
break;
}
! case OP_NEG:
! assert(0);
break;
case OP_CONTEXT:
assert(0);
break;
case OP_RANGE:
assert(0);
--- 1065,1100 ----
break;
case OP_NOT: {
LLVMValueRef src, target;
char target_name[64];
! src = pseudo_to_value(fn, insn->type, insn->src);
pseudo_name(insn->target, target_name);
target = LLVMBuildNot(fn->builder, src, target_name);
insn->target->priv = target;
break;
}
! case OP_FNEG:
! case OP_NEG: {
! LLVMValueRef src, target;
! char target_name[64];
!
! src = pseudo_to_value(fn, insn->type, insn->src);
!
! pseudo_name(insn->target, target_name);
!
! if (insn->opcode == OP_FNEG)
! target = LLVMBuildFNeg(fn->builder, src, target_name);
! else
! target = LLVMBuildNeg(fn->builder, src, target_name);
!
! insn->target->priv = target;
break;
+ }
case OP_CONTEXT:
assert(0);
break;
case OP_RANGE:
assert(0);
*** 914,929 ****
default:
break;
}
}
! static void output_bb(struct function *fn, struct basic_block *bb, unsigned long generation)
{
struct instruction *insn;
- bb->generation = generation;
-
FOR_EACH_PTR(bb->insns, insn) {
if (!insn->bb)
continue;
output_insn(fn, insn);
--- 1113,1126 ----
default:
break;
}
}
! static void output_bb(struct function *fn, struct basic_block *bb)
{
struct instruction *insn;
FOR_EACH_PTR(bb->insns, insn) {
if (!insn->bb)
continue;
output_insn(fn, insn);
*** 933,979 ****
#define MAX_ARGS 64
static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
{
- unsigned long generation = ++bb_generation;
struct symbol *sym = ep->name;
struct symbol *base_type = sym->ctype.base_type;
- struct symbol *ret_type = sym->ctype.base_type->ctype.base_type;
- LLVMTypeRef arg_types[MAX_ARGS];
- LLVMTypeRef return_type;
struct function function = { .module = module };
struct basic_block *bb;
- struct symbol *arg;
- const char *name;
int nr_args = 0;
! FOR_EACH_PTR(base_type->arguments, arg) {
! struct symbol *arg_base_type = arg->ctype.base_type;
!
! arg_types[nr_args++] = symbol_type(module, arg_base_type);
! } END_FOR_EACH_PTR(arg);
!
! name = show_ident(sym->ident);
!
! return_type = symbol_type(module, ret_type);
!
! function.type = LLVMFunctionType(return_type, arg_types, nr_args, 0);
!
! function.fn = LLVMAddFunction(module, name, function.type);
LLVMSetFunctionCallConv(function.fn, LLVMCCallConv);
-
LLVMSetLinkage(function.fn, function_linkage(sym));
function.builder = LLVMCreateBuilder();
! static int nr_bb;
! FOR_EACH_PTR(ep->bbs, bb) {
! if (bb->generation == generation)
! continue;
LLVMBasicBlockRef bbr;
char bbname[32];
struct instruction *insn;
sprintf(bbname, "L%d", nr_bb++);
--- 1130,1166 ----
#define MAX_ARGS 64
static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
{
struct symbol *sym = ep->name;
struct symbol *base_type = sym->ctype.base_type;
struct function function = { .module = module };
struct basic_block *bb;
int nr_args = 0;
+ int i;
! function.fn = get_sym_value(module, sym);
LLVMSetFunctionCallConv(function.fn, LLVMCCallConv);
LLVMSetLinkage(function.fn, function_linkage(sym));
function.builder = LLVMCreateBuilder();
! /* give a name to each argument */
! nr_args = symbol_list_size(base_type->arguments);
! for (i = 0; i < nr_args; i++) {
! char name[MAX_PSEUDO_NAME];
! LLVMValueRef arg;
! arg = LLVMGetParam(function.fn, i);
! snprintf(name, sizeof(name), "ARG%d.", i+1);
! LLVMSetValueName(arg, name);
! }
+ /* create the BBs */
+ FOR_EACH_PTR(ep->bbs, bb) {
+ static int nr_bb;
LLVMBasicBlockRef bbr;
char bbname[32];
struct instruction *insn;
sprintf(bbname, "L%d", nr_bb++);
*** 990,1015 ****
if (!insn->bb || insn->opcode != OP_PHI)
continue;
/* insert alloca into entry block */
entrybbr = LLVMGetEntryBasicBlock(function.fn);
LLVMPositionBuilderAtEnd(function.builder, entrybbr);
! phi_type = insn_symbol_type(module, insn);
ptr = LLVMBuildAlloca(function.builder, phi_type, "");
/* emit forward load for phi */
LLVMClearInsertionPosition(function.builder);
insn->target->priv = LLVMBuildLoad(function.builder, ptr, "phi");
} END_FOR_EACH_PTR(insn);
}
END_FOR_EACH_PTR(bb);
FOR_EACH_PTR(ep->bbs, bb) {
- if (bb->generation == generation)
- continue;
-
LLVMPositionBuilderAtEnd(function.builder, bb->priv);
! output_bb(&function, bb, generation);
}
END_FOR_EACH_PTR(bb);
}
static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
--- 1177,1199 ----
if (!insn->bb || insn->opcode != OP_PHI)
continue;
/* insert alloca into entry block */
entrybbr = LLVMGetEntryBasicBlock(function.fn);
LLVMPositionBuilderAtEnd(function.builder, entrybbr);
! phi_type = insn_symbol_type(insn);
ptr = LLVMBuildAlloca(function.builder, phi_type, "");
/* emit forward load for phi */
LLVMClearInsertionPosition(function.builder);
insn->target->priv = LLVMBuildLoad(function.builder, ptr, "phi");
} END_FOR_EACH_PTR(insn);
}
END_FOR_EACH_PTR(bb);
FOR_EACH_PTR(ep->bbs, bb) {
LLVMPositionBuilderAtEnd(function.builder, bb->priv);
! output_bb(&function, bb);
}
END_FOR_EACH_PTR(bb);
}
static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
*** 1020,1031 ****
const char *name;
if (initializer) {
switch (initializer->type) {
case EXPR_VALUE:
! initial_value = LLVMConstInt(symbol_type(module, sym), initializer->value, 1);
break;
case EXPR_SYMBOL: {
struct symbol *sym = initializer->symbol;
initial_value = LLVMGetNamedGlobal(module, show_ident(sym->ident));
if (!initial_value)
--- 1204,1218 ----
const char *name;
if (initializer) {
switch (initializer->type) {
case EXPR_VALUE:
! initial_value = LLVMConstInt(symbol_type(sym), initializer->value, 1);
break;
+ case EXPR_FVALUE:
+ initial_value = LLVMConstReal(symbol_type(sym), initializer->fvalue);
+ break;
case EXPR_SYMBOL: {
struct symbol *sym = initializer->symbol;
initial_value = LLVMGetNamedGlobal(module, show_ident(sym->ident));
if (!initial_value)
*** 1037,1056 ****
initial_value = LLVMConstString(strdup(s), strlen(s) + 1, true);
break;
}
default:
! assert(0);
}
} else {
! LLVMTypeRef type = symbol_type(module, sym);
initial_value = LLVMConstNull(type);
}
! name = show_ident(sym->ident);
data = LLVMAddGlobal(module, LLVMTypeOf(initial_value), name);
LLVMSetLinkage(data, data_linkage(sym));
if (sym->ctype.modifiers & MOD_CONST)
LLVMSetGlobalConstant(data, 1);
--- 1224,1248 ----
initial_value = LLVMConstString(strdup(s), strlen(s) + 1, true);
break;
}
default:
! warning(initializer->pos, "can't initialize type: %s", show_typename(sym));
! initial_value = NULL;
! break;
}
} else {
! LLVMTypeRef type = symbol_type(sym);
initial_value = LLVMConstNull(type);
}
! if (!initial_value)
! return NULL;
+ name = sym->ident ? show_ident(sym->ident) : "" ;
+
data = LLVMAddGlobal(module, LLVMTypeOf(initial_value), name);
LLVMSetLinkage(data, data_linkage(sym));
if (sym->ctype.modifiers & MOD_CONST)
LLVMSetGlobalConstant(data, 1);
*** 1078,1089 ****
FOR_EACH_PTR(list, sym) {
struct entrypoint *ep;
expand_symbol(sym);
! if (is_prototype(sym))
continue;
ep = linearize_symbol(sym);
if (ep)
output_fn(module, ep);
else
--- 1270,1284 ----
FOR_EACH_PTR(list, sym) {
struct entrypoint *ep;
expand_symbol(sym);
! if (is_prototype(sym)) {
! // this will do the LLVMAddFunction() we want
! get_sym_value(module, sym);
continue;
+ }
ep = linearize_symbol(sym);
if (ep)
output_fn(module, ep);
else
*** 1156,1171 ****
compile(module, symlist);
/* need ->phi_users */
dbg_dead = 1;
! FOR_EACH_PTR_NOTAG(filelist, file) {
symlist = sparse(file);
if (die_if_error)
return 1;
compile(module, symlist);
! } END_FOR_EACH_PTR_NOTAG(file);
LLVMVerifyModule(module, LLVMPrintMessageAction, NULL);
LLVMWriteBitcodeToFD(module, STDOUT_FILENO, 0, 0);
--- 1351,1366 ----
compile(module, symlist);
/* need ->phi_users */
dbg_dead = 1;
! FOR_EACH_PTR(filelist, file) {
symlist = sparse(file);
if (die_if_error)
return 1;
compile(module, symlist);
! } END_FOR_EACH_PTR(file);
LLVMVerifyModule(module, LLVMPrintMessageAction, NULL);
LLVMWriteBitcodeToFD(module, STDOUT_FILENO, 0, 0);