X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=b75ddc1cd19c23dd5868635fd5ce43b0e3c61831;hb=946ecca09f62b2e57a19e7f7fbfcfedd857ded37;hp=1e0f72bfb095d45a1ec7ed0b0902ecde9fd49430;hpb=cc6b178146de60a12ea0bb8dc80fc3b457c35bc5;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 1e0f72b..b75ddc1 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -16,19 +16,20 @@ #include "token_t.h" #include "type_t.h" #include "ast_t.h" +#include "parser.h" #define MAGIC_DEFAULT_PN_NUMBER (long) -314159265 static ir_type *ir_type_const_char; static ir_type *ir_type_void; static ir_type *ir_type_int; -static ir_type *ir_type_void_ptr; static type_t *type_const_char; static type_t *type_void; static type_t *type_int; -static symbol_t *symbol_alloca; +static symbol_t *symbol_builtin_alloca; +static symbol_t *symbol_builtin_nanf; static int next_value_number_function; static ir_node *continue_label; @@ -48,6 +49,7 @@ typedef enum declaration_type_t { DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY, DECLARATION_TYPE_COMPOUND_MEMBER, DECLARATION_TYPE_LABEL_BLOCK, + DECLARATION_TYPE_ENUM_ENTRY } declaration_type_t; static ir_type *get_ir_type(type_t *type); @@ -95,12 +97,11 @@ void init_ast2firm(void) ir_type_const_char = get_ir_type(type_const_char); ir_type_void = get_ir_type(type_int); /* we don't have a real void type in firm */ - ir_type_void_ptr = new_type_pointer(new_id_from_str("void_ptr"), - ir_type_void, mode_P_data); - type_void->firm_type = ir_type_void; + type_void->base.firm_type = ir_type_void; - symbol_alloca = symbol_table_insert("__builtin_alloca"); + symbol_builtin_alloca = symbol_table_insert("__builtin_alloca"); + symbol_builtin_nanf = symbol_table_insert("__builtin_nanf"); } void exit_ast2firm(void) @@ -211,13 +212,13 @@ static unsigned get_atomic_type_size(const atomic_type_t *type) static unsigned get_compound_type_size(compound_type_t *type) { - ir_type *irtype = get_ir_type(&type->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) { - ir_type *irtype = get_ir_type(&type->type); + ir_type *irtype = get_ir_type((type_t*) type); return get_type_size_bytes(irtype); } @@ -227,19 +228,19 @@ static unsigned get_type_size(type_t *type) switch(type->type) { case TYPE_ATOMIC: - return get_atomic_type_size((const atomic_type_t*) type); + return get_atomic_type_size(&type->atomic); case TYPE_ENUM: return get_mode_size_bytes(mode_Is); case TYPE_COMPOUND_UNION: case TYPE_COMPOUND_STRUCT: - return get_compound_type_size((compound_type_t*) type); + 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: return get_mode_size_bytes(mode_P_data); case TYPE_ARRAY: - return get_array_type_size((array_type_t*) type); + return get_array_type_size(&type->array); case TYPE_BUILTIN: case TYPE_TYPEDEF: case TYPE_TYPEOF: @@ -454,39 +455,72 @@ static ir_type *create_union_type(compound_type_t *type) return ir_type; } +static ir_node *expression_to_firm(const expression_t *expression); +static inline ir_mode *get_ir_mode(type_t *type); + +static ir_type *create_enum_type(enum_type_t *const type) +{ + type->type.firm_type = ir_type_int; + + ir_mode *const mode = get_ir_mode((type_t*) type); + tarval *const one = get_mode_one(mode); + tarval * tv_next = get_tarval_null(mode); + + declaration_t *declaration = type->declaration->next; + for (; declaration != NULL; declaration = declaration->next) { + if (declaration->storage_class != STORAGE_CLASS_ENUM_ENTRY) + break; + + declaration->declaration_type = DECLARATION_TYPE_ENUM_ENTRY; + + expression_t *const init = declaration->init.enum_value; + if (init != NULL) { + ir_node *const cnst = expression_to_firm(init); + if (!is_Const(cnst)) { + panic("couldn't fold constant"); + } + tv_next = get_Const_tarval(cnst); + } + declaration->v.enum_val = tv_next; + tv_next = tarval_add(tv_next, one); + } + + return ir_type_int; +} + static ir_type *get_ir_type(type_t *type) { assert(type != NULL); type = skip_typeref(type); - if(type->firm_type != NULL) { - assert(type->firm_type != INVALID_TYPE); - return type->firm_type; + if(type->base.firm_type != NULL) { + assert(type->base.firm_type != INVALID_TYPE); + return type->base.firm_type; } ir_type *firm_type = NULL; switch(type->type) { case TYPE_ATOMIC: - firm_type = create_atomic_type((atomic_type_t*) type); + firm_type = create_atomic_type(&type->atomic); break; case TYPE_FUNCTION: - firm_type = create_method_type((function_type_t*) type); + firm_type = create_method_type(&type->function); break; case TYPE_POINTER: - firm_type = create_pointer_type((pointer_type_t*) type); + firm_type = create_pointer_type(&type->pointer); break; case TYPE_ARRAY: - firm_type = create_array_type((array_type_t*) type); + firm_type = create_array_type(&type->array); break; case TYPE_COMPOUND_STRUCT: - firm_type = create_struct_type((compound_type_t*) type); + firm_type = create_struct_type(&type->compound); break; case TYPE_COMPOUND_UNION: - firm_type = create_union_type((compound_type_t*) type); + firm_type = create_union_type(&type->compound); break; case TYPE_ENUM: - firm_type = ir_type_int; + firm_type = create_enum_type(&type->enumt); break; case TYPE_BUILTIN: case TYPE_TYPEOF: @@ -497,7 +531,7 @@ static ir_type *get_ir_type(type_t *type) if(firm_type == NULL) panic("unknown type found"); - type->firm_type = firm_type; + type->base.firm_type = firm_type; return firm_type; } @@ -545,16 +579,12 @@ static ir_entity* get_function_entity(declaration_t *declaration) return entity; } - - -static ir_node *expression_to_firm(const expression_t *expression); - static dbg_info *get_dbg_info(const source_position_t *pos) { return (dbg_info*) pos; } -static ir_node *const_to_firm(const const_t *cnst) +static ir_node *const_to_firm(const const_expression_t *cnst) { dbg_info *dbgi = get_dbg_info(&cnst->expression.source_position); ir_mode *mode = get_ir_mode(cnst->expression.datatype); @@ -568,7 +598,8 @@ static ir_node *const_to_firm(const const_t *cnst) if(mode_is_signed(mode)) { len = snprintf(buf, sizeof(buf), "%lld", cnst->v.int_value); } else { - len = snprintf(buf, sizeof(buf), "%llu", cnst->v.int_value); + len = snprintf(buf, sizeof(buf), "%llu", + (unsigned long long) cnst->v.int_value); } tv = new_tarval_from_str(buf, len, mode); } @@ -620,30 +651,66 @@ static ir_node *string_to_firm(const source_position_t *const src_pos, return create_symconst(dbgi, entity); } -static ir_node *string_literal_to_firm(const string_literal_t* literal) +static ir_node *string_literal_to_firm( + const string_literal_expression_t* literal) { return string_to_firm(&literal->expression.source_position, "Lstr", literal->value); } -static ir_node *deref_address(type_t *const type, ir_node *const addr, +static ir_node *deref_address(ir_type *const irtype, ir_node *const addr, dbg_info *const dbgi) { - switch (type->type) { - case TYPE_ARRAY: - case TYPE_COMPOUND_STRUCT: - case TYPE_COMPOUND_UNION: - return addr; - - default: { - ir_mode *const mode = get_ir_mode(type); - ir_node *const memory = get_store(); - ir_node *const load = new_d_Load(dbgi, memory, addr, mode); - 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); - set_store(load_mem); - return load_res; + if(is_compound_type(irtype) || is_Array_type(irtype)) { + return addr; + } + + 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_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); + set_store(load_mem); + return load_res; +} + +static ir_node *do_strict_conv(dbg_info *dbgi, ir_node *node) +{ + ir_mode *mode = get_irn_mode(node); + + if(!(get_irg_fp_model(current_ir_graph) & fp_explicit_rounding)) + return node; + if(!mode_is_float(mode)) + return node; + + /* check if there is already a Conv */ + if (get_irn_op(node) == op_Conv) { + /* convert it into a strict Conv */ + set_Conv_strict(node, 1); + return node; + } + + /* otherwise create a new one */ + return new_d_strictConv(dbgi, node, mode); +} + +static ir_node *get_global_var_address(dbg_info *const dbgi, + const declaration_t *const decl) +{ + assert(decl->declaration_type == DECLARATION_TYPE_GLOBAL_VARIABLE); + + ir_entity *const entity = decl->v.entity; + switch ((storage_class_tag_t)decl->storage_class) { + case STORAGE_CLASS_THREAD: + case STORAGE_CLASS_THREAD_EXTERN: + case STORAGE_CLASS_THREAD_STATIC: { + ir_node *const no_mem = new_NoMem(); + ir_node *const tls = get_irg_tls(current_ir_graph); + return new_d_simpleSel(dbgi, no_mem, tls, entity); } + + default: + return create_symconst(dbgi, entity); } } @@ -655,7 +722,17 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref) switch((declaration_type_t) declaration->declaration_type) { case DECLARATION_TYPE_UNKNOWN: - break; + if (declaration->storage_class != STORAGE_CLASS_ENUM_ENTRY) { + break; + } + get_ir_type(type); + /* FALLTHROUGH */ + + case DECLARATION_TYPE_ENUM_ENTRY: { + ir_mode *const mode = get_ir_mode(type); + return new_Const(mode, declaration->v.enum_val); + } + case DECLARATION_TYPE_LOCAL_VARIABLE: { ir_mode *mode = get_ir_mode(type); return get_value(declaration->v.value_number, mode); @@ -664,15 +741,17 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref) return create_symconst(dbgi, declaration->v.entity); } case DECLARATION_TYPE_GLOBAL_VARIABLE: { - ir_entity *entity = declaration->v.entity; - ir_node *symconst = create_symconst(dbgi, entity); - return deref_address(type, symconst, dbgi); + ir_node *const addr = get_global_var_address(dbgi, declaration); + ir_type *const irtype = get_entity_type(declaration->v.entity); + return deref_address(irtype, addr, dbgi); } + case DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY: { ir_entity *entity = declaration->v.entity; ir_node *frame = get_irg_frame(current_ir_graph); ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), frame, entity); - return deref_address(type, sel, dbgi); + ir_type *irtype = get_entity_type(entity); + return deref_address(irtype, sel, dbgi); } case DECLARATION_TYPE_COMPOUND_MEMBER: @@ -697,9 +776,8 @@ static ir_node *reference_addr(const reference_expression_t *ref) return create_symconst(dbgi, declaration->v.entity); } case DECLARATION_TYPE_GLOBAL_VARIABLE: { - ir_entity *entity = declaration->v.entity; - ir_node *symconst = create_symconst(dbgi, entity); - return symconst; + ir_node *const addr = get_global_var_address(dbgi, declaration); + return addr; } case DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY: { ir_entity *entity = declaration->v.entity; @@ -708,6 +786,10 @@ static ir_node *reference_addr(const reference_expression_t *ref) return sel; } + + case DECLARATION_TYPE_ENUM_ENTRY: + panic("trying to reference enum entry"); + case DECLARATION_TYPE_COMPOUND_MEMBER: case DECLARATION_TYPE_LABEL_BLOCK: panic("not implemented reference type"); @@ -725,7 +807,7 @@ static ir_node *process_builtin_call(const call_expression_t *call) = (builtin_symbol_expression_t*) call->function; symbol_t *symbol = builtin->symbol; - if(symbol == symbol_alloca) { + if(symbol == symbol_builtin_alloca) { if(call->arguments == NULL || call->arguments->next != NULL) { panic("invalid number of parameters on __builtin_alloca"); } @@ -739,6 +821,12 @@ static ir_node *process_builtin_call(const call_expression_t *call) set_store(proj_m); ir_node *res = new_Proj(alloca, mode_P_data, pn_Alloc_res); + return res; + } else if(symbol == symbol_builtin_nanf) { + /* Ignore string for now... */ + ir_mode *mode = mode_D; + tarval *tv = get_mode_NAN(mode); + ir_node *res = new_d_Const(dbgi, mode, tv); return res; } else { panic("Unsupported builtin found\n"); @@ -749,21 +837,17 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) { assert(get_cur_block() != NULL); - expression_t *function = call->function; + expression_t *function = call->function; if(function->type == EXPR_BUILTIN_SYMBOL) { return process_builtin_call(call); } - ir_node *callee = expression_to_firm(function); + ir_node *callee = expression_to_firm(function); - function_type_t *function_type; - if (function->datatype->type == TYPE_POINTER) { - pointer_type_t *const ptr_type = (pointer_type_t*)function->datatype; - assert(ptr_type->points_to->type == TYPE_FUNCTION); - function_type = (function_type_t*)ptr_type->points_to; - } else { - assert(function->datatype->type == TYPE_FUNCTION); - function_type = (function_type_t*)function->datatype; - } + type_t *type = function->base.datatype; + assert(type->type == TYPE_POINTER); + pointer_type_t *const ptr_type = &type->pointer; + assert(ptr_type->points_to->type == TYPE_FUNCTION); + function_type_t *function_type = &ptr_type->points_to->function; int n_parameters = 0; call_argument_t *argument = call->arguments; @@ -771,6 +855,8 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) ++n_parameters; } + dbg_info *dbgi = get_dbg_info(&call->expression.source_position); + ir_type *ir_method_type = get_ir_type((type_t*) function_type); ir_type *new_method_type = NULL; if(function_type->variadic || function_type->unspecified_parameters) { @@ -797,9 +883,11 @@ 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); + in[n] = arg_node; if(new_method_type != NULL) { - ir_type *irtype = get_ir_type(expression->datatype); + ir_type *irtype = get_ir_type(expression->base.datatype); set_method_param_type(new_method_type, n, irtype); } @@ -810,17 +898,22 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) if(new_method_type != NULL) ir_method_type = new_method_type; - dbg_info *dbgi = get_dbg_info(&call->expression.source_position); ir_node *store = get_store(); ir_node *node = new_d_Call(dbgi, store, callee, n_parameters, in, ir_method_type); ir_node *mem = new_d_Proj(dbgi, node, mode_M, pn_Call_M_regular); set_store(mem); - type_t *result_type = function_type->result_type; + type_t *result_type = skip_typeref(function_type->result_type); ir_node *result = NULL; - if(result_type != type_void) { - ir_mode *mode = get_ir_mode(result_type); + + if(!is_type_atomic(result_type, ATOMIC_TYPE_VOID)) { + ir_mode *mode; + if(is_type_scalar(result_type)) { + mode = get_ir_mode(result_type); + } else { + mode = mode_P_data; + } ir_node *resproj = new_d_Proj(dbgi, node, mode_T, pn_Call_T_result); result = new_d_Proj(dbgi, resproj, mode, 0); } @@ -839,6 +932,9 @@ static void create_condition_evaluation(const expression_t *expression, static void set_value_for_expression(const expression_t *expression, ir_node *value) { + dbg_info *dbgi = get_dbg_info(&expression->base.source_position); + value = do_strict_conv(dbgi, value); + if(expression->type == EXPR_REFERENCE) { reference_expression_t *ref = (reference_expression_t*) expression; @@ -850,13 +946,20 @@ static void set_value_for_expression(const expression_t *expression, } } - dbg_info *dbgi = get_dbg_info(&expression->source_position); - ir_node *addr = expression_to_addr(expression); - assert(get_irn_mode(value) == get_ir_mode(expression->datatype)); - ir_node *memory = get_store(); - ir_node *store = new_d_Store(dbgi, memory, addr, value); - ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); - set_store(store_mem); + ir_node *addr = expression_to_addr(expression); + ir_node *memory = get_store(); + + type_t *type = skip_typeref(expression->base.datatype); + if(is_type_scalar(type)) { + ir_node *store = new_d_Store(dbgi, memory, addr, value); + ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); + set_store(store_mem); + } else { + ir_type *irtype = get_ir_type(type); + ir_node *copyb = new_d_CopyB(dbgi, memory, addr, value, irtype); + ir_node *copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M_regular); + set_store(copyb_mem); + } } static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) @@ -887,7 +990,7 @@ static ir_node *create_incdec(const unary_expression_t *expression) ir_node *offset; if(type->type == TYPE_POINTER) { - pointer_type_t *pointer_type = (pointer_type_t*) type; + pointer_type_t *pointer_type = &type->pointer; unsigned elem_size = get_type_size(pointer_type->points_to); offset = new_Const_long(mode_Is, elem_size); } else { @@ -951,14 +1054,21 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) } return value_node; } - case UNEXPR_DEREFERENCE: - return deref_address(type, value_node, dbgi); + case UNEXPR_DEREFERENCE: { + ir_type *irtype = get_ir_type(type); + return deref_address(irtype, value_node, dbgi); + } case UNEXPR_POSTFIX_INCREMENT: case UNEXPR_POSTFIX_DECREMENT: case UNEXPR_PREFIX_INCREMENT: case UNEXPR_PREFIX_DECREMENT: return create_incdec(expression); - case UNEXPR_CAST: + case UNEXPR_CAST: { + ir_node *node = create_conv(dbgi, value_node, get_ir_mode(type)); + node = do_strict_conv(dbgi, node); + return node; + } + case UNEXPR_CAST_IMPLICIT: return create_conv(dbgi, value_node, get_ir_mode(type)); case UNEXPR_TAKE_ADDRESS: @@ -1025,7 +1135,7 @@ static ir_node *create_arithmetic_binop(const binary_expression_t *expression, dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); ir_node *left = expression_to_firm(expression->left); ir_node *right = expression_to_firm(expression->right); - type_t *type = expression->right->datatype; + type_t *type = expression->right->base.datatype; /* be careful with the modes, because in arithmetic assign nodes only * the right operand has the mode of the arithmetic already */ ir_mode *mode = get_ir_mode(type); @@ -1088,8 +1198,8 @@ static ir_node *create_add(const binary_expression_t *expression) expression_t *expr_left = expression->left; expression_t *expr_right = expression->right; - type_t *type_left = skip_typeref(expr_left->datatype); - type_t *type_right = skip_typeref(expr_right->datatype); + type_t *type_left = skip_typeref(expr_left->base.datatype); + type_t *type_right = skip_typeref(expr_right->base.datatype); if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) { ir_mode *const mode = get_ir_mode(type); @@ -1112,14 +1222,15 @@ static ir_node *create_sub(const binary_expression_t *expression) ir_node *const left = expression_to_firm(expr_left); ir_node *const right = expression_to_firm(expr_right); type_t *const type = expression->expression.datatype; - type_t *const type_left = skip_typeref(expr_left->datatype); - type_t *const type_right = skip_typeref(expr_right->datatype); + type_t *const type_left = skip_typeref(expr_left->base.datatype); + type_t *const type_right = skip_typeref(expr_right->base.datatype); if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) { ir_mode *const mode = get_ir_mode(type); return new_d_Sub(dbgi, left, right, mode); - } else if (type_left->type == TYPE_POINTER && type_right->type == TYPE_POINTER) { - const pointer_type_t *const ptr_type = (const pointer_type_t*)type_left; + } else if (type_left->type == TYPE_POINTER + && type_right->type == TYPE_POINTER) { + const pointer_type_t *const ptr_type = &type_left->pointer; const unsigned elem_size = get_type_size(ptr_type->points_to); ir_mode *const mode = get_ir_mode(type); ir_node *const sub = new_d_Sub(dbgi, left, right, mode); @@ -1155,7 +1266,7 @@ static ir_node *create_shift(const binary_expression_t *expression) case BINEXPR_SHIFTRIGHT_ASSIGN: case BINEXPR_SHIFTRIGHT: { expression_t *expr_left = expression->left; - type_t *type_left = skip_typeref(expr_left->datatype); + type_t *type_left = skip_typeref(expr_left->base.datatype); if(is_type_signed(type_left)) { res = new_d_Shrs(dbgi, left, right, mode); @@ -1180,7 +1291,7 @@ static ir_node *create_divmod(const binary_expression_t *expression) ir_node *pin = new_Pin(new_NoMem()); /* be careful with the modes, because in arithmetic assign nodes only * the right operand has the mode of the arithmetic already */ - type_t *type = expression->right->datatype; + type_t *type = expression->right->base.datatype; ir_mode *mode = get_ir_mode(type); left = create_conv(dbgi, left, mode); ir_node *op; @@ -1262,6 +1373,7 @@ static ir_node *binary_expression_to_firm(const binary_expression_t *expression) case BINEXPR_ASSIGN: { ir_node *right = expression_to_firm(expression->right); set_value_for_expression(expression->left, right); + return right; } case BINEXPR_ADD: @@ -1312,25 +1424,16 @@ static ir_node *binary_expression_to_firm(const binary_expression_t *expression) static ir_node *array_access_addr(const array_access_expression_t *expression) { - dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); - ir_node *base_addr; - ir_node *offset; + dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); + ir_node *base_addr = expression_to_firm(expression->array_ref); + ir_node *offset = expression_to_firm(expression->index); + offset = create_conv(dbgi, offset, mode_Iu); - type_t *type_left = skip_typeref(expression->array_ref->datatype); - type_t *type_right = skip_typeref(expression->index->datatype); + type_t *ref_type = skip_typeref(expression->array_ref->base.datatype); + assert(is_type_pointer(ref_type)); + pointer_type_t *pointer_type = (pointer_type_t*) ref_type; - if(type_left->type == TYPE_POINTER || type_left->type == TYPE_ARRAY) { - base_addr = expression_to_firm(expression->array_ref); - offset = expression_to_firm(expression->index); - } else { - assert(type_right->type == TYPE_POINTER - || type_right->type == TYPE_ARRAY); - base_addr = expression_to_firm(expression->index); - offset = expression_to_firm(expression->array_ref); - } - offset = create_conv(dbgi, offset, mode_Iu); - - unsigned elem_size = get_type_size(expression->expression.datatype); + unsigned elem_size = get_type_size(pointer_type->points_to); ir_node *elem_size_const = new_Const_long(mode_Iu, elem_size); ir_node *real_offset = new_d_Mul(dbgi, offset, elem_size_const, mode_Iu); @@ -1342,17 +1445,21 @@ static ir_node *array_access_addr(const array_access_expression_t *expression) static ir_node *array_access_to_firm( const array_access_expression_t *expression) { - dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); - ir_node *addr = array_access_addr(expression); - type_t *type = skip_typeref(expression->expression.datatype); - return deref_address(type, addr, dbgi); + dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); + ir_node *addr = array_access_addr(expression); + type_t *type = revert_automatic_type_conversion( + (const expression_t*) expression); + type = skip_typeref(type); + ir_type *irtype = get_ir_type(type); + + return deref_address(irtype, addr, dbgi); } static ir_node *sizeof_to_firm(const sizeof_expression_t *expression) { type_t *type = expression->type; if(type == NULL) { - type = expression->size_expression->datatype; + type = expression->size_expression->base.datatype; assert(type != NULL); } @@ -1423,10 +1530,14 @@ static ir_node *select_addr(const select_expression_t *expression) static ir_node *select_to_firm(const select_expression_t *expression) { - dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); - ir_node *addr = select_addr(expression); - type_t *type = skip_typeref(expression->expression.datatype); - return deref_address(type, addr, dbgi); + dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); + ir_node *addr = select_addr(expression); + type_t *type = revert_automatic_type_conversion( + (const expression_t*) expression); + type = skip_typeref(type); + ir_type *irtype = get_ir_type(type); + + return deref_address(irtype, addr, dbgi); } /* Values returned by __builtin_classify_type. */ @@ -1456,13 +1567,13 @@ typedef enum gcc_type_class static ir_node *classify_type_to_firm(const classify_type_expression_t *const expr) { - const type_t *const type = expr->type_expression->datatype; + const type_t *const type = expr->type_expression->base.datatype; gcc_type_class tc; switch (type->type) { case TYPE_ATOMIC: { - const atomic_type_t *const atomic_type = (const atomic_type_t*)type; + const atomic_type_t *const atomic_type = &type->atomic; switch (atomic_type->atype) { // should not be reached case ATOMIC_TYPE_INVALID: @@ -1533,7 +1644,8 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex return new_d_Const(dbgi, mode, tv); } -static ir_node *function_name_to_firm(const string_literal_t *const expr) +static ir_node *function_name_to_firm( + const string_literal_expression_t *const expr) { if (current_function_name == NULL) { const source_position_t *const src_pos = @@ -1563,14 +1675,15 @@ static ir_node *expression_to_addr(const expression_t *expression) { switch(expression->type) { case EXPR_REFERENCE: - return reference_addr((const reference_expression_t*) expression); + return reference_addr(&expression->reference); case EXPR_ARRAY_ACCESS: - return array_access_addr((const array_access_expression_t*) expression); + return array_access_addr(&expression->array_access); case EXPR_SELECT: - return select_addr((const select_expression_t*) expression); + return select_addr(&expression->select); + case EXPR_CALL: + return call_expression_to_firm(&expression->call); case EXPR_UNARY: { - const unary_expression_t *const unary_expr = - (const unary_expression_t*)expression; + const unary_expression_t *const unary_expr = &expression->unary; if (unary_expr->type == UNEXPR_DEREFERENCE) { return dereference_addr(unary_expr); } @@ -1586,36 +1699,32 @@ static ir_node *_expression_to_firm(const expression_t *expression) { switch(expression->type) { case EXPR_CONST: - return const_to_firm((const const_t*) expression); + return const_to_firm(&expression->conste); case EXPR_STRING_LITERAL: - return string_literal_to_firm((const string_literal_t*) expression); + return string_literal_to_firm(&expression->string); case EXPR_REFERENCE: - return reference_expression_to_firm( - (const reference_expression_t*) expression); + return reference_expression_to_firm(&expression->reference); case EXPR_CALL: - return call_expression_to_firm((const call_expression_t*) expression); + return call_expression_to_firm(&expression->call); case EXPR_UNARY: - return unary_expression_to_firm((const unary_expression_t*) expression); + return unary_expression_to_firm(&expression->unary); case EXPR_BINARY: - return binary_expression_to_firm( - (const binary_expression_t*) expression); + return binary_expression_to_firm(&expression->binary); case EXPR_ARRAY_ACCESS: - return array_access_to_firm( - (const array_access_expression_t*) expression); + return array_access_to_firm(&expression->array_access); case EXPR_SIZEOF: - return sizeof_to_firm((const sizeof_expression_t*) expression); + return sizeof_to_firm(&expression->sizeofe); case EXPR_CONDITIONAL: - return conditional_to_firm((const conditional_expression_t*)expression); + return conditional_to_firm(&expression->conditional); case EXPR_SELECT: - return select_to_firm((const select_expression_t*) expression); + return select_to_firm(&expression->select); case EXPR_CLASSIFY_TYPE: - return classify_type_to_firm((const classify_type_expression_t*)expression); + return classify_type_to_firm(&expression->classify_type); case EXPR_FUNCTION: case EXPR_PRETTY_FUNCTION: - return function_name_to_firm((const string_literal_t*)expression); + return function_name_to_firm(&expression->string); case EXPR_STATEMENT: - return statement_expression_to_firm( - (const statement_expression_t*) expression); + return statement_expression_to_firm(&expression->statement); case EXPR_OFFSETOF: case EXPR_VA_ARG: case EXPR_BUILTIN_SYMBOL: @@ -1633,7 +1742,7 @@ static ir_node *expression_to_firm(const expression_t *expression) ir_node *res = _expression_to_firm(expression); if(res != NULL && get_irn_mode(res) == mode_b) { - ir_mode *mode = get_ir_mode(expression->datatype); + ir_mode *mode = get_ir_mode(expression->base.datatype); res = create_conv(NULL, res, mode); } @@ -1699,7 +1808,7 @@ static void create_condition_evaluation(const expression_t *expression, break; } - dbg_info *dbgi = get_dbg_info(&expression->source_position); + dbg_info *dbgi = get_dbg_info(&expression->base.source_position); ir_node *condition = expression_to_modeb(expression); ir_node *cond = new_d_Cond(dbgi, condition); ir_node *true_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_true); @@ -1711,24 +1820,45 @@ static void create_condition_evaluation(const expression_t *expression, set_cur_block(NULL); } - static void return_statement_to_firm(return_statement_t *statement) { if(get_cur_block() == NULL) return; - dbg_info *dbgi = get_dbg_info(&statement->statement.source_position); - ir_node *ret; + ir_type *func_irtype = get_ir_type(current_function_decl->type); - if(statement->return_value != NULL) { - ir_node *retval = expression_to_firm(statement->return_value); - ir_node *in[1]; + dbg_info *dbgi = get_dbg_info(&statement->statement.source_position); - in[0] = retval; - ret = new_d_Return(dbgi, get_store(), 1, in); + ir_node *in[1]; + int in_len; + if(get_method_n_ress(func_irtype) > 0) { + ir_type *res_type = get_method_res_type(func_irtype, 0); + + if(statement->return_value != NULL) { + ir_node *node = expression_to_firm(statement->return_value); + node = do_strict_conv(dbgi, node); + in[0] = node; + } else { + ir_mode *mode; + if(is_compound_type(res_type)) { + mode = mode_P_data; + } else { + mode = get_type_mode(res_type); + } + in[0] = new_Unknown(mode); + } + in_len = 1; } else { - ret = new_d_Return(dbgi, get_store(), 0, NULL); + /* build return_value for its side effects */ + if(statement->return_value != NULL) { + expression_to_firm(statement->return_value); + } + in_len = 0; } + + ir_node *store = get_store(); + ir_node *ret = new_d_Return(dbgi, store, in_len, in); + ir_node *end_block = get_irg_end_block(current_ir_graph); add_immBlock_pred(end_block, ret); @@ -1747,10 +1877,11 @@ static ir_node *compound_statement_to_firm(compound_statement_t *compound) { ir_node *result = NULL; statement_t *statement = compound->statements; - for( ; statement != NULL; statement = statement->next) { + for( ; statement != NULL; statement = statement->base.next) { //context2firm(&statement->context); - if(statement->next == NULL && statement->type == STATEMENT_EXPRESSION) { + if(statement->base.next == NULL + && statement->type == STATEMENT_EXPRESSION) { result = expression_statement_to_firm( (expression_statement_t*) statement); break; @@ -1843,7 +1974,7 @@ static void while_statement_to_firm(while_statement_t *statement) break_label = old_break_label; if(get_cur_block() != NULL) { - ir_node *jmp = new_Jmp(); + jmp = new_Jmp(); add_immBlock_pred(header_block, jmp); } } else { @@ -1960,7 +2091,7 @@ static void for_statement_to_firm(for_statement_t *statement) break_label = old_break_label; if (get_cur_block() != NULL) { - ir_node *const jmp = new_Jmp(); + jmp = new_Jmp(); add_immBlock_pred(step_block, jmp); } } else { @@ -1974,7 +2105,7 @@ static void for_statement_to_firm(for_statement_t *statement) false_block); } else { keep_alive(header_block); - ir_node *jmp = new_Jmp(); + jmp = new_Jmp(); add_immBlock_pred(body_block, jmp); } @@ -1996,7 +2127,7 @@ static void create_declaration_entity(declaration_t *declaration, ir_entity *entity = new_entity(parent_type, id, irtype); set_entity_ld_ident(entity, id); - declaration->declaration_type = declaration_type; + declaration->declaration_type = (unsigned char) declaration_type; declaration->v.entity = entity; set_entity_variability(entity, variability_uninitialized); /* TODO: visibility? */ @@ -2041,18 +2172,18 @@ static compound_graph_path *create_compound_path(ir_type *type, return path; } -static void create_initializer_value(initializer_t *initializer, +static void create_initializer_value(initializer_value_t *initializer, ir_entity *entity, compound_graph_path_entry_t *entry, int len) { - ir_node *node = expression_to_firm(initializer->v.value); + ir_node *node = expression_to_firm(initializer->value); ir_type *type = get_entity_type(entity); compound_graph_path *path = create_compound_path(type, entry, len); add_compound_ent_value_w_path(entity, node, path); } -static void create_initializer_compound(initializer_t *initializer, +static void create_initializer_compound(initializer_list_t *initializer, compound_type_t *type, ir_entity *entity, compound_graph_path_entry_t *last_entry, @@ -2074,30 +2205,31 @@ static void create_initializer_compound(initializer_t *initializer, if(compound_entry->namespc != NAMESPACE_NORMAL) continue; - if(i >= initializer->v.list.len) + if(i >= initializer->len) break; entry.v.entity = compound_entry->v.entity; - initializer_t *sub_initializer = initializer->v.list.initializers[i]; + initializer_t *sub_initializer = initializer->initializers[i]; assert(compound_entry != NULL); assert(compound_entry->declaration_type == DECLARATION_TYPE_COMPOUND_MEMBER); if(sub_initializer->type == INITIALIZER_VALUE) { - create_initializer_value(sub_initializer, entity, &entry, len); + create_initializer_value(&sub_initializer->value, + entity, &entry, len); } else { - type_t *type = skip_typeref(compound_entry->type); - create_initializer_object(sub_initializer, type, entity, &entry, - len); + type_t *entry_type = skip_typeref(compound_entry->type); + create_initializer_object(sub_initializer, entry_type, entity, + &entry, len); } ++i; } } -static void create_initializer_array(initializer_t *initializer, +static void create_initializer_array(initializer_list_t *initializer, array_type_t *type, ir_entity *entity, compound_graph_path_entry_t *last_entry, int len) @@ -2110,22 +2242,33 @@ static void create_initializer_array(initializer_t *initializer, entry.prev = last_entry; ++len; - for(size_t i = 0; i < initializer->v.list.len; ++i) { + size_t i; + for(i = 0; i < initializer->len; ++i) { entry.v.array_index = i; - initializer_t *sub_initializer = initializer->v.list.initializers[i]; + initializer_t *sub_initializer = initializer->initializers[i]; if(sub_initializer->type == INITIALIZER_VALUE) { - create_initializer_value(sub_initializer, entity, &entry, len); + create_initializer_value(&sub_initializer->value, + entity, &entry, len); } else { - assert(sub_initializer->type == INITIALIZER_LIST); create_initializer_object(sub_initializer, element_type, entity, &entry, len); } } + +#if 0 + /* TODO: initialize rest... */ + if(type->size_expression != NULL) { + size_t array_len = fold_constant(type->size_expression); + for( ; i < array_len; ++i) { + + } + } +#endif } -static void create_initializer_string(initializer_t *initializer, +static void create_initializer_string(initializer_string_t *initializer, array_type_t *type, ir_entity *entity, compound_graph_path_entry_t *last_entry, int len) @@ -2140,7 +2283,7 @@ static void create_initializer_string(initializer_t *initializer, ir_type *irtype = get_entity_type(entity); size_t arr_len = get_array_type_size(type); - const char *p = initializer->v.string; + const char *p = initializer->string; size_t i = 0; for(i = 0; i < arr_len; ++i, ++p) { entry.v.array_index = i; @@ -2158,21 +2301,24 @@ static void create_initializer_object(initializer_t *initializer, type_t *type, ir_entity *entity, compound_graph_path_entry_t *entry, int len) { if(type->type == TYPE_ARRAY) { - array_type_t *array_type = (array_type_t*) type; + array_type_t *array_type = &type->array; if(initializer->type == INITIALIZER_STRING) { - create_initializer_string(initializer, array_type, entity, entry, len); + initializer_string_t *string = &initializer->string; + create_initializer_string(string, array_type, entity, entry, len); } else { assert(initializer->type == INITIALIZER_LIST); - create_initializer_array(initializer, array_type, entity, entry, len); + initializer_list_t *list = &initializer->list; + create_initializer_array(list, array_type, entity, entry, len); } } else { assert(initializer->type == INITIALIZER_LIST); + initializer_list_t *list = &initializer->list; assert(type->type == TYPE_COMPOUND_STRUCT || type->type == TYPE_COMPOUND_UNION); - compound_type_t *compound_type = (compound_type_t*) type; - create_initializer_compound(initializer, compound_type, entity, entry, len); + compound_type_t *compound_type = &type->compound; + create_initializer_compound(list, compound_type, entity, entry, len); } } @@ -2188,8 +2334,9 @@ static void create_initializer_local_variable_entity(declaration_t *declaration) if(is_atomic_entity(entity)) { assert(initializer->type == INITIALIZER_VALUE); + initializer_value_t *initializer_value = &initializer->value; - ir_node *value = expression_to_firm(initializer->v.value); + ir_node *value = expression_to_firm(initializer_value->value); ir_node *store = new_d_Store(dbgi, memory, addr, value); ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); set_store(store_mem); @@ -2228,14 +2375,17 @@ static void create_initializer(declaration_t *declaration) if(initializer == NULL) return; - declaration_type_t declaration_type = (declaration_type_t)declaration->declaration_type; + declaration_type_t declaration_type + = (declaration_type_t) declaration->declaration_type; if(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY) { create_initializer_local_variable_entity(declaration); return; } if(initializer->type == INITIALIZER_VALUE) { - ir_node *value = expression_to_firm(initializer->v.value); + initializer_value_t *initializer_value = &initializer->value; + + ir_node *value = expression_to_firm(initializer_value->value); if(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE) { set_value(declaration->v.value_number, value); @@ -2248,7 +2398,6 @@ static void create_initializer(declaration_t *declaration) set_atomic_ent_value(entity, value); } } else { - declaration_type_t declaration_type = (declaration_type_t)declaration->declaration_type; assert(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE_ENTITY || declaration_type == DECLARATION_TYPE_GLOBAL_VARIABLE); @@ -2319,7 +2468,7 @@ static void declaration_statement_to_firm(declaration_statement_t *statement) for( ; declaration != end; declaration = declaration->next) { type_t *type = declaration->type; - switch(declaration->storage_class) { + switch ((storage_class_tag_t)declaration->storage_class) { case STORAGE_CLASS_TYPEDEF: continue; case STORAGE_CLASS_STATIC: @@ -2338,6 +2487,10 @@ static void declaration_statement_to_firm(declaration_statement_t *statement) create_local_variable(declaration); } continue; + case STORAGE_CLASS_THREAD: + case STORAGE_CLASS_THREAD_EXTERN: + case STORAGE_CLASS_THREAD_STATIC: + break; } panic("invalid storage class found"); } @@ -2349,7 +2502,7 @@ static void create_jump_statement(const statement_t *statement, if(get_cur_block() == NULL) return; - dbg_info *dbgi = get_dbg_info(&statement->source_position); + dbg_info *dbgi = get_dbg_info(&statement->base.source_position); ir_node *jump = new_d_Jmp(dbgi); add_immBlock_pred(target_block, jump); @@ -2500,26 +2653,28 @@ static void goto_to_firm(const goto_statement_t *statement) static void statement_to_firm(statement_t *statement) { switch(statement->type) { + case STATEMENT_INVALID: + panic("invalid statement found"); case STATEMENT_COMPOUND: - compound_statement_to_firm((compound_statement_t*) statement); + compound_statement_to_firm(&statement->compound); return; case STATEMENT_RETURN: - return_statement_to_firm((return_statement_t*) statement); + return_statement_to_firm(&statement->returns); return; case STATEMENT_EXPRESSION: - expression_statement_to_firm((expression_statement_t*) statement); + expression_statement_to_firm(&statement->expression); return; case STATEMENT_IF: - if_statement_to_firm((if_statement_t*) statement); + if_statement_to_firm(&statement->ifs); return; case STATEMENT_WHILE: - while_statement_to_firm((while_statement_t*) statement); + while_statement_to_firm(&statement->whiles); return; case STATEMENT_DO_WHILE: - do_while_statement_to_firm((do_while_statement_t*) statement); + do_while_statement_to_firm(&statement->do_while); return; case STATEMENT_DECLARATION: - declaration_statement_to_firm((declaration_statement_t*) statement); + declaration_statement_to_firm(&statement->declaration); return; case STATEMENT_BREAK: create_jump_statement(statement, break_label); @@ -2528,21 +2683,21 @@ static void statement_to_firm(statement_t *statement) create_jump_statement(statement, continue_label); return; case STATEMENT_SWITCH: - switch_statement_to_firm((switch_statement_t*) statement); + switch_statement_to_firm(&statement->switchs); return; case STATEMENT_CASE_LABEL: - case_label_to_firm((case_label_statement_t*) statement); + case_label_to_firm(&statement->case_label); return; case STATEMENT_FOR: - for_statement_to_firm((for_statement_t*) statement); + for_statement_to_firm(&statement->fors); return; case STATEMENT_LABEL: - label_to_firm((label_statement_t*) statement); + label_to_firm(&statement->label); return; case STATEMENT_GOTO: - goto_to_firm((goto_statement_t*) statement); + goto_to_firm(&statement->gotos); return; - default: + case STATEMENT_ASM: break; } panic("Statement not implemented\n"); @@ -2558,7 +2713,8 @@ static int count_local_declarations(const declaration_t * decl, case TYPE_ATOMIC: case TYPE_ENUM: case TYPE_POINTER: - if (!decl->address_taken) ++count; + if (!decl->address_taken) + ++count; break; default: break; @@ -2570,7 +2726,7 @@ static int count_local_declarations(const declaration_t * decl, static int count_decls_in_stmts(const statement_t *stmt) { int count = 0; - for (; stmt != NULL; stmt = stmt->next) { + for (; stmt != NULL; stmt = stmt->base.next) { switch (stmt->type) { case STATEMENT_DECLARATION: { const declaration_statement_t *const decl_stmt = @@ -2630,6 +2786,7 @@ static int count_decls_in_stmts(const statement_t *stmt) break; } + case STATEMENT_ASM: case STATEMENT_BREAK: case STATEMENT_CASE_LABEL: case STATEMENT_CONTINUE: @@ -2704,7 +2861,7 @@ static void initialize_function_parameters(declaration_t *declaration) static void create_function(declaration_t *declaration) { - ir_entity *entity = get_function_entity(declaration); + ir_entity *function_entity = get_function_entity(declaration); if(declaration->init.statement == NULL) return; @@ -2716,7 +2873,7 @@ static void create_function(declaration_t *declaration) imature_blocks = NEW_ARR_F(ir_node*, 0); int n_local_vars = get_function_n_local_vars(declaration); - ir_graph *irg = new_ir_graph(entity, n_local_vars); + ir_graph *irg = new_ir_graph(function_entity, n_local_vars); ir_node *first_block = get_cur_block(); next_value_number_function = 0; @@ -2729,14 +2886,21 @@ static void create_function(declaration_t *declaration) /* do we have a return statement yet? */ if(get_cur_block() != NULL) { assert(declaration->type->type == TYPE_FUNCTION); - const function_type_t* const func_type - = (const function_type_t*) declaration->type; + const function_type_t* const func_type = &declaration->type->function; + const type_t *result_type = skip_typeref(func_type->result_type); + ir_node *ret; - if (func_type->result_type == type_void) { + if (is_type_atomic(result_type, ATOMIC_TYPE_VOID)) { ret = new_Return(get_store(), 0, NULL); } else { - ir_mode *const mode = get_ir_mode(func_type->result_type); - ir_node * in[1]; + ir_mode *mode; + if(is_type_scalar(result_type)) { + mode = get_ir_mode(func_type->result_type); + } else { + mode = mode_P_data; + } + + ir_node *in[1]; // §5.1.2.2.3 main implicitly returns 0 if (strcmp(declaration->symbol->string, "main") == 0) { in[0] = new_Const(mode, get_mode_null(mode)); @@ -2791,20 +2955,57 @@ static void create_function(declaration_t *declaration) static void create_global_variable(declaration_t *declaration) { - ir_type *global_type = get_glob_type(); - create_declaration_entity(declaration, DECLARATION_TYPE_GLOBAL_VARIABLE, - global_type); + ir_visibility vis; + ir_type *var_type; + switch ((storage_class_tag_t)declaration->storage_class) { + case STORAGE_CLASS_STATIC: + vis = visibility_local; + goto global_var; - ir_entity *entity = declaration->v.entity; - if(declaration->storage_class == STORAGE_CLASS_STATIC) { - set_entity_visibility(entity, visibility_local); - } else if(declaration->storage_class == STORAGE_CLASS_EXTERN) { - set_entity_visibility(entity, visibility_external_allocated); - } else { - set_entity_visibility(entity, visibility_external_visible); + case STORAGE_CLASS_EXTERN: + vis = visibility_external_allocated; + goto global_var; + + case STORAGE_CLASS_NONE: + vis = visibility_external_visible; + goto global_var; + + case STORAGE_CLASS_THREAD: + vis = visibility_external_visible; + goto tls_var; + + case STORAGE_CLASS_THREAD_EXTERN: + vis = visibility_external_allocated; + goto tls_var; + + case STORAGE_CLASS_THREAD_STATIC: + vis = visibility_local; + goto tls_var; + +tls_var: + var_type = get_tls_type(); + goto create_var; + +global_var: + var_type = get_glob_type(); + goto create_var; + +create_var: + create_declaration_entity(declaration, DECLARATION_TYPE_GLOBAL_VARIABLE, + var_type); + set_entity_visibility(declaration->v.entity, vis); + + current_ir_graph = get_const_code_irg(); + create_initializer(declaration); + return; + + case STORAGE_CLASS_TYPEDEF: + case STORAGE_CLASS_AUTO: + case STORAGE_CLASS_REGISTER: + case STORAGE_CLASS_ENUM_ENTRY: + break; } - current_ir_graph = get_const_code_irg(); - create_initializer(declaration); + panic("Invalid storage class for global variable"); } static void context_to_firm(context_t *context)