X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=bc29eeee6dae656933b28a570da6de041983f950;hb=60dc045e7978b16a7ca18a790c5a8517016e2bbe;hp=9ab4e696fef6ba20c5d85d90c60e4cf89a79b0b9;hpb=839487dfb4a714fa7e66063495ade6a3726040ef;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index 9ab4e696f..bc29eeee6 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -56,27 +56,6 @@ struct _be_abi_call_t {
 	set *params;
 };
 
-#define N_FRAME_TYPES 3
-
-/**
- * This type describes the stack layout.
- * The stack is divided into 3 parts:
- * - arg_type:     A struct type describing the stack arguments and it's order.
- * - between_type: A struct type describing the stack layout between arguments
- *                 and frame type
- * - frame_type:   A class type descibing the frame layout
- */
-typedef struct _be_stack_layout_t {
-	ir_type *arg_type;                 /**< A type describing the stack argument layout. */
-	ir_type *between_type;             /**< A type describing the "between" layout. */
-	ir_type *frame_type;               /**< The frame type. */
-
-	ir_type *order[N_FRAME_TYPES];     /**< arg, between and frame types ordered. */
-
-	int initial_offset;
-	int stack_dir;                     /**< -1 for decreasing, 1 for increasing. */
-} be_stack_layout_t;
-
 struct _be_abi_irg_t {
 	struct obstack       obst;
 	be_stack_layout_t    *frame;        /**< The stack frame model. */
@@ -118,7 +97,7 @@ static const arch_irn_handler_t abi_irn_handler;
 static heights_t *ir_heights;
 
 /* Flag: if set, try to omit the frame pointer if called by the backend */
-int be_omit_fp = 1;
+static int be_omit_fp = 1;
 
 /*
      _    ____ ___    ____      _ _ _                _
@@ -314,11 +293,13 @@ static int stack_frame_compute_initial_offset(be_stack_layout_t *frame)
  * @param between   the between layout type
  * @param locals    the method frame type
  * @param stack_dir the stack direction
+ * @param param_map an array mapping method argument positions to the stack argument type
  *
  * @return the initialized stack layout
  */
 static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *args,
-                                           ir_type *between, ir_type *locals, int stack_dir)
+                                           ir_type *between, ir_type *locals, int stack_dir,
+                                           entity *param_map[])
 {
 	frame->arg_type       = args;
 	frame->between_type   = between;
@@ -326,6 +307,7 @@ static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *ar
 	frame->initial_offset = 0;
 	frame->stack_dir      = stack_dir;
 	frame->order[1]       = between;
+	frame->param_map      = param_map;
 
 	if(stack_dir > 0) {
 		frame->order[0] = args;
@@ -338,6 +320,7 @@ static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *ar
 	return frame;
 }
 
+#if 0
 /** Dumps the stack layout to file. */
 static void stack_layout_dump(FILE *file, be_stack_layout_t *frame)
 {
@@ -354,6 +337,7 @@ static void stack_layout_dump(FILE *file, be_stack_layout_t *frame)
 		}
 	}
 }
+#endif
 
 /**
  * Returns non-zero if the call argument at given position
@@ -748,6 +732,7 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 		ir_node *new_alloc;
 		ir_node *addr;
 		ir_node *copy;
+		ir_node *ins[2];
 
 		foreach_out_edge(alloc, edge) {
 			ir_node *irn = get_edge_src_irn(edge);
@@ -778,10 +763,22 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 		env->call->flags.bits.try_omit_fp = 0;
 		new_alloc = be_new_AddSP(env->isa->sp, irg, bl, curr_sp, get_Alloc_size(alloc));
 
-		exchange(alloc, new_alloc);
+		if(alloc_mem != NULL) {
+			ir_node *addsp_mem;
+			ir_node *sync;
 
-		if(alloc_mem != NULL)
-			set_Proj_proj(alloc_mem, pn_be_AddSP_M);
+			addsp_mem = new_r_Proj(irg, bl, new_alloc, mode_M, pn_be_AddSP_M);
+
+			// We need to sync the output mem of the AddSP with the input mem
+			// edge into the alloc node
+			ins[0] = get_Alloc_mem(alloc);
+			ins[1] = addsp_mem;
+			sync = new_r_Sync(irg, bl, 2, ins);
+
+			exchange(alloc_mem, sync);
+		}
+
+		exchange(alloc, new_alloc);
 
 		/* fix projnum of alloca res */
 		set_Proj_proj(alloc_res, pn_be_AddSP_res);
