update make_release.sh

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index ccb3ebc..f124790 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -82,8 +82,6 @@ static ir_node   *ijmp_list;
 static bool       constant_folding;
 static bool       initializer_use_bitfield_basetype;
 
-extern bool       have_const_functions;
-
 static const entity_t     *current_function_entity;
 static ir_node            *current_function_name;
 static ir_node            *current_funcsig;
@@ -901,7 +899,6 @@ static void handle_decl_modifiers(ir_entity *irentity, entity_t *entity)
                }
                if (modifiers & DM_CONST) {
                        add_entity_additional_properties(irentity, mtp_property_const);
-                       have_const_functions = true;
                }
        }
        if (modifiers & DM_USED) {
@@ -1068,16 +1065,14 @@ entity_created:
  * Creates a SymConst for a given entity.
  *
  * @param dbgi    debug info
- * @param mode    the (reference) mode for the SymConst
  * @param entity  the entity
  */
-static ir_node *create_symconst(dbg_info *dbgi, ir_mode *mode,
-                                ir_entity *entity)
+static ir_node *create_symconst(dbg_info *dbgi, ir_entity *entity)
 {
        assert(entity != NULL);
        union symconst_symbol sym;
        sym.entity_p = entity;
-       return new_d_SymConst(dbgi, mode, sym, symconst_addr_ent);
+       return new_d_SymConst(dbgi, mode_P, sym, symconst_addr_ent);
 }
 
 static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode)
@@ -1139,7 +1134,7 @@ static ir_node *wide_string_literal_to_firm(
        }
        set_entity_initializer(entity, initializer);
 
-       return create_symconst(dbgi, mode_P_data, entity);
+       return create_symconst(dbgi, entity);
 }
 
 /**
@@ -1182,7 +1177,7 @@ static ir_node *string_to_firm(const source_position_t *const src_pos,
        }
        set_entity_initializer(entity, initializer);
 
-       return create_symconst(dbgi, mode_P_data, entity);
+       return create_symconst(dbgi, entity);
 }
 
 static bool try_create_integer(literal_expression_t *literal,
@@ -1422,7 +1417,7 @@ static ir_node *create_trampoline(dbg_info *dbgi, ir_mode *mode,
        assert(entity != NULL);
        ir_node *in[3];
        in[0] = get_trampoline_region(dbgi, entity);
-       in[1] = create_symconst(dbgi, mode, entity);
+       in[1] = create_symconst(dbgi, entity);
        in[2] = get_irg_frame(current_ir_graph);
 
        ir_node *irn = new_d_Builtin(dbgi, get_store(), 3, in, ir_bk_inner_trampoline, get_unknown_type());
@@ -1487,25 +1482,6 @@ static ir_node *do_strict_conv(dbg_info *dbgi, ir_node *node)
        return new_d_strictConv(dbgi, node, mode);
 }
 
-/**
- * Returns the address of a global variable.
- *
- * @param dbgi      debug info
- * @param variable  the variable
- */
-static ir_node *get_global_var_address(dbg_info *const dbgi,
-                                       const variable_t *const variable)
-{
-       ir_entity *const irentity = variable->v.entity;
-       if (variable->thread_local) {
-               ir_node *const no_mem = new_NoMem();
-               ir_node *const tls    = get_irg_tls(current_ir_graph);
-               return new_d_simpleSel(dbgi, no_mem, tls, irentity);
-       } else {
-               return create_symconst(dbgi, mode_P_data, irentity);
-       }
-}
-
 /**
  * Returns the correct base address depending on whether it is a parameter or a
  * normal local variable.
@@ -1590,14 +1566,13 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
                return create_conv(NULL, value, get_ir_mode_arithmetic(type));
        }
        case DECLARATION_KIND_FUNCTION: {
-               ir_mode *const mode = get_ir_mode_storage(type);
-               return create_symconst(dbgi, mode, entity->function.irentity);
+               return create_symconst(dbgi, entity->function.irentity);
        }
        case DECLARATION_KIND_INNER_FUNCTION: {
                ir_mode *const mode = get_ir_mode_storage(type);
                if (!entity->function.goto_to_outer && !entity->function.need_closure) {
                        /* inner function not using the closure */
-                       return create_symconst(dbgi, mode, entity->function.irentity);
+                       return create_symconst(dbgi, entity->function.irentity);
                } else {
                        /* need trampoline here */
                        return create_trampoline(dbgi, mode, entity->function.irentity);
@@ -1605,7 +1580,7 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
        }
        case DECLARATION_KIND_GLOBAL_VARIABLE: {
                const variable_t *variable = &entity->variable;
-               ir_node *const addr = get_global_var_address(dbgi, variable);
+               ir_node *const addr = create_symconst(dbgi, variable->v.entity);
                return deref_address(dbgi, variable->base.type, addr);
        }
 
