X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ast2firm.c;h=0065ea235d30fa20ba53b70d80573affa929a98c;hb=a223a2177b4add7bc2f341675ec1932943553245;hp=b156f48b427d813394653924c1a5ec24840e6214;hpb=61bb8cbf62e7ca43ca99859159cc159bdb6c405c;p=cparser diff --git a/ast2firm.c b/ast2firm.c index b156f48..0065ea2 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -21,6 +21,7 @@ #define MAGIC_DEFAULT_PN_NUMBER (long) -314159265 static ir_type *ir_type_const_char; +static ir_type *ir_type_wchar_t; static ir_type *ir_type_void; static ir_type *ir_type_int; @@ -28,8 +29,6 @@ static type_t *type_const_char; static type_t *type_void; static type_t *type_int; -static symbol_t *symbol_alloca; - static int next_value_number_function; static ir_node *continue_label; static ir_node *break_label; @@ -88,18 +87,6 @@ const char *retrieve_dbg(const dbg_info *dbg, unsigned *line) void init_ast2firm(void) { - type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST); - type_void = make_atomic_type(ATOMIC_TYPE_VOID, TYPE_QUALIFIER_NONE); - type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE); - - ir_type_int = get_ir_type(type_int); - 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 */ - - type_void->base.firm_type = ir_type_void; - - symbol_alloca = symbol_table_insert("__builtin_alloca"); } void exit_ast2firm(void) @@ -276,15 +263,15 @@ static ir_type *create_atomic_type(const atomic_type_t *type) static ir_type *create_method_type(const function_type_t *function_type) { - type_t *result_type = function_type->result_type; + type_t *return_type = function_type->return_type; ident *id = unique_ident("functiontype"); int n_parameters = count_parameters(function_type); - int n_results = result_type == type_void ? 0 : 1; + int n_results = return_type == type_void ? 0 : 1; ir_type *irtype = new_type_method(id, n_parameters, n_results); - if(result_type != type_void) { - ir_type *restype = get_ir_type(result_type); + if(return_type != type_void) { + ir_type *restype = get_ir_type(return_type); set_method_res_type(irtype, 0, restype); } @@ -656,6 +643,42 @@ static ir_node *string_literal_to_firm( literal->value); } +static ir_node *wide_string_literal_to_firm( + const wide_string_literal_expression_t* const literal) +{ + ir_type *const global_type = get_glob_type(); + ir_type *const elem_type = ir_type_wchar_t; + ir_type *const type = new_type_array(unique_ident("strtype"), 1, + elem_type); + + ident *const id = unique_ident("Lstr"); + ir_entity *const entity = new_entity(global_type, id, type); + set_entity_ld_ident(entity, id); + set_entity_variability(entity, variability_constant); + + ir_mode *const mode = get_type_mode(elem_type); + + const wchar_rep_t *const string = literal->value.begin; + const size_t slen = literal->value.size; + + set_array_lower_bound_int(type, 0, 0); + set_array_upper_bound_int(type, 0, slen); + set_type_size_bytes(type, slen); + set_type_state(type, layout_fixed); + + tarval **const tvs = xmalloc(slen * sizeof(tvs[0])); + for(size_t i = 0; i < slen; ++i) { + tvs[i] = new_tarval_from_long(string[i], mode); + } + + set_array_entity_values(entity, tvs, slen); + free(tvs); + + dbg_info *const dbgi = get_dbg_info(&literal->expression.source_position); + + return create_symconst(dbgi, entity); +} + static ir_node *deref_address(ir_type *const irtype, ir_node *const addr, dbg_info *const dbgi) { @@ -672,6 +695,46 @@ static ir_node *deref_address(ir_type *const irtype, ir_node *const addr, 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); + } +} + static ir_node *reference_expression_to_firm(const reference_expression_t *ref) { dbg_info *dbgi = get_dbg_info(&ref->expression.source_position); @@ -699,11 +762,11 @@ 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); - ir_type *irtype = get_entity_type(entity); - return deref_address(irtype, 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); @@ -734,9 +797,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; @@ -762,11 +824,16 @@ static ir_node *process_builtin_call(const call_expression_t *call) dbg_info *dbgi = get_dbg_info(&call->expression.source_position); assert(call->function->type == EXPR_BUILTIN_SYMBOL); - builtin_symbol_expression_t *builtin - = (builtin_symbol_expression_t*) call->function; - symbol_t *symbol = builtin->symbol; + builtin_symbol_expression_t *builtin = &call->function->builtin_symbol; + + type_t *type = skip_typeref(builtin->expression.datatype); + assert(is_type_pointer(type)); + + type_t *function_type = skip_typeref(type->pointer.points_to); + symbol_t *symbol = builtin->symbol; - if(symbol == symbol_alloca) { + switch(symbol->ID) { + case T___builtin_alloca: { if(call->arguments == NULL || call->arguments->next != NULL) { panic("invalid number of parameters on __builtin_alloca"); } @@ -781,7 +848,18 @@ static ir_node *process_builtin_call(const call_expression_t *call) ir_node *res = new_Proj(alloca, mode_P_data, pn_Alloc_res); return res; - } else { + } + case T___builtin_nan: + case T___builtin_nanf: + case T___builtin_nand: { + /* Ignore string for now... */ + assert(is_type_function(function_type)); + ir_mode *mode = get_ir_mode(function_type->function.return_type); + tarval *tv = get_mode_NAN(mode); + ir_node *res = new_d_Const(dbgi, mode, tv); + return res; + } + default: panic("Unsupported builtin found\n"); } } @@ -796,11 +874,12 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) } ir_node *callee = expression_to_firm(function); - 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; + type_t *type = skip_typeref(function->base.datatype); + assert(is_type_pointer(type)); + pointer_type_t *pointer_type = &type->pointer; + type_t *points_to = skip_typeref(pointer_type->points_to); + assert(is_type_function(points_to)); + function_type_t *function_type = &points_to->function; int n_parameters = 0; call_argument_t *argument = call->arguments; @@ -808,6 +887,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) { @@ -834,6 +915,8 @@ 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->base.datatype); @@ -847,20 +930,19 @@ 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 = skip_typeref(function_type->result_type); + type_t *return_type = skip_typeref(function_type->return_type); ir_node *result = NULL; - if(!is_type_atomic(result_type, ATOMIC_TYPE_VOID)) { + if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) { ir_mode *mode; - if(is_type_scalar(result_type)) { - mode = get_ir_mode(result_type); + if(is_type_scalar(return_type)) { + mode = get_ir_mode(return_type); } else { mode = mode_P_data; } @@ -882,6 +964,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; @@ -893,7 +978,6 @@ static void set_value_for_expression(const expression_t *expression, } } - dbg_info *dbgi = get_dbg_info(&expression->base.source_position); ir_node *addr = expression_to_addr(expression); ir_node *memory = get_store(); @@ -930,14 +1014,14 @@ static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) static ir_node *create_incdec(const unary_expression_t *expression) { dbg_info *dbgi = get_dbg_info(&expression->expression.source_position); - type_t *type = expression->expression.datatype; + type_t *type = skip_typeref(expression->expression.datatype); ir_mode *mode = get_ir_mode(type); expression_t *value = expression->value; ir_node *value_node = expression_to_firm(value); ir_node *offset; - if(type->type == TYPE_POINTER) { + if(is_type_pointer(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); @@ -1011,7 +1095,12 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) 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: @@ -1114,10 +1203,10 @@ static ir_node *create_arithmetic_assign_binop( const binary_expression_t *expression, create_arithmetic_func func) { dbg_info *const dbgi = get_dbg_info(&expression->expression.source_position); - type_t *const type = expression->expression.datatype; + type_t *const type = skip_typeref(expression->expression.datatype); ir_node *value; - if (type->type == TYPE_POINTER) { + if (is_type_pointer(type)) { ir_node *const pointer = expression_to_firm(expression->left); ir_node * integer = expression_to_firm(expression->right); value = pointer_arithmetic(pointer, integer, type, dbgi, func); @@ -1149,10 +1238,10 @@ static ir_node *create_add(const binary_expression_t *expression) return new_d_Add(dbgi, left, right, mode); } - if (type_left->type == TYPE_POINTER || type_left->type == TYPE_ARRAY) { + if (is_type_pointer(type_left)) { return pointer_arithmetic(left, right, type, dbgi, new_d_Add); } else { - assert(type_right->type == TYPE_POINTER || type_right->type == TYPE_ARRAY); + assert(is_type_pointer(type_right)); return pointer_arithmetic(right, left, type, dbgi, new_d_Add); } } @@ -1171,8 +1260,7 @@ static ir_node *create_sub(const binary_expression_t *expression) 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) { + } else if (is_type_pointer(type_left) && is_type_pointer(type_right)) { 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); @@ -1184,7 +1272,7 @@ static ir_node *create_sub(const binary_expression_t *expression) return new_d_Proj(dbgi, div, mode, pn_Div_res); } - assert(type_left->type == TYPE_POINTER); + assert(is_type_pointer(type_left)); return pointer_arithmetic(left, right, type_left, dbgi, new_d_Sub); } @@ -1444,7 +1532,8 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression) mature_immBlock(common_block); /* TODO improve static semantics, so either both or no values are NULL */ - if (true_val == NULL || false_val == NULL) return NULL; + if (true_val == NULL || false_val == NULL) + return NULL; ir_node *in[2] = { true_val, false_val }; ir_mode *mode = get_irn_mode(true_val); @@ -1645,6 +1734,8 @@ static ir_node *_expression_to_firm(const expression_t *expression) return const_to_firm(&expression->conste); case EXPR_STRING_LITERAL: return string_literal_to_firm(&expression->string); + case EXPR_WIDE_STRING_LITERAL: + return wide_string_literal_to_firm(&expression->wide_string); case EXPR_REFERENCE: return reference_expression_to_firm(&expression->reference); case EXPR_CALL: @@ -1763,7 +1854,6 @@ 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) @@ -1778,32 +1868,20 @@ static void return_statement_to_firm(return_statement_t *statement) if(get_method_n_ress(func_irtype) > 0) { ir_type *res_type = get_method_res_type(func_irtype, 0); - if(is_compound_type(res_type)) { - ir_entity *entity = get_method_value_res_ent(func_irtype, 0); - - ir_node *frame = get_irg_frame(current_ir_graph); - ir_node *nomem = new_NoMem(); - ir_node *source_addr = expression_to_addr(statement->return_value); - ir_node *dest_addr = new_simpleSel(nomem, frame, entity); - - ir_node *store = get_store(); - ir_node *copyb = new_d_CopyB(dbgi, store, dest_addr, source_addr, - res_type); - - ir_node *copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M_regular); - set_store(copyb_mem); - - in[0] = dest_addr; - in_len = 1; + if(statement->return_value != NULL) { + ir_node *node = expression_to_firm(statement->return_value); + node = do_strict_conv(dbgi, node); + in[0] = node; } else { - in_len = 1; - if(statement->return_value != NULL) { - in[0] = expression_to_firm(statement->return_value); + ir_mode *mode; + if(is_compound_type(res_type)) { + mode = mode_P_data; } else { - ir_mode *mode = get_type_mode(res_type); - in[0] = new_Unknown(mode); + mode = get_type_mode(res_type); } + in[0] = new_Unknown(mode); } + in_len = 1; } else { /* build return_value for its side effects */ if(statement->return_value != NULL) { @@ -2256,7 +2334,7 @@ static void create_initializer_string(initializer_string_t *initializer, 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) { + if(is_type_array(type)) { array_type_t *array_type = &type->array; if(initializer->type == INITIALIZER_STRING) { @@ -2271,8 +2349,7 @@ static void create_initializer_object(initializer_t *initializer, type_t *type, assert(initializer->type == INITIALIZER_LIST); initializer_list_t *list = &initializer->list; - assert(type->type == TYPE_COMPOUND_STRUCT - || type->type == TYPE_COMPOUND_UNION); + assert(is_type_compound(type)); compound_type_t *compound_type = &type->compound; create_initializer_compound(list, compound_type, entity, entry, len); } @@ -2372,9 +2449,7 @@ static void create_local_variable(declaration_t *declaration) bool needs_entity = declaration->address_taken; type_t *type = skip_typeref(declaration->type); - if(type->type == TYPE_ARRAY - || type->type == TYPE_COMPOUND_STRUCT - || type->type == TYPE_COMPOUND_UNION) { + if(is_type_array(type) || is_type_compound(type)) { needs_entity = true; } @@ -2422,9 +2497,9 @@ static void declaration_statement_to_firm(declaration_statement_t *statement) declaration_t *declaration = statement->declarations_begin; declaration_t *end = statement->declarations_end->next; for( ; declaration != end; declaration = declaration->next) { - type_t *type = declaration->type; + type_t *type = skip_typeref(declaration->type); - switch(declaration->storage_class) { + switch ((storage_class_tag_t) declaration->storage_class) { case STORAGE_CLASS_TYPEDEF: continue; case STORAGE_CLASS_STATIC: @@ -2437,12 +2512,16 @@ static void declaration_statement_to_firm(declaration_statement_t *statement) case STORAGE_CLASS_NONE: case STORAGE_CLASS_AUTO: case STORAGE_CLASS_REGISTER: - if(type->type == TYPE_FUNCTION) { + if(is_type_function(type)) { panic("nested functions not supported yet"); } else { 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"); } @@ -2605,26 +2684,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); @@ -2633,21 +2714,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"); @@ -2736,6 +2817,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: @@ -2780,8 +2862,8 @@ static void initialize_function_parameters(declaration_t *declaration) type_t *type = skip_typeref(parameter->type); bool needs_entity = parameter->address_taken; - if(type->type == TYPE_COMPOUND_STRUCT - || type->type == TYPE_COMPOUND_UNION) { + assert(!is_type_array(type)); + if(is_type_compound(type)) { needs_entity = true; } @@ -2834,15 +2916,24 @@ 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 = &declaration->type->function; + type_t *type = skip_typeref(declaration->type); + assert(is_type_function(type)); + const function_type_t *func_type = &type->function; + const type_t *return_type + = skip_typeref(func_type->return_type); ir_node *ret; - if (func_type->result_type == type_void) { + if (is_type_atomic(return_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(return_type)) { + mode = get_ir_mode(func_type->return_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)); @@ -2897,20 +2988,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) @@ -2926,8 +3054,8 @@ static void context_to_firm(context_t *context) if(declaration->symbol == NULL) continue; - type_t *type = declaration->type; - if(type->type == TYPE_FUNCTION) { + type_t *type = skip_typeref(declaration->type); + if(is_type_function(type)) { get_function_entity(declaration); } else { create_global_variable(declaration); @@ -2955,6 +3083,18 @@ static void context_to_firm(context_t *context) void translation_unit_to_firm(translation_unit_t *unit) { + type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST); + type_void = make_atomic_type(ATOMIC_TYPE_VOID, TYPE_QUALIFIER_NONE); + type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE); + + ir_type_int = get_ir_type(type_int); + 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_int); /* we don't have a real void + type in firm */ + + type_void->base.firm_type = ir_type_void; + /* just to be sure */ continue_label = NULL; break_label = NULL;