const entity_t *entity = get_irg_loc_description(irg, pos);
if (entity != NULL) {
- source_position_t const *const pos = &entity->base.source_position;
+ position_t const *const pos = &entity->base.pos;
warningf(WARN_UNINITIALIZED, pos, "'%N' might be used uninitialized", entity);
}
return new_r_Unknown(irg, mode);
static src_loc_t dbg_retrieve(const dbg_info *dbg)
{
- source_position_t const *const pos = (source_position_t const*)dbg;
+ position_t const *const pos = (position_t const*)dbg;
if (pos) {
return (src_loc_t){ pos->input_name, pos->lineno, pos->colno };
} else {
}
}
-static dbg_info *get_dbg_info(const source_position_t *pos)
+static dbg_info *get_dbg_info(const position_t *pos)
{
return (dbg_info*) pos;
}
{
unsigned flags = get_atomic_type_flags(kind);
unsigned size = get_atomic_type_size(kind);
- if ((flags & ATOMIC_TYPE_FLAG_FLOAT)
- && !(flags & ATOMIC_TYPE_FLAG_COMPLEX)) {
+ if (flags & ATOMIC_TYPE_FLAG_FLOAT) {
switch (size) {
case 4: return get_modeF();
case 8: return get_modeD();
return count;
}
-/**
- * Creates a Firm type for an atomic type
- */
-static ir_type *create_atomic_type(atomic_type_kind_t akind, const type_t *type)
+static ir_type *create_primitive_irtype(atomic_type_kind_t akind,
+ type_dbg_info *dbgi)
{
ir_mode *mode = atomic_modes[akind];
- type_dbg_info *dbgi = get_type_dbg_info_(type);
ir_type *irtype = new_d_type_primitive(mode, dbgi);
- il_alignment_t alignment = get_atomic_type_alignment(akind);
+ unsigned alignment = get_atomic_type_alignment(akind);
+ unsigned size = get_atomic_type_size(akind);
- set_type_size_bytes(irtype, get_atomic_type_size(akind));
+ set_type_size_bytes(irtype, size);
set_type_alignment_bytes(irtype, alignment);
return irtype;
}
+/**
+ * Creates a Firm type for an atomic type
+ */
+static ir_type *create_atomic_type(atomic_type_kind_t akind, const type_t *type)
+{
+ type_dbg_info *dbgi = get_type_dbg_info_(type);
+ return create_primitive_irtype(akind, dbgi);
+}
+
/**
* Creates a Firm type for a complex type
*/
-static ir_type *create_complex_type(const atomic_type_t *type)
+static ir_type *create_complex_type(atomic_type_kind_t akind,
+ const type_t *type)
{
- atomic_type_kind_t kind = type->akind;
- ir_mode *mode = atomic_modes[kind];
- ident *id = get_mode_ident(mode);
+ type_dbg_info *dbgi = get_type_dbg_info_(type);
+ ir_type *etype = create_primitive_irtype(akind, NULL);
+ ir_type *irtype = new_d_type_array(1, etype, dbgi);
- (void) id;
+ int align = get_type_alignment_bytes(etype);
+ set_type_alignment_bytes(irtype, align);
+ unsigned n_elements = 2;
+ set_array_bounds_int(irtype, 0, 0, n_elements);
+ size_t elemsize = get_type_size_bytes(etype);
+ if (elemsize % align > 0) {
+ elemsize += align - (elemsize % align);
+ }
+ set_type_size_bytes(irtype, n_elements * elemsize);
- /* FIXME: finish the array */
- return NULL;
+ return irtype;
}
/**
ident = new_id_from_str(symbol->string);
}
- dbg_info *dbgi = get_dbg_info(&entry->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&entry->base.pos);
ir_type *entry_irtype;
if (entry->compound_member.bitfield) {
firm_type = create_atomic_type(type->atomic.akind, type);
break;
case TYPE_COMPLEX:
- firm_type = create_complex_type(&type->atomic);
+ firm_type = create_complex_type(type->atomic.akind, type);
break;
case TYPE_IMAGINARY:
firm_type = create_imaginary_type(&type->atomic);
else
nested_function = true;
- dbg_info *const dbgi = get_dbg_info(&entity->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&entity->base.pos);
irentity = new_d_entity(owner_type, id, ir_type_method, dbgi);
ident *ld_id;
* @param id_prefix a prefix for the name of the generated string constant
* @param value the value of the string constant
*/
-static ir_node *string_to_firm(source_position_t const *const src_pos, char const *const id_prefix, string_t const *const value)
+static ir_node *string_to_firm(position_t const *const src_pos, char const *const id_prefix, string_t const *const value)
{
size_t const slen = get_string_len(value) + 1;
ir_initializer_t *const initializer = create_initializer_compound(slen);
panic("invalid literal kind");
}
- dbg_info *dbgi = get_dbg_info(&literal->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&literal->base.pos);
ir_node *res = new_d_Const(dbgi, tv);
ir_mode *mode_arith = get_ir_mode_arithmetic(type);
return create_conv(dbgi, res, mode_arith);
panic("invalid literal kind");
}
- dbg_info *dbgi = get_dbg_info(&literal->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&literal->base.pos);
ir_node *res = new_d_Const(dbgi, tv);
ir_mode *mode_arith = get_ir_mode_arithmetic(type);
return create_conv(dbgi, res, mode_arith);
}
/**
- * Keep all memory edges of the given block.
+ * Keep the current block and memory.
+ * This is necessary for all loops, because they could become infinite.
*/
-static void keep_all_memory(ir_node *block)
+static void keep_loop(void)
{
- ir_node *old = get_cur_block();
-
- set_cur_block(block);
+ keep_alive(get_cur_block());
keep_alive(get_store());
- /* TODO: keep all memory edges from restricted pointers */
- set_cur_block(old);
}
static ir_node *enum_constant_to_firm(reference_expression_t const *const ref)
static ir_node *reference_addr(const reference_expression_t *ref)
{
- dbg_info *dbgi = get_dbg_info(&ref->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&ref->base.pos);
entity_t *entity = ref->entity;
assert(is_declaration(entity));
/* for gcc compatibility we have to produce (dummy) addresses for some
* builtins which don't have entities */
if (irentity == NULL) {
- source_position_t const *const pos = &ref->base.source_position;
+ position_t const *const pos = &ref->base.pos;
warningf(WARN_OTHER, pos, "taking address of builtin '%N'", ref->entity);
/* simply create a NULL pointer */
static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
{
- dbg_info *const dbgi = get_dbg_info(&ref->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&ref->base.pos);
entity_t *const entity = ref->entity;
assert(is_declaration(entity));
*/
static ir_node *process_builtin_call(const call_expression_t *call)
{
- dbg_info *dbgi = get_dbg_info(&call->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&call->base.pos);
assert(call->function->kind == EXPR_REFERENCE);
reference_expression_t *builtin = &call->function->reference;
*/
static ir_node *call_expression_to_firm(const call_expression_t *const call)
{
- dbg_info *const dbgi = get_dbg_info(&call->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&call->base.pos);
assert(currently_reachable());
expression_t *function = call->function;
static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type,
ir_node *value)
{
- if (!is_type_compound(type)) {
+ if (is_type_scalar(type)) {
ir_mode *mode = get_ir_mode_storage(type);
value = create_conv(dbgi, value, mode);
}
static ir_node *bitfield_extract_to_firm(const select_expression_t *expression,
ir_node *addr)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
entity_t *entity = expression->compound_entry;
type_t *base_type = entity->declaration.type;
ir_mode *mode = get_ir_mode_storage(base_type);
static ir_node *set_value_for_expression_addr(const expression_t *expression,
ir_node *value, ir_node *addr)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
type_t *type = skip_typeref(expression->base.type);
if (!is_type_compound(type)) {
}
assert(addr != NULL);
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_node *value;
if (expression->kind == EXPR_SELECT &&
static ir_node *create_incdec(const unary_expression_t *expression)
{
- dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expression->base.pos);
const expression_t *value_expr = expression->value;
ir_node *addr = expression_to_addr(value_expr);
ir_node *value = get_value_from_lvalue(value_expr, addr);
static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
type_t *type = skip_typeref(expression->base.type);
const expression_t *value = expression->value;
static ir_node *create_lazy_op(const binary_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
type_t *type = skip_typeref(expression->base.type);
ir_mode *mode = get_ir_mode_arithmetic(type);
static ir_node *create_assign_binop(const binary_expression_t *expression)
{
- dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expression->base.pos);
const expression_t *left_expr = expression->left;
type_t *type = skip_typeref(left_expr->base.type);
ir_node *right = expression_to_firm(expression->right);
case EXPR_BINARY_ISLESSEQUAL:
case EXPR_BINARY_ISLESSGREATER:
case EXPR_BINARY_ISUNORDERED: {
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
ir_relation relation = get_relation(kind);
case EXPR_BINARY_SHIFTLEFT:
case EXPR_BINARY_SHIFTRIGHT:
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_node *left = expression_to_firm(expression->left);
ir_node *right = expression_to_firm(expression->right);
return create_op(dbgi, expression, left, right);
static ir_node *array_access_addr(const array_access_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_node *base_addr = expression_to_firm(expression->array_ref);
ir_node *offset = expression_to_firm(expression->index);
type_t *ref_type = skip_typeref(expression->array_ref->base.type);
static ir_node *array_access_to_firm(
const array_access_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_node *addr = array_access_addr(expression);
type_t *type = revert_automatic_type_conversion(
(const expression_t*) expression);
ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
long offset = get_offsetof_offset(expression);
ir_tarval *tv = new_tarval_from_long(offset, mode);
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
return new_d_Const(dbgi, tv);
}
static ir_node *compound_literal_addr(compound_literal_expression_t const *const expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
type_t *type = expression->type;
initializer_t *initializer = expression->initializer;
- if (is_constant_initializer(initializer) == EXPR_CLASS_CONSTANT) {
+ if (expression->global_scope ||
+ ((type->base.qualifiers & TYPE_QUALIFIER_CONST)
+ && is_constant_initializer(initializer) == EXPR_CLASS_CONSTANT)) {
ir_entity *entity = create_initializer_entity(dbgi, initializer, type);
return create_symconst(dbgi, entity);
} else {
static ir_node *compound_literal_to_firm(compound_literal_expression_t const* const expr)
{
- dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
type_t *const type = expr->type;
ir_node *const addr = compound_literal_addr(expr);
return deref_address(dbgi, type, addr);
alignment = get_type_alignment(type);
}
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
ir_tarval *tv = new_tarval_from_long(alignment, mode);
return new_d_Const(dbgi, tv);
static ir_node *conditional_to_firm(const conditional_expression_t *expression)
{
- dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
-
/* first try to fold a constant condition */
if (is_constant_expression(expression->condition) == EXPR_CLASS_CONSTANT) {
bool val = fold_constant_to_bool(expression->condition);
ir_node *const false_val = expression_to_firm(expression->false_expression);
jump_to_target(&exit_target);
if (val) {
- ir_node *const in[] = { val, false_val };
+ ir_node *const in[] = { val, false_val };
+ dbg_info *const dbgi = get_dbg_info(&expression->base.pos);
val = new_rd_Phi(dbgi, exit_target.block, lengthof(in), in, get_irn_mode(val));
} else {
val = false_val;
*/
static ir_node *select_addr(const select_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
construct_select_compound(expression);
static ir_node *select_to_firm(const select_expression_t *expression)
{
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_node *addr = select_addr(expression);
type_t *type = revert_automatic_type_conversion(
(const expression_t*) expression);
}
make_const:;
- dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
ir_mode *const mode = atomic_modes[ATOMIC_TYPE_INT];
ir_tarval *const tv = new_tarval_from_long(tc, mode);
return new_d_Const(dbgi, tv);
case FUNCNAME_PRETTY_FUNCTION:
case FUNCNAME_FUNCDNAME:
if (current_function_name == NULL) {
- source_position_t const *const src_pos = &expr->base.source_position;
- char const *const name = current_function_entity->base.symbol->string;
- string_t const string = { name, strlen(name), STRING_ENCODING_CHAR };
+ position_t const *const src_pos = &expr->base.pos;
+ char const *const name = current_function_entity->base.symbol->string;
+ string_t const string = { name, strlen(name), STRING_ENCODING_CHAR };
current_function_name = string_to_firm(src_pos, "__func__.%u", &string);
}
return current_function_name;
case FUNCNAME_FUNCSIG:
if (current_funcsig == NULL) {
- source_position_t const *const src_pos = &expr->base.source_position;
- ir_entity *const ent = get_irg_entity(current_ir_graph);
- char const *const name = get_entity_ld_name(ent);
- string_t const string = { name, strlen(name), STRING_ENCODING_CHAR };
+ position_t const *const src_pos = &expr->base.pos;
+ ir_entity *const ent = get_irg_entity(current_ir_graph);
+ char const *const name = get_entity_ld_name(ent);
+ string_t const string = { name, strlen(name), STRING_ENCODING_CHAR };
current_funcsig = string_to_firm(src_pos, "__FUNCSIG__.%u", &string);
}
return current_funcsig;
}
ir_node *const frame = get_irg_frame(current_ir_graph);
- dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
ir_node *const no_mem = new_NoMem();
ir_node *const arg_sel = new_d_simpleSel(dbgi, no_mem, frame, param_ent);
expression_t *const ap_expr = expr->ap;
ir_node *const ap_addr = expression_to_addr(ap_expr);
ir_node *const ap = get_value_from_lvalue(ap_expr, ap_addr);
- dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
ir_node *const res = deref_address(dbgi, type, ap);
ir_node *const cnst = get_type_size_node(expr->base.type);
symconst_symbol value;
value.entity_p = create_Block_entity(label->label->indirect_block);
- dbg_info *const dbgi = get_dbg_info(&label->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&label->base.pos);
return new_d_SymConst(dbgi, mode_P_code, value, symconst_addr_ent);
}
case EXPR_VA_COPY: return va_copy_expression_to_firm( &expr->va_copye);
case EXPR_VA_START: return va_start_expression_to_firm( &expr->va_starte);
- case EXPR_STRING_LITERAL: return string_to_firm(&expr->base.source_position, "str.%u", &expr->string_literal.value);
+ case EXPR_STRING_LITERAL: return string_to_firm(&expr->base.pos, "str.%u", &expr->string_literal.value);
case EXPR_ERROR: break;
}
}
/* we have to produce a 0/1 from the mode_b expression */
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
return produce_condition_result(expression, mode, dbgi);
}
break;
}
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
- ir_node *cond_expr = _expression_to_firm(expression);
- ir_node *condition = create_conv(dbgi, cond_expr, mode_b);
- ir_node *cond = new_d_Cond(dbgi, condition);
- ir_node *true_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_true);
- ir_node *false_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_false);
-
- /* 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) == EXPR_CLASS_CONSTANT) {
- 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);
+ ir_node *cond_expr = _expression_to_firm(expression);
+ if (is_Const(cond_expr)) {
+ if (tarval_is_null(get_Const_tarval(cond_expr))) {
+ jump_to_target(false_target);
+ } else {
+ jump_to_target(true_target);
+ }
+ } else {
+ dbg_info *dbgi = get_dbg_info(&expression->base.pos);
+ ir_node *condition = create_conv(dbgi, cond_expr, mode_b);
+ ir_node *cond = new_d_Cond(dbgi, condition);
+ ir_node *true_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_true);
+ ir_node *false_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_false);
+
+ /* 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) == EXPR_CLASS_CONSTANT) {
+ 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_pred_to_jump_target(true_target, true_proj);
- add_pred_to_jump_target(false_target, false_proj);
+ add_pred_to_jump_target(true_target, true_proj);
+ add_pred_to_jump_target(false_target, false_proj);
+ }
set_unreachable_now();
return cond_expr;
}
ident *const id = new_id_from_str(variable->base.symbol->string);
ir_type *const irtype = get_ir_type(type);
- dbg_info *const dbgi = get_dbg_info(&variable->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&variable->base.pos);
ir_entity *const irentity = new_d_entity(parent_type, id, irtype, dbgi);
unsigned alignment = variable->declaration.alignment;
static ir_initializer_t *create_ir_initializer_value(
const initializer_value_t *initializer)
{
- if (is_type_compound(initializer->value->base.type)) {
- panic("initializer creation for compounds not implemented yet");
- }
- type_t *type = initializer->value->base.type;
expression_t *expr = initializer->value;
+ type_t *type = skip_typeref(expr->base.type);
+
+ if (is_type_compound(type)) {
+ if (expr->kind == EXPR_UNARY_CAST) {
+ expr = expr->unary.value;
+ type = skip_typeref(expr->base.type);
+ }
+ /* must be a compound literal... */
+ if (expr->kind == EXPR_COMPOUND_LITERAL) {
+ return create_ir_initializer(expr->compound_literal.initializer,
+ type);
+ }
+ }
+
ir_node *value = expression_to_firm(expr);
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(NULL, value, mode);
+ if (!is_type_compound(type)) {
+ ir_mode *mode = get_ir_mode_storage(type);
+ value = create_conv(NULL, value, mode);
+ }
return create_initializer_const(value);
}
-/** test wether type can be initialized by a string constant */
+/** Tests whether type can be initialized by a string constant */
static bool is_string_type(type_t *type)
{
if (!is_type_array(type))
}
if (sub_initializer->kind == INITIALIZER_VALUE) {
- /* we might have to descend into types until we're at a scalar
- * type */
+ const expression_t *expr = sub_initializer->value.value;
+ const type_t *expr_type = skip_typeref(expr->base.type);
+ /* we might have to descend into types until the types match */
while(true) {
type_t *orig_top_type = path.top_type;
type_t *top_type = skip_typeref(orig_top_type);
- if (is_type_scalar(top_type))
+ if (types_compatible(top_type, expr_type))
break;
descend_into_subtype(&path);
}
return;
}
- assert(get_type_mode(type) == get_irn_mode(node));
- ir_node *mem = get_store();
- ir_node *store = new_d_Store(dbgi, mem, base_addr, node, cons_none);
- ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M);
- set_store(proj_m);
+ ir_node *mem = get_store();
+ ir_node *new_mem;
+ if (is_compound_type(ent_type)) {
+ ir_node *copyb = new_d_CopyB(dbgi, mem, base_addr, node, ent_type);
+ new_mem = new_Proj(copyb, mode_M, pn_CopyB_M);
+ } else {
+ assert(get_type_mode(type) == get_irn_mode(node));
+ ir_node *store = new_d_Store(dbgi, mem, base_addr, node, cons_none);
+ new_mem = new_Proj(store, mode_M, pn_Store_M);
+ }
+ set_store(new_mem);
return;
}
case IR_INITIALIZER_TARVAL: {
{
assert(entity->kind == ENTITY_VARIABLE);
initializer_t *initializer = entity->variable.initializer;
- dbg_info *dbgi = get_dbg_info(&entity->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&entity->base.pos);
ir_entity *irentity = entity->variable.v.entity;
type_t *type = entity->declaration.type;
}
ir_node * node = expression_to_firm(value);
- dbg_info *const dbgi = get_dbg_info(&entity->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&entity->base.pos);
ir_mode *const mode = get_ir_mode_storage(init_type);
node = create_conv(dbgi, node, mode);
assert(entity->variable.initializer == NULL);
assert(currently_reachable());
- dbg_info *dbgi = get_dbg_info(&entity->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&entity->base.pos);
type_t *type = entity->declaration.type;
ir_type *el_type = get_ir_type(type->array.element_type);
ir_type *const var_type = entity->variable.thread_local ?
get_tls_type() : get_glob_type();
ir_type *const irtype = get_ir_type(type);
- dbg_info *const dbgi = get_dbg_info(&entity->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&entity->base.pos);
size_t l = strlen(entity->base.symbol->string);
char buf[l + sizeof(".%u")];
if (!currently_reachable())
return NULL;
- dbg_info *const dbgi = get_dbg_info(&statement->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(&statement->base.pos);
type_t *const type = skip_typeref(current_function_entity->declaration.type->function.return_type);
ir_node * res = statement->value ? expression_to_firm(statement->value) : NULL;
init_jump_target(&body_target, NULL);
jump_to_target(&body_target);
enter_immature_jump_target(&body_target);
+ keep_loop();
statement_to_firm(statement->body);
jump_to_target(&continue_target);
if (enter_jump_target(&continue_target))
init_jump_target(&header_target, NULL);
jump_to_target(&header_target);
enter_immature_jump_target(&header_target);
+ keep_loop();
expression_t *const step = statement->step;
PUSH_BREAK(NULL);
init_jump_target(&body_target, NULL);
create_condition_evaluation(cond, &body_target, &break_target);
enter_jump_target(&body_target);
- } else {
- /* for-ever. */
- keep_alive(header_target.block);
- keep_all_memory(header_target.block);
}
/* Create the loop body. */
static ir_node *switch_statement_to_firm(switch_statement_t *statement)
{
- dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->base.pos);
ir_node *switch_node = NULL;
if (currently_reachable()) {
enter_jump_target(&label->target);
} else {
enter_immature_jump_target(&label->target);
- keep_alive(label->target.block);
- keep_all_memory(label->target.block);
+ keep_loop();
}
return statement_to_firm(statement->statement);
const char *clobber_str = clobber->clobber.begin;
if (!be_is_valid_clobber(clobber_str)) {
- errorf(&statement->base.source_position,
+ errorf(&statement->base.pos,
"invalid clobber '%s' specified", clobber->clobber);
continue;
}
= be_parse_asm_constraints(constraints);
{
- source_position_t const *const pos = &statement->base.source_position;
+ position_t const *const pos = &statement->base.pos;
if (asm_flags & ASM_CONSTRAINT_FLAG_NO_SUPPORT) {
warningf(WARN_OTHER, pos, "some constraints in '%s' are not supported", constraints);
}
++in_size;
continue;
} else {
- errorf(&statement->base.source_position,
+ errorf(&statement->base.pos,
"only modifiers but no place set in constraints '%s'",
constraints);
continue;
= be_parse_asm_constraints(constraints);
if (asm_flags & ASM_CONSTRAINT_FLAG_NO_SUPPORT) {
- errorf(&statement->base.source_position,
+ errorf(&statement->base.pos,
"some constraints in '%s' are not supported", constraints);
continue;
}
if (asm_flags & ASM_CONSTRAINT_FLAG_INVALID) {
- errorf(&statement->base.source_position,
+ errorf(&statement->base.pos,
"some constraints in '%s' are invalid", constraints);
continue;
}
if (asm_flags & ASM_CONSTRAINT_FLAG_MODIFIER_WRITE) {
- errorf(&statement->base.source_position,
+ errorf(&statement->base.pos,
"write flag specified for input constraints '%s'",
constraints);
continue;
needs_memory = true;
input = expression_to_addr(argument->expression);
} else {
- errorf(&statement->base.source_position,
+ errorf(&statement->base.pos,
"only modifiers but no place set in constraints '%s'",
constraints);
continue;
ir_asm_constraint *input_constraints = obstack_finish(&asm_obst);
/* create asm node */
- dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
+ dbg_info *dbgi = get_dbg_info(&statement->base.pos);
ident *asm_text = new_id_from_str(statement->asm_text.begin);
static ir_node *ms_try_statement_to_firm(ms_try_statement_t *statement)
{
statement_to_firm(statement->try_statement);
- source_position_t const *const pos = &statement->base.source_position;
+ position_t const *const pos = &statement->base.pos;
warningf(WARN_OTHER, pos, "structured exception handling ignored");
return NULL;
}
static ir_node *leave_statement_to_firm(leave_statement_t *statement)
{
- errorf(&statement->base.source_position, "__leave not supported yet");
+ errorf(&statement->base.pos, "__leave not supported yet");
return NULL;
}
assert(parameter->declaration.kind == DECLARATION_KIND_UNKNOWN);
type_t *type = skip_typeref(parameter->declaration.type);
- dbg_info *const dbgi = get_dbg_info(¶meter->base.source_position);
+ dbg_info *const dbgi = get_dbg_info(¶meter->base.pos);
ir_type *const param_irtype = get_method_param_type(function_irtype, n);
if (var_needs_entity(¶meter->variable)) {
ir_type *frame_type = get_irg_frame_type(irg);
current_vararg_entity = NULL;
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));
}
if (enter_jump_target(&ijmp_target)) {
+ keep_loop();
size_t const n = ARR_LEN(ijmp_ops);
ir_node *const op = n == 1 ? ijmp_ops[0] : new_Phi(n, ijmp_ops, get_irn_mode(ijmp_ops[0]));
ir_node *const ijmp = new_IJmp(op);
projects / cparser / blobdiff