- completed __FUNCSIG__ and __FUNCDNAME__

- fixed some gcc warnings

[r18971]

diff --git a/TODO b/TODO
index 9944e79..9a85373 100644 (file)
--- a/TODO
+++ b/TODO
@@ -1,3 +1,6 @@
+Driver:
+- add an -std= option (for c99, gnu99, ms at least)
+
 Refactoring:
 - eliminate target_architecture.h and replace with stuff in lang_features.h
 - redo storage classes: so we can separate real from declared storage class

diff --git a/ast.c b/ast.c
index c1d1cf6..50eaec3 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -1508,6 +1508,8 @@ bool is_constant_expression(const expression_t *expression)
        case EXPR_SIZEOF:
        case EXPR_CLASSIFY_TYPE:
        case EXPR_FUNCTION:
+       case EXPR_FUNCSIG:
+       case EXPR_FUNCDNAME:
        case EXPR_PRETTY_FUNCTION:
        case EXPR_OFFSETOF:
        case EXPR_ALIGNOF:

diff --git a/ast2firm.c b/ast2firm.c
index aac4a31..09aa949 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -59,6 +59,7 @@ static ir_node **imature_blocks;
 
 static const declaration_t *current_function_decl;
 static ir_node             *current_function_name;
+static ir_node             *current_funcsig;
 
 static struct obstack asm_obst;
 
@@ -2644,6 +2645,20 @@ static ir_node *function_name_to_firm(
        return current_function_name;
 }
 
+static ir_node *funcsig_to_firm(
+               const string_literal_expression_t *const expr)
+{
+       if (current_funcsig == NULL) {
+               const source_position_t *const src_pos = &expr->base.source_position;
+               ir_entity *ent = get_irg_entity(current_ir_graph);
+               const char *const name = get_entity_ld_name(ent);
+               const string_t string = { name, strlen(name) + 1 };
+               current_funcsig = string_to_firm(src_pos, "__FUNCSIG__", &string);
+       }
+
+       return current_funcsig;
+}
+
 static ir_node *statement_expression_to_firm(const statement_expression_t *expr)
 {
        statement_t *statement = expr->statement;
@@ -2769,7 +2784,10 @@ static ir_node *_expression_to_firm(const expression_t *expression)
                return classify_type_to_firm(&expression->classify_type);
        case EXPR_FUNCTION:
        case EXPR_PRETTY_FUNCTION:
+       case EXPR_FUNCDNAME:
                return function_name_to_firm(&expression->string);
+       case EXPR_FUNCSIG:
+               return funcsig_to_firm(&expression->string);
        case EXPR_STATEMENT:
                return statement_expression_to_firm(&expression->statement);
        case EXPR_VA_START:
@@ -4401,6 +4419,8 @@ static int count_decls_in_expression(const expression_t *expression) {
        case EXPR_WIDE_STRING_LITERAL:
        case EXPR_FUNCTION:
        case EXPR_PRETTY_FUNCTION:
+       case EXPR_FUNCSIG:
+       case EXPR_FUNCDNAME:
        case EXPR_BUILTIN_SYMBOL:
        case EXPR_VA_START:
        case EXPR_VA_ARG:
@@ -4617,6 +4637,7 @@ static void create_function(declaration_t *declaration)
 
        current_function_decl = declaration;
        current_function_name = NULL;
+       current_funcsig       = NULL;
 
        assert(imature_blocks == NULL);
        imature_blocks = NEW_ARR_F(ir_node*, 0);

diff --git a/parser.c b/parser.c
index 037084f..26a647c 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -953,7 +953,9 @@ static void parse_gnu_attribute(void)
        while(true) {
                if(token.type != T_IDENTIFIER)
                        break;
-               symbol_t *symbol = token.v.symbol;
+               symbol_t *sym = token.v.symbol;
+               if(sym == sym_deprecated) {
+               }
                next_token();
                if(token.type == '(')
                        eat_until_matching_token('(');
@@ -5824,6 +5826,8 @@ static bool expression_has_effect(const expression_t *const expr)
 
                case EXPR_FUNCTION:                  return false;
                case EXPR_PRETTY_FUNCTION:           return false;
+               case EXPR_FUNCSIG:                   return false;
+               case EXPR_FUNCDNAME:                 return false;
                case EXPR_BUILTIN_SYMBOL:            break; /* handled in EXPR_CALL */
                case EXPR_BUILTIN_CONSTANT_P:        return false;
                case EXPR_BUILTIN_PREFETCH:          return true;

diff --git a/type.c b/type.c
index 8910878..88c52b4 100644 (file)
--- a/type.c
+++ b/type.c
@@ -1029,14 +1029,14 @@ atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size) {
        assert(size < 32);
        atomic_type_kind_t kind = kinds[size];
        if(kind == ATOMIC_TYPE_INVALID) {
-               static const possible_kinds[] = {
+               static const atomic_type_kind_t possible_kinds[] = {
                        ATOMIC_TYPE_SCHAR,
                        ATOMIC_TYPE_SHORT,
                        ATOMIC_TYPE_INT,
                        ATOMIC_TYPE_LONG,
                        ATOMIC_TYPE_LONGLONG
                };
-               for(int i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) {
+               for(unsigned i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) {
                        if(get_atomic_type_size(possible_kinds[i]) == size) {
                                kind = possible_kinds[i];
                                break;
@@ -1056,14 +1056,14 @@ atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size) {
        assert(size < 32);
        atomic_type_kind_t kind = kinds[size];
        if(kind == ATOMIC_TYPE_INVALID) {
-               static const possible_kinds[] = {
+               static const atomic_type_kind_t possible_kinds[] = {
                        ATOMIC_TYPE_UCHAR,
                        ATOMIC_TYPE_USHORT,
                        ATOMIC_TYPE_UINT,
                        ATOMIC_TYPE_ULONG,
                        ATOMIC_TYPE_ULONGLONG
                };
-               for(int i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) {
+               for(unsigned i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) {
                        if(get_atomic_type_size(possible_kinds[i]) == size) {
                                kind = possible_kinds[i];
                                break;