@@ -1647,7 +1622,7 @@ static ir_node *reference_addr(const reference_expression_t *ref)
                 * as an indicator for no real address) */
                return NULL;
        case DECLARATION_KIND_GLOBAL_VARIABLE: {
-               ir_node *const addr = get_global_var_address(dbgi, &entity->variable);
+               ir_node *const addr = create_symconst(dbgi, entity->variable.v.entity);
                return addr;
        }
        case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: {
@@ -1669,9 +1644,7 @@ static ir_node *reference_addr(const reference_expression_t *ref)
                return entity->variable.v.vla_base;
 
        case DECLARATION_KIND_FUNCTION: {
-               type_t  *const type = skip_typeref(entity->declaration.type);
-               ir_mode *const mode = get_ir_mode_storage(type);
-               return create_symconst(dbgi, mode, entity->function.irentity);
+               return create_symconst(dbgi, entity->function.irentity);
        }
 
        case DECLARATION_KIND_INNER_FUNCTION: {
@@ -1679,7 +1652,7 @@ static ir_node *reference_addr(const reference_expression_t *ref)
                ir_mode *const mode = get_ir_mode_storage(type);
                if (!entity->function.goto_to_outer && !entity->function.need_closure) {
                        /* inner function not using the closure */
-                       return create_symconst(dbgi, mode, entity->function.irentity);
+                       return create_symconst(dbgi, entity->function.irentity);
                } else {
                        /* need trampoline here */
                        return create_trampoline(dbgi, mode, entity->function.irentity);
@@ -2517,7 +2490,7 @@ static ir_node *handle_assume(dbg_info *dbi, const expression_t *expression)
        }
 }
 
-static ir_node *create_cast(dbg_info *dbgi,    ir_node *value_node,
+static ir_node *create_cast(dbg_info *dbgi, ir_node *value_node,
                             type_t *from_type, type_t *type)
 {
        type = skip_typeref(type);
@@ -2540,12 +2513,12 @@ static ir_node *create_cast(dbg_info *dbgi,     ir_node *value_node,
                const variable_t *to_var   = type->pointer.base_variable;
                if (from_var != to_var) {
                        if (from_var != NULL) {
-                               ir_node *const addr = get_global_var_address(dbgi, from_var);
+                               ir_node *const addr = create_symconst(dbgi, from_var->v.entity);
                                ir_node *const base = deref_address(dbgi, from_var->base.type, addr);
                                value_node = new_d_Add(dbgi, value_node, base, get_ir_mode_storage(from_type));
                        }
                        if (to_var != NULL) {
-                               ir_node *const addr = get_global_var_address(dbgi, to_var);
+                               ir_node *const addr = create_symconst(dbgi, to_var->v.entity);
                                ir_node *const base = deref_address(dbgi, to_var->base.type, addr);
                                value_node = new_d_Sub(dbgi, value_node, base, mode);
                        }
@@ -2603,7 +2576,7 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
                /* check for __based */
                const variable_t *const base_var = value_type->pointer.base_variable;
                if (base_var != NULL) {
-                       ir_node *const addr = get_global_var_address(dbgi, base_var);
+                       ir_node *const addr = create_symconst(dbgi, base_var->v.entity);
                        ir_node *const base = deref_address(dbgi, base_var->base.type, addr);
                        value_node = new_d_Add(dbgi, value_node, base, get_ir_mode_storage(value_type));
                }
@@ -4435,7 +4408,7 @@ static void create_local_initializer(initializer_t *initializer, dbg_info *dbgi,
 
        set_entity_initializer(init_entity, irinitializer);
 
-       ir_node *const src_addr = create_symconst(dbgi, mode_P_data, init_entity);
+       ir_node *const src_addr = create_symconst(dbgi, init_entity);
        ir_node *const copyb    = new_d_CopyB(dbgi, memory, addr, src_addr, irtype);
 
        ir_node *const copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M);
@@ -5504,13 +5477,13 @@ static void asm_statement_to_firm(const asm_statement_t *statement)
        }
 }
 
-static void    ms_try_statement_to_firm(ms_try_statement_t *statement)
+static void ms_try_statement_to_firm(ms_try_statement_t *statement)
 {
        statement_to_firm(statement->try_statement);
        warningf(&statement->base.source_position, "structured exception handling ignored");
 }
 
-static void    leave_statement_to_firm(leave_statement_t *statement)
+static void leave_statement_to_firm(leave_statement_t *statement)
 {
        errorf(&statement->base.source_position, "__leave not supported yet");
 }