X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ast2firm.c;h=f124790e236b4b14c8ee43f8b52a4615658fb3ad;hb=69bda5cf31457ea843bc4c6e3c13ed751a673b7f;hp=ccb3ebc390933cdb6f352c5aebc6a6acd193772b;hpb=c4004b40b7e11ae7ff32c26b330e5f33a7abe2d3;p=cparser

diff --git a/ast2firm.c b/ast2firm.c
index ccb3ebc..f124790 100644
--- 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");
 }