X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=401503c5c3adf2e346dd2bbf4b55733051fe412b;hb=b9d45e08e23bcf058fa8f2d9e18dd78e8cccd044;hp=55aab003d93292e17560aa693acbbc306dc3579d;hpb=86bdbc083cc46d7cffc7b5685c81c5c9203edf23;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index 55aab003d..401503c5c 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. */
@@ -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;
@@ -815,9 +797,33 @@ 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;
 
+		/* 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
@@ -887,16 +893,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);
@@ -944,6 +954,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;
 			}
@@ -958,7 +971,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.
@@ -1063,10 +1076,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;
@@ -1079,12 +1093,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 */
@@ -1104,6 +1121,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);
@@ -1360,7 +1378,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;
 
 /**
@@ -1529,6 +1547,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;)
@@ -1569,9 +1588,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) {
@@ -1802,6 +1821,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;
+}
 
 /*