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 (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)
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);
}
+static ir_node *create_Const_from_bool(ir_mode *const mode, bool const v)
+{
+ return new_Const((v ? get_mode_one : get_mode_null)(mode));
+}
+
/**
* Creates a SymConst node representing a wide string literal.
*
}
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.
/* simply create a NULL pointer */
ir_mode *mode = get_ir_mode_arithmetic(type_void_ptr);
- ir_node *res = new_Const_long(mode, 0);
+ ir_node *res = new_Const(get_mode_null(mode));
return res;
}
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);
long type_val = fold_constant_to_int(type_expression);
type_t *type = function_type->function.return_type;
ir_mode *mode = get_ir_mode_arithmetic(type);
- ir_tarval *result;
-
/* just produce a "I don't know" result */
- if (type_val & 2)
- result = new_tarval_from_long(0, mode);
- else
- result = new_tarval_from_long(-1, mode);
+ ir_tarval *result = type_val & 2 ? get_mode_null(mode) :
+ get_mode_minus_one(mode);
return new_d_Const(dbgi, result);
}
case bk_ms_ReturnAddress: {
ir_node *in[2];
- in[0] = new_Const_long(mode_int, 0);
+ in[0] = new_Const(get_mode_null(mode_int));
in[1] = get_irg_frame(current_ir_graph);
ir_type *tp = get_ir_type(function_type);
ir_node *irn = new_d_Builtin(dbgi, get_irg_no_mem(current_ir_graph), 2, in, ir_bk_return_address, tp);
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;
}
expression_t *con;
- if (is_local_variable(op1) && is_constant_expression(op2)) {
+ if (is_local_variable(op1) && is_constant_expression(op2) == EXPR_CLASS_CONSTANT) {
var = op1->reference.entity;
con = op2;
- } else if (is_constant_expression(op1) && is_local_variable(op2)) {
- cmp_val = get_inversed_pnc(cmp_val);
+ } else if (is_constant_expression(op1) == EXPR_CLASS_CONSTANT && is_local_variable(op2)) {
+ 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_DIV:
case EXPR_BINARY_DIV_ASSIGN: {
ir_node *pin = new_Pin(new_NoMem());
- ir_node *op;
- ir_node *res;
- if (mode_is_float(mode)) {
- op = new_d_Quot(dbgi, pin, left, right, mode, op_pin_state_floats);
- res = new_d_Proj(dbgi, op, mode, pn_Quot_res);
- } else {
- op = new_d_Div(dbgi, pin, left, right, mode, op_pin_state_floats);
- res = new_d_Proj(dbgi, op, mode, pn_Div_res);
- }
+ ir_node *op = new_d_Div(dbgi, pin, left, right, mode,
+ op_pin_state_floats);
+ ir_node *res = new_d_Proj(dbgi, op, mode, pn_Div_res);
return res;
}
case EXPR_BINARY_MOD:
type_t *type = skip_typeref(expression->base.type);
ir_mode *mode = get_ir_mode_arithmetic(type);
- if (is_constant_expression(expression->left)) {
+ if (is_constant_expression(expression->left) == EXPR_CLASS_CONSTANT) {
bool val = fold_constant_to_bool(expression->left);
expression_kind_t ekind = expression->base.kind;
assert(ekind == EXPR_BINARY_LOGICAL_AND || ekind == EXPR_BINARY_LOGICAL_OR);
}
}
- if (is_constant_expression(expression->right)) {
+ if (is_constant_expression(expression->right) == EXPR_CLASS_CONSTANT) {
bool valr = fold_constant_to_bool(expression->right);
- return valr ?
- new_Const(get_mode_one(mode)) :
- new_Const(get_mode_null(mode));
+ return create_Const_from_bool(mode, valr);
}
return produce_condition_result(expression->right, mode, dbgi);
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);
+ }
}
}
init_ir_types();
- assert(is_constant_expression(expression));
+ assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
ir_graph *old_current_ir_graph = current_ir_graph;
current_ir_graph = get_const_code_irg();
dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
/* first try to fold a constant condition */
- if (is_constant_expression(expression->condition)) {
+ if (is_constant_expression(expression->condition) == EXPR_CLASS_CONSTANT) {
bool val = fold_constant_to_bool(expression->condition);
if (val) {
expression_t *true_expression = expression->true_expression;
return NULL;
ir_node *const in[2] = { true_val, false_val };
- ir_mode *const mode = get_irn_mode(true_val);
- assert(get_irn_mode(false_val) == mode);
+ 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_node *const val = new_d_Phi(dbgi, lengthof(in), in, mode);
return val;
static ir_node *builtin_constant_to_firm(
const builtin_constant_expression_t *expression)
{
- ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
- long v;
-
- if (is_constant_expression(expression->value)) {
- v = 1;
- } else {
- v = 0;
- }
- return new_Const_long(mode, v);
+ ir_mode *const mode = get_ir_mode_arithmetic(expression->base.type);
+ bool const v = is_constant_expression(expression->value) == EXPR_CLASS_CONSTANT;
+ return create_Const_from_bool(mode, v);
}
static ir_node *builtin_types_compatible_to_firm(
{
type_t *const left = get_unqualified_type(skip_typeref(expression->left));
type_t *const right = get_unqualified_type(skip_typeref(expression->right));
- long const value = types_compatible(left, right) ? 1 : 0;
+ bool const value = types_compatible(left, right);
ir_mode *const mode = get_ir_mode_arithmetic(expression->base.type);
- return new_Const_long(mode, value);
+ return create_Const_from_bool(mode, value);
}
static ir_node *get_label_block(label_t *label)
return res;
}
- if (is_constant_expression(expression)) {
+ 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));
- if (is_Const_null(res)) {
- return new_Const_long(mode, 0);
- } else {
- return new_Const_long(mode, 1);
- }
+ return create_Const_from_bool(mode, !is_Const_null(res));
}
/* we have to produce a 0/1 from the mode_b expression */
/* set branch prediction info based on __builtin_expect */
if (is_builtin_expect(expression) && is_Cond(cond)) {
call_argument_t *argument = expression->call.arguments->next;
- if (is_constant_expression(argument->expression)) {
+ if (is_constant_expression(argument->expression) == EXPR_CLASS_CONSTANT) {
bool cnst = fold_constant_to_bool(argument->expression);
cond_jmp_predicate pred;
}
ir_mode *value_mode = get_type_mode(ent_type);
- ir_node *node = new_Const_long(value_mode, 0);
+ ir_node *node = new_Const(get_mode_null(value_mode));
/* is it a bitfield type? */
if (is_Primitive_type(ent_type) &&
return;
}
- if (!is_constant_initializer(initializer)) {
+ if (is_constant_initializer(initializer) == EXPR_CLASS_VARIABLE) {
bool old_initializer_use_bitfield_basetype
= initializer_use_bitfield_basetype;
initializer_use_bitfield_basetype = true;
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);
}
/* 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) {
ir_node * body_block;
ir_node * false_block;
expression_t *const cond = statement->condition;
- if (is_constant_expression(cond) && fold_constant_to_bool(cond)) {
+ if (is_constant_expression(cond) == EXPR_CLASS_CONSTANT &&
+ fold_constant_to_bool(cond)) {
/* Shortcut for while (true). */
body_block = header_block;
false_block = NULL;
break_label = old_break_label;
}
+static ir_node *get_break_label(void)
+{
+ if (break_label == NULL) {
+ break_label = new_immBlock();
+ }
+ return break_label;
+}
+
static void do_while_statement_to_firm(do_while_statement_t *statement)
{
/* create the header block */
set_cur_block(body_block);
statement_to_firm(statement->body);
- ir_node *false_block = break_label;
+ ir_node *const false_block = get_break_label();
assert(continue_label == header_block);
continue_label = old_continue_label;
jump_if_reachable(header_block);
- if (false_block == NULL) {
- false_block = new_immBlock();
- }
-
/* create the condition */
mature_immBlock(header_block);
set_cur_block(header_block);
set_cur_block(NULL);
}
-static ir_node *get_break_label(void)
-{
- if (break_label == NULL) {
- break_label = new_immBlock();
- }
- return break_label;
-}
-
static void switch_statement_to_firm(switch_statement_t *statement)
{
ir_node *first_block = NULL;
}
}
-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");
}
projects / cparser / blobdiff