X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=5dd66e6be29afe0bd2e4f8b46d1ef65e3fa6b900;hb=b269a558ba158e761c06161b14e4208c85a07955;hp=f45b0b8c0dba5f04cfb31bfb7c254a2d823df8ec;hpb=868c8b47eb3e9b006a4cd7dcdc4df2cdb32dc955;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index f45b0b8c0..5dd66e6be 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -444,7 +444,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		 * moving the stack pointer along the stack's direction.
 		 */
 		if(stack_dir < 0 && !do_seq && !no_alloc) {
-			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, stack_size, be_stack_dir_along);
+			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, stack_size, be_stack_dir_expand);
 		}
 
 		assert(mode_is_reference(mach_mode) && "machine mode must be pointer");
@@ -490,7 +490,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 			*/
 			if(do_seq) {
 				curr_ofs = 0;
-				curr_sp  = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, param_size, be_stack_dir_along);
+				curr_sp  = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, param_size, be_stack_dir_expand);
 				curr_mem = mem;
 			}
 		}
@@ -536,7 +536,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 					unspeakable Proj_T from the Call. Therefore, all real argument
 					Proj numbers must be increased by pn_Call_max
 				*/
-		   		proj += pn_Call_max;
+				proj += pn_Call_max;
 				set_Proj_proj(res, proj);
 				obstack_ptr_grow(obst, res);
 
@@ -565,9 +565,11 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
 	}
 
-	else
+  else
 		low_call = be_new_Call(irg, bl, curr_mem, curr_sp, call_ptr, curr_res_proj + pset_count(caller_save), n_low_args, in);
 
+  set_irn_dbg_info(low_call, get_irn_dbg_info(irn));
+
 	/*
 		TODO:
 		Set the register class of the call address to the same as the stack pointer's.
@@ -645,7 +647,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
 		 /* Clean up the stack frame if we allocated it */
 		if(!no_alloc)
-			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, mem_proj, stack_size, be_stack_dir_against);
+			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, mem_proj, stack_size, be_stack_dir_shrink);
 	}
 
 	be_abi_call_free(call);
