- create strict convs where necessary

- implement __builtin_nanf (enough so bits/nan.h works)
- avoid more casts
- fix determination of integer constant type

[r18561]

diff --git a/ast.c b/ast.c
index 8515e93..6c5aee0 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -166,6 +166,8 @@ static void print_unary_expression(const unary_expression_t *unexpr)
                print_type(unexpr->expression.datatype);
                fputs(")", out);
                break;
+       case UNEXPR_CAST_IMPLICIT:
+               break;
        case UNEXPR_INVALID:
                fprintf(out, "unop%d", (int) unexpr->type);
                break;
@@ -489,9 +491,9 @@ static void print_asm_clobbers(asm_clobber_t *clobbers)
 
 static void print_asm_statement(const asm_statement_t *statement)
 {
-       fputs("asm", out);
+       fputs("asm ", out);
        if(statement->is_volatile) {
-               fputs(" volatile", out);
+               fputs("volatile ", out);
        }
        fputs("(", out);
        print_quoted_string(statement->asm_text);
@@ -504,12 +506,12 @@ static void print_asm_statement(const asm_statement_t *statement)
        if(statement->outputs == NULL && statement->clobbers == NULL)
                goto end_of_print_asm_statement;
 
-       fputs(": ", out);
+       fputs(" : ", out);
        print_asm_constraints(statement->outputs);
        if(statement->clobbers == NULL)
                goto end_of_print_asm_statement;
 
-       fputs(": ", out);
+       fputs(" : ", out);
        print_asm_clobbers(statement->clobbers);
 
 end_of_print_asm_statement:

diff --git a/ast2firm.c b/ast2firm.c
index b5f38db..b75ddc1 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -28,7 +28,8 @@ static type_t *type_const_char;
 static type_t *type_void;
 static type_t *type_int;
 
-static symbol_t *symbol_alloca;
+static symbol_t *symbol_builtin_alloca;
+static symbol_t *symbol_builtin_nanf;
 
 static int       next_value_number_function;
 static ir_node  *continue_label;
@@ -99,7 +100,8 @@ void init_ast2firm(void)
 
        type_void->base.firm_type = ir_type_void;
 
-       symbol_alloca = symbol_table_insert("__builtin_alloca");
+       symbol_builtin_alloca = symbol_table_insert("__builtin_alloca");
+       symbol_builtin_nanf   = symbol_table_insert("__builtin_nanf");
 }
 
 void exit_ast2firm(void)
@@ -672,6 +674,26 @@ static ir_node *deref_address(ir_type *const irtype, ir_node *const addr,
        return load_res;
 }
 
