construct 0/1 instead of mode_b->int convs

[r18872]

diff --git a/ast2firm.c b/ast2firm.c
index debae68..a069e66 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -1871,25 +1871,10 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
        panic("invalid UNEXPR type found");
 }
 
-static ir_node *create_lazy_op(const binary_expression_t *expression)
+static ir_node *produce_condition_result(const expression_t *expression,
+                                         dbg_info *dbgi)
 {
-       dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
-       type_t   *type = expression->base.type;
-       ir_mode  *mode = get_ir_mode(type);
-
-       if(is_constant_expression(expression->left)) {
-               long val = fold_constant(expression->left);
-               expression_kind_t ekind = expression->base.kind;
-               if((ekind == EXPR_BINARY_LOGICAL_AND && val != 0)
-                               || (ekind == EXPR_BINARY_LOGICAL_OR && val == 0)) {
-                       return expression_to_firm(expression->right);
-               } else {
-                       assert((ekind == EXPR_BINARY_LOGICAL_AND && val == 0)
-                                       || (ekind == EXPR_BINARY_LOGICAL_OR && val != 0));
-                       return new_Const(mode, get_mode_one(mode));
-               }
-       }
-
+       ir_mode *mode      = get_ir_mode(expression->base.type);
        ir_node *cur_block = get_cur_block();
 
        ir_node *one_block = new_immBlock();
@@ -1901,8 +1886,7 @@ static ir_node *create_lazy_op(const binary_expression_t *expression)
        ir_node *jmp_zero   = new_d_Jmp(dbgi);
 
        set_cur_block(cur_block);
-       create_condition_evaluation((const expression_t*) expression,
-                                   one_block, zero_block);
+       create_condition_evaluation(expression, one_block, zero_block);
        mature_immBlock(one_block);
        mature_immBlock(zero_block);
 
@@ -1917,6 +1901,28 @@ static ir_node *create_lazy_op(const binary_expression_t *expression)
        return val;
 }
 
+static ir_node *create_lazy_op(const binary_expression_t *expression)
+{
+       dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+       type_t   *type = expression->base.type;
+       ir_mode  *mode = get_ir_mode(type);
+
+       if(is_constant_expression(expression->left)) {
+               long val = fold_constant(expression->left);
+               expression_kind_t ekind = expression->base.kind;
+               if((ekind == EXPR_BINARY_LOGICAL_AND && val != 0)
+                               || (ekind == EXPR_BINARY_LOGICAL_OR && val == 0)) {
+                       return expression_to_firm(expression->right);
+               } else {
+                       assert((ekind == EXPR_BINARY_LOGICAL_AND && val == 0)
+                                       || (ekind == EXPR_BINARY_LOGICAL_OR && val != 0));
+                       return new_Const(mode, get_mode_one(mode));
+               }
+       }
+
+       return produce_condition_result((const expression_t*) expression, dbgi);
+}
+
 typedef ir_node * (*create_arithmetic_func)(dbg_info *dbgi, ir_node *left,
                                             ir_node *right, ir_mode *mode);
 
@@ -2764,7 +2770,17 @@ static ir_node *expression_to_firm(const expression_t *expression)
 
        if(res != NULL && get_irn_mode(res) == mode_b) {
                ir_mode *mode = get_ir_mode(expression->base.type);
-               res           = create_conv(NULL, res, mode);
+               if(is_Const(res)) {
+                       if(is_Const_null(res)) {
+                               return new_Const_long(mode, 0);
+                       } else {
+                               assert(is_Const_one(res));
+                               return new_Const_long(mode, 1);
+                       }
+               }
+
+               dbg_info *dbgi        = get_dbg_info(&expression->base.source_position);
+               return produce_condition_result(expression, dbgi);
        }
 
        return res;