@@ -800,9 +797,34 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 
 		curr_sp = alloc_res;
 	}
+	return curr_sp;
+}  /* adjust_alloc */
 
+/**
+ * Adjust a Free.
+ * The Free is transformed into a back end free node and connected to the stack nodes.
+ */
+static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
+{
+	if (get_Free_where(free) == stack_alloc) {
+		ir_node *bl        = get_nodes_block(free);
+		ir_graph *irg      = get_irn_irg(bl);
+		ir_node *addsp, *mem, *res;
+		dbg_info *db = get_irn_dbg_info(free);
+
+		/* The stack pointer will be modified in an unknown manner.
+		   We cannot omit it. */
+		env->call->flags.bits.try_omit_fp = 0;
+		addsp = be_new_SubSP(env->isa->sp, irg, bl, curr_sp, get_Free_size(free));
+
+		mem = new_r_Proj(irg, bl, addsp, mode_M, pn_be_SubSP_M);
+		res = new_r_Proj(irg, bl, addsp, mode_P_data, pn_be_SubSP_res);
+
+		exchange(free, mem);
+		curr_sp = res;
+	}
 	return curr_sp;
-}
+}  /* adjust_free */
 
 /* the following function is replaced by the usage of the heights module */
 #if 0
@@ -872,16 +894,20 @@ static int cmp_call_dependecy(const void *c1, const void *c2)
 }
 
 /**
- * Walker: links all Call nodes to the Block they are contained.
+ * Walker: links all Call/alloc/Free nodes to the Block they are contained.
  */
 static void link_calls_in_block_walker(ir_node *irn, void *data)
 {
-	if(is_Call(irn) || (get_irn_opcode(irn) == iro_Alloc && get_Alloc_where(irn) == stack_alloc)) {
+	opcode code = get_irn_opcode(irn);
+
+	if (code == iro_Call ||
+		(code == iro_Alloc && get_Alloc_where(irn) == stack_alloc) ||
+		(code == iro_Free && get_Free_where(irn) == stack_alloc)) {
 		be_abi_irg_t *env = data;
 		ir_node *bl       = get_nodes_block(irn);
 		void *save        = get_irn_link(bl);
 
-		if (is_Call(irn))
+		if (code == iro_Call)
 			env->call->flags.bits.irg_is_leaf = 0;
 
 		set_irn_link(irn, save);
@@ -929,6 +955,9 @@ static void process_calls_in_block(ir_node *bl, void *data)
 			case iro_Alloc:
 				curr_sp = adjust_alloc(env, irn, curr_sp, &copy);
 				break;
+			case iro_Free:
+				curr_sp = adjust_free(env, irn, curr_sp);
+				break;
 			default:
 				break;
 			}
@@ -943,7 +972,7 @@ static void process_calls_in_block(ir_node *bl, void *data)
 	}
 
 	set_irn_link(bl, curr_sp);
-}
+}  /* process_calls_in_block */
 
 /**
  * Adjust all call nodes in the graph to the ABI conventions.
@@ -960,14 +989,6 @@ static void process_calls(be_abi_irg_t *env)
 	heights_free(ir_heights);
 }
 
-static void collect_return_walker(ir_node *irn, void *data)
-{
-	if(get_irn_opcode(irn) == iro_Return) {
-		struct obstack *obst = data;
-		obstack_ptr_grow(obst, irn);
-	}
-}
-
 #if 0 /*
 static ir_node *setup_frame(be_abi_irg_t *env)
 {
@@ -1056,10 +1077,11 @@ static void clearup_frame(be_abi_irg_t *env, ir_node *ret, pmap *reg_map, struct
  * @param env          the ABI environment
  * @param call         the current call ABI
  * @param method_type  the method type
+ * @param param_map    an array mapping method arguments to the stack layout type
  *
  * @return the stack argument layout type
  */