@@ -662,7 +664,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
  */
 static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
 {
-	if(get_Alloc_where(alloc) == stack_alloc) {
+	if (get_Alloc_where(alloc) == stack_alloc) {
 		ir_node *bl        = get_nodes_block(alloc);
 		ir_graph *irg      = get_irn_irg(bl);
 		ir_node *alloc_mem = NULL;
@@ -691,6 +693,9 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 			}
 		}
 
+    /* TODO: Beware: currently Alloc nodes without a result might happen,
+       only escape analysis kills them and this phase runs only for object
+       oriented source. So this must be fixed. */
 		assert(alloc_res != NULL);
 		exchange(alloc_res, env->isa->stack_dir < 0 ? new_alloc : curr_sp);
 
@@ -864,7 +869,7 @@ static ir_node *setup_frame(be_abi_irg_t *env)
 	int stack_nr       = get_Proj_proj(stack);
 
 	if(flags.try_omit_fp) {
-		stack = be_new_IncSP(sp, irg, bl, stack, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+		stack = be_new_IncSP(sp, irg, bl, stack, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_expand);
 		frame = stack;
 	}
 
@@ -878,7 +883,7 @@ static ir_node *setup_frame(be_abi_irg_t *env)
 			arch_set_irn_register(env->birg->main_env->arch_env, frame, bp);
 		}
 
-		stack = be_new_IncSP(sp, irg, bl, stack, frame, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+		stack = be_new_IncSP(sp, irg, bl, stack, frame, BE_STACK_FRAME_SIZE, be_stack_dir_expand);
 	}
 
 	be_node_set_flags(env->reg_params, -(stack_nr + 1), arch_irn_flags_ignore);
@@ -903,7 +908,7 @@ static void clearup_frame(be_abi_irg_t *env, ir_node *ret, pmap *reg_map, struct
 	pmap_entry *ent;
 
 	if(env->call->flags.bits.try_omit_fp) {
-		stack = be_new_IncSP(sp, irg, bl, stack, ret_mem, BE_STACK_FRAME_SIZE, be_stack_dir_against);
+		stack = be_new_IncSP(sp, irg, bl, stack, ret_mem, BE_STACK_FRAME_SIZE, be_stack_dir_shrink);
 	}
 
 	else {
@@ -1037,7 +1042,7 @@ static reg_node_map_t *reg_map_to_arr(struct obstack *obst, pmap *reg_map)
 static void create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *regs, int in_req)
 {
 	ir_graph *irg = env->birg->irg;
-	int i, n;
+	int n;
 	int n_regs = pmap_count(regs);
 	ir_node *irn;
 	ir_node **in;
@@ -1045,8 +1050,8 @@ static void create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *
 
 	rm = reg_map_to_arr(&env->obst, regs);
 
-	for(i = 0, n = 0; i < n_regs; ++i, ++n)
-		obstack_ptr_grow(&env->obst, rm[i].irn);
+	for(n = 0; n < n_regs; ++n)
+		obstack_ptr_grow(&env->obst, rm[n].irn);
 
 	if(mem) {
 		obstack_ptr_grow(&env->obst, *mem);
@@ -1062,7 +1067,7 @@ static void create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *
 		ir_node *proj;
 		const arch_register_t *reg = rm[n].reg;
 
-		proj = new_r_Proj(env->birg->irg, bl, irn, get_irn_mode(rm[i].irn), n);
+		proj = new_r_Proj(env->birg->irg, bl, irn, get_irn_mode(rm[n].irn), n);
 		be_node_set_reg_class(irn, n, reg->reg_class);
 		if(in_req)
 			be_set_constr_single_reg(irn, n, reg);
@@ -1217,7 +1222,7 @@ static void modify_irg(be_abi_irg_t *env)
 	create_barrier(env, bl, &mem, env->regs, 0);
 
 	env->init_sp  = be_abi_reg_map_get(env->regs, sp);
-	env->init_sp  = be_new_IncSP(sp, irg, bl, env->init_sp, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+	env->init_sp  = be_new_IncSP(sp, irg, bl, env->init_sp, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_expand);
 	arch_set_irn_register(env->birg->main_env->arch_env, env->init_sp, sp);
 	be_abi_reg_map_set(env->regs, sp, env->init_sp);
 	frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
@@ -1335,7 +1340,7 @@ static void modify_irg(be_abi_irg_t *env)
 			}
 
 			/* The in array for the new back end return is now ready. */
-			ret = be_new_Return(irg, bl, n, in);
+			ret = be_new_Return(get_irn_dbg_info(irn), irg, bl, n, in);
 
 			/* Set the register classes of the return's parameter accordingly. */
 			for(i = 0; i < n; ++i)
@@ -1349,6 +1354,7 @@ static void modify_irg(be_abi_irg_t *env)
 		}
 	}
 
+	del_pset(dont_save);
 	obstack_free(&env->obst, args);
 }
 
@@ -1378,9 +1384,9 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 
 	env->dce_survivor     = new_survive_dce();
 	env->birg             = birg;
-	env->dbg              = firm_dbg_register("firm.be.abi");
 	env->stack_phis       = pset_new_ptr(16);
 	env->init_sp = dummy  = new_r_Unknown(irg, env->isa->sp->reg_class->mode);
+	FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
 
 	env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg);
 
@@ -1461,14 +1467,14 @@ void be_abi_fix_stack_nodes(be_abi_irg_t *env)
 }
 
 /**
- * Translates a direction of an IncSP node (either be_stack_dir_against, or ...along)
+ * Translates a direction of an IncSP node (either be_stack_dir_shrink, or ...expand)
  * into -1 or 1, respectively.
  * @param irn The node.
  * @return 1, if the direction of the IncSP was along, -1 if against.
  */
 static int get_dir(ir_node *irn)
 {
-	return 1 - 2 * (be_get_IncSP_direction(irn) == be_stack_dir_against);
+	return 1 - 2 * (be_get_IncSP_direction(irn) == be_stack_dir_shrink);
 }
 
 static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)