+static ir_node *do_strict_conv(dbg_info *dbgi, ir_node *node)
+{
+       ir_mode *mode = get_irn_mode(node);
+
+       if(!(get_irg_fp_model(current_ir_graph) & fp_explicit_rounding))
+               return node;
+       if(!mode_is_float(mode))
+               return node;
+
+       /* check if there is already a Conv */
+       if (get_irn_op(node) == op_Conv) {
+               /* convert it into a strict Conv */
+               set_Conv_strict(node, 1);
+               return node;
+       }
+
+       /* otherwise create a new one */
+       return new_d_strictConv(dbgi, node, mode);
+}
+
 static ir_node *get_global_var_address(dbg_info *const dbgi,
                                        const declaration_t *const decl)
 {
@@ -785,7 +807,7 @@ static ir_node *process_builtin_call(const call_expression_t *call)
                = (builtin_symbol_expression_t*) call->function;
        symbol_t *symbol = builtin->symbol;
 
-       if(symbol == symbol_alloca) {
+       if(symbol == symbol_builtin_alloca) {
                if(call->arguments == NULL || call->arguments->next != NULL) {
                        panic("invalid number of parameters on __builtin_alloca");
                }
@@ -799,6 +821,12 @@ static ir_node *process_builtin_call(const call_expression_t *call)
                set_store(proj_m);
                ir_node *res    = new_Proj(alloca, mode_P_data, pn_Alloc_res);
 
+               return res;
+       } else if(symbol == symbol_builtin_nanf) {
+               /* Ignore string for now... */
+               ir_mode *mode = mode_D;
+               tarval  *tv   = get_mode_NAN(mode);
+               ir_node *res  = new_d_Const(dbgi, mode, tv);
                return res;
        } else {
                panic("Unsupported builtin found\n");
@@ -827,6 +855,8 @@ static ir_node *call_expression_to_firm(const call_expression_t *call)
                ++n_parameters;
        }
 
+       dbg_info *dbgi  = get_dbg_info(&call->expression.source_position);
+
        ir_type *ir_method_type  = get_ir_type((type_t*) function_type);
        ir_type *new_method_type = NULL;
        if(function_type->variadic || function_type->unspecified_parameters) {
@@ -853,6 +883,8 @@ static ir_node *call_expression_to_firm(const call_expression_t *call)
                expression_t *expression = argument->expression;
                ir_node      *arg_node   = expression_to_firm(expression);
 
+               arg_node = do_strict_conv(dbgi, arg_node);
+
                in[n] = arg_node;
                if(new_method_type != NULL) {
                        ir_type *irtype = get_ir_type(expression->base.datatype);
@@ -866,7 +898,6 @@ static ir_node *call_expression_to_firm(const call_expression_t *call)
        if(new_method_type != NULL)
                ir_method_type = new_method_type;
 
-       dbg_info *dbgi  = get_dbg_info(&call->expression.source_position);
        ir_node  *store = get_store();
        ir_node  *node  = new_d_Call(dbgi, store, callee, n_parameters, in,
                                     ir_method_type);
@@ -901,6 +932,9 @@ static void create_condition_evaluation(const expression_t *expression,
 static void set_value_for_expression(const expression_t *expression,
                                      ir_node *value)
 {
+       dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
+       value          = do_strict_conv(dbgi, value);
+
        if(expression->type == EXPR_REFERENCE) {
                reference_expression_t *ref = (reference_expression_t*) expression;
 
@@ -912,7 +946,6 @@ static void set_value_for_expression(const expression_t *expression,
                }
        }
 
-       dbg_info *dbgi   = get_dbg_info(&expression->base.source_position);
        ir_node  *addr   = expression_to_addr(expression);
        ir_node  *memory = get_store();
 
@@ -1030,7 +1063,12 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
        case UNEXPR_PREFIX_INCREMENT:
        case UNEXPR_PREFIX_DECREMENT:
                return create_incdec(expression);
-       case UNEXPR_CAST:
+       case UNEXPR_CAST: {
+               ir_node *node = create_conv(dbgi, value_node, get_ir_mode(type));
+               node = do_strict_conv(dbgi, node);
+               return node;
+       }
+       case UNEXPR_CAST_IMPLICIT:
                return create_conv(dbgi, value_node, get_ir_mode(type));
 
        case UNEXPR_TAKE_ADDRESS:
@@ -1782,7 +1820,6 @@ static void create_condition_evaluation(const expression_t *expression,
        set_cur_block(NULL);
 }
 
-
 static void return_statement_to_firm(return_statement_t *statement)
 {
        if(get_cur_block() == NULL)
@@ -1798,7 +1835,9 @@ static void return_statement_to_firm(return_statement_t *statement)
                ir_type *res_type = get_method_res_type(func_irtype, 0);
 
                if(statement->return_value != NULL) {
-                       in[0] = expression_to_firm(statement->return_value);
+                       ir_node *node = expression_to_firm(statement->return_value);
+                       node  = do_strict_conv(dbgi, node);
+                       in[0] = node;
                } else {
                        ir_mode *mode;
                        if(is_compound_type(res_type)) {
@@ -2617,25 +2656,25 @@ static void statement_to_firm(statement_t *statement)
        case STATEMENT_INVALID:
                panic("invalid statement found");
        case STATEMENT_COMPOUND:
-               compound_statement_to_firm((compound_statement_t*) statement);
+               compound_statement_to_firm(&statement->compound);
                return;
        case STATEMENT_RETURN:
-               return_statement_to_firm((return_statement_t*) statement);
+               return_statement_to_firm(&statement->returns);
                return;
        case STATEMENT_EXPRESSION:
-               expression_statement_to_firm((expression_statement_t*) statement);
+               expression_statement_to_firm(&statement->expression);
                return;
        case STATEMENT_IF:
-               if_statement_to_firm((if_statement_t*) statement);
+               if_statement_to_firm(&statement->ifs);
                return;
        case STATEMENT_WHILE:
-               while_statement_to_firm((while_statement_t*) statement);
+               while_statement_to_firm(&statement->whiles);
                return;
        case STATEMENT_DO_WHILE:
-               do_while_statement_to_firm((do_while_statement_t*) statement);
+               do_while_statement_to_firm(&statement->do_while);
                return;
        case STATEMENT_DECLARATION:
-               declaration_statement_to_firm((declaration_statement_t*) statement);
+               declaration_statement_to_firm(&statement->declaration);
                return;
        case STATEMENT_BREAK:
                create_jump_statement(statement, break_label);
@@ -2644,19 +2683,19 @@ static void statement_to_firm(statement_t *statement)
                create_jump_statement(statement, continue_label);
                return;
        case STATEMENT_SWITCH:
-               switch_statement_to_firm((switch_statement_t*) statement);
+               switch_statement_to_firm(&statement->switchs);
                return;
        case STATEMENT_CASE_LABEL:
-               case_label_to_firm((case_label_statement_t*) statement);
+               case_label_to_firm(&statement->case_label);
                return;
        case STATEMENT_FOR:
-               for_statement_to_firm((for_statement_t*) statement);
+               for_statement_to_firm(&statement->fors);
                return;
        case STATEMENT_LABEL:
-               label_to_firm((label_statement_t*) statement);
+               label_to_firm(&statement->label);
                return;
        case STATEMENT_GOTO:
-               goto_to_firm((goto_statement_t*) statement);
+               goto_to_firm(&statement->gotos);
                return;
        case STATEMENT_ASM:
                break;

diff --git a/ast_t.h b/ast_t.h
index 3314400..9216030 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -92,7 +92,8 @@ typedef enum {
        UNEXPR_POSTFIX_DECREMENT,
        UNEXPR_PREFIX_INCREMENT,
        UNEXPR_PREFIX_DECREMENT,
-       UNEXPR_CAST
+       UNEXPR_CAST,
+       UNEXPR_CAST_IMPLICIT /* compiler generated cast */
 } unary_expression_type_t;
 
 struct unary_expression_t {

diff --git a/lexer.c b/lexer.c
index 2099360..38473a2 100644 (file)
--- a/lexer.c
+++ b/lexer.c
@@ -7,6 +7,7 @@
 #include "adt/strset.h"
 #include "adt/util.h"
 #include "type_t.h"
+#include "target_architecture.h"
 
 #include <assert.h>
 #include <errno.h>
@@ -22,9 +23,6 @@
 #define strtold(s, e) strtod(s, e)
 #endif
 
-#define HAS_SIGNED_CHAR
-//#define HAS_UNSIGNED_CHAR
-
 #if defined HAS_SIGNED_CHAR
 typedef signed char char_type;
 #elif defined HAS_UNSIGNED_CHAR
@@ -44,6 +42,7 @@ static strset_t    stringset;
 
 static type_t     *type_int        = NULL;
 static type_t     *type_uint       = NULL;
+static type_t     *type_long       = NULL;
 static type_t     *type_ulong      = NULL;
 static type_t     *type_longlong   = NULL;
 static type_t     *type_ulonglong  = NULL;
@@ -279,39 +278,78 @@ end_symbol:
        }
 }
 
-static void parse_integer_suffix(void)
+static void parse_integer_suffix(bool is_oct_hex)
 {
+       bool is_unsigned  = false;
+       bool min_long     = false;
+       bool min_longlong = false;
+
        if(c == 'U' || c == 'u') {
+               is_unsigned = true;
                next_char();
                if(c == 'L' || c == 'l') {
+                       min_long = true;
                        next_char();
                        if(c == 'L' || c == 'l') {
+                               min_longlong = true;
                                next_char();
-                               lexer_token.datatype = type_ulonglong;
-                       } else {
-                               lexer_token.datatype = type_ulong;
                        }
-               } else {
-                       lexer_token.datatype = type_uint;
                }
        } else if(c == 'l' || c == 'L') {
+               min_long = true;
                next_char();
                if(c == 'l' || c == 'L') {
+                       min_longlong = true;
                        next_char();
                        if(c == 'u' || c == 'U') {
+                               is_unsigned = true;
                                next_char();
-                               lexer_token.datatype = type_ulonglong;
-                       } else {
-                               lexer_token.datatype = type_longlong;
                        }
                } else if(c == 'u' || c == 'U') {
+                       is_unsigned = true;
                        next_char();
                        lexer_token.datatype = type_ulong;
-               } else {
-                       lexer_token.datatype = type_int;
                }
+       }
+
+       if(!is_unsigned) {
+               long long v = lexer_token.v.intvalue;
+               if(!min_long) {
+                       if(v >= TARGET_INT_MIN && v <= TARGET_INT_MAX) {
+                               lexer_token.datatype = type_int;
+                               return;
+                       } else if(is_oct_hex && v >= 0 && v <= TARGET_UINT_MAX) {
+                               lexer_token.datatype = type_uint;
+                               return;
+                       }
+               }
+               if(!min_longlong) {
+                       if(v >= TARGET_LONG_MIN && v <= TARGET_LONG_MAX) {
+                               lexer_token.datatype = type_long;
+                               return;
+                       } else if(is_oct_hex && v >= 0 && v <= TARGET_ULONG_MAX) {
+                               lexer_token.datatype = type_ulong;
+                               return;
+                       }
+               }
+               unsigned long long uv = (unsigned long long) v;
+               if(is_oct_hex && uv > (unsigned long long) TARGET_LONGLONG_MAX) {
+                       lexer_token.datatype = type_ulonglong;
+                       return;
+               }
+
+               lexer_token.datatype = type_longlong;
        } else {
-               lexer_token.datatype = type_int;
+               unsigned long long v = (unsigned long long) lexer_token.v.intvalue;
+               if(!min_long && v <= TARGET_UINT_MAX) {
+                       lexer_token.datatype = type_uint;
+                       return;
+               }
+               if(!min_longlong && v <= TARGET_ULONG_MAX) {
+                       lexer_token.datatype = type_ulong;
+                       return;
+               }
+               lexer_token.datatype = type_ulonglong;
        }
 }
 
@@ -448,7 +486,7 @@ static void parse_number_hex(void)
        }
 
        obstack_free(&symbol_obstack, string);
-       parse_integer_suffix();
+       parse_integer_suffix(true);
 }
 
 static inline bool is_octal_digit(int chr)
@@ -473,7 +511,7 @@ static void parse_number_oct(void)
        }
 
        obstack_free(&symbol_obstack, string);
-       parse_integer_suffix();
+       parse_integer_suffix(true);
 }
 
 static void parse_number_dec(void)
@@ -532,7 +570,7 @@ static void parse_number_dec(void)
                        parse_error("invalid number literal");
                }
 
-               parse_integer_suffix();
+               parse_integer_suffix(false);
        }
        obstack_free(&symbol_obstack, string);
 }
@@ -1139,13 +1177,14 @@ void init_lexer(void)
 {
        strset_init(&stringset);
 
-       type_int       = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_CONST);
-       type_uint      = make_atomic_type(ATOMIC_TYPE_UINT, TYPE_QUALIFIER_CONST);
-       type_ulong     = make_atomic_type(ATOMIC_TYPE_ULONG, TYPE_QUALIFIER_CONST);
+       type_int       = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE);
+       type_uint      = make_atomic_type(ATOMIC_TYPE_UINT, TYPE_QUALIFIER_NONE);
+       type_long      = make_atomic_type(ATOMIC_TYPE_LONG, TYPE_QUALIFIER_NONE);
+       type_ulong     = make_atomic_type(ATOMIC_TYPE_ULONG, TYPE_QUALIFIER_NONE);
        type_longlong  = make_atomic_type(ATOMIC_TYPE_LONGLONG,
-                                         TYPE_QUALIFIER_CONST);
+                                         TYPE_QUALIFIER_NONE);
        type_ulonglong = make_atomic_type(ATOMIC_TYPE_ULONGLONG,
-                                         TYPE_QUALIFIER_CONST);
+                                         TYPE_QUALIFIER_NONE);
 
        type_float      = make_atomic_type(ATOMIC_TYPE_FLOAT, TYPE_QUALIFIER_CONST);
        type_double     = make_atomic_type(ATOMIC_TYPE_DOUBLE,

diff --git a/main.c b/main.c
index 8795cdd..1ba0918 100644 (file)
--- a/main.c
+++ b/main.c
@@ -25,7 +25,7 @@
 #include "write_fluffy.h"
 
 #ifndef PREPROCESSOR
-#define PREPROCESSOR "cpp"
+#define PREPROCESSOR "cpp -std=c99"
 #endif
 
 #ifndef LINKER

diff --git a/parser.c b/parser.c
index 6e3c44b..b486ad2 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -746,7 +746,7 @@ static expression_t *create_cast_expression(expression_t *expression,
 {
        expression_t *cast = allocate_expression_zero(EXPR_UNARY);
 
-       cast->unary.type    = UNEXPR_CAST;
+       cast->unary.type    = UNEXPR_CAST_IMPLICIT;
        cast->unary.value   = expression;
        cast->base.datatype = dest_type;
 
@@ -2651,6 +2651,8 @@ static type_t *get_builtin_symbol_type(symbol_t *symbol)
        switch(symbol->ID) {
        case T___builtin_alloca:
                return make_function_1_type(type_void_ptr, type_size_t);
+       case T___builtin_nanf:
+               return make_function_1_type(type_double, type_string);
        default:
                panic("not implemented builtin symbol found");
        }
@@ -3010,6 +3012,7 @@ static expression_t *parse_primary_expression(void)
                return parse_offsetof();
        case T___builtin_va_arg:
                return parse_va_arg();
+       case T___builtin_nanf:
        case T___builtin_alloca:
        case T___builtin_expect:
        case T___builtin_va_start:

diff --git a/tokens.inc b/tokens.inc
index 7288ba0..977d3b5 100644 (file)
--- a/tokens.inc
+++ b/tokens.inc
@@ -52,11 +52,11 @@ S(__builtin_va_start)
 S(__builtin_va_arg)
 S(__builtin_va_end)
 S(__builtin_alloca)
+S(__builtin_nanf)
 S(__PRETTY_FUNCTION__)
 S(__FUNCTION__)
 S(__func__)
 S(__alignof__)
-S(__typeof__)
 S(__real__)
 S(__imag__)
 #undef S
@@ -72,6 +72,8 @@ T(__volatile__,   "__volatile__", = T_volatile)
 T(inline,               "inline",)
 T(__inline,           "__inline", = T_inline)
 T(__inline__,       "__inline__", = T_inline)
+T(typeof,               "typeof",)
+T(__typeof__,       "__typeof__", = T_typeof)
 
 T(MINUSGREATER,             "->",)
 T(PLUSPLUS,                 "++",)