#include <assert.h>
#include <string.h>
#include <stdbool.h>
+#include <unistd.h>
#include <limits.h>
#include <libfirm/firm.h>
static ir_type *ir_type_char;
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;
/* architecture specific floating point arithmetic mode (if any) */
static ir_mode *mode_float_arithmetic;
return new_r_Unknown(irg, mode);
}
-static const char *dbg_retrieve(const dbg_info *dbg, unsigned *line)
+static src_loc_t dbg_retrieve(const dbg_info *dbg)
{
- const source_position_t *pos = (const source_position_t*) dbg;
- if (pos == NULL)
- return NULL;
- if (line != NULL)
- *line = pos->lineno;
- return pos->input_name;
+ source_position_t const *const pos = (source_position_t const*)dbg;
+ if (pos) {
+ return (src_loc_t){ pos->input_name, pos->lineno, pos->colno };
+ } else {
+ return (src_loc_t){ NULL, 0, 0 };
+ }
}
static dbg_info *get_dbg_info(const source_position_t *pos)
static ir_node *_expression_to_firm(const expression_t *expression);
static ir_node *expression_to_firm(const expression_t *expression);
-static void create_local_declaration(entity_t *entity);
static unsigned decide_modulo_shift(unsigned type_size)
{
int n_parameters = count_parameters(function_type)
+ (for_closure ? 1 : 0);
- int n_results = return_type == type_void ? 0 : 1;
+ int n_results = is_type_void(return_type) ? 0 : 1;
type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) function_type);
ir_type *irtype = new_d_type_method(n_parameters, n_results, dbgi);
- if (return_type != type_void) {
+ if (!is_type_void(return_type)) {
ir_type *restype = get_ir_type(return_type);
set_method_res_type(irtype, 0, restype);
}
}
}
-#define INVALID_TYPE ((ir_type*)-1)
-
-enum {
- COMPOUND_IS_STRUCT = false,
- COMPOUND_IS_UNION = true
-};
-
/**
* Construct firm type from ast struct type.
*/
-static ir_type *create_compound_type(compound_type_t *type,
- bool incomplete, bool is_union)
+static ir_type *create_compound_type(compound_type_t *const type, bool const incomplete)
{
compound_t *compound = type->compound;
return compound->irtype;
}
+ bool const is_union = type->base.kind == TYPE_COMPOUND_UNION;
+
symbol_t *type_symbol = compound->base.symbol;
ident *id;
if (type_symbol != NULL) {
type = skip_typeref(type);
if (type->base.firm_type != NULL) {
- assert(type->base.firm_type != INVALID_TYPE);
return type->base.firm_type;
}
- switch (type->kind) {
- case TYPE_COMPOUND_STRUCT:
- return create_compound_type(&type->compound, true, COMPOUND_IS_STRUCT);
- case TYPE_COMPOUND_UNION:
- return create_compound_type(&type->compound, true, COMPOUND_IS_UNION);
- default:
+ if (is_type_compound(type)) {
+ return create_compound_type(&type->compound, true);
+ } else {
return get_ir_type(type);
}
}
type = skip_typeref(type);
if (type->base.firm_type != NULL) {
- assert(type->base.firm_type != INVALID_TYPE);
return type->base.firm_type;
}
firm_type = create_array_type(&type->array);
break;
case TYPE_COMPOUND_STRUCT:
- firm_type = create_compound_type(&type->compound, false, COMPOUND_IS_STRUCT);
- break;
case TYPE_COMPOUND_UNION:
- firm_type = create_compound_type(&type->compound, false, COMPOUND_IS_UNION);
+ firm_type = create_compound_type(&type->compound, false);
break;
case TYPE_ENUM:
firm_type = create_enum_type(&type->enumt);
static ir_mode *get_ir_mode_storage(type_t *type)
{
- ir_type *irtype = get_ir_type(type);
+ type = skip_typeref(type);
- /* firm doesn't report a mode for arrays somehow... */
- if (is_Array_type(irtype)) {
+ /* Firm doesn't report a mode for arrays and structs/unions. */
+ if (!is_type_scalar(type)) {
return mode_P_data;
}
- ir_mode *mode = get_type_mode(irtype);
+ ir_type *const irtype = get_ir_type(type);
+ ir_mode *const mode = get_type_mode(irtype);
assert(mode != NULL);
return mode;
}
create_ld_ident = func;
}
+static bool declaration_is_definition(const entity_t *entity)
+{
+ switch (entity->kind) {
+ case ENTITY_VARIABLE:
+ return entity->declaration.storage_class != STORAGE_CLASS_EXTERN;
+ case ENTITY_FUNCTION:
+ return entity->function.statement != NULL;
+ case ENTITY_PARAMETER:
+ case ENTITY_COMPOUND_MEMBER:
+ return false;
+ case ENTITY_TYPEDEF:
+ case ENTITY_ENUM:
+ case ENTITY_ENUM_VALUE:
+ case ENTITY_NAMESPACE:
+ case ENTITY_LABEL:
+ case ENTITY_LOCAL_LABEL:
+ break;
+ }
+ panic("declaration_is_definition called on non-declaration");
+}
+
/**
* Handle GNU attributes for entities
*
add_entity_additional_properties(irentity, mtp_property_const);
}
}
- if (modifiers & DM_USED) {
+ if ((modifiers & DM_USED) && declaration_is_definition(entity)) {
add_entity_linkage(irentity, IR_LINKAGE_HIDDEN_USER);
}
- if (modifiers & DM_WEAK) {
+ if ((modifiers & DM_WEAK) && declaration_is_definition(entity)
+ && entity->declaration.storage_class != STORAGE_CLASS_EXTERN) {
add_entity_linkage(irentity, IR_LINKAGE_WEAK);
}
}
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);
ir_entity *irentity = entitymap_get(&entitymap, symbol);
bool const has_body = entity->function.statement != NULL;
if (irentity != NULL) {
- if (get_entity_visibility(irentity) == ir_visibility_external
- && has_body) {
- set_entity_visibility(irentity, ir_visibility_default);
- }
goto entity_created;
}
handle_decl_modifiers(irentity, entity);
if (! nested_function) {
- /* static inline => local
- * extern inline => local
- * inline without definition => local
- * inline with definition => external_visible */
storage_class_tag_t const storage_class
= (storage_class_tag_t) entity->declaration.storage_class;
- bool const is_inline = entity->function.is_inline;
-
- if (is_inline && storage_class == STORAGE_CLASS_NONE && has_body) {
- set_entity_visibility(irentity, ir_visibility_default);
- } else if (storage_class == STORAGE_CLASS_STATIC ||
- (is_inline && has_body)) {
+ if (storage_class == STORAGE_CLASS_STATIC) {
set_entity_visibility(irentity, ir_visibility_local);
- } else if (has_body) {
- set_entity_visibility(irentity, ir_visibility_default);
} else {
set_entity_visibility(irentity, ir_visibility_external);
}
+
+ bool const is_inline = entity->function.is_inline;
+ if (is_inline && has_body) {
+ if (((c_mode & _C99) && storage_class == STORAGE_CLASS_NONE)
+ || ((c_mode & _C99) == 0
+ && storage_class == STORAGE_CLASS_EXTERN)) {
+ add_entity_linkage(irentity, IR_LINKAGE_NO_CODEGEN);
+ }
+ }
} else {
/* nested functions are always local */
set_entity_visibility(irentity, ir_visibility_local);
continue;
type_t *return_type = skip_typeref(function_type->return_type);
- int n_res = return_type != type_void ? 1 : 0;
+ int n_res = is_type_void(return_type) ? 0 : 1;
if (n_res != rts_data[i].n_res)
continue;
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:
size_t len = snprintf(buf, sizeof(buf), UTF32_PRINTF_FORMAT, v);
tv = new_tarval_from_str(buf, len, mode);
- goto make_const;
+ break;
}
+
case EXPR_LITERAL_CHARACTER: {
long long int v;
bool char_is_signed
size_t len = snprintf(buf, sizeof(buf), "%lld", v);
tv = new_tarval_from_str(buf, len, mode);
- goto make_const;
+ break;
}
+
case EXPR_LITERAL_INTEGER:
- case EXPR_LITERAL_INTEGER_OCTAL:
- case EXPR_LITERAL_INTEGER_HEXADECIMAL:
assert(literal->target_value != NULL);
tv = literal->target_value;
- goto make_const;
+ break;
+
case EXPR_LITERAL_FLOATINGPOINT:
tv = new_tarval_from_str(string, size, mode);
- goto make_const;
- 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);
- goto make_const;
- }
+ break;
+
case EXPR_LITERAL_BOOLEAN:
if (string[0] == 't') {
tv = get_mode_one(mode);
} else {
assert(string[0] == 'f');
+ case EXPR_LITERAL_MS_NOOP:
tv = get_mode_null(mode);
}
- goto make_const;
- case EXPR_LITERAL_MS_NOOP:
- tv = get_mode_null(mode);
- goto make_const;
- default:
break;
+
+ default:
+ panic("Invalid literal kind found");
}
- panic("Invalid literal kind found");
-make_const: ;
dbg_info *dbgi = get_dbg_info(&literal->base.source_position);
ir_node *res = new_d_Const(dbgi, tv);
ir_mode *mode_arith = get_ir_mode_arithmetic(type);
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.
*/
type_t *arg_type = skip_typeref(expression->base.type);
if (!is_type_compound(arg_type)) {
- ir_mode *mode = get_ir_mode_storage(expression->base.type);
- arg_node = create_conv(dbgi, arg_node, mode);
- arg_node = do_strict_conv(dbgi, arg_node);
+ ir_mode *const mode = get_ir_mode_storage(arg_type);
+ arg_node = create_conv(dbgi, arg_node, mode);
+ arg_node = do_strict_conv(dbgi, arg_node);
}
in[n] = arg_node;
set_store(mem);
}
- if (!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ if (!is_type_void(return_type)) {
assert(is_type_scalar(return_type));
ir_mode *mode = get_ir_mode_storage(return_type);
result = new_Proj(node, mode, pn_Builtin_max+1);
set_store(mem);
}
- if (!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
- ir_node *resproj = new_Proj(node, mode_T, pn_Call_T_result);
-
- if (is_type_scalar(return_type)) {
- ir_mode *mode = get_ir_mode_storage(return_type);
- result = new_Proj(resproj, mode, 0);
- ir_mode *mode_arith = get_ir_mode_arithmetic(return_type);
- result = create_conv(NULL, result, mode_arith);
- } else {
- ir_mode *mode = mode_P_data;
- result = new_Proj(resproj, mode, 0);
- }
+ if (!is_type_void(return_type)) {
+ ir_node *const resproj = new_Proj(node, mode_T, pn_Call_T_result);
+ ir_mode *const mode = get_ir_mode_storage(return_type);
+ result = new_Proj(resproj, mode, 0);
+ ir_mode *const mode_arith = get_ir_mode_arithmetic(return_type);
+ result = create_conv(NULL, result, mode_arith);
}
}
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));
}
}
type_t *from_type, type_t *type)
{
type = skip_typeref(type);
- if (type == type_void) {
+ if (is_type_void(type)) {
/* make sure firm type is constructed */
(void) get_ir_type(type);
return NULL;
if (from_var != NULL) {
ir_node *const addr = create_symconst(dbgi, from_var->v.entity);
ir_node *const base = deref_address(dbgi, from_var->base.type, addr);
- value_node = new_d_Add(dbgi, value_node, base, get_ir_mode_storage(from_type));
+ value_node = new_d_Add(dbgi, value_node, base, mode);
}
if (to_var != NULL) {
ir_node *const addr = create_symconst(dbgi, to_var->v.entity);
&& expression->tp_expression != NULL) {
expression_to_firm(expression->tp_expression);
}
- /* strange gnu extensions: sizeof(function) == 1 */
- if (is_type_function(type)) {
- ir_mode *mode = get_ir_mode_storage(type_size_t);
- return new_Const(get_mode_one(mode));
- }
return get_type_size_node(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);
}
}
ir_graph *old_current_ir_graph = current_ir_graph;
current_ir_graph = get_const_code_irg();
- ir_node *cnst = expression_to_firm(expression);
+ ir_node *const cnst = _expression_to_firm(expression);
+
current_ir_graph = old_current_ir_graph;
set_optimize(old_optimize);
set_opt_constant_folding(old_constant_folding);
constant_folding = constant_folding_old;
- return get_Const_tarval(cnst);
+ ir_tarval *const tv = get_Const_tarval(cnst);
+ ir_mode *const mode = get_ir_mode_arithmetic(skip_typeref(expression->base.type));
+ return tarval_convert_to(tv, mode);
}
/* this function is only used in parser.c, but it relies on libfirm functionality */
ir_node *const in[2] = { true_val, false_val };
type_t *const type = skip_typeref(expression->base.type);
- ir_mode *mode;
- if (is_type_compound(type)) {
- mode = mode_P;
- } else {
- mode = get_ir_mode_arithmetic(type);
- }
+ ir_mode *const mode = get_ir_mode_arithmetic(type);
ir_node *const val = new_d_Phi(dbgi, lengthof(in), in, mode);
return val;
}
if (is_constant_expression(expression) == EXPR_CLASS_CONSTANT) {
- bool const constant_folding_old = constant_folding;
- constant_folding = true;
- ir_node *res = _expression_to_firm(expression);
- constant_folding = constant_folding_old;
- ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
- assert(is_Const(res));
- return create_Const_from_bool(mode, !is_Const_null(res));
+ return new_Const(fold_constant_to_tarval(expression));
}
/* we have to produce a 0/1 from the mode_b expression */
type_qualifiers_t tq = get_type_qualifier(type, true);
if (initializer->kind == INITIALIZER_VALUE) {
- initializer_value_t *initializer_value = &initializer->value;
- dbg_info *dbgi = get_dbg_info(&entity->base.source_position);
- expression_t *value = initializer_value->value;
- type_t *init_type = value->base.type;
- type_t *skipped = skip_typeref(init_type);
+ expression_t * value = initializer->value.value;
+ type_t *const init_type = skip_typeref(value->base.type);
- if (!is_type_scalar(skipped)) {
+ if (!is_type_scalar(init_type)) {
/* skip convs */
while (value->kind == EXPR_UNARY_CAST)
value = value->unary.value;
goto have_initializer;
}
- ir_node *node = expression_to_firm(initializer_value->value);
-
- ir_mode *mode = get_ir_mode_storage(init_type);
+ ir_node * node = expression_to_firm(value);
+ dbg_info *const dbgi = get_dbg_info(&entity->base.source_position);
+ ir_mode *const mode = get_ir_mode_storage(init_type);
node = create_conv(dbgi, node, mode);
node = do_strict_conv(dbgi, node);
set_entity_ld_ident(irentity, id);
set_entity_visibility(irentity, ir_visibility_local);
+ if (entity->variable.initializer == NULL) {
+ ir_initializer_t *null_init = get_initializer_null();
+ set_entity_initializer(irentity, null_init);
+ }
+
ir_graph *const old_current_ir_graph = current_ir_graph;
current_ir_graph = get_const_code_irg();
if (!currently_reachable())
return NULL;
- dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
- type_t *type = current_function_entity->declaration.type;
- ir_type *func_irtype = get_ir_type(type);
-
- ir_node *in[1];
- int in_len;
- if (get_method_n_ress(func_irtype) > 0) {
- ir_type *res_type = get_method_res_type(func_irtype, 0);
-
- if (statement->value != NULL) {
- ir_node *node = expression_to_firm(statement->value);
- if (!is_compound_type(res_type)) {
- type_t *ret_value_type = statement->value->base.type;
- ir_mode *mode = get_ir_mode_storage(ret_value_type);
- node = create_conv(dbgi, node, mode);
- node = do_strict_conv(dbgi, node);
- }
- in[0] = node;
+ dbg_info *const dbgi = get_dbg_info(&statement->base.source_position);
+ type_t *const type = skip_typeref(current_function_entity->declaration.type->function.return_type);
+ ir_node * res = statement->value ? expression_to_firm(statement->value) : NULL;
+
+ int in_len;
+ if (!is_type_void(type)) {
+ ir_mode *const mode = get_ir_mode_storage(type);
+ if (res) {
+ res = create_conv(dbgi, res, mode);
+ res = do_strict_conv(dbgi, res);
} else {
- ir_mode *mode;
- if (is_compound_type(res_type)) {
- mode = mode_P_data;
- } else {
- mode = get_type_mode(res_type);
- }
- in[0] = new_Unknown(mode);
+ res = new_Unknown(mode);
}
in_len = 1;
} else {
- /* build return_value for its side effects */
- if (statement->value != NULL) {
- expression_to_firm(statement->value);
- }
in_len = 0;
}
- ir_node *store = get_store();
- ir_node *ret = new_d_Return(dbgi, store, in_len, in);
+ ir_node *const in[1] = { res };
+ ir_node *const store = get_store();
+ ir_node *const ret = new_d_Return(dbgi, store, in_len, in);
ir_node *end_block = get_irg_end_block(current_ir_graph);
add_immBlock_pred(end_block, ret);
return expression_to_firm(statement->expression);
}
+static void create_local_declarations(entity_t*);
+
static ir_node *compound_statement_to_firm(compound_statement_t *compound)
{
- entity_t *entity = compound->scope.entities;
- for ( ; entity != NULL; entity = entity->base.next) {
- if (!is_declaration(entity))
- continue;
-
- create_local_declaration(entity);
- }
+ create_local_declarations(compound->scope.entities);
ir_node *result = NULL;
statement_t *statement = compound->statements;
static void create_global_variable(entity_t *entity)
{
- ir_linkage linkage = IR_LINKAGE_DEFAULT;
- ir_visibility visibility = ir_visibility_default;
- ir_entity *irentity;
+ ir_linkage linkage = IR_LINKAGE_DEFAULT;
+ ir_visibility visibility = ir_visibility_external;
+ storage_class_tag_t storage
+ = (storage_class_tag_t)entity->declaration.storage_class;
+ decl_modifiers_t modifiers = entity->declaration.modifiers;
assert(entity->kind == ENTITY_VARIABLE);
- switch ((storage_class_tag_t)entity->declaration.storage_class) {
+ switch (storage) {
case STORAGE_CLASS_EXTERN: visibility = ir_visibility_external; break;
case STORAGE_CLASS_STATIC: visibility = ir_visibility_local; break;
- case STORAGE_CLASS_NONE:
- visibility = ir_visibility_default;
- /* uninitialized globals get merged in C */
- if (entity->variable.initializer == NULL)
- linkage |= IR_LINKAGE_MERGE;
- break;
+ case STORAGE_CLASS_NONE: visibility = ir_visibility_external; break;
case STORAGE_CLASS_TYPEDEF:
case STORAGE_CLASS_AUTO:
case STORAGE_CLASS_REGISTER:
panic("invalid storage class for global var");
}
+ /* "common" symbols */
+ if (storage == STORAGE_CLASS_NONE
+ && entity->variable.initializer == NULL
+ && !entity->variable.thread_local
+ && (modifiers & DM_WEAK) == 0) {
+ linkage |= IR_LINKAGE_MERGE;
+ }
+
ir_type *var_type = get_glob_type();
if (entity->variable.thread_local) {
var_type = get_tls_type();
- /* LINKAGE_MERGE not supported by current linkers */
- linkage &= ~IR_LINKAGE_MERGE;
}
create_variable_entity(entity, DECLARATION_KIND_GLOBAL_VARIABLE, var_type);
- irentity = entity->variable.v.entity;
+ ir_entity *irentity = entity->variable.v.entity;
add_entity_linkage(irentity, linkage);
set_entity_visibility(irentity, visibility);
+ if (entity->variable.initializer == NULL
+ && storage != STORAGE_CLASS_EXTERN) {
+ ir_initializer_t *null_init = get_initializer_null();
+ set_entity_initializer(irentity, null_init);
+ }
}
static void create_local_declaration(entity_t *entity)
panic("invalid storage class found");
}
+static void create_local_declarations(entity_t *e)
+{
+ for (; e; e = e->base.next) {
+ if (is_declaration(e))
+ create_local_declaration(e);
+ }
+}
+
static void initialize_local_declaration(entity_t *entity)
{
if (entity->base.symbol == NULL)
static ir_node *if_statement_to_firm(if_statement_t *statement)
{
+ create_local_declarations(statement->scope.entities);
+
/* Create the condition. */
ir_node *true_block = NULL;
ir_node *false_block = NULL;
return NULL;
}
-/* Create a jump node which jumps into target_block, if the current block is
- * reachable. */
-static void jump_if_reachable(ir_node *const target_block)
+/**
+ * Add an unconditional jump to the target block. If the source block is not
+ * reachable, then a Bad predecessor is created to prevent Phi-less unreachable
+ * loops. This is necessary if the jump potentially enters a loop.
+ */
+static void jump_to(ir_node *const target_block)
{
ir_node *const pred = currently_reachable() ? new_Jmp() : new_Bad(mode_X);
add_immBlock_pred(target_block, pred);
}
+/**
+ * Add an unconditional jump to the target block, if the current block is
+ * reachable and do nothing otherwise. This is only valid if the jump does not
+ * enter a loop (a back edge is ok).
+ */
+static void jump_if_reachable(ir_node *const target_block)
+{
+ if (currently_reachable())
+ add_immBlock_pred(target_block, new_Jmp());
+}
+
static ir_node *while_statement_to_firm(while_statement_t *statement)
{
+ create_local_declarations(statement->scope.entities);
+
/* Create the header block */
ir_node *const header_block = new_immBlock();
- jump_if_reachable(header_block);
+ jump_to(header_block);
/* Create the condition. */
ir_node * body_block;
static ir_node *do_while_statement_to_firm(do_while_statement_t *statement)
{
+ create_local_declarations(statement->scope.entities);
+
/* create the header block */
ir_node *header_block = new_immBlock();
/* the loop body */
ir_node *body_block = new_immBlock();
- jump_if_reachable(body_block);
+ jump_to(body_block);
ir_node *old_continue_label = continue_label;
ir_node *old_break_label = break_label;
static ir_node *for_statement_to_firm(for_statement_t *statement)
{
- /* create declarations */
- entity_t *entity = statement->scope.entities;
- for ( ; entity != NULL; entity = entity->base.next) {
- if (!is_declaration(entity))
- continue;
-
- create_local_declaration(entity);
- }
+ create_local_declarations(statement->scope.entities);
if (currently_reachable()) {
- entity = statement->scope.entities;
+ entity_t *entity = statement->scope.entities;
for ( ; entity != NULL; entity = entity->base.next) {
if (!is_declaration(entity))
continue;
/* Create the header block */
ir_node *const header_block = new_immBlock();
- jump_if_reachable(header_block);
+ jump_to(header_block);
/* Create the condition. */
ir_node *body_block;
statement_to_firm(statement->body);
- jump_if_reachable(get_break_label());
+ if (currently_reachable()) {
+ add_immBlock_pred(get_break_label(), new_Jmp());
+ }
if (!saw_default_label && switch_node) {
ir_node *proj = new_d_Proj(dbgi, switch_node, mode_X, pn_Switch_default);
static ir_node *label_to_firm(const label_statement_t *statement)
{
ir_node *block = get_label_block(statement->label);
- jump_if_reachable(block);
+ jump_to(block);
set_cur_block(block);
keep_alive(block);
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);
}
}
if (currently_reachable()) {
type_t *type = skip_typeref(entity->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);
+ type_t *const return_type = skip_typeref(type->function.return_type);
ir_node *ret;
- if (is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ if (is_type_void(return_type)) {
ret = new_Return(get_store(), 0, NULL);
} else {
- ir_mode *mode;
- if (is_type_scalar(return_type)) {
- mode = get_ir_mode_storage(func_type->return_type);
- } else {
- mode = mode_P_data;
- }
+ ir_mode *const mode = get_ir_mode_storage(return_type);
ir_node *in[1];
/* ยง5.1.2.2.3 main implicitly returns 0 */
return;
ir_types_initialized = 1;
- ir_type_int = get_ir_type(type_int);
ir_type_char = get_ir_type(type_char);
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_void);
be_params = be_get_backend_param();
mode_float_arithmetic = be_params->mode_float_arithmetic;
}
}
+static const char *get_cwd(void)
+{
+ static char buf[1024];
+ if (buf[0] == '\0')
+ getcwd(buf, sizeof(buf));
+ return buf;
+}
+
void translation_unit_to_firm(translation_unit_t *unit)
{
+ if (c_mode & _CXX) {
+ be_dwarf_set_source_language(DW_LANG_C_plus_plus);
+ } else if (c_mode & _C99) {
+ be_dwarf_set_source_language(DW_LANG_C99);
+ } else if (c_mode & _C89) {
+ be_dwarf_set_source_language(DW_LANG_C89);
+ } else {
+ be_dwarf_set_source_language(DW_LANG_C);
+ }
+ be_dwarf_set_compilation_directory(get_cwd());
+
/* initialize firm arithmetic */
tarval_set_integer_overflow_mode(TV_OVERFLOW_WRAP);
ir_set_uninitialized_local_variable_func(uninitialized_local_var);
projects / cparser / blobdiff