{
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;
}
/**
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);
return new_d_Conv(dbgi, value, dest_mode);
}
+static ir_node *conv_to_storage_type(dbg_info *const dbgi, ir_node *const val, type_t *const type)
+{
+ ir_mode *const mode = get_ir_mode_storage(type);
+ return create_conv(dbgi, val, mode);
+}
+
/**
* Creates a SymConst node representing a string constant.
*
for (int n = 0; n < n_parameters; ++n) {
expression_t *expression = argument->expression;
ir_node *arg_node = expression_to_firm(expression);
-
- type_t *arg_type = skip_typeref(expression->base.type);
- if (!is_type_compound(arg_type)) {
- ir_mode *const mode = get_ir_mode_storage(arg_type);
- arg_node = create_conv(dbgi, arg_node, mode);
- }
-
- in[n] = arg_node;
+ type_t *arg_type = skip_typeref(expression->base.type);
+ in[n] = conv_to_storage_type(dbgi, arg_node, arg_type);
argument = argument->next;
}
static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type,
ir_node *value)
{
- if (!is_type_compound(type)) {
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(dbgi, value, mode);
- }
+ value = conv_to_storage_type(dbgi, value, type);
ir_node *memory = get_store();
{
dbg_info *dbgi = get_dbg_info(&expression->base.pos);
type_t *type = skip_typeref(expression->base.type);
-
- if (!is_type_compound(type)) {
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(dbgi, value, mode);
- }
+ value = conv_to_storage_type(dbgi, value, type);
if (expression->kind == EXPR_REFERENCE) {
const reference_expression_t *ref = &expression->reference;
dbgi);
}
-typedef ir_node * (*create_arithmetic_func)(dbg_info *dbgi, ir_node *left,
- ir_node *right, ir_mode *mode);
-
static ir_node *create_assign_binop(const binary_expression_t *expression)
{
dbg_info *const dbgi = get_dbg_info(&expression->base.pos);
}
ir_node *value = expression_to_firm(expr);
- if (!is_type_compound(type)) {
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(NULL, value, mode);
- }
+ value = conv_to_storage_type(NULL, value, type);
return create_initializer_const(value);
}
ir_node * node = expression_to_firm(value);
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);
+ node = conv_to_storage_type(dbgi, node, init_type);
if (declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE) {
set_value(entity->variable.v.value_number, node);
int in_len;
if (!is_type_void(type)) {
- ir_mode *const mode = get_ir_mode_storage(type);
if (res) {
- res = create_conv(dbgi, res, mode);
+ res = conv_to_storage_type(dbgi, res, type);
} else {
- res = new_Unknown(mode);
+ res = new_Unknown(get_ir_mode_storage(type));
}
in_len = 1;
} else {
ir_mode *param_mode = get_type_mode(param_irtype);
long pn = n;
ir_node *value = new_rd_Proj(dbgi, args, param_mode, pn);
-
- ir_mode *mode = get_ir_mode_storage(type);
- value = create_conv(NULL, value, mode);
+ value = conv_to_storage_type(dbgi, value, type);
parameter->declaration.kind = DECLARATION_KIND_PARAMETER;
parameter->variable.v.value_number = next_value_number_function;
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