#include "printer.h"
#include "entitymap_t.h"
#include "driver/firm_opt.h"
-#include "driver/firm_cmdline.h"
typedef struct trampoline_region trampoline_region;
struct trampoline_region {
ir_entity *region; /**< created region for the trampoline */
};
+fp_model_t firm_fp_model = fp_model_precise;
+
static const backend_params *be_params;
static ir_type *ir_type_char;
static bool constant_folding;
static bool initializer_use_bitfield_basetype;
-extern bool have_const_functions;
-
static const entity_t *current_function_entity;
static ir_node *current_function_name;
static ir_node *current_funcsig;
{
const entity_t *entity = get_irg_loc_description(irg, pos);
- if (entity != NULL) {
+ if (entity != NULL && warning.uninitialized) {
warningf(&entity->base.source_position,
"%s '%#T' might be used uninitialized",
get_entity_kind_name(entity->kind),
if (pos == NULL)
return NULL;
if (line != NULL)
- *line = pos->linenr;
+ *line = pos->lineno;
return pos->input_name;
}
return (type_dbg_info*) type;
}
+/* is the current block a reachable one? */
+static bool currently_reachable(void)
+{
+ ir_node *const block = get_cur_block();
+ return block != NULL && !is_Bad(block);
+}
+
+static void set_unreachable_now(void)
+{
+ set_cur_block(NULL);
+}
+
static ir_mode *atomic_modes[ATOMIC_TYPE_LAST+1];
static ir_mode *mode_int, *mode_uint;
case TYPE_ENUM:
firm_type = create_enum_type(&type->enumt);
break;
- case TYPE_BUILTIN:
- firm_type = get_ir_type(type->builtin.real_type);
- break;
case TYPE_BITFIELD:
firm_type = create_bitfield_type(&type->bitfield);
break;
}
if (modifiers & DM_CONST) {
add_entity_additional_properties(irentity, mtp_property_const);
- have_const_functions = true;
}
}
if (modifiers & DM_USED) {
* Creates a SymConst for a given entity.
*
* @param dbgi debug info
- * @param mode the (reference) mode for the SymConst
* @param entity the entity
*/
-static ir_node *create_symconst(dbg_info *dbgi, ir_mode *mode,
- ir_entity *entity)
+static ir_node *create_symconst(dbg_info *dbgi, ir_entity *entity)
{
assert(entity != NULL);
union symconst_symbol sym;
sym.entity_p = entity;
- return new_d_SymConst(dbgi, mode, sym, symconst_addr_ent);
+ return new_d_SymConst(dbgi, mode_P, sym, symconst_addr_ent);
}
static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode)
{
ir_mode *value_mode = get_irn_mode(value);
- if (value_mode == dest_mode || is_Bad(value))
+ if (value_mode == dest_mode)
return value;
if (dest_mode == mode_b) {
ir_node *zero = new_Const(get_mode_null(value_mode));
- ir_node *cmp = new_d_Cmp(dbgi, value, zero);
- ir_node *proj = new_d_Proj(dbgi, cmp, mode_b, pn_Cmp_Lg);
- return proj;
+ ir_node *cmp = new_d_Cmp(dbgi, value, zero, ir_relation_less_greater);
+ return cmp;
}
return new_d_Conv(dbgi, value, dest_mode);
}
set_entity_initializer(entity, initializer);
- return create_symconst(dbgi, mode_P_data, entity);
+ return create_symconst(dbgi, entity);
}
/**
}
set_entity_initializer(entity, initializer);
- return create_symconst(dbgi, mode_P_data, entity);
+ return create_symconst(dbgi, entity);
}
static bool try_create_integer(literal_expression_t *literal,
assert(entity != NULL);
ir_node *in[3];
in[0] = get_trampoline_region(dbgi, entity);
- in[1] = create_symconst(dbgi, mode, entity);
+ in[1] = create_symconst(dbgi, entity);
in[2] = get_irg_frame(current_ir_graph);
ir_node *irn = new_d_Builtin(dbgi, get_store(), 3, in, ir_bk_inner_trampoline, get_unknown_type());
return new_d_strictConv(dbgi, node, mode);
}
-/**
- * Returns the address of a global variable.
- *
- * @param dbgi debug info
- * @param variable the variable
- */
-static ir_node *get_global_var_address(dbg_info *const dbgi,
- const variable_t *const variable)
-{
- ir_entity *const irentity = variable->v.entity;
- if (variable->thread_local) {
- ir_node *const no_mem = new_NoMem();
- ir_node *const tls = get_irg_tls(current_ir_graph);
- return new_d_simpleSel(dbgi, no_mem, tls, irentity);
- } else {
- return create_symconst(dbgi, mode_P_data, irentity);
- }
-}
-
/**
* Returns the correct base address depending on whether it is a parameter or a
* normal local variable.
return create_conv(NULL, value, get_ir_mode_arithmetic(type));
}
case DECLARATION_KIND_FUNCTION: {
- ir_mode *const mode = get_ir_mode_storage(type);
- return create_symconst(dbgi, mode, entity->function.irentity);
+ 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, mode, entity->function.irentity);
+ 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 = get_global_var_address(dbgi, variable);
+ ir_node *const addr = create_symconst(dbgi, variable->v.entity);
return deref_address(dbgi, variable->base.type, addr);
}
* as an indicator for no real address) */
return NULL;
case DECLARATION_KIND_GLOBAL_VARIABLE: {
- ir_node *const addr = get_global_var_address(dbgi, &entity->variable);
+ ir_node *const addr = create_symconst(dbgi, entity->variable.v.entity);
return addr;
}
case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: {
return entity->variable.v.vla_base;
case DECLARATION_KIND_FUNCTION: {
- type_t *const type = skip_typeref(entity->declaration.type);
- ir_mode *const mode = get_ir_mode_storage(type);
- return create_symconst(dbgi, mode, entity->function.irentity);
+ 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, mode, entity->function.irentity);
+ return create_symconst(dbgi, entity->function.irentity);
} else {
/* need trampoline here */
return create_trampoline(dbgi, mode, entity->function.irentity);
static ir_node *call_expression_to_firm(const call_expression_t *const call)
{
dbg_info *const dbgi = get_dbg_info(&call->base.source_position);
- assert(get_cur_block() != NULL);
+ assert(currently_reachable());
expression_t *function = call->function;
if (function->kind == EXPR_REFERENCE) {
return entity->declaration.kind == DECLARATION_KIND_LOCAL_VARIABLE;
}
-static pn_Cmp get_pnc(const expression_kind_t kind, type_t *const type)
+static ir_relation get_relation(const expression_kind_t kind)
{
switch(kind) {
- case EXPR_BINARY_EQUAL: return pn_Cmp_Eq;
- case EXPR_BINARY_ISLESSGREATER: return pn_Cmp_Lg;
- case EXPR_BINARY_NOTEQUAL:
- return is_type_float(skip_typeref(type)) ? pn_Cmp_Ne : pn_Cmp_Lg;
+ case EXPR_BINARY_EQUAL: return ir_relation_equal;
+ case EXPR_BINARY_ISLESSGREATER: return ir_relation_less_greater;
+ case EXPR_BINARY_NOTEQUAL: return ir_relation_unordered_less_greater;
case EXPR_BINARY_ISLESS:
- case EXPR_BINARY_LESS: return pn_Cmp_Lt;
+ case EXPR_BINARY_LESS: return ir_relation_less;
case EXPR_BINARY_ISLESSEQUAL:
- case EXPR_BINARY_LESSEQUAL: return pn_Cmp_Le;
+ case EXPR_BINARY_LESSEQUAL: return ir_relation_less_equal;
case EXPR_BINARY_ISGREATER:
- case EXPR_BINARY_GREATER: return pn_Cmp_Gt;
+ case EXPR_BINARY_GREATER: return ir_relation_greater;
case EXPR_BINARY_ISGREATEREQUAL:
- case EXPR_BINARY_GREATEREQUAL: return pn_Cmp_Ge;
- case EXPR_BINARY_ISUNORDERED: return pn_Cmp_Uo;
+ case EXPR_BINARY_GREATEREQUAL: return ir_relation_greater_equal;
+ case EXPR_BINARY_ISUNORDERED: return ir_relation_unordered;
default:
break;
expression_t *op1 = expression->left;
expression_t *op2 = expression->right;
entity_t *var2, *var = NULL;
- ir_node *res = NULL;
- pn_Cmp cmp_val;
-
- cmp_val = get_pnc(expression->base.kind, op1->base.type);
+ ir_node *res = NULL;
+ ir_relation relation = get_relation(expression->base.kind);
if (is_local_variable(op1) && is_local_variable(op2)) {
var = op1->reference.entity;
ir_node *const irn1 = get_value(var->variable.v.value_number, mode);
ir_node *const irn2 = get_value(var2->variable.v.value_number, mode);
- res = new_d_Confirm(dbi, irn2, irn1, get_inversed_pnc(cmp_val));
+ res = new_d_Confirm(dbi, irn2, irn1, get_inversed_relation(relation));
set_value(var2->variable.v.value_number, res);
- res = new_d_Confirm(dbi, irn1, irn2, cmp_val);
+ res = new_d_Confirm(dbi, irn1, irn2, relation);
set_value(var->variable.v.value_number, res);
return res;
var = op1->reference.entity;
con = op2;
} else if (is_constant_expression(op1) == EXPR_CLASS_CONSTANT && is_local_variable(op2)) {
- cmp_val = get_inversed_pnc(cmp_val);
+ relation = get_inversed_relation(relation);
var = op2->reference.entity;
con = op1;
}
ir_mode *const mode = get_ir_mode_storage(type);
res = get_value(var->variable.v.value_number, mode);
- res = new_d_Confirm(dbi, res, expression_to_firm(con), cmp_val);
+ res = new_d_Confirm(dbi, res, expression_to_firm(con), relation);
set_value(var->variable.v.value_number, res);
}
return res;
}
}
-static ir_node *create_cast(dbg_info *dbgi, ir_node *value_node,
+static ir_node *create_cast(dbg_info *dbgi, ir_node *value_node,
type_t *from_type, type_t *type)
{
type = skip_typeref(type);
const variable_t *to_var = type->pointer.base_variable;
if (from_var != to_var) {
if (from_var != NULL) {
- ir_node *const addr = get_global_var_address(dbgi, from_var);
+ 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));
}
if (to_var != NULL) {
- ir_node *const addr = get_global_var_address(dbgi, to_var);
+ ir_node *const addr = create_symconst(dbgi, to_var->v.entity);
ir_node *const base = deref_address(dbgi, to_var->base.type, addr);
value_node = new_d_Sub(dbgi, value_node, base, mode);
}
/* check for __based */
const variable_t *const base_var = value_type->pointer.base_variable;
if (base_var != NULL) {
- ir_node *const addr = get_global_var_address(dbgi, base_var);
+ ir_node *const addr = create_symconst(dbgi, base_var->v.entity);
ir_node *const base = deref_address(dbgi, base_var->base.type, addr);
value_node = new_d_Add(dbgi, value_node, base, get_ir_mode_storage(value_type));
}
case EXPR_BINARY_SHIFTRIGHT:
case EXPR_BINARY_SHIFTLEFT_ASSIGN:
case EXPR_BINARY_SHIFTRIGHT_ASSIGN:
- mode = get_irn_mode(left);
+ mode = get_ir_mode_arithmetic(expression->base.type);
right = create_conv(dbgi, right, mode_uint);
break;
case EXPR_BINARY_ISLESSEQUAL:
case EXPR_BINARY_ISLESSGREATER:
case EXPR_BINARY_ISUNORDERED: {
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
- ir_node *left = expression_to_firm(expression->left);
- ir_node *right = expression_to_firm(expression->right);
- ir_node *cmp = new_d_Cmp(dbgi, left, right);
- long pnc = get_pnc(kind, expression->left->base.type);
- ir_node *proj = new_d_Proj(dbgi, cmp, mode_b, pnc);
- return proj;
+ dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ ir_node *left = expression_to_firm(expression->left);
+ ir_node *right = expression_to_firm(expression->right);
+ ir_relation relation = get_relation(kind);
+ ir_node *cmp = new_d_Cmp(dbgi, left, right, relation);
+ return cmp;
}
case EXPR_BINARY_ASSIGN: {
ir_node *addr = expression_to_addr(expression->left);
&& 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) {
- alignment = get_cparser_entity_alignment(entity);
+ if (entity->kind == ENTITY_FUNCTION) {
+ /* a gnu-extension */
+ alignment = 1;
+ } else {
+ alignment = get_cparser_entity_alignment(entity);
+ }
}
}
/* gcc classifies the referenced type */
case TYPE_REFERENCE: type = type->reference.refers_to; continue;
- case TYPE_BUILTIN:
/* typedef/typeof should be skipped already */
case TYPE_TYPEDEF:
case TYPE_TYPEOF:
if (is_builtin_expect(expression) && is_Cond(cond)) {
call_argument_t *argument = expression->call.arguments->next;
if (is_constant_expression(argument->expression) == EXPR_CLASS_CONSTANT) {
- bool cnst = fold_constant_to_bool(argument->expression);
- cond_jmp_predicate pred;
-
- if (cnst == false) {
- pred = COND_JMP_PRED_FALSE;
- } else {
- pred = COND_JMP_PRED_TRUE;
- }
+ bool const cnst = fold_constant_to_bool(argument->expression);
+ cond_jmp_predicate const pred = cnst ? COND_JMP_PRED_TRUE : COND_JMP_PRED_FALSE;
set_Cond_jmp_pred(cond, pred);
}
}
add_immBlock_pred(true_block, true_proj);
add_immBlock_pred(false_block, false_proj);
- set_cur_block(NULL);
+ set_unreachable_now();
return cond_expr;
}
set_entity_initializer(init_entity, irinitializer);
- ir_node *const src_addr = create_symconst(dbgi, mode_P_data, init_entity);
+ ir_node *const src_addr = create_symconst(dbgi, init_entity);
ir_node *const copyb = new_d_CopyB(dbgi, memory, addr, src_addr, irtype);
ir_node *const copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M);
{
assert(entity->kind == ENTITY_VARIABLE);
assert(entity->variable.initializer == NULL);
- assert(get_cur_block() != NULL);
+ assert(currently_reachable());
dbg_info *dbgi = get_dbg_info(&entity->base.source_position);
type_t *type = entity->declaration.type;
static void return_statement_to_firm(return_statement_t *statement)
{
- if (get_cur_block() == NULL)
+ if (!currently_reachable())
return;
dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *end_block = get_irg_end_block(current_ir_graph);
add_immBlock_pred(end_block, ret);
- set_cur_block(NULL);
+ set_unreachable_now();
}
static ir_node *expression_statement_to_firm(expression_statement_t *statement)
{
- if (get_cur_block() == NULL)
+ if (!currently_reachable())
return NULL;
return expression_to_firm(statement->expression);
// no need to emit code in dead blocks
if (entity->declaration.storage_class != STORAGE_CLASS_STATIC
- && get_cur_block() == NULL)
+ && !currently_reachable())
return;
switch ((declaration_kind_t) entity->declaration.kind) {
/* Create the condition. */
ir_node *true_block = NULL;
ir_node *false_block = NULL;
- if (get_cur_block() != NULL) {
+ if (currently_reachable()) {
true_block = new_immBlock();
false_block = new_immBlock();
create_condition_evaluation(statement->condition, true_block, false_block);
}
/* Create the false statement.
- * Hadle false before true, so if no false statement is present, then the
+ * Handle false before true, so if no false statement is present, then the
* empty false block is reused as fallthrough block. */
ir_node *fallthrough_block = NULL;
if (statement->false_statement != NULL) {
}
set_cur_block(false_block);
statement_to_firm(statement->false_statement);
- if (get_cur_block() != NULL) {
+ if (currently_reachable()) {
fallthrough_block = new_immBlock();
add_immBlock_pred(fallthrough_block, new_Jmp());
}
/* Create the true statement. */
set_cur_block(true_block);
statement_to_firm(statement->true_statement);
- if (get_cur_block() != NULL) {
+ if (currently_reachable()) {
if (fallthrough_block == NULL) {
fallthrough_block = new_immBlock();
}
* reachable. */
static void jump_if_reachable(ir_node *const target_block)
{
- if (get_cur_block() != NULL) {
- add_immBlock_pred(target_block, new_Jmp());
- }
+ ir_node *const pred = currently_reachable() ? new_Jmp() : new_Bad(mode_X);
+ add_immBlock_pred(target_block, pred);
}
static void while_statement_to_firm(while_statement_t *statement)
create_local_declaration(entity);
}
- if (get_cur_block() != NULL) {
+ if (currently_reachable()) {
entity = statement->scope.entities;
for ( ; entity != NULL; entity = entity->base.next) {
if (!is_declaration(entity))
static void create_jump_statement(const statement_t *statement,
ir_node *target_block)
{
- if (get_cur_block() == NULL)
+ if (!currently_reachable())
return;
dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *jump = new_d_Jmp(dbgi);
add_immBlock_pred(target_block, jump);
- set_cur_block(NULL);
+ set_unreachable_now();
}
static void switch_statement_to_firm(switch_statement_t *statement)
dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
ir_node *cond = NULL;
- if (get_cur_block() != NULL) {
+ if (currently_reachable()) {
ir_node *expression = expression_to_firm(statement->expression);
cond = new_d_Cond(dbgi, expression);
first_block = get_cur_block();
}
- set_cur_block(NULL);
+ set_unreachable_now();
ir_node *const old_switch_cond = current_switch_cond;
ir_node *const old_break_label = break_label;
default_proj_nr = l->last_case;
}
- if (default_proj_nr == INT_MAX) {
+ if (default_proj_nr == LONG_MAX) {
/* Bad: an overflow will occur, we cannot be sure that the
* maximum + 1 is a free number. Scan the values a second
* time to find a free number.
static void goto_to_firm(const goto_statement_t *statement)
{
- if (get_cur_block() == NULL)
+ if (!currently_reachable())
return;
if (statement->expression) {
ir_node *jmp = new_Jmp();
add_immBlock_pred(block, jmp);
}
- set_cur_block(NULL);
+ set_unreachable_now();
}
static void asm_statement_to_firm(const asm_statement_t *statement)
}
}
-static void ms_try_statement_to_firm(ms_try_statement_t *statement)
+static void ms_try_statement_to_firm(ms_try_statement_t *statement)
{
statement_to_firm(statement->try_statement);
warningf(&statement->base.source_position, "structured exception handling ignored");
}
-static void leave_statement_to_firm(leave_statement_t *statement)
+static void leave_statement_to_firm(leave_statement_t *statement)
{
errorf(&statement->base.source_position, "__leave not supported yet");
}
ir_graph *old_current_function = current_function;
current_function = irg;
- set_irg_fp_model(irg, firm_opt.fp_model);
+ set_irg_fp_model(irg, firm_fp_model);
tarval_enable_fp_ops(1);
set_irn_dbg_info(get_irg_start_block(irg),
get_entity_dbg_info(function_entity));
ir_node *end_block = get_irg_end_block(irg);
/* do we have a return statement yet? */
- if (get_cur_block() != NULL) {
+ if (currently_reachable()) {
type_t *type = skip_typeref(entity->declaration.type);
assert(is_type_function(type));
const function_type_t *func_type = &type->function;
projects / cparser / blobdiff