X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=3a2e22078c2d92f66a5a880125317918851b5689;hb=4108d31ed34aee3c0841ae01b844420da8a3cdf1;hp=655f6d4eaba5921a37c313f3ca4da79f3e6f493c;hpb=984da01e9c6590b18df8e6f49c4d7077c80dfee6;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 655f6d4..3a2e220 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -96,9 +96,11 @@ ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos) { const declaration_t *declaration = get_irg_loc_description(irg, pos); - warningf(&declaration->source_position, - "variable '%#T' might be used uninitialized", - declaration->type, declaration->symbol); + if (declaration != NULL) { + warningf(&declaration->source_position, + "variable '%#T' might be used uninitialized", + declaration->type, declaration->symbol); + } return new_r_Unknown(irg, mode); } @@ -219,8 +221,6 @@ static unsigned get_array_type_size(array_type_t *type) static unsigned get_type_size_const(type_t *type) { - type = skip_typeref(type); - switch(type->kind) { case TYPE_ERROR: panic("error type occurred"); @@ -339,6 +339,21 @@ static ir_type *create_imaginary_type(const imaginary_type_t *type) return irtype; } +/** + * return type of a parameter (and take transparent union gnu extension into + * account) + */ +static type_t *get_parameter_type(type_t *type) +{ + type = skip_typeref(type); + if (type->base.modifiers & TYPE_MODIFIER_TRANSPARENT_UNION) { + declaration_t *decl = type->compound.declaration; + type = decl->scope.declarations->type; + } + + return type; +} + static ir_type *create_method_type(const function_type_t *function_type) { type_t *return_type = function_type->return_type; @@ -357,7 +372,8 @@ static ir_type *create_method_type(const function_type_t *function_type) function_parameter_t *parameter = function_type->parameters; int n = 0; for ( ; parameter != NULL; parameter = parameter->next) { - ir_type *p_irtype = get_ir_type(parameter->type); + type_t *type = get_parameter_type(parameter->type); + ir_type *p_irtype = get_ir_type(type); set_method_param_type(irtype, n, p_irtype); ++n; } @@ -366,6 +382,34 @@ static ir_type *create_method_type(const function_type_t *function_type) set_method_variadicity(irtype, variadicity_variadic); } + unsigned cc = get_method_calling_convention(irtype); + switch (function_type->calling_convention) { + case CC_DEFAULT: /* unspecified calling convention, equal to one of the other, typically cdecl */ + case CC_CDECL: +is_cdecl: + set_method_calling_convention(irtype, SET_CDECL(cc)); + break; + + case CC_STDCALL: + if (function_type->variadic || function_type->unspecified_parameters) + goto is_cdecl; + + /* only non-variadic function can use stdcall, else use cdecl */ + set_method_calling_convention(irtype, SET_STDCALL(cc)); + break; + + case CC_FASTCALL: + if (function_type->variadic || function_type->unspecified_parameters) + goto is_cdecl; + /* only non-variadic function can use fastcall, else use cdecl */ + set_method_calling_convention(irtype, SET_FASTCALL(cc)); + break; + + case CC_THISCALL: + /* Hmm, leave default, not accepted by the parser yet. */ + warningf(&function_type->base.source_position, "THISCALL calling convention not supported yet"); + break; + } return irtype; } @@ -484,7 +528,7 @@ static ir_type *get_unsigned_int_type_for_bit_size(ir_type *base_tp, static ir_type *create_bitfield_type(bitfield_type_t *const type) { type_t *base = skip_typeref(type->base_type); - assert(base->kind == TYPE_ATOMIC); + assert(base->kind == TYPE_ATOMIC || base->kind == TYPE_ENUM); ir_type *irbase = get_ir_type(base); unsigned size = fold_constant(type->size); @@ -966,6 +1010,26 @@ typedef ident* (*create_ld_ident_func)(ir_entity *entity, declaration_t *declaration); create_ld_ident_func create_ld_ident = create_ld_ident_linux_elf; +/** + * Handle GNU attributes for entities + * + * @param ent the entity + * @param decl the routine declaration + */ +static void handle_gnu_attributes_ent(ir_entity *ent, declaration_t *decl) +{ + if (decl->modifiers & DM_PURE) { + /* TRUE if the declaration includes the GNU + __attribute__((pure)) specifier. */ + set_entity_additional_property(ent, mtp_property_pure); + } + if (decl->modifiers & DM_USED) { + /* TRUE if the declaration includes the GNU + __attribute__((used)) specifier. */ + set_entity_stickyness(ent, stickyness_sticky); + } +} + /** * Creates an entity representing a function. * @@ -998,14 +1062,25 @@ static ir_entity *get_function_entity(declaration_t *declaration) entity = new_d_entity(global_type, id, ir_type_method, dbgi); set_entity_ld_ident(entity, create_ld_ident(entity, declaration)); - if (declaration->storage_class == STORAGE_CLASS_STATIC - || declaration->is_inline) { - if (declaration->init.statement == NULL) { + handle_gnu_attributes_ent(entity, declaration); + + /* static inline => local + * extern inline => local + * inline without definition => local + * inline with definition => external_visible */ + storage_class_tag_t const storage_class = declaration->storage_class; + bool const is_inline = declaration->is_inline; + bool const has_body = declaration->init.statement != NULL; + if (is_inline && storage_class == STORAGE_CLASS_NONE && has_body) { + set_entity_visibility(entity, visibility_external_visible); + } else if (storage_class == STORAGE_CLASS_STATIC || + (is_inline && has_body)) { + if (!has_body) { /* this entity was declared, but is defined nowhere */ set_entity_peculiarity(entity, peculiarity_description); } set_entity_visibility(entity, visibility_local); - } else if (declaration->init.statement != NULL) { + } else if (has_body) { set_entity_visibility(entity, visibility_external_visible); } else { set_entity_visibility(entity, visibility_external_allocated); @@ -1472,9 +1547,10 @@ static ir_node *process_builtin_call(const call_expression_t *call) /** * Transform a call expression. - * Handles some special cases, like alloca() calls, which must be resolved BEFORE the inlines runs. - * Inlining routines calling alloca() is dangerous, 176.gcc for instance might allocate 2GB instead of - * 256 MB if alloca is not handled right... + * Handles some special cases, like alloca() calls, which must be resolved + * BEFORE the inlines runs. Inlining routines calling alloca() is dangerous, + * 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) { @@ -2072,7 +2148,7 @@ static ir_node *adjust_for_pointer_arithmetic(dbg_info *dbgi, ir_node *value, type_t *type) { pointer_type_t *const pointer_type = &type->pointer; - type_t *const points_to = pointer_type->points_to; + type_t *const points_to = skip_typeref(pointer_type->points_to); unsigned elem_size = get_type_size_const(points_to); /* gcc extension */ @@ -3399,7 +3475,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_type_mode(ir_type_const_char); + ir_mode *mode = get_ir_mode(type->array.element_type); for(size_t i = 0; i < len; ++i) { char c = 0; @@ -4690,6 +4766,11 @@ static void asm_statement_to_firm(const asm_statement_t *statement) } /* create output projs & connect them */ + if (needs_memory) { + ir_node *projm = new_Proj(node, mode_M, out_size+1); + set_store(projm); + } + size_t i; for (i = 0; i < out_size; ++i) { const expression_t *out_expr = out_exprs[i]; @@ -4700,10 +4781,6 @@ static void asm_statement_to_firm(const asm_statement_t *statement) set_value_for_expression_addr(out_expr, proj, addr); } - if (needs_memory) { - ir_node *projm = new_Proj(node, mode_M, i); - set_store(projm); - } } static void ms_try_statement_to_firm(ms_try_statement_t *statement) { @@ -4796,7 +4873,8 @@ static int count_local_declarations(const declaration_t * decl, for (; decl != end; decl = decl->next) { if (decl->namespc != NAMESPACE_NORMAL) continue; - const type_t *type = skip_typeref(decl->type); + type_t *type = skip_typeref(decl->type); + if (!decl->address_taken && is_type_scalar(type)) ++count; const initializer_t *initializer = decl->init.initializer; @@ -5061,7 +5139,7 @@ static void initialize_function_parameters(declaration_t *declaration) long pn = n; ir_node *value = new_r_Proj(irg, start_block, args, param_mode, pn); - ir_mode *mode = get_ir_mode(parameter->type); + ir_mode *mode = get_ir_mode(type); value = create_conv(NULL, value, mode); value = do_strict_conv(NULL, value); @@ -5353,6 +5431,23 @@ void exit_ast2firm(void) obstack_free(&asm_obst, NULL); } +static void global_asm_to_firm(statement_t *s) +{ + for (; s != NULL; s = s->base.next) { + assert(s->kind == STATEMENT_ASM); + + char const *const text = s->asms.asm_text.begin; + size_t size = s->asms.asm_text.size; + + /* skip the last \0 */ + if (text[size - 1] == '\0') + --size; + + ident *const id = new_id_from_chars(text, size); + add_irp_asm(id); + } +} + void translation_unit_to_firm(translation_unit_t *unit) { /* just to be sure */ @@ -5363,4 +5458,5 @@ void translation_unit_to_firm(translation_unit_t *unit) init_ir_types(); scope_to_firm(&unit->scope); + global_asm_to_firm(unit->global_asm); }