#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;
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;
type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) type);
type_t *points_to = type->points_to;
ir_type *ir_points_to = get_ir_type_incomplete(points_to);
- ir_type *ir_type = new_d_type_pointer(ir_points_to, dbgi);
+ ir_type *irtype = new_d_type_pointer(ir_points_to, dbgi);
- return ir_type;
+ return irtype;
}
static ir_type *create_reference_type(reference_type_t *type)
type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) type);
type_t *refers_to = type->refers_to;
ir_type *ir_refers_to = get_ir_type_incomplete(refers_to);
- ir_type *ir_type = new_d_type_pointer(ir_refers_to, dbgi);
+ ir_type *irtype = new_d_type_pointer(ir_refers_to, dbgi);
- return ir_type;
+ return irtype;
}
static ir_type *create_array_type(array_type_t *type)
type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) type);
type_t *element_type = type->element_type;
ir_type *ir_element_type = get_ir_type(element_type);
- ir_type *ir_type = new_d_type_array(1, ir_element_type, dbgi);
+ ir_type *irtype = new_d_type_array(1, ir_element_type, dbgi);
const int align = get_type_alignment_bytes(ir_element_type);
- set_type_alignment_bytes(ir_type, align);
+ set_type_alignment_bytes(irtype, align);
if (type->size_constant) {
int n_elements = type->size;
- set_array_bounds_int(ir_type, 0, 0, n_elements);
+ set_array_bounds_int(irtype, 0, 0, n_elements);
size_t elemsize = get_type_size_bytes(ir_element_type);
if (elemsize % align > 0) {
elemsize += align - (elemsize % align);
}
- set_type_size_bytes(ir_type, n_elements * elemsize);
+ set_type_size_bytes(irtype, n_elements * elemsize);
} else {
- set_array_lower_bound_int(ir_type, 0, 0);
+ set_array_lower_bound_int(irtype, 0, 0);
}
- set_type_state(ir_type, layout_fixed);
+ set_type_state(irtype, layout_fixed);
- return ir_type;
+ return irtype;
}
/**
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) {
{
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) {
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) {
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;
/* 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;
}
{
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);
}
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)
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