inline is not a type qualifier anymore, fix function entity creation

[r18411]

diff --git a/ast.c b/ast.c
index 3d8c045..901eef1 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -521,6 +521,10 @@ static void print_normal_declaration(const declaration_t *declaration)
        print_storage_class(declaration->storage_class);
        print_type_ext(declaration->type, declaration->symbol,
                       &declaration->context);
+       if(declaration->is_inline) {
+               fputs("inline ", out);
+       }
+
        if(declaration->type->type == TYPE_FUNCTION) {
                if(declaration->init.statement != NULL) {
                        fputs("\n", out);

diff --git a/ast2firm.c b/ast2firm.c
index 8e3b3ac..4a68ed8 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -519,11 +519,10 @@ static ir_entity* get_function_entity(declaration_t *declaration)
        ir_type  *ir_type_method = get_ir_type(declaration->type);
        assert(is_Method_type(ir_type_method));
 
-       type_t    *type   = declaration->type;
        ir_entity *entity = new_entity(global_type, id, ir_type_method);
        set_entity_ld_ident(entity, id);
-       if(declaration->storage_class & STORAGE_CLASS_STATIC
-                       || type->qualifiers & TYPE_QUALIFIER_INLINE) {
+       if(declaration->storage_class == STORAGE_CLASS_STATIC
+                       || declaration->is_inline) {
                set_entity_visibility(entity, visibility_local);
        } else if(declaration->init.statement != NULL) {
                set_entity_visibility(entity, visibility_external_visible);

diff --git a/ast_t.h b/ast_t.h
index 66cddcc..9ff8c13 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -226,6 +226,7 @@ struct declaration_t {
        unsigned char       namespace;
        unsigned char       storage_class;
        unsigned int        address_taken : 1;
+       unsigned int        is_inline     : 1;
        type_t             *type;
        symbol_t           *symbol;
        source_position_t   source_position;

diff --git a/main.c b/main.c
index 802eb35..3660a45 100644 (file)
--- a/main.c
+++ b/main.c
@@ -213,6 +213,8 @@ static void create_firm_prog(translation_unit_t *unit)
 {
        translation_unit_to_firm(unit);
 
+       dump_globals_as_text(dump_verbosity_max, "-globals");
+
        int n_irgs = get_irp_n_irgs();
        for(int i = 0; i < n_irgs; ++i) {
                ir_graph *const irg = get_irp_irg(i);

diff --git a/parser.c b/parser.c
index 0ec8867..5c4ecd7 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -201,6 +201,13 @@ static void parse_error(const char *message)
        fprintf(stderr, "parse error: %s\n", message);
 }
 
+static void parser_print_warning_prefix_pos(
+               const source_position_t source_position)
+{
+       parser_print_prefix_pos(source_position);
+       fputs("warning: ", stderr);
+}
+
 static void parse_warning(const char *message)
 {
        parser_print_prefix_pos(token.source_position);
@@ -644,17 +651,19 @@ static expression_t *parse_assignment_expression(void)
        return parse_sub_expression(2);
 }
 
-static void parse_compound_type_entries(void);
-static declaration_t *parse_declarator(storage_class_t storage_class,
-               type_t *type, int may_be_abstract);
-static declaration_t *record_declaration(declaration_t *declaration);
-
 typedef struct declaration_specifiers_t  declaration_specifiers_t;
 struct declaration_specifiers_t {
        storage_class_t  storage_class;
+       bool             is_inline;
        type_t          *type;
 };
 
+static void parse_compound_type_entries(void);
+static declaration_t *parse_declarator(
+               const declaration_specifiers_t *specifiers, type_t *type,
+               bool may_be_abstract);
+static declaration_t *record_declaration(declaration_t *declaration);
+
 static const char *parse_string_literals(void)
 {
        assert(token.type == T_STRING_LITERAL);
@@ -1123,7 +1132,6 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
                MATCH_TYPE_QUALIFIER(T_const,    TYPE_QUALIFIER_CONST);
                MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
                MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
-               MATCH_TYPE_QUALIFIER(T_inline,   TYPE_QUALIFIER_INLINE);
 
                case T___extension__:
                        /* TODO */
@@ -1156,6 +1164,11 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 #ifdef PROVIDE_IMAGINARY
                MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary")
 #endif
+               case T_inline:
+                       next_token();
+                       specifiers->is_inline = true;
+                       break;
+
                case T_long:
                        next_token();
                        if(type_specifiers & SPECIFIER_LONG_LONG) {
@@ -1372,7 +1385,6 @@ static type_qualifier_t parse_type_qualifiers(void)
                MATCH_TYPE_QUALIFIER(T_const,    TYPE_QUALIFIER_CONST);
                MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
                MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
-               MATCH_TYPE_QUALIFIER(T_inline,   TYPE_QUALIFIER_INLINE);
 
                default:
                        return type_qualifiers;
@@ -1402,8 +1414,8 @@ static declaration_t *parse_parameter(void)
 
        parse_declaration_specifiers(&specifiers);
 
-       declaration_t *declaration = parse_declarator(specifiers.storage_class,
-                                                     specifiers.type, 1);
+       declaration_t *declaration
+               = parse_declarator(&specifiers, specifiers.type, true);
 
        /* TODO check declaration constraints for parameters */
        if(declaration->storage_class == STORAGE_CLASS_TYPEDEF) {
@@ -1719,11 +1731,13 @@ static type_t *construct_declarator_type(construct_type_t *construct_list,
        return type;
 }
 
-static declaration_t *parse_declarator(storage_class_t storage_class,
-               type_t *type, int may_be_abstract)
+static declaration_t *parse_declarator(
+               const declaration_specifiers_t *specifiers,
+               type_t *type, bool may_be_abstract)
 {
        declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-       declaration->storage_class = storage_class;
+       declaration->storage_class = specifiers->storage_class;
+       declaration->is_inline     = specifiers->is_inline;
 
        construct_type_t *construct_type
                = parse_inner_declarator(declaration, may_be_abstract);
@@ -1787,9 +1801,17 @@ static void parse_init_declarators(const declaration_specifiers_t *specifiers)
 {
        while(true) {
                declaration_t *ndeclaration
-                       = parse_declarator(specifiers->storage_class, specifiers->type, 0);
+                       = parse_declarator(specifiers, specifiers->type, false);
 
                declaration_t *declaration = record_declaration(ndeclaration);
+
+               type_t *type = declaration->type;
+               if(type->type != TYPE_FUNCTION && declaration->is_inline) {
+                       parser_print_warning_prefix_pos(declaration->source_position);
+                       fprintf(stderr, "variable ‘%s’ declared ‘inline’\n",
+                               declaration->symbol->string);
+               }
+
                if(token.type == '=') {
                        next_token();
 
@@ -1862,8 +1884,7 @@ static void parse_struct_declarators(const declaration_specifiers_t *specifiers)
                        /* TODO (bitfields) */
                } else {
                        declaration_t *declaration
-                               = parse_declarator(specifiers->storage_class,
-                                                  specifiers->type, 1);
+                               = parse_declarator(specifiers, specifiers->type, true);
 
                        /* TODO: check constraints for struct declarations */
                        /* TODO: check for doubled fields */

diff --git a/type.c b/type.c
index c694cf8..76e9241 100644 (file)
--- a/type.c
+++ b/type.c
@@ -46,7 +46,6 @@ void print_type_qualifiers(unsigned qualifiers)
        if(qualifiers & TYPE_QUALIFIER_CONST)    fputs("const ",    out);
        if(qualifiers & TYPE_QUALIFIER_VOLATILE) fputs("volatile ", out);
        if(qualifiers & TYPE_QUALIFIER_RESTRICT) fputs("restrict ", out);
-       if(qualifiers & TYPE_QUALIFIER_INLINE)   fputs("inline ",   out);
 }
 
 static

diff --git a/type_t.h b/type_t.h
index b47f7b5..58703f4 100644 (file)
--- a/type_t.h
+++ b/type_t.h
@@ -63,7 +63,6 @@ typedef enum {
        TYPE_QUALIFIER_CONST    = 1 << 0,
        TYPE_QUALIFIER_RESTRICT = 1 << 1,
        TYPE_QUALIFIER_VOLATILE = 1 << 2,
-       TYPE_QUALIFIER_INLINE   = 1 << 3,
 } type_qualifier_t;
 
 struct type_t {