X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=5ec10b4f709d4a82c2aa63b325b8d87d065a0894;hb=c3bca446c415740a35b343ae9d23f0f431561cb8;hp=0c7fe10d7942825eac631bd1fafabdc93650b11f;hpb=bde3c6e26bff65fcee2f6142a9f865cc19d7abd0;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index 0c7fe10d7..5ec10b4f7 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -362,6 +362,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	int                    *reg_param_idxs;
 	int                    *stack_param_idx;
 	int                     i, n, destroy_all_regs;
+	int                     throws_exception;
 	size_t                  s;
 	size_t                  p;
 	dbg_info               *dbgi;
@@ -470,7 +471,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
 			/* Insert a store for primitive arguments. */
 			if (is_atomic_type(param_type)) {
-				ir_node *mem_input = do_seq ? curr_mem : new_r_NoMem(irg);
+				ir_node *nomem     = get_irg_no_mem(irg);
+				ir_node *mem_input = do_seq ? curr_mem : nomem;
 				ir_node *store     = new_rd_Store(dbgi, bl, mem_input, addr, param, cons_none);
 				mem   = new_r_Proj(store, mode_M, pn_Store_M);
 			} else {
@@ -590,6 +592,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	assert(n_ins == (int) (n_reg_params + ARR_LEN(states)));
 
 	/* ins collected, build the call */
+	throws_exception = ir_throws_exception(irn);
 	if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
 		/* direct call */
 		low_call = be_new_Call(dbgi, irg, bl, curr_mem, curr_sp, curr_sp,
@@ -602,6 +605,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		                       n_reg_results + pn_be_Call_first_res + ARR_LEN(destroyed_regs),
 		                       n_ins, in, get_Call_type(irn));
 	}
+	ir_set_throws_exception(low_call, throws_exception);
 	be_Call_set_pop(low_call, call->pop);
 
 	/* put the call into the list of all calls for later processing */
@@ -615,9 +619,9 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
 	/* now handle results */
 	for (i = 0; i < n_res; ++i) {
-		int pn;
 		ir_node           *proj = res_projs[i];
 		be_abi_call_arg_t *arg  = get_call_arg(call, 1, i, 0);
+		long               pn   = i + pn_be_Call_first_res;
 
 		/* returns values on stack not supported yet */
 		assert(arg->in_reg);
@@ -752,7 +756,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		}
 
 		if (! mem_proj) {
-			mem_proj = new_r_Proj(low_call, mode_M, pn_be_Call_M_regular);
+			mem_proj = new_r_Proj(low_call, mode_M, pn_be_Call_M);
 			keep_alive(mem_proj);
 		}
 	}
@@ -1509,6 +1513,7 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_graph *irg,
 		/* the new memory Proj gets the last Proj from store */
 		set_Proj_pred(nmem, store);
 		set_Proj_proj(nmem, pn_Store_M);
+		set_nodes_block(nmem, get_nodes_block(store));
 
 		/* move all entities to the frame type */
 		frame_tp = get_irg_frame_type(irg);
@@ -1555,7 +1560,22 @@ static void fix_start_block(ir_graph *irg)
 
 	assert(is_Proj(initial_X));
 	exchange(initial_X, jmp);
-	set_irg_initial_exec(irg, new_r_Bad(irg));
+	set_irg_initial_exec(irg, new_r_Bad(irg, mode_X));
+
+	/* merge start block with successor if possible */
+	{
+		const ir_edge_t *edge;
+		foreach_out_edge(jmp, edge) {
+			ir_node *succ = get_edge_src_irn(edge);
+			if (!is_Block(succ))
+				continue;
+
+			if (get_irn_arity(succ) == 1) {
+				exchange(succ, start_block);
+			}
+			break;
+		}
+	}
 }
 
 /**
@@ -1861,8 +1881,9 @@ static void modify_irg(ir_graph *irg)
 				if (is_atomic_type(param_type) && get_irn_n_edges(args[i]) > 0) {
 					ir_mode *mode      = get_type_mode(param_type);
 					ir_mode *load_mode = arg->load_mode;
+					ir_node *nomem     = get_irg_no_mem(irg);
 
-					ir_node *load = new_r_Load(start_bl, new_r_NoMem(irg), addr, load_mode, cons_floats);
+					ir_node *load = new_r_Load(start_bl, nomem, addr, load_mode, cons_floats);
 					repl = new_r_Proj(load, load_mode, pn_Load_res);
 
 					if (mode != load_mode) {
@@ -1891,7 +1912,7 @@ static void modify_irg(ir_graph *irg)
 	/* the arg proj is not needed anymore now and should be only used by the anchor */
 	assert(get_irn_n_edges(arg_tuple) == 1);
 	kill_node(arg_tuple);