-static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type)
+static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type, entity ***param_map)
 {
 	int dir  = env->call->flags.bits.left_to_right ? 1 : -1;
 	int inc  = env->birg->main_env->arch_env->isa->stack_dir * dir;
@@ -1072,12 +1094,15 @@ static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type
 	int i;
 	ir_type *val_param_tp = get_method_value_param_type(method_type);
 	ident *id = get_entity_ident(get_irg_entity(env->birg->irg));
+	entity **map;
 
+	*param_map = map = obstack_alloc(&env->obst, n * sizeof(entity *));
 	res = new_type_struct(mangle_u(id, new_id_from_chars("arg_type", 8)));
 	for (i = 0; i < n; ++i, curr += inc) {
 		ir_type *param_type    = get_method_param_type(method_type, curr);
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, curr);
 
+		map[i] = NULL;
 		if (arg->on_stack) {
 			if (val_param_tp) {
 				/* the entity was already created, move it to the param type */
@@ -1097,6 +1122,7 @@ static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type
 			set_entity_offset_bytes(arg->stack_ent, ofs);
 			ofs += arg->space_after;
 			ofs += get_type_size_bytes(param_type);
+			map[i] = arg->stack_ent;
 		}
 	}
 	set_type_size_bytes(res, ofs);
@@ -1104,6 +1130,7 @@ static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type
 	return res;
 }
 
+#if 0
 static void create_register_perms(const arch_isa_t *isa, ir_graph *irg, ir_node *bl, pmap *regs)
 {
 	int i, j, n;
@@ -1145,6 +1172,7 @@ static void create_register_perms(const arch_isa_t *isa, ir_graph *irg, ir_node
 
 	obstack_free(&obst, NULL);
 }
+#endif
 
 typedef struct {
 	const arch_register_t *reg;
@@ -1351,7 +1379,7 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i
 
 typedef struct lower_frame_sels_env_t {
 	be_abi_irg_t *env;
-	entity       *value_param_list;  /**< the list of all value param antities */
+	entity       *value_param_list;  /**< the list of all value param entities */
 } lower_frame_sels_env_t;
 
 /**
@@ -1520,6 +1548,7 @@ static void modify_irg(be_abi_irg_t *env)
 	const ir_edge_t *edge;
 	ir_type *arg_type, *bet_type;
 	lower_frame_sels_env_t ctx;
+	entity **param_map;
 
 	bitset_t *used_proj_nr;
 	DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
@@ -1560,9 +1589,9 @@ static void modify_irg(be_abi_irg_t *env)
 		DBG((dbg, LEVEL_2, "\treading arg: %d -> %+F\n", nr, irn));
 	}
 
-	arg_type = compute_arg_type(env, call, method_type);
+	arg_type = compute_arg_type(env, call, method_type, &param_map);
 	bet_type = call->cb->get_between_type(env->cb);
-	stack_frame_init(env->frame, arg_type, bet_type, get_irg_frame_type(irg), isa->stack_dir);
+	stack_frame_init(env->frame, arg_type, bet_type, get_irg_frame_type(irg), isa->stack_dir, param_map);
 
 	/* Count the register params and add them to the number of Projs for the RegParams node */
 	for(i = 0; i < n_params; ++i) {
@@ -1708,16 +1737,6 @@ static void modify_irg(be_abi_irg_t *env)
 	obstack_free(&env->obst, args);
 }
 
-/**
- * Walker: puts all Alloc(stack_alloc) on a obstack
- */
-static void collect_alloca_walker(ir_node *irn, void *data)
-{
-	be_abi_irg_t *env = data;
-	if(get_irn_opcode(irn) == iro_Alloc && get_Alloc_where(irn) == stack_alloc)
-		obstack_ptr_grow(&env->obst, irn);
-}
-
 be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 {
 	be_abi_irg_t *env  = xmalloc(sizeof(env[0]));
@@ -1728,6 +1747,8 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	ir_node *dummy;
 	optimization_state_t state;
 
+	be_omit_fp = birg->main_env->options->omit_fp;
+
 	obstack_init(&env->obst);
 
 	env->isa           = birg->main_env->arch_env->isa;
@@ -1801,6 +1822,10 @@ void be_abi_put_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls,
 			bitset_set(bs, reg->index);
 }
 
+/* Returns the stack layout from a abi environment. */
+const be_stack_layout_t *be_abi_get_stack_layout(const be_abi_irg_t *abi) {
+	return abi->frame;
+}
 
 /*