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);
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);
jump_to_target(&exit_target);
if (val) {
ir_node *const in[] = { val, false_val };
- dbg_info *const dbgi = get_dbg_info(&expression->base.source_position);
+ 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);
}
jump_to_target(true_target);
}
} else {
- dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+ 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);
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;
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))
{
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;
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()) {
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));
projects / cparser / blobdiff