{
switch (entity->kind) {
case ENTITY_VARIABLE:
- return entity->variable.initializer != NULL;
+ return entity->declaration.storage_class != STORAGE_CLASS_EXTERN;
case ENTITY_FUNCTION:
return entity->function.statement != NULL;
case ENTITY_PARAMETER:
return NULL;
}
- if (is_main(entity)) {
- /* force main to C linkage */
- type_t *type = entity->declaration.type;
- assert(is_type_function(type));
- if (type->function.linkage != LINKAGE_C) {
- type_t *new_type = duplicate_type(type);
- new_type->function.linkage = LINKAGE_C;
- type = identify_new_type(new_type);
- entity->declaration.type = type;
- }
- }
-
symbol_t *symbol = entity->base.symbol;
ident *id = new_id_from_str(symbol->string);
return create_symconst(dbgi, entity);
}
-static bool try_create_integer(literal_expression_t *literal,
- type_t *type, unsigned char base)
+static bool try_create_integer(literal_expression_t *literal, type_t *type)
{
const char *string = literal->value.begin;
size_t size = literal->value.size;
assert(type->kind == TYPE_ATOMIC);
atomic_type_kind_t akind = type->atomic.akind;
- ir_mode *mode = atomic_modes[akind];
- ir_tarval *tv = new_integer_tarval_from_str(string, size, 1, base, mode);
+ ir_mode *const mode = atomic_modes[akind];
+ ir_tarval *const tv = new_tarval_from_str(string, size, mode);
if (tv == tarval_bad)
return false;
static void create_integer_tarval(literal_expression_t *literal)
{
- unsigned us = 0;
+ /* -1: signed only, 0: any, 1: unsigned only */
+ int sign = literal->value.begin[0] != '0' /* decimal */ ? -1 : 0;
unsigned ls = 0;
const string_t *suffix = &literal->suffix;
/* parse suffix */
if (suffix->size > 0) {
for (const char *c = suffix->begin; *c != '\0'; ++c) {
- if (*c == 'u' || *c == 'U') { ++us; }
+ if (*c == 'u' || *c == 'U') sign = 1;
if (*c == 'l' || *c == 'L') { ++ls; }
}
}
- unsigned base;
- switch (literal->base.kind) {
- case EXPR_LITERAL_INTEGER_OCTAL: base = 8; break;
- case EXPR_LITERAL_INTEGER: base = 10; break;
- case EXPR_LITERAL_INTEGER_HEXADECIMAL: base = 16; break;
- default: panic("invalid literal kind");
- }
-
tarval_int_overflow_mode_t old_mode = tarval_get_integer_overflow_mode();
/* now try if the constant is small enough for some types */
tarval_set_integer_overflow_mode(TV_OVERFLOW_BAD);
if (ls < 1) {
- if (us == 0 && try_create_integer(literal, type_int, base))
+ if (sign <= 0 && try_create_integer(literal, type_int))
goto finished;
- if ((us == 1 || base != 10)
- && try_create_integer(literal, type_unsigned_int, base))
+ if (sign >= 0 && try_create_integer(literal, type_unsigned_int))
goto finished;
}
if (ls < 2) {
- if (us == 0 && try_create_integer(literal, type_long, base))
+ if (sign <= 0 && try_create_integer(literal, type_long))
goto finished;
- if ((us == 1 || base != 10)
- && try_create_integer(literal, type_unsigned_long, base))
+ if (sign >= 0 && try_create_integer(literal, type_unsigned_long))
goto finished;
}
/* last try? then we should not report tarval_bad */
- if (us != 1 && base == 10)
+ if (sign < 0)
tarval_set_integer_overflow_mode(TV_OVERFLOW_WRAP);
- if (us == 0 && try_create_integer(literal, type_long_long, base))
+ if (sign <= 0 && try_create_integer(literal, type_long_long))
goto finished;
/* last try */
- assert(us == 1 || base != 10);
+ assert(sign >= 0);
tarval_set_integer_overflow_mode(TV_OVERFLOW_WRAP);
- bool res = try_create_integer(literal, type_unsigned_long_long, base);
+ bool res = try_create_integer(literal, type_unsigned_long_long);
if (!res)
panic("internal error when parsing number literal");
{
switch (literal->base.kind) {
case EXPR_LITERAL_INTEGER:
- case EXPR_LITERAL_INTEGER_OCTAL:
- case EXPR_LITERAL_INTEGER_HEXADECIMAL:
create_integer_tarval(literal);
return;
default:
}
case EXPR_LITERAL_INTEGER:
- case EXPR_LITERAL_INTEGER_OCTAL:
- case EXPR_LITERAL_INTEGER_HEXADECIMAL:
assert(literal->target_value != NULL);
tv = literal->target_value;
break;
tv = new_tarval_from_str(string, size, mode);
break;
- case EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL: {
- char buffer[size + 2];
- memcpy(buffer, "0x", 2);
- memcpy(buffer+2, string, size);
- tv = new_tarval_from_str(buffer, size+2, mode);
- break;
- }
-
case EXPR_LITERAL_BOOLEAN:
if (string[0] == 't') {
tv = get_mode_one(mode);
return new_Const(entity->enum_value.tv);
}
-static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
+static ir_node *reference_addr(const reference_expression_t *ref)
{
dbg_info *dbgi = get_dbg_info(&ref->base.source_position);
entity_t *entity = ref->entity;
assert(is_declaration(entity));
- type_t *type = skip_typeref(entity->declaration.type);
-
- /* make sure the type is constructed */
- (void) get_ir_type(type);
if (entity->kind == ENTITY_FUNCTION
&& entity->function.btk != BUILTIN_NONE) {
* builtins which don't have entities */
if (irentity == NULL) {
source_position_t const *const pos = &ref->base.source_position;
- symbol_t const *const sym = ref->entity->base.symbol;
- warningf(WARN_OTHER, pos, "taking address of builtin '%Y'", sym);
+ warningf(WARN_OTHER, pos, "taking address of builtin '%N'", ref->entity);
/* simply create a NULL pointer */
ir_mode *mode = get_ir_mode_arithmetic(type_void_ptr);
}
}
- switch ((declaration_kind_t) entity->declaration.kind) {
- case DECLARATION_KIND_UNKNOWN:
- break;
-
- case DECLARATION_KIND_LOCAL_VARIABLE: {
- ir_mode *const mode = get_ir_mode_storage(type);
- ir_node *const value = get_value(entity->variable.v.value_number, mode);
- return create_conv(NULL, value, get_ir_mode_arithmetic(type));
- }
- case DECLARATION_KIND_PARAMETER: {
- ir_mode *const mode = get_ir_mode_storage(type);
- ir_node *const value = get_value(entity->parameter.v.value_number,mode);
- return create_conv(NULL, value, get_ir_mode_arithmetic(type));
- }
- case DECLARATION_KIND_FUNCTION: {
- return create_symconst(dbgi, entity->function.irentity);
- }
- case DECLARATION_KIND_INNER_FUNCTION: {
- ir_mode *const mode = get_ir_mode_storage(type);
- if (!entity->function.goto_to_outer && !entity->function.need_closure) {
- /* inner function not using the closure */
- return create_symconst(dbgi, entity->function.irentity);
- } else {
- /* need trampoline here */
- return create_trampoline(dbgi, mode, entity->function.irentity);
- }
- }
- case DECLARATION_KIND_GLOBAL_VARIABLE: {
- const variable_t *variable = &entity->variable;
- ir_node *const addr = create_symconst(dbgi, variable->v.entity);
- return deref_address(dbgi, variable->base.type, addr);
- }
-
- case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: {
- ir_entity *irentity = entity->variable.v.entity;
- ir_node *frame = get_local_frame(irentity);
- ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), frame, irentity);
- return deref_address(dbgi, entity->declaration.type, sel);
- }
- case DECLARATION_KIND_PARAMETER_ENTITY: {
- ir_entity *irentity = entity->parameter.v.entity;
- ir_node *frame = get_local_frame(irentity);
- ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), frame, irentity);
- return deref_address(dbgi, entity->declaration.type, sel);
- }
-
- case DECLARATION_KIND_VARIABLE_LENGTH_ARRAY:
- return entity->variable.v.vla_base;
-
- case DECLARATION_KIND_COMPOUND_MEMBER:
- panic("not implemented reference type");
- }
-
- panic("reference to declaration with unknown type found");
-}
-
-static ir_node *reference_addr(const reference_expression_t *ref)
-{
- dbg_info *dbgi = get_dbg_info(&ref->base.source_position);
- entity_t *entity = ref->entity;
- assert(is_declaration(entity));
-
switch((declaration_kind_t) entity->declaration.kind) {
case DECLARATION_KIND_UNKNOWN:
break;
ir_node *const addr = create_symconst(dbgi, entity->variable.v.entity);
return addr;
}
- case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: {
- ir_entity *irentity = entity->variable.v.entity;
- ir_node *frame = get_local_frame(irentity);
- ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), frame, irentity);
- return sel;
- }
+ case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY:
case DECLARATION_KIND_PARAMETER_ENTITY: {
- ir_entity *irentity = entity->parameter.v.entity;
+ ir_entity *irentity = entity->variable.v.entity;
ir_node *frame = get_local_frame(irentity);
ir_node *sel = new_d_simpleSel(dbgi, new_NoMem(), frame, irentity);
-
return sel;
}
panic("reference to declaration with unknown type found");
}
+static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
+{
+ dbg_info *const dbgi = get_dbg_info(&ref->base.source_position);
+ entity_t *const entity = ref->entity;
+ assert(is_declaration(entity));
+
+ switch ((declaration_kind_t)entity->declaration.kind) {
+ case DECLARATION_KIND_LOCAL_VARIABLE:
+ case DECLARATION_KIND_PARAMETER: {
+ type_t *const type = skip_typeref(entity->declaration.type);
+ ir_mode *const mode = get_ir_mode_storage(type);
+ ir_node *const value = get_value(entity->variable.v.value_number, mode);
+ return create_conv(dbgi, value, get_ir_mode_arithmetic(type));
+ }
+
+ default: {
+ ir_node *const addr = reference_addr(ref);
+ return deref_address(dbgi, entity->declaration.type, addr);
+ }
+ }
+}
+
/**
* Transform calls to builtin functions.
*/
entity_t *entity = ref->entity;
assert(is_declaration(entity));
assert(entity->declaration.kind != DECLARATION_KIND_UNKNOWN);
- if (entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE) {
+ if (entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE ||
+ entity->declaration.kind == DECLARATION_KIND_PARAMETER) {
set_value(entity->variable.v.value_number, value);
return value;
- } else if (entity->declaration.kind == DECLARATION_KIND_PARAMETER) {
- set_value(entity->parameter.v.value_number, value);
- return value;
}
}
|| entity->kind == ENTITY_PARAMETER);
assert(entity->declaration.kind != DECLARATION_KIND_UNKNOWN);
int value_number;
- if (entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE) {
+ if (entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE ||
+ entity->declaration.kind == DECLARATION_KIND_PARAMETER) {
value_number = entity->variable.v.value_number;
assert(addr == NULL);
type_t *type = skip_typeref(expression->base.type);
ir_mode *mode = get_ir_mode_storage(type);
ir_node *res = get_value(value_number, mode);
return create_conv(NULL, res, get_ir_mode_arithmetic(type));
- } else if (entity->declaration.kind == DECLARATION_KIND_PARAMETER) {
- value_number = entity->parameter.v.value_number;
- assert(addr == NULL);
- type_t *type = skip_typeref(expression->base.type);
- ir_mode *mode = get_ir_mode_storage(type);
- ir_node *res = get_value(value_number, mode);
- return create_conv(NULL, res, get_ir_mode_arithmetic(type));
}
}
if (tp_expression != NULL) {
entity_t *entity = get_expression_entity(tp_expression);
if (entity != NULL) {
- if (entity->kind == ENTITY_FUNCTION) {
- /* a gnu-extension */
- alignment = 1;
- } else {
- alignment = get_cparser_entity_alignment(entity);
- }
+ alignment = get_cparser_entity_alignment(entity);
}
}
int count = 0;
entity_t const *const end = last != NULL ? last->base.next : NULL;
for (; entity != end; entity = entity->base.next) {
- type_t *type;
- bool address_taken;
-
- if (entity->kind == ENTITY_VARIABLE) {
- type = skip_typeref(entity->declaration.type);
- address_taken = entity->variable.address_taken;
- } else if (entity->kind == ENTITY_PARAMETER) {
- type = skip_typeref(entity->declaration.type);
- address_taken = entity->parameter.address_taken;
- } else {
- continue;
- }
-
- if (!address_taken && is_type_scalar(type))
+ if ((entity->kind == ENTITY_VARIABLE || entity->kind == ENTITY_PARAMETER) &&
+ !entity->variable.address_taken &&
+ is_type_scalar(skip_typeref(entity->declaration.type)))
++count;
}
return count;
assert(parameter->declaration.kind == DECLARATION_KIND_UNKNOWN);
type_t *type = skip_typeref(parameter->declaration.type);
- bool needs_entity = parameter->parameter.address_taken;
assert(!is_type_array(type));
- if (is_type_compound(type)) {
- needs_entity = true;
- }
+ bool const needs_entity = parameter->variable.address_taken || is_type_compound(type);
ir_type *param_irtype = get_method_param_type(function_irtype, n);
if (needs_entity) {
ir_type *frame_type = get_irg_frame_type(irg);
ir_entity *param
= new_parameter_entity(frame_type, n, param_irtype);
- parameter->declaration.kind
- = DECLARATION_KIND_PARAMETER_ENTITY;
- parameter->parameter.v.entity = param;
+ parameter->declaration.kind = DECLARATION_KIND_PARAMETER_ENTITY;
+ parameter->variable.v.entity = param;
continue;
}
value = create_conv(NULL, value, mode);
value = do_strict_conv(NULL, value);
- parameter->declaration.kind = DECLARATION_KIND_PARAMETER;
- parameter->parameter.v.value_number = next_value_number_function;
+ parameter->declaration.kind = DECLARATION_KIND_PARAMETER;
+ parameter->variable.v.value_number = next_value_number_function;
set_irg_loc_description(current_ir_graph, next_value_number_function,
parameter);
++next_value_number_function;
- set_value(parameter->parameter.v.value_number, value);
+ set_value(parameter->variable.v.value_number, value);
}
}
projects / cparser / blobdiff