static ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos)
{
const entity_t *entity = get_irg_loc_description(irg, pos);
-
- if (entity != NULL) {
- position_t const *const pos = &entity->base.pos;
- warningf(WARN_UNINITIALIZED, pos, "'%N' might be used uninitialized", entity);
- }
+ if (entity)
+ warningf(WARN_UNINITIALIZED, &entity->base.pos, "'%N' might be used uninitialized", entity);
return new_r_Unknown(irg, mode);
}
}
}
-ir_mode *get_atomic_mode(atomic_type_kind_t kind)
-{
- assert(kind <= ATOMIC_TYPE_LAST);
- return atomic_modes[kind];
-}
-
static ir_node *get_vla_size(array_type_t *const type)
{
ir_node *size_node = type->size_node;
return type;
}
+static ir_type *get_ir_type(type_t *type);
+
static ir_type *create_method_type(const function_type_t *function_type, bool for_closure)
{
type_t *return_type = skip_typeref(function_type->return_type);
mode = s_modes[size];
if (mode == NULL) {
- char name[32];
+ ir_mode *base_mode = get_type_mode(base_tp);
+ unsigned modulo_shift = get_mode_modulo_shift(base_mode);
+ char name[32];
snprintf(name, sizeof(name), "bf_I%u", size);
- mode = new_int_mode(name, irma_twos_complement, size, 1, 0);
+ mode = new_int_mode(name, irma_twos_complement, size, 1, modulo_shift);
s_modes[size] = mode;
}
mode = u_modes[size];
if (mode == NULL) {
- char name[32];
+ ir_mode *base_mode = get_type_mode(base_tp);
+ unsigned modulo_shift = get_mode_modulo_shift(base_mode);
+ char name[32];
snprintf(name, sizeof(name), "bf_U%u", size);
- mode = new_int_mode(name, irma_twos_complement, size, 0, 0);
+ mode = new_int_mode(name, irma_twos_complement, size, 0, modulo_shift);
u_modes[size] = mode;
}
symbol_t *symbol = entry->base.symbol;
type_t *entry_type = entry->declaration.type;
- ident *ident;
+ ident *member_id;
if (symbol == NULL) {
/* anonymous bitfield member, skip */
if (entry->compound_member.bitfield)
continue;
assert(is_type_compound(entry_type));
- ident = id_unique("anon.%u");
+ member_id = id_unique("anon.%u");
} else {
- ident = new_id_from_str(symbol->string);
+ member_id = new_id_from_str(symbol->string);
}
dbg_info *dbgi = get_dbg_info(&entry->base.pos);
} else {
entry_irtype = get_ir_type(entry_type);
}
- ir_entity *entity = new_d_entity(irtype, ident, entry_irtype, dbgi);
+ ir_entity *entity = new_d_entity(irtype, member_id, entry_irtype, dbgi);
set_entity_offset(entity, entry->compound_member.offset);
set_entity_offset_bits_remainder(entity,
}
}
-ir_type *get_ir_type(type_t *type)
+static ir_type *get_ir_type(type_t *type)
{
type = skip_typeref(type);
}
expression_t *con = NULL;
- if (is_local_variable(op1) && is_constant_expression(op2) == EXPR_CLASS_CONSTANT) {
+ if (is_local_variable(op1) && is_constant_expression(op2) != EXPR_CLASS_VARIABLE) {
var = op1->reference.entity;
con = op2;
- } else if (is_constant_expression(op1) == EXPR_CLASS_CONSTANT && is_local_variable(op2)) {
+ } else if (is_constant_expression(op1) != EXPR_CLASS_VARIABLE && is_local_variable(op2)) {
relation = get_inversed_relation(relation);
var = op2->reference.entity;
con = op1;
static ir_node *create_cast(unary_expression_t const *const expr)
{
+ type_t *const from_type = skip_typeref(expr->value->base.type);
+ ir_node *value = is_type_complex(from_type)
+ ? expression_to_complex(expr->value).real
+ : expression_to_value(expr->value);
+
type_t *const type = skip_typeref(expr->base.type);
if (is_type_void(type))
return NULL;
- ir_node *value = expression_to_value(expr->value);
- dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
- type_t *const from_type = skip_typeref(expr->value->base.type);
- ir_mode *const mode = get_ir_mode_storage(type);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
+ ir_mode *const mode = get_ir_mode_storage(type);
/* check for conversion from / to __based types */
if (is_type_pointer(type) && is_type_pointer(from_type)) {
const variable_t *from_var = from_type->pointer.base_variable;
/* set branch prediction info based on __builtin_expect */
if (is_builtin_expect(expr) && is_Cond(cond)) {
call_argument_t *const argument = expr->call.arguments->next;
- if (is_constant_expression(argument->expression) == EXPR_CLASS_CONSTANT) {
+ if (is_constant_expression(argument->expression) != EXPR_CLASS_VARIABLE) {
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);
type_t *type = expression->type;
initializer_t *initializer = expression->initializer;
- if (expression->global_scope ||
- ((type->base.qualifiers & TYPE_QUALIFIER_CONST)
- && is_constant_initializer(initializer) == EXPR_CLASS_CONSTANT)) {
+ if (expression->global_scope || (
+ type->base.qualifiers & TYPE_QUALIFIER_CONST &&
+ is_constant_initializer(initializer) != EXPR_CLASS_VARIABLE
+ )) {
ir_entity *entity = create_initializer_entity(dbgi, initializer, type);
return create_symconst(dbgi, entity);
} else {
ir_tarval *fold_constant_to_tarval(const expression_t *expression)
{
- assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
+ assert(is_constant_expression(expression) >= EXPR_CLASS_CONSTANT);
bool constant_folding_old = constant_folding;
constant_folding = true;
static complex_constant fold_complex_constant(const expression_t *expression)
{
- assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
+ assert(is_constant_expression(expression) >= EXPR_CLASS_CONSTANT);
bool constant_folding_old = constant_folding;
constant_folding = true;
const builtin_constant_expression_t *expression)
{
ir_mode *const mode = get_ir_mode_storage(expression->base.type);
- bool const v = is_constant_expression(expression->value) == EXPR_CLASS_CONSTANT;
+ bool const v = is_constant_expression(expression->value) != EXPR_CLASS_VARIABLE;
return create_Const_from_bool(mode, v);
}
switch (expr->kind) {
case EXPR_UNARY_CAST:
- if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) {
+ if (!is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL))
+ return create_cast(&expr->unary);
+ /* FALLTHROUGH */
case EXPR_BINARY_EQUAL:
case EXPR_BINARY_GREATER:
case EXPR_BINARY_GREATEREQUAL:
case EXPR_BINARY_LOGICAL_AND:
case EXPR_BINARY_LOGICAL_OR:
case EXPR_BINARY_NOTEQUAL:
- case EXPR_UNARY_NOT:;
- jump_target true_target;
- jump_target false_target;
- init_jump_target(&true_target, NULL);
- init_jump_target(&false_target, NULL);
- expression_to_control_flow(expr, &true_target, &false_target);
- return control_flow_to_1_0(expr, &true_target, &false_target);
- } else {
- return create_cast(&expr->unary);
- }
+ case EXPR_UNARY_NOT: {
+ jump_target true_target;
+ jump_target false_target;
+ init_jump_target(&true_target, NULL);
+ init_jump_target(&false_target, NULL);
+ expression_to_control_flow(expr, &true_target, &false_target);
+ return control_flow_to_1_0(expr, &true_target, &false_target);
+ }
case EXPR_BINARY_ADD:
case EXPR_BINARY_BITWISE_AND:
if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) {
expression_to_control_flow(expr->unary.value, true_target, false_target);
return NULL;
- } else {
- default:;
- type_t *const type = skip_typeref(expr->base.type);
- if (is_type_complex(type)) {
- complex_to_control_flow(expr, true_target, false_target);
- return NULL;
- }
-
- dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
- ir_mode *const mode = get_ir_mode_arithmetic(type);
- ir_node *const val = create_conv(dbgi, expression_to_value(expr), mode);
- ir_node *const left = val;
- ir_node *const right = new_Const(get_mode_null(get_irn_mode(val)));
- ir_relation const relation = ir_relation_unordered_less_greater;
- compare_to_control_flow(expr, left, right, relation, true_target, false_target);
- return val;
}
+ /* FALLTHROUGH */
+ default: {
+ type_t *const type = skip_typeref(expr->base.type);
+ if (is_type_complex(type)) {
+ complex_to_control_flow(expr, true_target, false_target);
+ return NULL;
+ }
+
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
+ ir_mode *const mode = get_ir_mode_arithmetic(type);
+ ir_node *const val = create_conv(dbgi, expression_to_value(expr), mode);
+ ir_node *const left = val;
+ ir_node *const right = new_Const(get_mode_null(get_irn_mode(val)));
+ ir_relation const relation = ir_relation_unordered_less_greater;
+ compare_to_control_flow(expr, left, right, relation, true_target, false_target);
+ return val;
+ }
}
}
&& get_entity_owner(irentity) != get_tls_type()) {
add_entity_linkage(irentity, IR_LINKAGE_CONSTANT);
}
- ir_initializer_t *initializer = create_initializer_compound(2);
+ ir_initializer_t *complex_init = create_initializer_compound(2);
ir_initializer_t *reali = create_initializer_const(real);
- set_initializer_compound_value(initializer, 0, reali);
+ set_initializer_compound_value(complex_init, 0, reali);
ir_initializer_t *imagi = create_initializer_const(imag);
- set_initializer_compound_value(initializer, 1, imagi);
- set_entity_initializer(irentity, initializer);
+ set_initializer_compound_value(complex_init, 1, imagi);
+ set_entity_initializer(irentity, complex_init);
}
return;
} else if (!is_type_scalar(init_type)) {
expression_t *const cond = statement->condition;
/* Avoid an explicit body block in case of do ... while (0);. */
- if (is_constant_expression(cond) == EXPR_CLASS_CONSTANT && !fold_constant_to_bool(cond)) {
+ if (is_constant_expression(cond) != EXPR_CLASS_VARIABLE && !fold_constant_to_bool(cond)) {
/* do ... while (0);. */
statement_to_firm(statement->body);
jump_to_target(&continue_target);
/* Create the condition. */
expression_t *const cond = statement->condition;
- if (cond && (is_constant_expression(cond) != EXPR_CLASS_CONSTANT || !fold_constant_to_bool(cond))) {
+ if (cond && (is_constant_expression(cond) == EXPR_CLASS_VARIABLE || !fold_constant_to_bool(cond))) {
jump_target body_target;
init_jump_target(&body_target, NULL);
expression_to_control_flow(cond, &body_target, &break_target);