-	set_irg_args(irg, new_r_Bad(irg));
+	set_irg_args(irg, new_r_Bad(irg, mode_T));
 
 	/* All Return nodes hang on the End node, so look for them there. */
 	end = get_irg_end_block(irg);
@@ -2096,14 +2117,14 @@ static void fix_pic_symconsts(ir_node *node, void *data)
 		/* we need an extra indirection for global data outside our current
 		   module. The loads are always safe and can therefore float
 		   and need no memory input */
-		load     = new_r_Load(block, new_r_NoMem(irg), add, mode, cons_floats);
+		load     = new_r_Load(block, get_irg_no_mem(irg), add, mode, cons_floats);
 		load_res = new_r_Proj(load, mode, pn_Load_res);
 
 		set_irn_n(node, i, load_res);
 	}
 }
 
-be_abi_irg_t *be_abi_introduce(ir_graph *irg)
+void be_abi_introduce(ir_graph *irg)
 {
 	be_abi_irg_t     *env         = XMALLOCZ(be_abi_irg_t);
 	ir_node          *old_frame   = get_irg_frame(irg);
@@ -2142,6 +2163,8 @@ be_abi_irg_t *be_abi_introduce(ir_graph *irg)
 	env->init_sp = dummy;
 	env->calls   = NEW_ARR_F(ir_node*, 0);
 
+	edges_assure(irg);
+
 	if (options->pic) {
 		irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
 	}
@@ -2167,7 +2190,8 @@ be_abi_irg_t *be_abi_introduce(ir_graph *irg)
 	exchange(dummy, env->init_sp);
 	exchange(old_frame, get_irg_frame(irg));
 
-	return env;
+	pmap_destroy(env->regs);
+	env->regs = NULL;
 }
 
 void be_abi_free(ir_graph *irg)
@@ -2176,35 +2200,12 @@ void be_abi_free(ir_graph *irg)
 
 	if (env->call != NULL)
 		be_abi_call_free(env->call);
-	if (env->regs != NULL)
-		pmap_destroy(env->regs);
+	assert(env->regs == NULL);
 	free(env);
 
 	be_set_irg_abi(irg, NULL);
 }
 
-/**
- * called after nodes have been transformed so some node references can be
- * replaced with new nodes
- */
-void be_abi_transform_fixup(ir_graph *irg)
-{
-	be_abi_irg_t *abi = be_get_irg_abi(irg);
-	pmap         *new_regs;
-	pmap_entry   *entry;
-	if (abi == NULL || abi->regs == NULL)
-		return;
-
-	new_regs = pmap_create();
-	foreach_pmap(abi->regs, entry) {
-		ir_node *value       = (ir_node*)entry->value;
-		ir_node *transformed = be_transform_node(value);
-		pmap_insert(new_regs, entry->key, transformed);
-	}
-	pmap_destroy(abi->regs);
-	abi->regs = new_regs;
-}
-
 void be_put_allocatable_regs(const ir_graph *irg,
                              const arch_register_class_t *cls, bitset_t *bs)
 {
@@ -2245,22 +2246,7 @@ void be_set_allocatable_regs(const ir_graph *irg,
 	}
 }
 
-ir_node *be_abi_get_callee_save_irn(ir_graph *irg, const arch_register_t *reg)
-{
-	const be_abi_irg_t *abi = be_get_irg_abi(irg);
-	assert(reg->type & arch_register_type_callee_save);
-	assert(pmap_contains(abi->regs, (void *) reg));
-	return (ir_node*)pmap_get(abi->regs, (void *) reg);
-}
-
-ir_node *be_abi_get_ignore_irn(ir_graph *irg, const arch_register_t *reg)
-{
-	const be_abi_irg_t *abi = be_get_irg_abi(irg);
-	assert(pmap_contains(abi->regs, (void *) reg));
-	return (ir_node*)pmap_get(abi->regs, (void *) reg);
-}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_abi);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_abi)
 void be_init_abi(void)
 {
 	FIRM_DBG_REGISTER(dbg, "firm.be.abi");