X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=27c82207bd096c57899853b819239d44658e0d5a;hb=3cdead30b5c1d131d5c363188c26255514ea2fc8;hp=c30463cc7690e3654355d9ef37cd362efabd01f0;hpb=ed1ed2b5fb813fd8de24b2eaa6fffce033246a8c;p=cparser diff --git a/ast2firm.c b/ast2firm.c index c30463c..27c8220 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -32,6 +32,7 @@ #include "adt/error.h" #include "adt/array.h" +#include "adt/util.h" #include "symbol_t.h" #include "token_t.h" #include "type_t.h" @@ -54,6 +55,12 @@ static ir_type *ir_type_wchar_t; static ir_type *ir_type_void; static ir_type *ir_type_int; +/* architecture specific floating point arithmetic mode (if any) */ +static ir_mode *mode_float_arithmetic; + +/* alignment of stack parameters */ +static unsigned stack_param_align; + static int next_value_number_function; static ir_node *continue_label; static ir_node *break_label; @@ -90,7 +97,14 @@ typedef enum declaration_kind_t { DECLARATION_KIND_INNER_FUNCTION } declaration_kind_t; -static ir_mode *get_ir_mode(type_t *type); +static ir_mode *get_ir_mode_storage(type_t *type); +/* + * get arithmetic mode for a type. This is different from get_ir_mode_storage, + * int that it returns bigger modes for floating point on some platforms + * (x87 internally does arithemtic with 80bits) + */ +static ir_mode *get_ir_mode_arithmetic(type_t *type); + static ir_type *get_ir_type_incomplete(type_t *type); static void enqueue_inner_function(entity_t *entity) @@ -230,55 +244,6 @@ ir_mode *get_atomic_mode(atomic_type_kind_t kind) return atomic_modes[kind]; } -static unsigned get_compound_type_size(compound_type_t *type) -{ - ir_type *irtype = get_ir_type((type_t*) type); - return get_type_size_bytes(irtype); -} - -static unsigned get_array_type_size(array_type_t *type) -{ - assert(!type->is_vla); - ir_type *irtype = get_ir_type((type_t*) type); - return get_type_size_bytes(irtype); -} - -static unsigned get_type_size_const(type_t *type) -{ - switch(type->kind) { - case TYPE_ERROR: - panic("error type occurred"); - case TYPE_ATOMIC: - return get_atomic_type_size(type->atomic.akind); - case TYPE_COMPLEX: - return 2 * get_atomic_type_size(type->complex.akind); - case TYPE_IMAGINARY: - return get_atomic_type_size(type->imaginary.akind); - case TYPE_ENUM: - return get_mode_size_bytes(mode_int); - case TYPE_COMPOUND_UNION: - case TYPE_COMPOUND_STRUCT: - return get_compound_type_size(&type->compound); - case TYPE_FUNCTION: - /* just a pointer to the function */ - return get_mode_size_bytes(mode_P_code); - case TYPE_POINTER: - case TYPE_REFERENCE: - return get_mode_size_bytes(mode_P_data); - case TYPE_ARRAY: - return get_array_type_size(&type->array); - case TYPE_BUILTIN: - return get_type_size_const(type->builtin.real_type); - case TYPE_BITFIELD: - panic("type size of bitfield request"); - case TYPE_TYPEDEF: - case TYPE_TYPEOF: - case TYPE_INVALID: - break; - } - panic("Trying to determine size of invalid type"); -} - static ir_node *get_vla_size(array_type_t *const type) { ir_node *size_node = type->size_node; @@ -289,6 +254,9 @@ static ir_node *get_vla_size(array_type_t *const type) return size_node; } +/** + * Return a node representing the size of a type. + */ static ir_node *get_type_size(type_t *type) { type = skip_typeref(type); @@ -301,7 +269,7 @@ static ir_node *get_type_size(type_t *type) return real_size; } - ir_mode *mode = get_ir_mode(type_size_t); + ir_mode *mode = get_ir_mode_storage(type_size_t); symconst_symbol sym; sym.type_p = get_ir_type(type); return new_SymConst(mode, sym, symconst_type_size); @@ -319,17 +287,30 @@ static unsigned count_parameters(const function_type_t *function_type) return count; } +static type_t *get_aligned_type(type_t *type, int alignment) +{ + if (alignment == 0) + return type; + + type = skip_typeref(type); + if (alignment > type->base.alignment) { + type_t *copy = duplicate_type(type); + copy->base.alignment = alignment; + type = identify_new_type(copy); + } + return type; +} + /** * Creates a Firm type for an atomic type */ -static ir_type *create_atomic_type(const atomic_type_t *type) +static ir_type *create_atomic_type(atomic_type_kind_t akind, int alignment) { - atomic_type_kind_t kind = type->akind; - ir_mode *mode = atomic_modes[kind]; + ir_mode *mode = atomic_modes[akind]; ident *id = get_mode_ident(mode); ir_type *irtype = new_type_primitive(id, mode); - set_type_alignment_bytes(irtype, type->base.alignment); + set_type_alignment_bytes(irtype, alignment); return irtype; } @@ -643,6 +624,8 @@ static ir_type *create_compound_type(compound_type_t *type, ir_type *irtype, symbol_t *symbol = entry->base.symbol; type_t *entry_type = skip_typeref(entry->declaration.type); + entry_type + = get_aligned_type(entry_type, entry->compound_member.alignment); dbg_info *dbgi = get_dbg_info(&entry->base.source_position); ident *ident; @@ -796,7 +779,7 @@ static ir_type *create_enum_type(enum_type_t *const type) constant_folding = constant_folding_old; - return ir_type_int; + return create_atomic_type(type->akind, type->base.alignment); } static ir_type *get_ir_type_incomplete(type_t *type) @@ -836,10 +819,11 @@ ir_type *get_ir_type(type_t *type) switch (type->kind) { case TYPE_ERROR: /* Happens while constant folding, when there was an error */ - return create_atomic_type(&type_void->atomic); + return create_atomic_type(ATOMIC_TYPE_VOID, 0); case TYPE_ATOMIC: - firm_type = create_atomic_type(&type->atomic); + firm_type = create_atomic_type(type->atomic.akind, + type->base.alignment); break; case TYPE_COMPLEX: firm_type = create_complex_type(&type->complex); @@ -889,7 +873,7 @@ ir_type *get_ir_type(type_t *type) return firm_type; } -ir_mode *get_ir_mode(type_t *type) +static ir_mode *get_ir_mode_storage(type_t *type) { ir_type *irtype = get_ir_type(type); @@ -903,6 +887,16 @@ ir_mode *get_ir_mode(type_t *type) return mode; } +static ir_mode *get_ir_mode_arithmetic(type_t *type) +{ + ir_mode *mode = get_ir_mode_storage(type); + if (mode_is_float(mode) && mode_float_arithmetic != NULL) { + return mode_float_arithmetic; + } + + return mode; +} + /** Names of the runtime functions. */ static const struct { int id; /**< the rts id */ @@ -985,7 +979,7 @@ static const struct { { rts_strncmp, 1, "strncmp", 3, _C89 } }; -static ident *rts_idents[sizeof(rts_data) / sizeof(rts_data[0])]; +static ident *rts_idents[lengthof(rts_data)]; static ident* (*create_ld_ident)(entity_t*) = create_name_linux_elf; @@ -1050,12 +1044,8 @@ static ir_entity *get_function_entity(entity_t *entity) if (type->function.linkage != LINKAGE_C) { type_t *new_type = duplicate_type(type); new_type->function.linkage = LINKAGE_C; - - type = typehash_insert(new_type); - if (type != new_type) { - obstack_free(type_obst, new_type); - } - entity->declaration.type = type; + type = identify_new_type(new_type); + entity->declaration.type = type; } } @@ -1109,7 +1099,7 @@ static ir_entity *get_function_entity(entity_t *entity) this is not needed. */ if (! firm_opt.freestanding) { /* check for a known runtime function */ - for (size_t i = 0; i < sizeof(rts_data) / sizeof(rts_data[0]); ++i) { + for (size_t i = 0; i < lengthof(rts_data); ++i) { if (id != rts_idents[i]) continue; @@ -1130,13 +1120,31 @@ entity_created: return irentity; } +static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) +{ + ir_mode *value_mode = get_irn_mode(value); + + if (value_mode == dest_mode || is_Bad(value)) + return value; + + if (dest_mode == mode_b) { + ir_node *zero = new_Const(get_mode_null(value_mode)); + ir_node *cmp = new_d_Cmp(dbgi, value, zero); + ir_node *proj = new_d_Proj(dbgi, cmp, mode_b, pn_Cmp_Lg); + return proj; + } + + return new_d_Conv(dbgi, value, dest_mode); +} + /** * Creates a Const node representing a constant. */ static ir_node *const_to_firm(const const_expression_t *cnst) { dbg_info *dbgi = get_dbg_info(&cnst->base.source_position); - ir_mode *mode = get_ir_mode(cnst->base.type); + type_t *type = skip_typeref(cnst->base.type); + ir_mode *mode = get_ir_mode_storage(type); char buf[128]; tarval *tv; @@ -1153,7 +1161,9 @@ static ir_node *const_to_firm(const const_expression_t *cnst) tv = new_tarval_from_str(buf, len, mode); } - return new_d_Const(dbgi, tv); + ir_node *res = new_d_Const(dbgi, tv); + ir_mode *mode_arith = get_ir_mode_arithmetic(type); + return create_conv(dbgi, res, mode_arith); } /** @@ -1162,13 +1172,15 @@ static ir_node *const_to_firm(const const_expression_t *cnst) static ir_node *character_constant_to_firm(const const_expression_t *cnst) { dbg_info *dbgi = get_dbg_info(&cnst->base.source_position); - ir_mode *mode = get_ir_mode(cnst->base.type); + ir_mode *mode = get_ir_mode_arithmetic(cnst->base.type); - long long int v = 0; - for (size_t i = 0; i < cnst->v.character.size; ++i) { - if (char_is_signed) { - v = (v << 8) | ((signed char)cnst->v.character.begin[i]); - } else { + long long int v; + size_t const size = cnst->v.character.size; + if (size == 1 && char_is_signed) { + v = (signed char)cnst->v.character.begin[0]; + } else { + v = 0; + for (size_t i = 0; i < size; ++i) { v = (v << 8) | ((unsigned char)cnst->v.character.begin[i]); } } @@ -1185,7 +1197,7 @@ static ir_node *character_constant_to_firm(const const_expression_t *cnst) static ir_node *wide_character_constant_to_firm(const const_expression_t *cnst) { dbg_info *dbgi = get_dbg_info(&cnst->base.source_position); - ir_mode *mode = get_ir_mode(cnst->base.type); + ir_mode *mode = get_ir_mode_arithmetic(cnst->base.type); long long int v = cnst->v.wide_character.begin[0]; @@ -1319,22 +1331,22 @@ static ir_node *deref_address(dbg_info *const dbgi, type_t *const type, return addr; } + ir_cons_flags flags = type->base.qualifiers & TYPE_QUALIFIER_VOLATILE + ? cons_volatile : cons_none; ir_mode *const mode = get_type_mode(irtype); ir_node *const memory = get_store(); - ir_node *const load = new_d_Load(dbgi, memory, addr, mode); + ir_node *const load = new_d_Load(dbgi, memory, addr, mode, flags); ir_node *const load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M); ir_node *const load_res = new_d_Proj(dbgi, load, mode, pn_Load_res); - if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE && !is_Bad(load)) { - set_Load_volatility(load, volatility_is_volatile); - } - set_store(load_mem); - return load_res; + + ir_mode *const mode_arithmetic = get_ir_mode_arithmetic(type); + return create_conv(dbgi, load_res, mode_arithmetic); } /** - * Creates a strict Conv if neccessary. + * Creates a strict Conv if necessary. */ static ir_node *do_strict_conv(dbg_info *dbgi, ir_node *node) { @@ -1388,27 +1400,11 @@ static ir_node *get_local_frame(ir_entity *const ent) } } -static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) -{ - ir_mode *value_mode = get_irn_mode(value); - - if (value_mode == dest_mode || is_Bad(value)) - return value; - - if (dest_mode == mode_b) { - ir_node *zero = new_Const(get_mode_null(value_mode)); - ir_node *cmp = new_d_Cmp(dbgi, value, zero); - ir_node *proj = new_d_Proj(dbgi, cmp, mode_b, pn_Cmp_Lg); - return proj; - } - - return new_d_Conv(dbgi, value, dest_mode); -} - /** * Keep all memory edges of the given block. */ -static void keep_all_memory(ir_node *block) { +static void keep_all_memory(ir_node *block) +{ ir_node *old = get_cur_block(); set_cur_block(block); @@ -1443,19 +1439,36 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref) break; case DECLARATION_KIND_LOCAL_VARIABLE: { - ir_mode *const mode = get_ir_mode(type); - return get_value(entity->variable.v.value_number, mode); + ir_mode *const mode = get_ir_mode_storage(type); + ir_node *const value = get_value(entity->variable.v.value_number, mode); + return create_conv(NULL, value, get_ir_mode_arithmetic(type)); } case DECLARATION_KIND_PARAMETER: { - ir_mode *const mode = get_ir_mode(type); - return get_value(entity->parameter.v.value_number, mode); + ir_mode *const mode = get_ir_mode_storage(type); + ir_node *const value = get_value(entity->parameter.v.value_number,mode); + return create_conv(NULL, value, get_ir_mode_arithmetic(type)); } case DECLARATION_KIND_FUNCTION: { - ir_mode *const mode = get_ir_mode(type); + ir_mode *const mode = get_ir_mode_storage(type); + + if (entity->function.btk != bk_none) { + /* for gcc compatibility we have to produce (dummy) addresses for some + * builtins */ + if (warning.other) { + warningf(&ref->base.source_position, + "taking address of builtin '%Y'", ref->entity->base.symbol); + } + + /* simply create a NULL pointer */ + ir_mode *mode = get_ir_mode_arithmetic(type_void_ptr); + ir_node *res = new_Const_long(mode, 0); + + return res; + } return create_symconst(dbgi, mode, entity->function.entity); } case DECLARATION_KIND_INNER_FUNCTION: { - ir_mode *const mode = get_ir_mode(type); + ir_mode *const mode = get_ir_mode_storage(type); if (!entity->function.goto_to_outer && !entity->function.need_closure) { /* inner function not using the closure */ return create_symconst(dbgi, mode, entity->function.entity); @@ -1531,7 +1544,7 @@ static ir_node *reference_addr(const reference_expression_t *ref) case DECLARATION_KIND_FUNCTION: { type_t *const type = skip_typeref(entity->declaration.type); - ir_mode *const mode = get_ir_mode(type); + ir_mode *const mode = get_ir_mode_storage(type); return create_symconst(dbgi, mode, entity->function.entity); } @@ -1543,6 +1556,71 @@ static ir_node *reference_addr(const reference_expression_t *ref) panic("reference to declaration with unknown type found"); } +/** + * Generate an unary builtin. + * + * @param kind the builtin kind to generate + * @param op the operand + * @param function_type the function type for the GNU builtin routine + * @param db debug info + */ +static ir_node *gen_unary_builtin(ir_builtin_kind kind, expression_t *op, type_t *function_type, dbg_info *db) +{ + ir_node *in[1]; + in[0] = expression_to_firm(op); + + ir_type *tp = get_ir_type(function_type); + ir_type *res = get_method_res_type(tp, 0); + ir_node *irn = new_d_Builtin(db, get_irg_no_mem(current_ir_graph), kind, 1, in, tp); + set_irn_pinned(irn, op_pin_state_floats); + return new_Proj(irn, get_type_mode(res), pn_Builtin_1_result); +} + +/** + * Generate a pinned unary builtin. + * + * @param kind the builtin kind to generate + * @param op the operand + * @param function_type the function type for the GNU builtin routine + * @param db debug info + */ +static ir_node *gen_unary_builtin_pinned(ir_builtin_kind kind, expression_t *op, type_t *function_type, dbg_info *db) +{ + ir_node *in[1]; + in[0] = expression_to_firm(op); + + ir_type *tp = get_ir_type(function_type); + ir_type *res = get_method_res_type(tp, 0); + ir_node *mem = get_store(); + ir_node *irn = new_d_Builtin(db, mem, kind, 1, in, tp); + set_store(new_Proj(irn, mode_M, pn_Builtin_M)); + return new_Proj(irn, get_type_mode(res), pn_Builtin_1_result); +} + + +/** + * Generate an binary-void-return builtin. + * + * @param kind the builtin kind to generate + * @param op1 the first operand + * @param op2 the second operand + * @param function_type the function type for the GNU builtin routine + * @param db debug info + */ +static ir_node *gen_binary_builtin_mem(ir_builtin_kind kind, expression_t *op1, expression_t *op2, + type_t *function_type, dbg_info *db) +{ + ir_node *in[2]; + in[0] = expression_to_firm(op1); + in[1] = expression_to_firm(op2); + + ir_type *tp = get_ir_type(function_type); + ir_node *mem = get_store(); + ir_node *irn = new_d_Builtin(db, mem, kind, 2, in, tp); + set_store(new_Proj(irn, mode_M, pn_Builtin_M)); + return NULL; +} + /** * Transform calls to builtin functions. */ @@ -1550,17 +1628,16 @@ static ir_node *process_builtin_call(const call_expression_t *call) { dbg_info *dbgi = get_dbg_info(&call->base.source_position); - assert(call->function->kind == EXPR_BUILTIN_SYMBOL); - builtin_symbol_expression_t *builtin = &call->function->builtin_symbol; + assert(call->function->kind == EXPR_REFERENCE); + reference_expression_t *builtin = &call->function->reference; type_t *type = skip_typeref(builtin->base.type); assert(is_type_pointer(type)); type_t *function_type = skip_typeref(type->pointer.points_to); - symbol_t *symbol = builtin->symbol; - switch(symbol->ID) { - case T___builtin_alloca: { + switch (builtin->entity->function.btk) { + case bk_gnu_builtin_alloca: { if (call->arguments == NULL || call->arguments->next != NULL) { panic("invalid number of parameters on __builtin_alloca"); } @@ -1577,33 +1654,152 @@ static ir_node *process_builtin_call(const call_expression_t *call) return res; } - case T___builtin_huge_val: - case T___builtin_inf: - case T___builtin_inff: - case T___builtin_infl: { - ir_mode *mode = get_ir_mode(function_type->function.return_type); + case bk_gnu_builtin_huge_val: + case bk_gnu_builtin_inf: + case bk_gnu_builtin_inff: + case bk_gnu_builtin_infl: { + type_t *type = function_type->function.return_type; + ir_mode *mode = get_ir_mode_arithmetic(type); tarval *tv = get_mode_infinite(mode); ir_node *res = new_d_Const(dbgi, tv); return res; } - case T___builtin_nan: - case T___builtin_nanf: - case T___builtin_nanl: { + case bk_gnu_builtin_nan: + case bk_gnu_builtin_nanf: + case bk_gnu_builtin_nanl: { /* Ignore string for now... */ assert(is_type_function(function_type)); - ir_mode *mode = get_ir_mode(function_type->function.return_type); + type_t *type = function_type->function.return_type; + ir_mode *mode = get_ir_mode_arithmetic(type); tarval *tv = get_mode_NAN(mode); ir_node *res = new_d_Const(dbgi, tv); return res; } - case T___builtin_expect: { + case bk_gnu_builtin_expect: { expression_t *argument = call->arguments->expression; return _expression_to_firm(argument); } - case T___builtin_va_end: + case bk_gnu_builtin_va_end: /* evaluate the argument of va_end for its side effects */ _expression_to_firm(call->arguments->expression); return NULL; + case bk_gnu_builtin_frame_address: { + expression_t *const expression = call->arguments->expression; + long val = fold_constant(expression); + if (val == 0) { + /* the nice case */ + return get_irg_frame(current_ir_graph); + } else { + /* get the argument */ + ir_node *in[2]; + + in[0] = expression_to_firm(expression); + in[1] = get_irg_frame(current_ir_graph); + ir_type *tp = get_ir_type(function_type); + ir_node *irn = new_d_Builtin(dbgi, get_irg_no_mem(current_ir_graph), ir_bk_frame_addess, 2, in, tp); + return new_Proj(irn, mode_P_data, pn_Builtin_1_result); + } + } + case bk_gnu_builtin_return_address: { + expression_t *const expression = call->arguments->expression; + ir_node *in[2]; + + in[0] = expression_to_firm(expression); + in[1] = get_irg_frame(current_ir_graph); + ir_type *tp = get_ir_type(function_type); + ir_node *irn = new_d_Builtin(dbgi, get_irg_no_mem(current_ir_graph), ir_bk_return_address, 2, in, tp); + return new_Proj(irn, mode_P_data, pn_Builtin_1_result); + } + case bk_gnu_builtin_ffs: + return gen_unary_builtin(ir_bk_ffs, call->arguments->expression, function_type, dbgi); + case bk_gnu_builtin_clz: + return gen_unary_builtin(ir_bk_clz, call->arguments->expression, function_type, dbgi); + case bk_gnu_builtin_ctz: + return gen_unary_builtin(ir_bk_ctz, call->arguments->expression, function_type, dbgi); + case bk_gnu_builtin_popcount: + case bk_ms__popcount: + return gen_unary_builtin(ir_bk_popcount, call->arguments->expression, function_type, dbgi); + case bk_gnu_builtin_parity: + return gen_unary_builtin(ir_bk_parity, call->arguments->expression, function_type, dbgi); + case bk_gnu_builtin_prefetch: { + call_argument_t *const args = call->arguments; + expression_t *const addr = args->expression; + ir_node *in[3]; + + in[0] = _expression_to_firm(addr); + if (args->next != NULL) { + expression_t *const rw = args->next->expression; + + in[1] = _expression_to_firm(rw); + + if (args->next->next != NULL) { + expression_t *const locality = args->next->next->expression; + + in[2] = expression_to_firm(locality); + } else { + in[2] = new_Const_long(mode_int, 3); + } + } else { + in[1] = new_Const_long(mode_int, 0); + in[2] = new_Const_long(mode_int, 3); + } + ir_type *tp = get_ir_type(function_type); + ir_node *irn = new_d_Builtin(dbgi, get_store(), ir_bk_prefetch, 3, in, tp); + set_store(new_Proj(irn, mode_M, pn_Builtin_M)); + return NULL; + } + case bk_gnu_builtin_trap: + case bk_ms__ud2: + { + ir_type *tp = get_ir_type(function_type); + ir_node *irn = new_d_Builtin(dbgi, get_store(), ir_bk_trap, 0, NULL, tp); + set_store(new_Proj(irn, mode_M, pn_Builtin_M)); + return NULL; + } + case bk_ms__debugbreak: { + ir_type *tp = get_ir_type(function_type); + ir_node *irn = new_d_Builtin(dbgi, get_store(), ir_bk_debugbreak, 0, NULL, tp); + set_store(new_Proj(irn, mode_M, pn_Builtin_M)); + return NULL; + } + case bk_ms_ReturnAddress: { + ir_node *in[2]; + + in[0] = new_Const_long(mode_int, 0); + in[1] = get_irg_frame(current_ir_graph); + ir_type *tp = get_ir_type(function_type); + ir_node *irn = new_d_Builtin(dbgi, get_irg_no_mem(current_ir_graph), ir_bk_return_address, 2, in, tp); + return new_Proj(irn, mode_P_data, pn_Builtin_1_result); + } + case bk_ms_rotl: + case bk_ms_rotl64: { + ir_node *val = expression_to_firm(call->arguments->expression); + ir_node *shf = expression_to_firm(call->arguments->next->expression); + ir_mode *mode = get_irn_mode(val); + return new_d_Rotl(dbgi, val, create_conv(dbgi, shf, mode_uint), mode); + } + case bk_ms_rotr: + case bk_ms_rotr64: { + ir_node *val = expression_to_firm(call->arguments->expression); + ir_node *shf = expression_to_firm(call->arguments->next->expression); + ir_mode *mode = get_irn_mode(val); + ir_node *c = new_Const_long(mode_uint, get_mode_size_bits(mode)); + ir_node *sub = new_d_Sub(dbgi, c, create_conv(dbgi, shf, mode_uint), mode_uint); + return new_d_Rotl(dbgi, val, sub, mode); + } + case bk_ms_byteswap_ushort: + case bk_ms_byteswap_ulong: + case bk_ms_byteswap_uint64: + return gen_unary_builtin(ir_bk_bswap, call->arguments->expression, function_type, dbgi); + case bk_ms__inbyte: + case bk_ms__inword: + case bk_ms__indword: + return gen_unary_builtin_pinned(ir_bk_inport, call->arguments->expression, function_type, dbgi); + case bk_ms__outbyte: + case bk_ms__outword: + case bk_ms__outdword: + return gen_binary_builtin_mem(ir_bk_outport, call->arguments->expression, + call->arguments->next->expression, function_type, dbgi); default: panic("unsupported builtin found"); } @@ -1616,29 +1812,31 @@ static ir_node *process_builtin_call(const call_expression_t *call) * 176.gcc for instance might allocate 2GB instead of 256 MB if alloca is not * handled right... */ -static ir_node *call_expression_to_firm(const call_expression_t *call) +static ir_node *call_expression_to_firm(const call_expression_t *const call) { - dbg_info *dbgi = get_dbg_info(&call->base.source_position); + dbg_info *const dbgi = get_dbg_info(&call->base.source_position); assert(get_cur_block() != NULL); expression_t *function = call->function; - if (function->kind == EXPR_BUILTIN_SYMBOL) { - return process_builtin_call(call); - } if (function->kind == EXPR_REFERENCE) { const reference_expression_t *ref = &function->reference; entity_t *entity = ref->entity; + if (ref->entity->kind == ENTITY_FUNCTION && + ref->entity->function.btk != bk_none) { + return process_builtin_call(call); + } + if (entity->kind == ENTITY_FUNCTION && entity->function.entity == rts_entities[rts_alloca]) { /* handle alloca() call */ expression_t *argument = call->arguments->expression; ir_node *size = expression_to_firm(argument); + ir_mode *mode = get_ir_mode_arithmetic(type_size_t); - size = create_conv(dbgi, size, get_ir_mode(type_size_t)); + size = create_conv(dbgi, size, mode); ir_node *store = get_store(); - dbg_info *dbgi = get_dbg_info(&call->base.source_position); ir_node *alloca = new_d_Alloc(dbgi, store, size, firm_unknown_type, stack_alloc); ir_node *proj_m = new_Proj(alloca, mode_M, pn_Alloc_M); @@ -1669,7 +1867,6 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) /* we need to construct a new method type matching the call * arguments... */ int n_res = get_method_n_ress(ir_method_type); - dbg_info *dbgi = get_dbg_info(&call->base.source_position); new_method_type = new_d_type_method(id_unique("calltype.%u"), n_parameters, n_res, dbgi); set_method_calling_convention(new_method_type, @@ -1701,7 +1898,12 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) expression_t *expression = argument->expression; ir_node *arg_node = expression_to_firm(expression); - arg_node = do_strict_conv(dbgi, arg_node); + type_t *type = skip_typeref(expression->base.type); + if (!is_type_compound(type)) { + ir_mode *mode = get_ir_mode_storage(expression->base.type); + arg_node = create_conv(dbgi, arg_node, mode); + arg_node = do_strict_conv(dbgi, arg_node); + } in[n] = arg_node; @@ -1718,14 +1920,17 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) ir_node *result = NULL; if (!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) { - ir_mode *mode; + ir_node *resproj = new_d_Proj(dbgi, node, mode_T, pn_Call_T_result); + if (is_type_scalar(return_type)) { - mode = get_ir_mode(return_type); + ir_mode *mode = get_ir_mode_storage(return_type); + result = new_d_Proj(dbgi, resproj, mode, 0); + ir_mode *mode_arith = get_ir_mode_arithmetic(return_type); + result = create_conv(NULL, result, mode_arith); } else { - mode = mode_P_data; + ir_mode *mode = mode_P_data; + result = new_d_Proj(dbgi, resproj, mode, 0); } - ir_node *resproj = new_d_Proj(dbgi, node, mode_T, pn_Call_T_result); - result = new_d_Proj(dbgi, resproj, mode, 0); } if (function->kind == EXPR_REFERENCE && @@ -1751,15 +1956,19 @@ static ir_node *create_condition_evaluation(const expression_t *expression, static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type, ir_node *value) { - value = do_strict_conv(dbgi, value); + if (!is_type_compound(type)) { + ir_mode *mode = get_ir_mode_storage(type); + value = create_conv(dbgi, value, mode); + value = do_strict_conv(dbgi, value); + } ir_node *memory = get_store(); if (is_type_scalar(type)) { - ir_node *store = new_d_Store(dbgi, memory, addr, value); + ir_cons_flags flags = type->base.qualifiers & TYPE_QUALIFIER_VOLATILE + ? cons_volatile : cons_none; + ir_node *store = new_d_Store(dbgi, memory, addr, value, flags); ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); - if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE && !is_Bad(store)) - set_Store_volatility(store, volatility_is_volatile); set_store(store_mem); } else { ir_type *irtype = get_ir_type(type); @@ -1791,7 +2000,7 @@ static tarval *create_bitfield_mask(ir_mode *mode, int offset, int size) return mask1; } -static void bitfield_store_to_firm(dbg_info *dbgi, +static ir_node *bitfield_store_to_firm(dbg_info *dbgi, ir_entity *entity, ir_node *addr, ir_node *value, bool set_volatile) { ir_type *entity_type = get_entity_type(entity); @@ -1814,7 +2023,8 @@ static void bitfield_store_to_firm(dbg_info *dbgi, /* load current value */ ir_node *mem = get_store(); - ir_node *load = new_d_Load(dbgi, mem, addr, mode); + ir_node *load = new_d_Load(dbgi, mem, addr, mode, + set_volatile ? cons_volatile : cons_none); ir_node *load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M); ir_node *load_res = new_d_Proj(dbgi, load, mode, pn_Load_res); tarval *shift_mask = create_bitfield_mask(mode, bitoffset, bitsize); @@ -1824,16 +2034,12 @@ static void bitfield_store_to_firm(dbg_info *dbgi, /* construct new value and store */ ir_node *new_val = new_d_Or(dbgi, load_res_masked, value_maskshift, mode); - ir_node *store = new_d_Store(dbgi, load_mem, addr, new_val); + ir_node *store = new_d_Store(dbgi, load_mem, addr, new_val, + set_volatile ? cons_volatile : cons_none); ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); set_store(store_mem); - if (set_volatile) { - if (!is_Bad(load)) - set_Load_volatility(load, volatility_is_volatile); - if (!is_Bad(store)) - set_Store_volatility(store, volatility_is_volatile); - } + return value_masked; } static ir_node *bitfield_extract_to_firm(const select_expression_t *expression, @@ -1841,9 +2047,9 @@ static ir_node *bitfield_extract_to_firm(const select_expression_t *expression, { dbg_info *dbgi = get_dbg_info(&expression->base.source_position); type_t *type = expression->base.type; - ir_mode *mode = get_ir_mode(type); + ir_mode *mode = get_ir_mode_storage(type); ir_node *mem = get_store(); - ir_node *load = new_d_Load(dbgi, mem, addr, mode); + ir_node *load = new_d_Load(dbgi, mem, addr, mode, cons_none); ir_node *load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M); ir_node *load_res = new_d_Proj(dbgi, load, mode, pn_Load_res); @@ -1887,11 +2093,17 @@ static void construct_select_compound(const select_expression_t *expression) (void) get_ir_type(type); } -static void set_value_for_expression_addr(const expression_t *expression, - ir_node *value, ir_node *addr) +static ir_node *set_value_for_expression_addr(const expression_t *expression, + ir_node *value, ir_node *addr) { dbg_info *dbgi = get_dbg_info(&expression->base.source_position); - value = do_strict_conv(dbgi, value); + type_t *type = skip_typeref(expression->base.type); + + if (!is_type_compound(type)) { + ir_mode *mode = get_ir_mode_storage(type); + value = create_conv(dbgi, value, mode); + value = do_strict_conv(dbgi, value); + } if (expression->kind == EXPR_REFERENCE) { const reference_expression_t *ref = &expression->reference; @@ -1901,10 +2113,10 @@ static void set_value_for_expression_addr(const expression_t *expression, assert(entity->declaration.kind != DECLARATION_KIND_UNKNOWN); if (entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE) { set_value(entity->variable.v.value_number, value); - return; + return value; } else if (entity->declaration.kind == DECLARATION_KIND_PARAMETER) { set_value(entity->parameter.v.value_number, value); - return; + return value; } } @@ -1912,8 +2124,6 @@ static void set_value_for_expression_addr(const expression_t *expression, addr = expression_to_addr(expression); assert(addr != NULL); - type_t *type = skip_typeref(expression->base.type); - if (expression->kind == EXPR_SELECT) { const select_expression_t *select = &expression->select; @@ -1925,12 +2135,14 @@ static void set_value_for_expression_addr(const expression_t *expression, ir_entity *irentity = entity->compound_member.entity; bool set_volatile = select->base.type->base.qualifiers & TYPE_QUALIFIER_VOLATILE; - bitfield_store_to_firm(dbgi, irentity, addr, value, set_volatile); - return; + value = bitfield_store_to_firm(dbgi, irentity, addr, value, + set_volatile); + return value; } } assign_value(dbgi, addr, type, value); + return value; } static void set_value_for_expression(const expression_t *expression, @@ -1949,14 +2161,21 @@ static ir_node *get_value_from_lvalue(const expression_t *expression, assert(entity->kind == ENTITY_VARIABLE || entity->kind == ENTITY_PARAMETER); assert(entity->declaration.kind != DECLARATION_KIND_UNKNOWN); + int value_number; if (entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE) { + value_number = entity->variable.v.value_number; assert(addr == NULL); - ir_mode *mode = get_ir_mode(expression->base.type); - return get_value(entity->variable.v.value_number, mode); + type_t *type = skip_typeref(expression->base.type); + ir_mode *mode = get_ir_mode_storage(type); + ir_node *res = get_value(value_number, mode); + return create_conv(NULL, res, get_ir_mode_arithmetic(type)); } else if (entity->declaration.kind == DECLARATION_KIND_PARAMETER) { + value_number = entity->parameter.v.value_number; assert(addr == NULL); - ir_mode *mode = get_ir_mode(expression->base.type); - return get_value(entity->parameter.v.value_number, mode); + type_t *type = skip_typeref(expression->base.type); + ir_mode *mode = get_ir_mode_storage(type); + ir_node *res = get_value(value_number, mode); + return create_conv(NULL, res, get_ir_mode_arithmetic(type)); } } @@ -1984,7 +2203,7 @@ static ir_node *create_incdec(const unary_expression_t *expression) ir_node *value = get_value_from_lvalue(value_expr, addr); type_t *type = skip_typeref(expression->base.type); - ir_mode *mode = get_ir_mode(expression->base.type); + ir_mode *mode = get_ir_mode_arithmetic(expression->base.type); ir_node *offset; if (is_type_pointer(type)) { @@ -2086,7 +2305,7 @@ static ir_node *handle_assume_compare(dbg_info *dbi, var2 = op2->reference.entity; type_t *const type = skip_typeref(var->declaration.type); - ir_mode *const mode = get_ir_mode(type); + ir_mode *const mode = get_ir_mode_storage(type); ir_node *const irn1 = get_value(var->variable.v.value_number, mode); ir_node *const irn2 = get_value(var2->variable.v.value_number, mode); @@ -2112,7 +2331,7 @@ static ir_node *handle_assume_compare(dbg_info *dbi, if (var != NULL) { type_t *const type = skip_typeref(var->declaration.type); - ir_mode *const mode = get_ir_mode(type); + ir_mode *const mode = get_ir_mode_storage(type); res = get_value(var->variable.v.value_number, mode); res = new_d_Confirm(dbi, res, expression_to_firm(con), cmp_val); @@ -2127,7 +2346,8 @@ static ir_node *handle_assume_compare(dbg_info *dbi, * @param dbi debug info * @param expr the IL assume expression */ -static ir_node *handle_assume(dbg_info *dbi, const expression_t *expression) { +static ir_node *handle_assume(dbg_info *dbi, const expression_t *expression) +{ switch(expression->kind) { case EXPR_BINARY_EQUAL: case EXPR_BINARY_NOTEQUAL: @@ -2154,14 +2374,14 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) switch(expression->base.kind) { case EXPR_UNARY_NEGATE: { ir_node *value_node = expression_to_firm(value); - ir_mode *mode = get_ir_mode(type); + ir_mode *mode = get_ir_mode_arithmetic(type); return new_d_Minus(dbgi, value_node, mode); } case EXPR_UNARY_PLUS: return expression_to_firm(value); case EXPR_UNARY_BITWISE_NEGATE: { ir_node *value_node = expression_to_firm(value); - ir_mode *mode = get_ir_mode(type); + ir_mode *mode = get_ir_mode_arithmetic(type); return new_d_Not(dbgi, value_node, mode); } case EXPR_UNARY_NOT: { @@ -2185,9 +2405,11 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) case EXPR_UNARY_CAST: { ir_node *value_node = expression_to_firm(value); if (is_type_scalar(type)) { - ir_mode *mode = get_ir_mode(type); - ir_node *node = create_conv(dbgi, value_node, mode); - node = do_strict_conv(dbgi, node); + ir_mode *mode = get_ir_mode_storage(type); + ir_node *node = create_conv(dbgi, value_node, mode); + node = do_strict_conv(dbgi, node); + ir_mode *mode_arith = get_ir_mode_arithmetic(type); + node = create_conv(dbgi, node, mode_arith); return node; } else { /* make sure firm type is constructed */ @@ -2198,8 +2420,11 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) case EXPR_UNARY_CAST_IMPLICIT: { ir_node *value_node = expression_to_firm(value); if (is_type_scalar(type)) { - ir_mode *mode = get_ir_mode(type); - return create_conv(dbgi, value_node, mode); + ir_mode *mode = get_ir_mode_storage(type); + ir_node *res = create_conv(dbgi, value_node, mode); + ir_mode *mode_arith = get_ir_mode_arithmetic(type); + res = create_conv(dbgi, res, mode_arith); + return res; } else { return value_node; } @@ -2251,26 +2476,14 @@ static ir_node *produce_condition_result(const expression_t *expression, static ir_node *adjust_for_pointer_arithmetic(dbg_info *dbgi, ir_node *value, type_t *type) { - ir_mode *const mode = get_ir_mode(type_ptrdiff_t); + ir_mode *const mode = get_ir_mode_arithmetic(type_ptrdiff_t); assert(is_type_pointer(type)); pointer_type_t *const pointer_type = &type->pointer; type_t *const points_to = skip_typeref(pointer_type->points_to); - unsigned elem_size = get_type_size_const(points_to); - - value = create_conv(dbgi, value, mode); - - /* gcc extension: allow arithmetic with void * and function * */ - if ((elem_size == 0 && is_type_atomic(points_to, ATOMIC_TYPE_VOID)) || - is_type_function(points_to)) { - elem_size = 1; - } - - assert(elem_size >= 1); - if (elem_size == 1) - return value; - - ir_node *const cnst = new_Const_long(mode, (long)elem_size); - ir_node *const mul = new_d_Mul(dbgi, value, cnst, mode); + ir_node * elem_size = get_type_size(points_to); + elem_size = create_conv(dbgi, elem_size, mode); + value = create_conv(dbgi, value, mode); + ir_node *const mul = new_d_Mul(dbgi, value, elem_size, mode); return mul; } @@ -2296,7 +2509,7 @@ static ir_node *create_op(dbg_info *dbgi, const binary_expression_t *expression, if (is_type_pointer(type_left) && is_type_pointer(type_right)) { const pointer_type_t *const ptr_type = &type_left->pointer; - mode = get_ir_mode(expression->base.type); + mode = get_ir_mode_arithmetic(expression->base.type); ir_node *const elem_size = get_type_size(ptr_type->points_to); ir_node *const conv_size = new_d_Conv(dbgi, elem_size, mode); ir_node *const sub = new_d_Sub(dbgi, left, right, mode); @@ -2309,7 +2522,7 @@ static ir_node *create_op(dbg_info *dbgi, const binary_expression_t *expression, case EXPR_BINARY_SUB_ASSIGN: if (is_type_pointer(type_left)) { right = adjust_for_pointer_arithmetic(dbgi, right, type_left); - mode = get_ir_mode(type_left); + mode = get_ir_mode_arithmetic(type_left); break; } goto normal_node; @@ -2318,18 +2531,18 @@ static ir_node *create_op(dbg_info *dbgi, const binary_expression_t *expression, case EXPR_BINARY_ADD_ASSIGN: if (is_type_pointer(type_left)) { right = adjust_for_pointer_arithmetic(dbgi, right, type_left); - mode = get_ir_mode(type_left); + mode = get_ir_mode_arithmetic(type_left); break; } else if (is_type_pointer(type_right)) { left = adjust_for_pointer_arithmetic(dbgi, left, type_right); - mode = get_ir_mode(type_right); + mode = get_ir_mode_arithmetic(type_right); break; } goto normal_node; default: normal_node: - mode = get_ir_mode(type_right); + mode = get_ir_mode_arithmetic(type_right); left = create_conv(dbgi, left, mode); break; } @@ -2394,8 +2607,8 @@ normal_node: static ir_node *create_lazy_op(const binary_expression_t *expression) { dbg_info *dbgi = get_dbg_info(&expression->base.source_position); - type_t *type = expression->base.type; - ir_mode *mode = get_ir_mode(type); + type_t *type = skip_typeref(expression->base.type); + ir_mode *mode = get_ir_mode_arithmetic(type); if (is_constant_expression(expression->left)) { long val = fold_constant(expression->left); @@ -2412,7 +2625,7 @@ static ir_node *create_lazy_op(const binary_expression_t *expression) } if (is_constant_expression(expression->right)) { - long const valr = fold_constant(expression->left); + long const valr = fold_constant(expression->right); return valr != 0 ? new_Const(get_mode_one(mode)) : new_Const(get_mode_null(mode)); @@ -2432,7 +2645,8 @@ static ir_node *create_assign_binop(const binary_expression_t *expression) { dbg_info *const dbgi = get_dbg_info(&expression->base.source_position); const expression_t *left_expr = expression->left; - ir_mode *left_mode = get_ir_mode(left_expr->base.type); + type_t *type = skip_typeref(left_expr->base.type); + ir_mode *left_mode = get_ir_mode_storage(type); ir_node *right = expression_to_firm(expression->right); ir_node *left_addr = expression_to_addr(left_expr); ir_node *left = get_value_from_lvalue(left_expr, left_addr); @@ -2441,8 +2655,12 @@ static ir_node *create_assign_binop(const binary_expression_t *expression) result = create_conv(dbgi, result, left_mode); result = do_strict_conv(dbgi, result); - set_value_for_expression_addr(left_expr, result, left_addr); + result = set_value_for_expression_addr(left_expr, result, left_addr); + if (!is_type_compound(type)) { + ir_mode *mode_arithmetic = get_ir_mode_arithmetic(type); + result = create_conv(dbgi, result, mode_arithmetic); + } return result; } @@ -2474,9 +2692,15 @@ static ir_node *binary_expression_to_firm(const binary_expression_t *expression) case EXPR_BINARY_ASSIGN: { ir_node *addr = expression_to_addr(expression->left); ir_node *right = expression_to_firm(expression->right); - set_value_for_expression_addr(expression->left, right, addr); + ir_node *res + = set_value_for_expression_addr(expression->left, right, addr); - return right; + type_t *type = skip_typeref(expression->base.type); + if (!is_type_compound(type)) { + ir_mode *mode_arithmetic = get_ir_mode_arithmetic(type); + res = create_conv(NULL, res, mode_arithmetic); + } + return res; } case EXPR_BINARY_ADD: case EXPR_BINARY_SUB: @@ -2592,7 +2816,7 @@ static long get_offsetof_offset(const offsetof_expression_t *expression) static ir_node *offsetof_to_firm(const offsetof_expression_t *expression) { - ir_mode *mode = get_ir_mode(expression->base.type); + ir_mode *mode = get_ir_mode_arithmetic(expression->base.type); long offset = get_offsetof_offset(expression); tarval *tv = new_tarval_from_long(offset, mode); dbg_info *dbgi = get_dbg_info(&expression->base.source_position); @@ -2641,7 +2865,7 @@ static ir_node *sizeof_to_firm(const typeprop_expression_t *expression) } type = skip_typeref(type); - /* § 6.5.3.4 (2) if the type is a VLA, evaluate the expression. */ + /* §6.5.3.4:2 if the type is a VLA, evaluate the expression. */ if (is_type_array(type) && type->array.is_vla && expression->tp_expression != NULL) { expression_to_firm(expression->tp_expression); @@ -2650,28 +2874,61 @@ static ir_node *sizeof_to_firm(const typeprop_expression_t *expression) return get_type_size(type); } +static entity_t *get_expression_entity(const expression_t *expression) +{ + if (expression->kind != EXPR_REFERENCE) + return NULL; + + return expression->reference.entity; +} + /** * Transform an alignof expression into Firm code. */ static ir_node *alignof_to_firm(const typeprop_expression_t *expression) { - type_t *type = expression->type; - if (type == NULL) { - /* beware: if expression is a variable reference, return the - alignment of the variable. */ - const expression_t *tp_expression = expression->tp_expression; - const entity_t *entity = expression_is_variable(tp_expression); - if (entity != NULL) { - /* TODO: get the alignment of this variable. */ - (void) entity; + ir_entity *irentity = NULL; + + const expression_t *tp_expression = expression->tp_expression; + if (tp_expression != NULL) { + entity_t *entity = get_expression_entity(tp_expression); + if (entity != NULL && is_declaration(entity)) { + switch (entity->declaration.kind) { + case DECLARATION_KIND_UNKNOWN: + panic("unknown entity reference found"); + case DECLARATION_KIND_COMPOUND_MEMBER: + irentity = entity->compound_member.entity; + break; + case DECLARATION_KIND_GLOBAL_VARIABLE: + case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: + irentity = entity->variable.v.entity; + break; + case DECLARATION_KIND_PARAMETER_ENTITY: + irentity = entity->parameter.v.entity; + break; + case DECLARATION_KIND_FUNCTION: + case DECLARATION_KIND_INNER_FUNCTION: + irentity = entity->function.entity; + break; + case DECLARATION_KIND_PARAMETER: + case DECLARATION_KIND_LOCAL_VARIABLE: + case DECLARATION_KIND_VARIABLE_LENGTH_ARRAY: + break; + } } - type = tp_expression->base.type; - assert(type != NULL); } - ir_mode *const mode = get_ir_mode(expression->base.type); + ir_type *irtype; + if (irentity != NULL) { + irtype = get_entity_type(irentity); + } else { + type_t *type = expression->type; + irtype = get_ir_type(type); + } + + ir_mode *const mode = get_ir_mode_arithmetic(expression->base.type); symconst_symbol sym; - sym.type_p = get_ir_type(type); + sym.type_p = irtype; return new_SymConst(mode, sym, symconst_type_align); } @@ -2689,9 +2946,7 @@ long fold_constant(const expression_t *expression) assert(is_constant_expression(expression)); ir_graph *old_current_ir_graph = current_ir_graph; - if (current_ir_graph == NULL) { - current_ir_graph = get_const_code_irg(); - } + current_ir_graph = get_const_code_irg(); ir_node *cnst = expression_to_firm(expression); current_ir_graph = old_current_ir_graph; @@ -2748,11 +3003,11 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression) set_cur_block(cur_block); ir_node *const cond_expr = create_condition_evaluation(expression->condition, true_block, false_block); if (expression->true_expression == NULL) { - if (cond_expr != NULL) { + if (cond_expr != NULL && get_irn_mode(cond_expr) != mode_b) { true_val = cond_expr; } else { - /* Condition ended with a short circuit (&&, ||, !) operation. - * Generate a "1" as value for the true branch. */ + /* Condition ended with a short circuit (&&, ||, !) operation or a + * comparison. Generate a "1" as value for the true branch. */ true_val = new_Const(get_mode_one(mode_Is)); } } @@ -2975,7 +3230,12 @@ static ir_node *va_start_expression_to_firm( new_d_simpleSel(dbgi, no_mem, arg_base, parm_ent); ir_node *const cnst = get_type_size(expr->parameter->base.type); - ir_node *const add = new_d_Add(dbgi, arg_sel, cnst, mode_P_data); + ir_mode *const mode = get_irn_mode(cnst); + ir_node *const c1 = new_Const_long(mode, stack_param_align - 1); + ir_node *const c2 = new_d_Add(dbgi, cnst, c1, mode); + ir_node *const c3 = new_Const_long(mode, -(long)stack_param_align); + ir_node *const c4 = new_d_And(dbgi, c2, c3, mode); + ir_node *const add = new_d_Add(dbgi, arg_sel, c2, mode_P_data); set_value_for_expression(expr->ap, add); return NULL; @@ -2991,7 +3251,12 @@ static ir_node *va_arg_expression_to_firm(const va_arg_expression_t *const expr) ir_node *const res = deref_address(dbgi, type, ap); ir_node *const cnst = get_type_size(expr->base.type); - ir_node *const add = new_d_Add(dbgi, ap, cnst, mode_P_data); + ir_mode *const mode = get_irn_mode(cnst); + ir_node *const c1 = new_Const_long(mode, stack_param_align - 1); + ir_node *const c2 = new_d_Add(dbgi, cnst, c1, mode); + ir_node *const c3 = new_Const_long(mode, -(long)stack_param_align); + ir_node *const c4 = new_d_And(dbgi, c2, c3, mode); + ir_node *const add = new_d_Add(dbgi, ap, c4, mode_P_data); set_value_for_expression_addr(ap_expr, add, ap_addr); @@ -3031,7 +3296,7 @@ static ir_node *expression_to_addr(const expression_t *expression) static ir_node *builtin_constant_to_firm( const builtin_constant_expression_t *expression) { - ir_mode *mode = get_ir_mode(expression->base.type); + ir_mode *mode = get_ir_mode_arithmetic(expression->base.type); long v; if (is_constant_expression(expression->value)) { @@ -3042,13 +3307,14 @@ static ir_node *builtin_constant_to_firm( return new_Const_long(mode, v); } -static ir_node *builtin_prefetch_to_firm( - const builtin_prefetch_expression_t *expression) +static ir_node *builtin_types_compatible_to_firm( + const builtin_types_compatible_expression_t *expression) { - ir_node *adr = expression_to_firm(expression->adr); - /* no Firm support for prefetch yet */ - (void) adr; - return NULL; + type_t *const left = get_unqualified_type(skip_typeref(expression->left)); + type_t *const right = get_unqualified_type(skip_typeref(expression->right)); + long const value = types_compatible(left, right) ? 1 : 0; + ir_mode *const mode = get_ir_mode_arithmetic(expression->base.type); + return new_Const_long(mode, value); } static ir_node *get_label_block(label_t *label) @@ -3090,23 +3356,6 @@ static ir_node *label_address_to_firm( return new_SymConst(mode_P_code, value, symconst_label); } -static ir_node *builtin_symbol_to_firm( - const builtin_symbol_expression_t *expression) -{ - /* for gcc compatibility we have to produce (dummy) addresses for some - * builtins */ - if (warning.other) { - warningf(&expression->base.source_position, - "taking address of builtin '%Y'", expression->symbol); - } - - /* simply create a NULL pointer */ - ir_mode *mode = get_ir_mode(type_void_ptr); - ir_node *res = new_Const_long(mode, 0); - - return res; -} - /** * creates firm nodes for an expression. The difference between this function * and expression_to_firm is, that this version might produce mode_b nodes @@ -3162,12 +3411,10 @@ static ir_node *_expression_to_firm(const expression_t *expression) return va_start_expression_to_firm(&expression->va_starte); case EXPR_VA_ARG: return va_arg_expression_to_firm(&expression->va_arge); - case EXPR_BUILTIN_SYMBOL: - return builtin_symbol_to_firm(&expression->builtin_symbol); case EXPR_BUILTIN_CONSTANT_P: return builtin_constant_to_firm(&expression->builtin_constant); - case EXPR_BUILTIN_PREFETCH: - return builtin_prefetch_to_firm(&expression->builtin_prefetch); + case EXPR_BUILTIN_TYPES_COMPATIBLE_P: + return builtin_types_compatible_to_firm(&expression->builtin_types_compatible); case EXPR_OFFSETOF: return offsetof_to_firm(&expression->offsetofe); case EXPR_COMPOUND_LITERAL: @@ -3182,15 +3429,20 @@ static ir_node *_expression_to_firm(const expression_t *expression) panic("invalid expression found"); } +/** + * Check if a given expression is a GNU __builtin_expect() call. + */ static bool is_builtin_expect(const expression_t *expression) { if (expression->kind != EXPR_CALL) return false; expression_t *function = expression->call.function; - if (function->kind != EXPR_BUILTIN_SYMBOL) + if (function->kind != EXPR_REFERENCE) return false; - if (function->builtin_symbol.symbol->ID != T___builtin_expect) + reference_expression_t *ref = &function->reference; + if (ref->entity->kind != ENTITY_FUNCTION || + ref->entity->function.btk != bk_gnu_builtin_expect) return false; return true; @@ -3238,7 +3490,7 @@ static ir_node *expression_to_firm(const expression_t *expression) if (is_constant_expression(expression)) { ir_node *res = _expression_to_firm(expression); - ir_mode *mode = get_ir_mode(expression->base.type); + ir_mode *mode = get_ir_mode_arithmetic(expression->base.type); assert(is_Const(res)); if (is_Const_null(res)) { return new_Const_long(mode, 0); @@ -3249,7 +3501,7 @@ static ir_node *expression_to_firm(const expression_t *expression) /* we have to produce a 0/1 from the mode_b expression */ dbg_info *dbgi = get_dbg_info(&expression->base.source_position); - ir_mode *mode = get_ir_mode(expression->base.type); + ir_mode *mode = get_ir_mode_arithmetic(expression->base.type); return produce_condition_result(expression, mode, dbgi); } @@ -3304,7 +3556,7 @@ static ir_node *create_condition_evaluation(const expression_t *expression, ir_node *false_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_false); /* set branch prediction info based on __builtin_expect */ - if (is_builtin_expect(expression)) { + if (is_builtin_expect(expression) && is_Cond(cond)) { call_argument_t *argument = expression->call.arguments->next; if (is_constant_expression(argument->expression)) { long cnst = fold_constant(argument->expression); @@ -3332,10 +3584,13 @@ static void create_variable_entity(entity_t *variable, ir_type *parent_type) { assert(variable->kind == ENTITY_VARIABLE); - type_t *const type = skip_typeref(variable->declaration.type); + type_t *type = skip_typeref(variable->declaration.type); + type = get_aligned_type(type, variable->variable.alignment); + ident *const id = new_id_from_str(variable->base.symbol->string); ir_type *const irtype = get_ir_type(type); dbg_info *const dbgi = get_dbg_info(&variable->base.source_position); + ir_entity *const irentity = new_d_entity(parent_type, id, irtype, dbgi); handle_gnu_attributes_ent(irentity, variable); @@ -3344,6 +3599,7 @@ static void create_variable_entity(entity_t *variable, variable->variable.v.entity = irentity; set_entity_variability(irentity, variability_uninitialized); set_entity_ld_ident(irentity, create_ld_ident(variable)); + if (parent_type == get_tls_type()) set_entity_allocation(irentity, allocation_automatic); else if (declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE) @@ -3607,6 +3863,9 @@ static ir_initializer_t *create_ir_initializer_value( panic("initializer creation for compounds not implemented yet"); } ir_node *value = expression_to_firm(initializer->value); + type_t *type = initializer->value->base.type; + ir_mode *mode = get_ir_mode_storage(type); + value = create_conv(NULL, value, mode); return create_initializer_const(value); } @@ -3700,7 +3959,7 @@ static ir_initializer_t *create_ir_initializer_string( ir_initializer_t *irinitializer = create_initializer_compound(len); const char *string = initializer->string.begin; - ir_mode *mode = get_ir_mode(type->array.element_type); + ir_mode *mode = get_ir_mode_storage(type->array.element_type); for (size_t i = 0; i < len; ++i) { char c = 0; @@ -3775,7 +4034,7 @@ static void create_dynamic_null_initializer(ir_type *type, dbg_info *dbgi, /* TODO: bitfields */ ir_node *mem = get_store(); - ir_node *store = new_d_Store(dbgi, mem, base_addr, cnst); + ir_node *store = new_d_Store(dbgi, mem, base_addr, cnst, cons_none); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); set_store(proj_m); } else { @@ -3833,7 +4092,7 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, assert(get_type_mode(type) == mode); ir_node *mem = get_store(); - ir_node *store = new_d_Store(dbgi, mem, base_addr, node); + ir_node *store = new_d_Store(dbgi, mem, base_addr, node, cons_none); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); set_store(proj_m); return; @@ -3853,7 +4112,7 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, assert(get_type_mode(type) == mode); ir_node *mem = get_store(); - ir_node *store = new_d_Store(dbgi, mem, base_addr, cnst); + ir_node *store = new_d_Store(dbgi, mem, base_addr, cnst, cons_none); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); set_store(proj_m); return; @@ -3975,6 +4234,8 @@ static void create_initializer_local_variable_entity(entity_t *entity) dbg_info *dbgi = get_dbg_info(&entity->base.source_position); ir_entity *irentity = entity->variable.v.entity; type_t *type = entity->declaration.type; + + type = get_aligned_type(type, entity->variable.alignment); create_local_initializer(initializer, dbgi, irentity, type); } @@ -4000,6 +4261,10 @@ static void create_variable_initializer(entity_t *entity) dbg_info *dbgi = get_dbg_info(&entity->base.source_position); ir_node *value = expression_to_firm(initializer_value->value); + + type_t *type = initializer_value->value->base.type; + ir_mode *mode = get_ir_mode_storage(type); + value = create_conv(dbgi, value, mode); value = do_strict_conv(dbgi, value); if (declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE) { @@ -4109,7 +4374,9 @@ static void create_local_static_variable(entity_t *entity) assert(entity->kind == ENTITY_VARIABLE); assert(entity->declaration.kind == DECLARATION_KIND_UNKNOWN); - type_t *const type = skip_typeref(entity->declaration.type); + type_t *type = skip_typeref(entity->declaration.type); + type = get_aligned_type(type, entity->variable.alignment); + ir_type *const var_type = entity->variable.thread_local ? get_tls_type() : get_glob_type(); ir_type *const irtype = get_ir_type(type); @@ -4128,6 +4395,7 @@ static void create_local_static_variable(entity_t *entity) entity->declaration.kind = DECLARATION_KIND_GLOBAL_VARIABLE; entity->variable.v.entity = irentity; + set_entity_ld_ident(irentity, id); set_entity_variability(irentity, variability_uninitialized); set_entity_visibility(irentity, visibility_local); @@ -4162,7 +4430,12 @@ static void return_statement_to_firm(return_statement_t *statement) if (statement->value != NULL) { ir_node *node = expression_to_firm(statement->value); - node = do_strict_conv(dbgi, node); + if (!is_compound_type(res_type)) { + type_t *type = statement->value->base.type; + ir_mode *mode = get_ir_mode_storage(type); + node = create_conv(dbgi, node, mode); + node = do_strict_conv(dbgi, node); + } in[0] = node; } else { ir_mode *mode; @@ -4321,20 +4594,21 @@ static void initialize_local_declaration(entity_t *entity) static void declaration_statement_to_firm(declaration_statement_t *statement) { - entity_t * entity = statement->declarations_begin; - entity_t *const last = statement->declarations_end; - if (entity != NULL) { - for ( ;; entity = entity->base.next) { - if (is_declaration(entity)) { - initialize_local_declaration(entity); - } else if (entity->kind == ENTITY_TYPEDEF) { - type_t *const type = entity->typedefe.type; - if (is_type_array(type) && type->array.is_vla) - get_vla_size(&type->array); - } - if (entity == last) - break; + entity_t *entity = statement->declarations_begin; + if (entity == NULL) + return; + + entity_t *const last = statement->declarations_end; + for ( ;; entity = entity->base.next) { + if (is_declaration(entity)) { + initialize_local_declaration(entity); + } else if (entity->kind == ENTITY_TYPEDEF) { + type_t *const type = skip_typeref(entity->typedefe.type); + if (is_type_array(type) && type->array.is_vla) + get_vla_size(&type->array); } + if (entity == last) + break; } } @@ -4900,7 +5174,7 @@ static void asm_statement_to_firm(const asm_statement_t *statement) ir_asm_constraint constraint; constraint.pos = pos; constraint.constraint = new_id_from_str(buf); - constraint.mode = get_ir_mode(expr->base.type); + constraint.mode = get_ir_mode_storage(expr->base.type); tmp_in_constraints[in_size] = constraint; ins[in_size] = value; @@ -4940,7 +5214,7 @@ static void asm_statement_to_firm(const asm_statement_t *statement) ir_asm_constraint constraint; constraint.pos = pos; constraint.constraint = new_id_from_str(constraints); - constraint.mode = get_ir_mode(argument->expression->base.type); + constraint.mode = get_ir_mode_storage(argument->expression->base.type); obstack_grow(&asm_obst, &constraint, sizeof(constraint)); } @@ -5043,7 +5317,7 @@ static void asm_statement_to_firm(const asm_statement_t *statement) for (i = 0; i < out_size; ++i) { const expression_t *out_expr = out_exprs[i]; long pn = i; - ir_mode *mode = get_ir_mode(out_expr->base.type); + ir_mode *mode = get_ir_mode_storage(out_expr->base.type); ir_node *proj = new_Proj(node, mode, pn); ir_node *addr = out_addrs[i]; @@ -5051,12 +5325,14 @@ static void asm_statement_to_firm(const asm_statement_t *statement) } } -static void ms_try_statement_to_firm(ms_try_statement_t *statement) { +static void ms_try_statement_to_firm(ms_try_statement_t *statement) +{ statement_to_firm(statement->try_statement); warningf(&statement->base.source_position, "structured exception handling ignored"); } -static void leave_statement_to_firm(leave_statement_t *statement) { +static void leave_statement_to_firm(leave_statement_t *statement) +{ errorf(&statement->base.source_position, "__leave not supported yet"); } @@ -5135,7 +5411,8 @@ static int count_local_variables(const entity_t *entity, const entity_t *const last) { int count = 0; - for (; entity != NULL; entity = entity->base.next) { + entity_t const *const end = last != NULL ? last->base.next : NULL; + for (; entity != end; entity = entity->base.next) { type_t *type; bool address_taken; @@ -5151,9 +5428,6 @@ static int count_local_variables(const entity_t *entity, if (!address_taken && is_type_scalar(type)) ++count; - - if (entity == last) - break; } return count; } @@ -5203,7 +5477,9 @@ static void initialize_function_parameters(entity_t *entity) int n = 0; entity_t *parameter = entity->function.parameters.entities; for ( ; parameter != NULL; parameter = parameter->base.next, ++n) { - assert(parameter->kind == ENTITY_PARAMETER); + if (parameter->kind != ENTITY_PARAMETER) + continue; + assert(parameter->declaration.kind == DECLARATION_KIND_UNKNOWN); type_t *type = skip_typeref(parameter->declaration.type); @@ -5230,7 +5506,7 @@ static void initialize_function_parameters(entity_t *entity) long pn = n; ir_node *value = new_r_Proj(irg, start_block, args, param_mode, pn); - ir_mode *mode = get_ir_mode(type); + ir_mode *mode = get_ir_mode_storage(type); value = create_conv(NULL, value, mode); value = do_strict_conv(NULL, value); @@ -5304,7 +5580,8 @@ static void add_function_pointer(ir_type *segment, ir_entity *method, /** * Generate possible IJmp branches to a given label block. */ -static void gen_ijmp_branches(ir_node *block) { +static void gen_ijmp_branches(ir_node *block) +{ ir_node *ijmp; for (ijmp = ijmp_list; ijmp != NULL; ijmp = get_irn_link(ijmp)) { add_immBlock_pred(block, ijmp); @@ -5346,7 +5623,7 @@ static void create_function(entity_t *entity) current_function = irg; set_irg_fp_model(irg, firm_opt.fp_model); - tarval_enable_fp_ops((firm_opt.fp_model & fp_strict_algebraic) == 0); + tarval_enable_fp_ops(1); set_irn_dbg_info(get_irg_start_block(irg), get_entity_dbg_info(function_entity)); ir_node *first_block = get_cur_block(); @@ -5377,7 +5654,7 @@ static void create_function(entity_t *entity) } else { ir_mode *mode; if (is_type_scalar(return_type)) { - mode = get_ir_mode(func_type->return_type); + mode = get_ir_mode_storage(func_type->return_type); } else { mode = mode_P_data; } @@ -5467,6 +5744,10 @@ static void scope_to_firm(scope_t *scope) continue; if (entity->kind == ENTITY_FUNCTION) { + if (entity->function.btk != bk_none) { + /* builtins have no representation */ + continue; + } get_function_entity(entity); } else if (entity->kind == ENTITY_VARIABLE) { create_global_variable(entity); @@ -5480,6 +5761,10 @@ static void scope_to_firm(scope_t *scope) continue; if (entity->kind == ENTITY_FUNCTION) { + if (entity->function.btk != bk_none) { + /* builtins have no representation */ + continue; + } create_function(entity); } else if (entity->kind == ENTITY_VARIABLE) { assert(entity->declaration.kind @@ -5511,7 +5796,7 @@ void init_ast2firm(void) } /* create idents for all known runtime functions */ - for (size_t i = 0; i < sizeof(rts_data) / sizeof(rts_data[0]); ++i) { + for (size_t i = 0; i < lengthof(rts_data); ++i) { rts_idents[i] = new_id_from_str(rts_data[i].name); } @@ -5529,6 +5814,11 @@ static void init_ir_types(void) ir_type_const_char = get_ir_type(type_const_char); ir_type_wchar_t = get_ir_type(type_wchar_t); ir_type_void = get_ir_type(type_void); + + const backend_params *be_params = be_get_backend_param(); + mode_float_arithmetic = be_params->mode_float_arithmetic; + + stack_param_align = be_params->stack_param_align; } void exit_ast2firm(void)