X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=e5a38a0d2c63f4346ba2267737caec469681bd43;hb=9e9141455d9e7a9028d7ffa1d5656b1e9bb25c74;hp=86638a7f9873b58f70e28b26cab0204492e69f34;hpb=23146090167f790fa1ec9c842a37d818d4f776f8;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 86638a7..e5a38a0 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -25,6 +25,7 @@ #include #include +#include #include #include "ast2firm.h" @@ -64,6 +65,8 @@ static int inner_function_idx; static ir_node *ijmp_list; static bool constant_folding; +extern bool have_const_functions; + static const declaration_t *current_function_decl; static ir_node *current_function_name; static ir_node *current_funcsig; @@ -1047,6 +1050,10 @@ static void handle_gnu_attributes_ent(ir_entity *ent, declaration_t *decl) __attribute__((pure)) specifier. */ set_entity_additional_property(ent, mtp_property_pure); } + if (decl->modifiers & DM_CONST) { + set_entity_additional_property(ent, mtp_property_const); + have_const_functions = true; + } if (decl->modifiers & DM_USED) { /* TRUE if the declaration includes the GNU __attribute__((used)) specifier. */ @@ -1527,7 +1534,12 @@ static ir_node *reference_addr(const reference_expression_t *ref) case DECLARATION_KIND_ENUM_ENTRY: panic("trying to reference enum entry"); - case DECLARATION_KIND_FUNCTION: + case DECLARATION_KIND_FUNCTION: { + type_t *const type = skip_typeref(declaration->type); + ir_mode *const mode = get_ir_mode(type); + return create_symconst(dbgi, mode, declaration->v.entity); + } + case DECLARATION_KIND_INNER_FUNCTION: case DECLARATION_KIND_COMPOUND_TYPE_INCOMPLETE: case DECLARATION_KIND_COMPOUND_TYPE_COMPLETE: @@ -1572,7 +1584,11 @@ static ir_node *process_builtin_call(const call_expression_t *call) return res; } - case T___builtin_huge_val: { + + 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); tarval *tv = get_mode_infinite(mode); ir_node *res = new_d_Const(dbgi, mode, tv); @@ -1580,7 +1596,7 @@ static ir_node *process_builtin_call(const call_expression_t *call) } case T___builtin_nan: case T___builtin_nanf: - case T___builtin_nand: { + case T___builtin_nanl: { /* Ignore string for now... */ assert(is_type_function(function_type)); ir_mode *mode = get_ir_mode(function_type->function.return_type); @@ -1778,21 +1794,19 @@ static tarval *create_bitfield_mask(ir_mode *mode, int offset, int size) return mask1; } -static void bitfield_store_to_firm(const select_expression_t *expression, - ir_node *addr, ir_node *value) +static void bitfield_store_to_firm(dbg_info *dbgi, + ir_entity *entity, ir_node *addr, ir_node *value, bool set_volatile) { - type_t *type = expression->base.type; - ir_mode *mode = get_ir_mode(type); + ir_type *entity_type = get_entity_type(entity); + ir_type *base_type = get_primitive_base_type(entity_type); + assert(base_type != NULL); + ir_mode *mode = get_type_mode(base_type); - assert(get_irn_mode(value) == mode || is_Bad(value)); - - dbg_info *dbgi = get_dbg_info(&expression->base.source_position); + value = create_conv(dbgi, value, mode); /* kill upper bits of value and shift to right position */ - ir_entity *entity = expression->compound_entry->v.entity; - int bitoffset = get_entity_offset_bits_remainder(entity); - ir_type *entity_type = get_entity_type(entity); - int bitsize = get_mode_size_bits(get_type_mode(entity_type)); + int bitoffset = get_entity_offset_bits_remainder(entity); + int bitsize = get_mode_size_bits(get_type_mode(entity_type)); tarval *mask = create_bitfield_mask(mode, 0, bitsize); ir_node *mask_node = new_d_Const(dbgi, mode, mask); @@ -1817,7 +1831,7 @@ static void bitfield_store_to_firm(const select_expression_t *expression, ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); set_store(store_mem); - if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) { + if (set_volatile) { set_Load_volatility(load, volatility_is_volatile); set_Store_volatility(store, volatility_is_volatile); } @@ -1890,7 +1904,10 @@ static void set_value_for_expression_addr(const expression_t *expression, declaration_t *declaration = select->compound_entry; if (declaration->type->kind == TYPE_BITFIELD) { - bitfield_store_to_firm(select, addr, value); + ir_entity *entity = select->compound_entry->v.entity; + bool set_volatile + = select->base.type->base.qualifiers & TYPE_QUALIFIER_VOLATILE; + bitfield_store_to_firm(dbgi, entity, addr, value, set_volatile); return; } } @@ -2530,7 +2547,6 @@ static long get_offsetof_offset(const offsetof_expression_t *expression) expression_t *array_index = designator->array_index; assert(designator->array_index != NULL); assert(is_type_array(type)); - assert(is_type_valid(array_index->base.type)); long index = fold_constant(array_index); ir_type *arr_type = get_ir_type(type); @@ -2634,6 +2650,8 @@ static void init_ir_types(void); long fold_constant(const expression_t *expression) { + assert(is_type_valid(skip_typeref(expression->base.type))); + bool constant_folding_old = constant_folding; constant_folding = true; @@ -3257,6 +3275,8 @@ static void create_declaration_entity(declaration_t *declaration, dbg_info *const dbgi = get_dbg_info(&declaration->source_position); ir_entity *const entity = new_d_entity(parent_type, id, irtype, dbgi); + handle_gnu_attributes_ent(entity, declaration); + declaration->declaration_kind = (unsigned char) declaration_kind; declaration->v.entity = entity; set_entity_variability(entity, variability_uninitialized); @@ -3443,12 +3463,11 @@ static void walk_designator(type_path_t *path, const designator_t *designator) expression_t *array_index = designator->array_index; assert(designator->array_index != NULL); assert(is_type_array(type)); - assert(is_type_valid(array_index->base.type)); long index = fold_constant(array_index); assert(index >= 0); #ifndef NDEBUG - if (type->array.size_constant == 1) { + if (type->array.size_constant) { long array_size = type->array.size; assert(index < array_size); } @@ -3701,7 +3720,7 @@ static void create_dynamic_null_initializer(ir_type *type, dbg_info *dbgi, } static void create_dynamic_initializer_sub(ir_initializer_t *initializer, - ir_type *type, dbg_info *dbgi, ir_node *base_addr) + ir_entity *entity, ir_type *type, dbg_info *dbgi, ir_node *base_addr) { switch(get_initializer_kind(initializer)) { case IR_INITIALIZER_NULL: { @@ -3709,11 +3728,18 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, return; } case IR_INITIALIZER_CONST: { - ir_node *node = get_initializer_const_value(initializer); - ir_mode *mode = get_irn_mode(node); - assert(get_type_mode(type) == mode); + ir_node *node = get_initializer_const_value(initializer); + ir_mode *mode = get_irn_mode(node); + ir_type *ent_type = get_entity_type(entity); + + /* is it a bitfield type? */ + if (is_Primitive_type(ent_type) && + get_primitive_base_type(ent_type) != NULL) { + bitfield_store_to_firm(dbgi, entity, base_addr, node, false); + return; + } - /* TODO: bitfields... */ + assert(get_type_mode(type) == mode); ir_node *mem = get_store(); ir_node *store = new_d_Store(dbgi, mem, base_addr, node); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); @@ -3721,12 +3747,19 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, return; } case IR_INITIALIZER_TARVAL: { - tarval *tv = get_initializer_tarval_value(initializer); - ir_mode *mode = get_tarval_mode(tv); - ir_node *cnst = new_d_Const(dbgi, mode, tv); - assert(get_type_mode(type) == mode); + tarval *tv = get_initializer_tarval_value(initializer); + ir_mode *mode = get_tarval_mode(tv); + ir_node *cnst = new_d_Const(dbgi, mode, tv); + ir_type *ent_type = get_entity_type(entity); + + /* is it a bitfield type? */ + if (is_Primitive_type(ent_type) && + get_primitive_base_type(ent_type) != NULL) { + bitfield_store_to_firm(dbgi, entity, base_addr, cnst, false); + return; + } - /* TODO: bitfields... */ + assert(get_type_mode(type) == mode); ir_node *mem = get_store(); ir_node *store = new_d_Store(dbgi, mem, base_addr, cnst); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); @@ -3748,26 +3781,29 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, panic("initializer doesn't match compound type"); for(int i = 0; i < n_members; ++i) { - ir_node *addr; - ir_type *irtype; + ir_node *addr; + ir_type *irtype; + ir_entity *sub_entity; if (is_Array_type(type)) { - ir_entity *entity = get_array_element_entity(type); tarval *index_tv = new_tarval_from_long(i, mode_uint); ir_node *cnst = new_d_Const(dbgi, mode_uint, index_tv); ir_node *in[1] = { cnst }; - irtype = get_array_element_type(type); - addr = new_d_Sel(dbgi, new_NoMem(), base_addr, 1, in, entity); + irtype = get_array_element_type(type); + sub_entity = get_array_element_entity(type); + addr = new_d_Sel(dbgi, new_NoMem(), base_addr, 1, in, + sub_entity); } else { - ir_entity *member = get_compound_member(type, i); - - irtype = get_entity_type(member); - addr = new_d_simpleSel(dbgi, new_NoMem(), base_addr, member); + sub_entity = get_compound_member(type, i); + irtype = get_entity_type(sub_entity); + addr = new_d_simpleSel(dbgi, new_NoMem(), base_addr, + sub_entity); } ir_initializer_t *sub_init = get_initializer_compound_value(initializer, i); - create_dynamic_initializer_sub(sub_init, irtype, dbgi, addr); + create_dynamic_initializer_sub(sub_init, sub_entity, irtype, dbgi, + addr); } return; } @@ -3783,7 +3819,7 @@ static void create_dynamic_initializer(ir_initializer_t *initializer, ir_node *base_addr = new_d_simpleSel(dbgi, new_NoMem(), frame, entity); ir_type *type = get_entity_type(entity); - create_dynamic_initializer_sub(initializer, type, dbgi, base_addr); + create_dynamic_initializer_sub(initializer, entity, type, dbgi, base_addr); } static void create_local_initializer(initializer_t *initializer, dbg_info *dbgi, @@ -3862,7 +3898,8 @@ static void create_declaration_initializer(declaration_t *declaration) return; } - type_t *type = skip_typeref(declaration->type); + type_t *type = declaration->type; + type_qualifiers_t tq = get_type_qualifier(type, true); if (initializer->kind == INITIALIZER_VALUE) { initializer_value_t *initializer_value = &initializer->value; @@ -3879,7 +3916,7 @@ static void create_declaration_initializer(declaration_t *declaration) ir_entity *entity = declaration->v.entity; - if (type->base.qualifiers & TYPE_QUALIFIER_CONST) { + if (tq & TYPE_QUALIFIER_CONST) { set_entity_variability(entity, variability_constant); } else { set_entity_variability(entity, variability_initialized); @@ -3887,14 +3924,14 @@ static void create_declaration_initializer(declaration_t *declaration) set_atomic_ent_value(entity, value); } } else { - assert(declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE_ENTITY - || declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE); + assert(declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE_ENTITY || + declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE); ir_entity *entity = declaration->v.entity; ir_initializer_t *irinitializer = create_ir_initializer(initializer, type); - if (type->base.qualifiers & TYPE_QUALIFIER_CONST) { + if (tq & TYPE_QUALIFIER_CONST) { set_entity_variability(entity, variability_constant); } else { set_entity_variability(entity, variability_initialized);