The standard calls it "file scope", so rename global_scope to file_scope.

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index f3f8f20..86638a7 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -59,6 +59,8 @@ static ir_node        *break_label;
 static ir_node        *current_switch_cond;
 static bool            saw_default_label;
 static declaration_t **all_labels;
+static declaration_t **inner_functions;
+static int             inner_function_idx;
 static ir_node        *ijmp_list;
 static bool            constant_folding;
 
@@ -84,13 +86,34 @@ typedef enum declaration_kind_t {
        DECLARATION_KIND_ENUM_ENTRY,
        DECLARATION_KIND_COMPOUND_TYPE_INCOMPLETE,
        DECLARATION_KIND_COMPOUND_TYPE_COMPLETE,
-       DECLARATION_KIND_TYPE
+       DECLARATION_KIND_TYPE,
+       DECLARATION_KIND_INNER_FUNCTION
 } declaration_kind_t;
 
 static ir_type *get_ir_type(type_t *type);
 static ir_type *get_ir_type_incomplete(type_t *type);
 static int count_decls_in_stmts(const statement_t *stmt);
 
+static void enqueue_inner_function(declaration_t *declaration) {
+       if (inner_functions == NULL) {
+               inner_functions = NEW_ARR_F(declaration_t *, 16);
+               inner_functions[0] = declaration;
+               inner_function_idx = 1;
+       } else {
+               int size = ARR_LEN(inner_functions);
+               if (inner_function_idx >= size) {
+                       ARR_RESIZE(declaration_t *, inner_functions, size + 16);
+               }
+               inner_functions[inner_function_idx++] = declaration;
+       }
+}
+
+static declaration_t *next_inner_function(void) {
+       if (inner_function_idx == 0)
+               return 0;
+       return inner_functions[--inner_function_idx];
+}
+
 ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos)
 {
        const declaration_t *declaration = get_irg_loc_description(irg, pos);
@@ -530,7 +553,7 @@ static ir_type *create_bitfield_type(bitfield_type_t *const type)
        assert(base->kind == TYPE_ATOMIC || base->kind == TYPE_ENUM);
        ir_type *irbase = get_ir_type(base);
 
-       unsigned size = fold_constant(type->size);
+       unsigned size = type->bit_size;
 
        assert(!is_type_float(base));
        if (is_type_signed(base)) {
@@ -650,7 +673,7 @@ static ir_type *create_compound_type(compound_type_t *type, ir_type *irtype,
                size_t base;
                size_t bits_remainder;
                if (entry_type->kind == TYPE_BITFIELD) {
-                       size_t size_bits      = fold_constant(entry_type->bitfield.size);
+                       size_t size_bits      = entry_type->bitfield.bit_size;
                        size_t rest_size_bits = (entry_alignment - misalign)*8 - bit_offset;
 
                        if (size_bits > rest_size_bits) {
@@ -807,7 +830,9 @@ static ir_type *get_ir_type(type_t *type)
        ir_type *firm_type = NULL;
        switch (type->kind) {
        case TYPE_ERROR:
-               panic("error type occurred");
+               /* Happens while constant folding, when there was an error */
+               return create_atomic_type(&type_void->atomic);
+
        case TYPE_ATOMIC:
                firm_type = create_atomic_type(&type->atomic);
                break;
@@ -1036,7 +1061,8 @@ static void handle_gnu_attributes_ent(ir_entity *ent, declaration_t *decl)
  */
 static ir_entity *get_function_entity(declaration_t *declaration)
 {
-       if (declaration->declaration_kind == DECLARATION_KIND_FUNCTION)
+       if (declaration->declaration_kind == DECLARATION_KIND_FUNCTION ||
+           declaration->declaration_kind == DECLARATION_KIND_INNER_FUNCTION)
                return declaration->v.entity;
        assert(declaration->declaration_kind == DECLARATION_KIND_UNKNOWN);
 
@@ -1418,7 +1444,12 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
 
        case DECLARATION_KIND_ENUM_ENTRY: {
                ir_mode *const mode = get_ir_mode(type);
-               return new_Const(mode, declaration->v.enum_val);
+               if (ref->is_outer_ref) {
+                       /* reference to an outer variable */
+                       panic("Outer variable reference not implemented");
+               } else {
+                       return new_Const(mode, declaration->v.enum_val);
+               }
        }
 
        case DECLARATION_KIND_LOCAL_VARIABLE: {
@@ -1429,6 +1460,17 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
                ir_mode *const mode = get_ir_mode(type);
                return create_symconst(dbgi, mode, declaration->v.entity);
        }
+       case DECLARATION_KIND_INNER_FUNCTION: {
+               ir_mode *const mode = get_ir_mode(type);
+               if (! declaration->goto_to_outer && !declaration->need_closure) {
+                       /* inner function not using the closure */
+                       return create_symconst(dbgi, mode, declaration->v.entity);
+               } else {
+                       /* TODO: need trampoline here */
+                       panic("Trampoline code not implemented");
+                       return create_symconst(dbgi, mode, declaration->v.entity);
+               }
+       }
        case DECLARATION_KIND_GLOBAL_VARIABLE: {
                ir_node *const addr   = get_global_var_address(dbgi, declaration);
                return deref_address(dbgi, declaration->type, addr);
@@ -1467,11 +1509,6 @@ static ir_node *reference_addr(const reference_expression_t *ref)
                /* you can store to a local variable (so we don't panic but return NULL
                 * as an indicator for no real address) */
                return NULL;
-       case DECLARATION_KIND_FUNCTION: {
-               type_t *const  type = skip_typeref(ref->base.type);
-               ir_mode *const mode = get_ir_mode(type);
-               return create_symconst(dbgi, mode, declaration->v.entity);
-       }
        case DECLARATION_KIND_GLOBAL_VARIABLE: {
                ir_node *const addr = get_global_var_address(dbgi, declaration);
                return addr;
@@ -1490,6 +1527,8 @@ static ir_node *reference_addr(const reference_expression_t *ref)
        case DECLARATION_KIND_ENUM_ENTRY:
                panic("trying to reference enum entry");
 
+       case DECLARATION_KIND_FUNCTION:
+       case DECLARATION_KIND_INNER_FUNCTION:
        case DECLARATION_KIND_COMPOUND_TYPE_INCOMPLETE:
        case DECLARATION_KIND_COMPOUND_TYPE_COMPLETE:
        case DECLARATION_KIND_COMPOUND_MEMBER:
@@ -2956,7 +2995,7 @@ static ir_node *builtin_prefetch_to_firm(
 
 static ir_node *get_label_block(declaration_t *label)
 {
-       assert(label->namespc == NAMESPACE_LABEL);
+       assert(label->namespc == NAMESPACE_LABEL || label->namespc == NAMESPACE_LOCAL_LABEL);
 
        if (label->declaration_kind == DECLARATION_KIND_LABEL_BLOCK) {
                return label->v.block;
@@ -4128,7 +4167,9 @@ static void create_local_declaration(declaration_t *declaration)
        case STORAGE_CLASS_REGISTER:
                if (is_type_function(type)) {
                        if (declaration->init.statement != NULL) {
-                               panic("nested functions not supported yet");
+                               get_function_entity(declaration);
+                               declaration->declaration_kind = DECLARATION_KIND_INNER_FUNCTION;
+                               enqueue_inner_function(declaration);
                        } else {
                                get_function_entity(declaration);
                        }
@@ -4174,10 +4215,11 @@ static void initialize_local_declaration(declaration_t *declaration)
        case DECLARATION_KIND_FUNCTION:
        case DECLARATION_KIND_TYPE:
        case DECLARATION_KIND_ENUM_ENTRY:
+       case DECLARATION_KIND_INNER_FUNCTION:
                return;
 
        case DECLARATION_KIND_UNKNOWN:
-               panic("can't initialize unknwon declaration");
+               panic("can't initialize unknown declaration");
        }
        panic("invalid declaration kind");
 }
@@ -4376,12 +4418,13 @@ static void for_statement_to_firm(for_statement_t *statement)
        for( ; declaration != NULL; declaration = declaration->next) {
                create_local_declaration(declaration);
        }
-       declaration = statement->scope.declarations;
-       for( ; declaration != NULL; declaration = declaration->next) {
-               initialize_local_declaration(declaration);
-       }
 
        if (get_cur_block() != NULL) {
+               declaration = statement->scope.declarations;
+               for( ; declaration != NULL; declaration = declaration->next) {
+                       initialize_local_declaration(declaration);
+               }
+
                if (statement->initialisation != NULL) {
                        expression_to_firm(statement->initialisation);
                }
@@ -4572,7 +4615,7 @@ static void switch_statement_to_firm(switch_statement_t *statement)
 
 static void case_label_to_firm(const case_label_statement_t *statement)
 {
-       if (statement->is_empty)
+       if (statement->is_empty_range)
                return;
 
        dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
@@ -4643,9 +4686,14 @@ static void goto_to_firm(const goto_statement_t *statement)
                set_irn_link(ijmp, ijmp_list);
                ijmp_list = ijmp;
        } else {
-               ir_node *block = get_label_block(statement->label);
-               ir_node *jmp   = new_Jmp();
-               add_immBlock_pred(block, jmp);
+               if (statement->outer_fkt_jmp) {
+                       /* TODO: this is a outer function jmp */
+                       panic("outer function jump not implemented");
+               } else {
+                       ir_node *block = get_label_block(statement->label);
+                       ir_node *jmp   = new_Jmp();
+                       add_immBlock_pred(block, jmp);
+               }
        }
        set_cur_block(NULL);
 }
@@ -5078,6 +5126,7 @@ static int count_decls_in_expression(const expression_t *expression) {
        case EXPR_BUILTIN_SYMBOL:
        case EXPR_VA_START:
        case EXPR_VA_ARG:
+       case EXPR_LABEL_ADDRESS:
                break;
        }
 
@@ -5500,6 +5549,10 @@ static void scope_to_firm(scope_t *scope)
                type_t *type = declaration->type;
                if (type->kind == TYPE_FUNCTION) {
                        create_function(declaration);
+                       declaration_t *inner;
+                       for (inner = next_inner_function(); inner != NULL;
+                            inner = next_inner_function())
+                                create_function(inner);
                } else {
                        assert(declaration->declaration_kind
                                        == DECLARATION_KIND_GLOBAL_VARIABLE);