#include <libfirm/firm.h>
#include <libfirm/adt/obst.h>
+#include <libfirm/adt/bitfiddle.h>
#include <libfirm/be.h>
#include "ast2firm.h"
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;
__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. */
panic("Trampoline code not implemented");
return create_symconst(dbgi, mode, declaration->v.entity);
}
- }
+ }
case DECLARATION_KIND_GLOBAL_VARIABLE: {
ir_node *const addr = get_global_var_address(dbgi, declaration);
return deref_address(dbgi, declaration->type, addr);
/* you can store to a local variable (so we don't panic but return NULL
* as an indicator for no real address) */
return NULL;
- case DECLARATION_KIND_FUNCTION: {
- type_t *const type = skip_typeref(ref->base.type);
- ir_mode *const mode = get_ir_mode(type);
- return create_symconst(dbgi, mode, declaration->v.entity);
- }
case DECLARATION_KIND_GLOBAL_VARIABLE: {
ir_node *const addr = get_global_var_address(dbgi, declaration);
return addr;
case DECLARATION_KIND_ENUM_ENTRY:
panic("trying to reference enum entry");
+ 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:
case DECLARATION_KIND_COMPOUND_MEMBER:
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);
}
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);
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);
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);
}
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;
}
}
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);
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;
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);
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);
}
}
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: {
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);
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);
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;
}
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,
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;
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);
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);
projects / cparser / blobdiff