If a K&R function definition has a variadic prototype earlier, then make the function...

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index d08bc72..e4a12a7 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -2399,21 +2399,18 @@ static ir_node *handle_assume(dbg_info *dbi, const expression_t *expression)
        }
 }
 
-static ir_node *cast_to_firm(const unary_expression_t *expression)
+static ir_node *create_cast(dbg_info *dbgi,    ir_node *value_node,
+                            type_t *from_type, type_t *type)
 {
-       dbg_info           *dbgi = get_dbg_info(&expression->base.source_position);
-       type_t             *type = skip_typeref(expression->base.type);
-       const expression_t *value      = expression->value;
-       ir_node            *value_node = expression_to_firm(value);
-
+       type = skip_typeref(type);
        if (!is_type_scalar(type)) {
                /* make sure firm type is constructed */
                (void) get_ir_type(type);
                return value_node;
        }
 
-       type_t  *from_type = skip_typeref(value->base.type);
-       ir_mode *mode      = get_ir_mode_storage(type);
+       from_type     = skip_typeref(from_type);
+       ir_mode *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;
@@ -2432,20 +2429,17 @@ static ir_node *cast_to_firm(const unary_expression_t *expression)
                }
        }
 
+       if (is_type_atomic(type, ATOMIC_TYPE_BOOL)) {
+               /* bool adjustments (we save a mode_Bu, but have to temporarily
+                * convert to mode_b so we only get a 0/1 value */
+               value_node = create_conv(dbgi, value_node, mode_b);
+       }
+
        ir_mode *mode_arith = get_ir_mode_arithmetic(type);
        ir_node *node       = create_conv(dbgi, value_node, mode);
        node                = do_strict_conv(dbgi, node);
        node                = create_conv(dbgi, node, mode_arith);
 
-       if (is_type_atomic(type, ATOMIC_TYPE_BOOL)) {
-               /* bool adjustments (have to compare to get 0/1 value */
-               ir_node *zero = new_Const(get_mode_null(mode_arith));
-               ir_node *cmp  = new_d_Cmp(dbgi, node, zero);
-               ir_node *proj = new_d_Proj(dbgi, cmp, mode_b, pn_Cmp_Lg);
-               ir_node *one  = new_Const_long(mode_arith, 1);
-               node          = new_d_Mux(dbgi, proj, zero, one, mode_arith);
-       }
-
        return node;
 }
 
@@ -2499,8 +2493,11 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
        case EXPR_UNARY_PREFIX_DECREMENT:
                return create_incdec(expression);
        case EXPR_UNARY_CAST_IMPLICIT:
-       case EXPR_UNARY_CAST:
-               return cast_to_firm(expression);
+       case EXPR_UNARY_CAST: {
+               ir_node *value_node = expression_to_firm(value);
+               type_t  *from_type  = value->base.type;
+               return create_cast(dbgi, value_node, from_type, type);
+       }
        case EXPR_UNARY_ASSUME:
                if (firm_opt.confirm)
                        return handle_assume(dbgi, value);
@@ -2718,13 +2715,12 @@ static ir_node *create_assign_binop(const binary_expression_t *expression)
        dbg_info *const     dbgi = get_dbg_info(&expression->base.source_position);
        const expression_t *left_expr = expression->left;
        type_t             *type      = skip_typeref(left_expr->base.type);
-       ir_mode            *left_mode = get_ir_mode_storage(type);
        ir_node            *right     = expression_to_firm(expression->right);
        ir_node            *left_addr = expression_to_addr(left_expr);
        ir_node            *left      = get_value_from_lvalue(left_expr, left_addr);
        ir_node            *result    = create_op(dbgi, expression, left, right);
 
-       result = create_conv(dbgi, result, left_mode);
+       result = create_cast(dbgi, result, expression->right->base.type, type);
        result = do_strict_conv(dbgi, result);
 
        result = set_value_for_expression_addr(left_expr, result, left_addr);