X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=74367c6116049bcefda3eb76027a990885816515;hb=8ff73b92722cccf0ea26ad36480d2b56344e3d5f;hp=b3b09ae561fb3fd3528836b97d53a0d8a73dca14;hpb=3f3175b653a9a02b08a50a23199b5451ade318bc;p=cparser diff --git a/ast2firm.c b/ast2firm.c index b3b09ae..74367c6 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -209,8 +209,7 @@ static ir_mode *init_atomic_ir_mode(atomic_type_kind_t kind) { 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(); @@ -271,35 +270,50 @@ static unsigned count_parameters(const function_type_t *function_type) 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; } /** @@ -682,7 +696,7 @@ ir_type *get_ir_type(type_t *type) 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); @@ -1120,6 +1134,12 @@ static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) 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. * @@ -1756,14 +1776,8 @@ static ir_node *call_expression_to_firm(const call_expression_t *const call) 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; } @@ -1830,10 +1844,7 @@ static ir_node *create_condition_evaluation(expression_t const *expression, jump 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(); @@ -1993,11 +2004,7 @@ static ir_node *set_value_for_expression_addr(const expression_t *expression, { 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; @@ -2080,52 +2087,29 @@ static ir_node *get_value_from_lvalue(const expression_t *expression, return value; } - -static ir_node *create_incdec(const unary_expression_t *expression) +static ir_node *create_incdec(unary_expression_t const *const expr, bool const inc, bool const pre) { - 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); - - type_t *type = skip_typeref(expression->base.type); - ir_mode *mode = get_ir_mode_arithmetic(expression->base.type); + type_t *const type = skip_typeref(expr->base.type); + ir_mode *const mode = get_ir_mode_arithmetic(type); ir_node *offset; if (is_type_pointer(type)) { - pointer_type_t *pointer_type = &type->pointer; - offset = get_type_size_node(pointer_type->points_to); + offset = get_type_size_node(type->pointer.points_to); } else { assert(is_type_arithmetic(type)); offset = new_Const(get_mode_one(mode)); } - ir_node *result; - ir_node *store_value; - switch(expression->base.kind) { - case EXPR_UNARY_POSTFIX_INCREMENT: - result = value; - store_value = new_d_Add(dbgi, value, offset, mode); - break; - case EXPR_UNARY_POSTFIX_DECREMENT: - result = value; - store_value = new_d_Sub(dbgi, value, offset, mode); - break; - case EXPR_UNARY_PREFIX_INCREMENT: - result = new_d_Add(dbgi, value, offset, mode); - store_value = result; - break; - case EXPR_UNARY_PREFIX_DECREMENT: - result = new_d_Sub(dbgi, value, offset, mode); - store_value = result; - break; - default: - panic("no incdec expr"); - } - - set_value_for_expression_addr(value_expr, store_value, addr); + dbg_info *const dbgi = get_dbg_info(&expr->base.pos); + expression_t const *const value_expr = expr->value; + ir_node *const addr = expression_to_addr(value_expr); + ir_node *const value = get_value_from_lvalue(value_expr, addr); + ir_node *const new_value = inc + ? new_d_Add(dbgi, value, offset, mode) + : new_d_Sub(dbgi, value, offset, mode); - return result; + set_value_for_expression_addr(value_expr, new_value, addr); + return pre ? new_value : value; } static bool is_local_variable(expression_t *expression) @@ -2336,11 +2320,18 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) type_t *points_to = value_type->pointer.points_to; return deref_address(dbgi, points_to, value_node); } - case EXPR_UNARY_POSTFIX_INCREMENT: - case EXPR_UNARY_POSTFIX_DECREMENT: - case EXPR_UNARY_PREFIX_INCREMENT: - case EXPR_UNARY_PREFIX_DECREMENT: - return create_incdec(expression); + + { + bool inc; + bool pre; + case EXPR_UNARY_POSTFIX_DECREMENT: inc = false; pre = false; goto incdec; + case EXPR_UNARY_POSTFIX_INCREMENT: inc = true; pre = false; goto incdec; + case EXPR_UNARY_PREFIX_DECREMENT: inc = false; pre = true; goto incdec; + case EXPR_UNARY_PREFIX_INCREMENT: inc = true; pre = true; goto incdec; +incdec: + return create_incdec(expression, inc, pre); + } + case EXPR_UNARY_CAST: { ir_node *value_node = expression_to_firm(value); type_t *from_type = value->base.type; @@ -2550,9 +2541,6 @@ static ir_node *create_lazy_op(const binary_expression_t *expression) 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); @@ -3755,14 +3743,11 @@ static ir_initializer_t *create_ir_initializer_value( } 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); } -/** 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)) @@ -4136,8 +4121,7 @@ static void create_variable_initializer(entity_t *entity) 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); @@ -4289,11 +4273,10 @@ static ir_node *return_statement_to_firm(return_statement_t *statement) 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 { @@ -5126,9 +5109,7 @@ static void initialize_function_parameters(entity_t *entity) 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; @@ -5209,7 +5190,6 @@ static void create_function(entity_t *entity) 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));