#include "driver/firm_opt.h"
#include "driver/firm_cmdline.h"
-#define MAGIC_DEFAULT_PN_NUMBER (long) -314159265
-
/* some idents needed for name mangling */
static ident *id_underscore;
static ident *id_imp;
static ir_type *ir_type_void;
static ir_type *ir_type_int;
-static type_t *type_const_char;
-
static int next_value_number_function;
static ir_node *continue_label;
static ir_node *break_label;
static const declaration_t *current_function_decl;
static ir_node *current_function_name;
static ir_node *current_funcsig;
+static switch_statement_t *current_switch;
static entitymap_t entitymap;
* extern inline => local
* inline without definition => local
* inline with definition => external_visible */
- storage_class_tag_t const storage_class = declaration->storage_class;
+ storage_class_tag_t const storage_class = (storage_class_tag_t)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) {
tarval *all_one = get_mode_all_one(mode);
int mode_size = get_mode_size_bits(mode);
- assert(offset >= 0 && size >= 0);
+ assert(offset >= 0);
+ assert(size >= 0);
assert(offset + size <= mode_size);
if (size == mode_size) {
return all_one;
type_t *const points_to = skip_typeref(pointer_type->points_to);
unsigned elem_size = get_type_size_const(points_to);
- /* gcc extension */
- if (elem_size == 0 && is_type_atomic(points_to, ATOMIC_TYPE_VOID)) {
+ /* gcc extension: allow arithmetic with void * and function * */
+ if ((elem_size == 0 && is_type_atomic(points_to, ATOMIC_TYPE_VOID)) ||
+ is_type_function(points_to)) {
elem_size = 1;
}
if (is_constant_expression(expression->left)) {
long val = fold_constant(expression->left);
expression_kind_t ekind = expression->base.kind;
- if ((ekind == EXPR_BINARY_LOGICAL_AND && val != 0)
- || (ekind == EXPR_BINARY_LOGICAL_OR && val == 0)) {
+ assert(ekind == EXPR_BINARY_LOGICAL_AND || ekind == EXPR_BINARY_LOGICAL_OR);
+ if ((ekind == EXPR_BINARY_LOGICAL_AND && val != 0) ||
+ (ekind == EXPR_BINARY_LOGICAL_OR && val == 0)) {
return expression_to_firm(expression->right);
} else {
- assert((ekind == EXPR_BINARY_LOGICAL_AND && val == 0)
- || (ekind == EXPR_BINARY_LOGICAL_OR && val != 0));
return new_Const(mode, get_mode_one(mode));
}
}
}
static void init_ir_types(void);
+
long fold_constant(const expression_t *expression)
{
bool constant_folding_old = constant_folding;
type = skip_typeref(type);
size_t string_len = initializer->string.size;
- assert(type->kind == TYPE_ARRAY && type->array.size_constant);
+ assert(type->kind == TYPE_ARRAY);
+ assert(type->array.size_constant);
size_t len = type->array.size;
ir_initializer_t *irinitializer = create_initializer_compound(len);
const initializer_wide_string_t *initializer, type_t *type)
{
size_t string_len = initializer->string.size;
- assert(type->kind == TYPE_ARRAY && type->array.size_constant);
+ assert(type->kind == TYPE_ARRAY);
+ assert(type->array.size_constant);
size_t len = type->array.size;
ir_initializer_t *irinitializer = create_initializer_compound(len);
return break_label;
}
-static void switch_statement_to_firm(const switch_statement_t *statement)
+static void switch_statement_to_firm(switch_statement_t *statement)
{
dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
saw_default_label = false;
current_switch_cond = cond;
break_label = NULL;
+ switch_statement_t *const old_switch = current_switch;
+ current_switch = statement;
+
+ /* determine a free number for the default label */
+ unsigned long num_cases = 0;
+ long def_nr = 0;
+ for (case_label_statement_t *l = statement->first_case; l != NULL; l = l->next) {
+ if (l->expression == NULL) {
+ /* default case */
+ continue;
+ }
+ for (long cns = l->first_case; cns <= l->last_case; ++cns)
+ ++num_cases;
+ if (l->last_case > def_nr)
+ def_nr = l->last_case;
+ }
+
+ if (def_nr + 1 < 0) {
+ /* Bad: an overflow occurred, we cannot be sure that the
+ * maximum + 1 is a free number. Scan the values a second
+ * time to find a free number.
+ */
+ unsigned char *bits = xmalloc((num_cases + 7) >> 3);
+ unsigned long i;
+
+ memset(bits, 0, (num_cases + 7) >> 3);
+ for (case_label_statement_t *l = statement->first_case; l != NULL; l = l->next) {
+ if (l->expression == NULL) {
+ /* default case */
+ continue;
+ }
+ for (long cns = l->first_case; cns <= l->last_case; ++cns) {
+ if (cns >= 0 && (unsigned long)cns < num_cases)
+ bits[cns >> 3] |= (1 << (cns & 7));
+ }
+ }
+ /* We look at the first num_cases constants:
+ * Either they are densed, so we took the last (num_cases)
+ * one, or they are non densed, so we will find one free
+ * there...
+ */
+ for (i = 0; i < num_cases; ++i)
+ if ((bits[i >> 3] & (i & 7)) == 0)
+ break;
+
+ free(bits);
+ def_nr = i;
+ } else {
+ ++def_nr;
+ }
+ statement->default_proj_nr = def_nr;
if (statement->body != NULL) {
statement_to_firm(statement->body);
if (!saw_default_label) {
set_cur_block(get_nodes_block(cond));
ir_node *const proj = new_d_defaultProj(dbgi, cond,
- MAGIC_DEFAULT_PN_NUMBER);
+ statement->default_proj_nr);
add_immBlock_pred(get_break_label(), proj);
}
set_cur_block(break_label);
assert(current_switch_cond == cond);
+ current_switch = old_switch;
current_switch_cond = old_switch_cond;
break_label = old_break_label;
saw_default_label = old_saw_default_label;
static void case_label_to_firm(const case_label_statement_t *statement)
{
+ if (statement->is_empty)
+ return;
+
dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *const fallthrough = (get_cur_block() == NULL ? NULL : new_Jmp());
- /* let's create a node and hope firm constant folding creates a Const
- * node... */
ir_node *proj;
ir_node *old_block = get_nodes_block(current_switch_cond);
ir_node *block = new_immBlock();
set_cur_block(old_block);
if (statement->expression != NULL) {
- long start_pn = fold_constant(statement->expression);
- long end_pn = start_pn;
- if (statement->end_range != NULL) {
- end_pn = fold_constant(statement->end_range);
- }
+ long start_pn = statement->first_case;
+ long end_pn = statement->last_case;
assert(start_pn <= end_pn);
/* create jumps for all cases in the given range */
for (long pn = start_pn; pn <= end_pn; ++pn) {
- if (pn == MAGIC_DEFAULT_PN_NUMBER) {
- /* oops someone detected our cheating... */
- panic("magic default pn used");
- }
proj = new_d_Proj(dbgi, current_switch_cond, mode_X, pn);
add_immBlock_pred(block, proj);
}
} else {
saw_default_label = true;
proj = new_d_defaultProj(dbgi, current_switch_cond,
- MAGIC_DEFAULT_PN_NUMBER);
+ current_switch->default_proj_nr);
add_immBlock_pred(block, proj);
}
ir_node *ins[n_inputs + n_outputs + 1];
size_t in_size = 0;
- ir_asm_constraint *tmp_in_constraints
- = xmalloc(n_outputs * sizeof(tmp_in_constraints[0]));
+ ir_asm_constraint tmp_in_constraints[n_outputs];
const expression_t *out_exprs[n_outputs];
ir_node *out_addrs[n_outputs];
obstack_grow(&asm_obst, tmp_in_constraints,
in_size * sizeof(tmp_in_constraints[0]));
- free(tmp_in_constraints);
/* find and count input and output arguments */
argument = statement->inputs;
for( ; argument != NULL; argument = argument->next) {
in[0] = new_Const(mode, get_mode_null(mode));
} else {
in[0] = new_Unknown(mode);
- if (warning.return_type) {
- warningf(&declaration->source_position,
- "missing return statement at end of non-void function '%Y'",
- declaration->symbol);
- }
}
ret = new_Return(get_store(), 1, in);
}
return;
ir_types_initialized = 1;
- type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST);
- type_void = make_atomic_type(ATOMIC_TYPE_VOID, TYPE_QUALIFIER_NONE);
- type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE);
-
ir_type_int = get_ir_type(type_int);
ir_type_const_char = get_ir_type(type_const_char);
ir_type_wchar_t = get_ir_type(type_wchar_t);