don't print trailing 0 in strings

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index 5a12c4b..7e06f49 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -358,8 +358,12 @@ static ir_type *create_atomic_type(const atomic_type_t *type)
        ident   *id     = get_mode_ident(mode);
        ir_type *irtype = new_d_type_primitive(id, mode, dbgi);
 
+       /* TODO: this is x86 specific, we should fiddle this into
+        * lang_features.h somehow... */
        if(type->akind == ATOMIC_TYPE_LONG_DOUBLE
-                       || type->akind == ATOMIC_TYPE_DOUBLE) {
+                       || type->akind == ATOMIC_TYPE_DOUBLE
+                       || type->akind == ATOMIC_TYPE_LONGLONG
+                       || type->akind == ATOMIC_TYPE_ULONGLONG) {
                set_type_alignment_bytes(irtype, 4);
        }
 
@@ -1871,25 +1875,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 +1890,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 +1905,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 +2774,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;
@@ -4559,7 +4579,6 @@ static void create_function(declaration_t *declaration)
        }
        set_type_size_bytes(frame_type, offset);
        set_type_alignment_bytes(frame_type, align_all);
-       set_type_state(frame_type, layout_fixed);
 
        irg_vrfy(irg);
 }