X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbestate.c;h=8e819fd76cf2fe7f4a34264476ee95d6d9e63962;hb=7c4e33eb7648d9e1cc7efcffc8682a2f27a570a3;hp=57eb30e97926a049fa3ee6859b1b23273453003c;hpb=4d5c3365a58cba59993045a9e08e686d8ae079a7;p=libfirm

diff --git a/ir/be/bestate.c b/ir/be/bestate.c
index 57eb30e97..8e819fd76 100644
--- a/ir/be/bestate.c
+++ b/ir/be/bestate.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -24,8 +24,6 @@
  * @author      Matthias Braun
  * @date        26.03.2007
  * @version     $Id$
- * Copyright:   (c) Universitaet Karlsruhe
- * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -41,9 +39,12 @@
 #include "iredges_t.h"
 #include "ircons_t.h"
 #include "irgmod.h"
+#include "irnodeset.h"
+#include "irnodemap.h"
+#include "adt/cpset.h"
 
 #include "bearch_t.h"
-#include "beuses_t.h"
+#include "beuses.h"
 #include "besched_t.h"
 #include "belive_t.h"
 #include "bemodule.h"
@@ -68,6 +69,7 @@ typedef struct minibelady_env_t {
 	create_reload_func     create_reload;
 	create_spill_func      create_spill;
 	spill_info_t          *spills;
+	ir_nodemap_t           spill_infos;
 
 	be_uses_t             *uses;           /**< env for the next-use magic */
 } minibelady_env_t;
@@ -83,6 +85,7 @@ block_info_t *new_block_info(struct obstack *obst, ir_node *block)
 	block_info_t *res = obstack_alloc(obst, sizeof(*res));
 	memset(res, 0, sizeof(res[0]));
 
+	assert(is_Block(block));
 	set_irn_link(block, res);
 	mark_irn_visited(block);
 
@@ -104,8 +107,8 @@ spill_info_t *create_spill_info(minibelady_env_t *env, ir_node *state)
 	spill_info->value = state;
 	spill_info->reloads = NEW_ARR_F(ir_node*, 0);
 
-	set_irn_link(state, spill_info);
-	mark_irn_visited(state);
+	ir_nodemap_insert(&env->spill_infos, state, spill_info);
+	//ir_fprintf(stderr, "Insert %+F -> %p\n", state, spill_info);
 
 	spill_info->next = env->spills;
 	env->spills = spill_info;
@@ -113,6 +116,15 @@ spill_info_t *create_spill_info(minibelady_env_t *env, ir_node *state)
 	return spill_info;
 }
 
+static INLINE
+spill_info_t *get_spill_info(minibelady_env_t *env, const ir_node *node)
+{
+	spill_info_t *spill_info
+		= (spill_info_t*) ir_nodemap_get(&env->spill_infos, node);
+	//ir_fprintf(stderr, "Get %+F -> %p\n", node, spill_info);
+	return spill_info;
+}
+
 static
 spill_info_t *create_spill(minibelady_env_t *env, ir_node *state, int force)
 {
@@ -120,12 +132,11 @@ spill_info_t *create_spill(minibelady_env_t *env, ir_node *state, int force)
 	ir_node *next;
 	ir_node *after;
 
-	if(irn_visited(state)) {
-		spill_info = (spill_info_t*) get_irn_link(state);
-		if(spill_info->spill != NULL || !force)
-			return spill_info;
-	} else {
+	spill_info = get_spill_info(env, state);
+	if(spill_info == NULL) {
 		spill_info = create_spill_info(env, state);
+	} else if(spill_info->spill != NULL) {
+		return spill_info;
 	}
 
 	if(sched_is_scheduled(state)) {
@@ -166,8 +177,8 @@ void spill_phi(minibelady_env_t *env, ir_node *phi)
 	spill_info_t *spill_info;
 
 	/* does a spill exist for the phis value? */
-	if(irn_visited(phi)) {
-		spill_info = (spill_info_t*) get_irn_link(phi);
+	spill_info = get_spill_info(env, phi);
+	if(spill_info != NULL) {
 		spill_to_kill = spill_info->spill;
 	} else {
 		spill_info = create_spill_info(env, phi);
@@ -175,7 +186,7 @@ void spill_phi(minibelady_env_t *env, ir_node *phi)
 
 	/* create a new phi-M with bad preds */
 	for(i = 0; i < arity; ++i) {
-		in[i] = new_r_Bad(irg);
+		in[i] = new_r_Unknown(irg, mode_M);
 	}
 
 	DBG((dbg, LEVEL_2, "\tcreate Phi-M for %+F\n", phi));
@@ -304,6 +315,9 @@ block_info_t *compute_block_start_state(minibelady_env_t *env, ir_node *block)
 	be_lv_foreach(env->lv, block, be_lv_state_in, i) {
 		node = be_lv_get_irn(env->lv, block, i);
 
+		if(!mode_is_data(get_irn_mode(node)))
+			continue;
+
 		if (arch_get_irn_register(env->arch_env, node) != env->reg)
 			continue;
 
@@ -389,9 +403,13 @@ void belady(minibelady_env_t *env, ir_node *block)
 		/* check which state is desired for the node */
 		arity = get_irn_arity(node);
 		for(i = 0; i < arity; ++i) {
+			const arch_register_t *reg;
 			ir_node *in = get_irn_n(node, i);
-			const arch_register_t *reg =
-			   	arch_get_irn_register(env->arch_env, in);
+
+			if(!mode_is_data(get_irn_mode(in)))
+				continue;
+
+			reg = arch_get_irn_register(env->arch_env, in);
 			if(reg == env->reg) {
 				assert(need_val == NULL);
 				need_val = in;
@@ -409,22 +427,29 @@ void belady(minibelady_env_t *env, ir_node *block)
 
 		/* record state changes by the node */
 		if (get_irn_mode(node) == mode_T) {
-			ir_node *proj;
-			for(proj = sched_next(node); is_Proj(proj);
-			    proj = sched_next(proj)) {
-				const arch_register_t *reg =
-					arch_get_irn_register(env->arch_env, proj);
+			const ir_edge_t *edge;
+
+			foreach_out_edge(node, edge) {
+				const arch_register_t *reg;
+				ir_node *proj = get_edge_src_irn(edge);
+
+				if(!mode_is_data(get_irn_mode(proj)))
+					continue;
+
+				reg = arch_get_irn_register(env->arch_env, proj);
 				if(reg == env->reg) {
 					current_state = proj;
 					DBG((dbg, LEVEL_3, "\t... current_state <- %+F\n", current_state));
 				}
 			}
 		} else {
-			const arch_register_t *reg =
-				arch_get_irn_register(env->arch_env, node);
-			if(reg == env->reg) {
-				current_state = node;
-				DBG((dbg, LEVEL_3, "\t... current_state <- %+F\n", current_state));
+			if(mode_is_data(get_irn_mode(node))) {
+				const arch_register_t *reg =
+					arch_get_irn_register(env->arch_env, node);
+				if(reg == env->reg) {
+					current_state = node;
+					DBG((dbg, LEVEL_3, "\t... current_state <- %+F\n", current_state));
+				}
 			}
 		}
 	}
@@ -445,14 +470,14 @@ ir_node *get_end_of_block_insertion_point(ir_node *block)
 {
 	ir_node *last = sched_last(block);
 
-	/* skip projs and keepanies behind the jump... */
+	/* skip Projs and Keep-alikes behind the jump... */
 	while(is_Proj(last) || be_is_Keep(last)) {
 		last = sched_prev(last);
 	}
 
 	if(!is_cfop(last)) {
 		last = sched_next(last);
-		// last node must be a cfop, only exception is the start block
+		/* last node must be a cfop, only exception is the start block */
 		assert(last	== get_irg_start_block(get_irn_irg(block)));
 	}
 
@@ -475,24 +500,34 @@ void fix_block_borders(ir_node *block, void *data) {
 		return;
 
 	DBG((dbg, LEVEL_3, "\n"));
-	DBG((dbg, LEVEL_3, "Fixing %+F\n", block));
 
 	block_info = get_block_info(block);
 
+	DBG((dbg, LEVEL_3, "Fixing %+F (needs %+F)\n", block,
+	     block_info->start_state));
+
 	/* process all pred blocks */
 	arity = get_irn_arity(block);
 	for (i = 0; i < arity; ++i) {
-		ir_node *pred = get_Block_cfgpred_block(block, i);
-		block_info_t *pred_info = get_block_info(pred);
+		ir_node      *pred       = get_Block_cfgpred_block(block, i);
+		block_info_t *pred_info  = get_block_info(pred);
+		ir_node      *need_state = block_info->start_state;
+
+		if(need_state == NULL)
+			continue;
+
+		if(is_Phi(need_state) && get_nodes_block(need_state) == block) {
+			need_state = get_irn_n(need_state, i);
+		}
+
+		DBG((dbg, LEVEL_3, "  Pred %+F (ends in %+F, we need %+F)\n", pred,
+		     pred_info->end_state, need_state));
 
-		DBG((dbg, LEVEL_3, "  Pred %+F\n", pred));
+		if(pred_info->end_state != need_state) {
+			ir_node *insert_point =	get_end_of_block_insertion_point(pred);
 
-		if(pred_info->end_state != block_info->start_state &&
-			block_info->start_state != NULL) {
-			ir_node *need_state = block_info->start_state;
-			ir_node *insert_point =
-				get_end_of_block_insertion_point(pred);
 
+			DBG((dbg, LEVEL_3, "  Creating reload for %+F\n", need_state));
 			create_reload(env, need_state, insert_point, pred_info->end_state);
 		}
 	}
@@ -504,9 +539,9 @@ void be_assure_state(be_irg_t *birg, const arch_register_t *reg, void *func_env,
 	minibelady_env_t env;
 	ir_graph *irg = be_get_birg_irg(birg);
 	spill_info_t *info;
-	be_lv_t *lv = be_get_birg_liveness(birg);
+	be_lv_t *lv = be_assure_liveness(birg);
 
-	be_assure_liveness(birg);
+	be_liveness_assure_sets(lv);
 	be_assure_dom_front(birg);
 	/* construct control flow loop tree */
 	if(! (get_irg_loopinfo_state(irg) & loopinfo_cf_consistent)) {
@@ -522,8 +557,10 @@ void be_assure_state(be_irg_t *birg, const arch_register_t *reg, void *func_env,
 	env.lv            = be_get_birg_liveness(birg);
 	env.uses          = be_begin_uses(irg, env.lv);
 	env.spills        = NULL;
+	ir_nodemap_init(&env.spill_infos);
 
-	set_using_visited(irg);
+	assure_doms(irg);
+	set_using_irn_visited(irg);
 	set_using_irn_link(irg);
 	inc_irg_visited(irg);
 
@@ -533,7 +570,7 @@ void be_assure_state(be_irg_t *birg, const arch_register_t *reg, void *func_env,
 	/* fix block end_states that don't match the next blocks start_state */
 	irg_block_walk_graph(irg, fix_block_borders, NULL, &env);
 
-	clear_using_visited(irg);
+	clear_using_irn_visited(irg);
 	clear_using_irn_link(irg);
 
 	/* reconstruct ssa-form */
@@ -576,8 +613,9 @@ void be_assure_state(be_irg_t *birg, const arch_register_t *reg, void *func_env,
 	}
 
 	/* some nodes might be dead now. */
-	be_remove_dead_nodes_from_schedule(irg);
+	be_remove_dead_nodes_from_schedule(birg);
 
+	ir_nodemap_destroy(&env.spill_infos);
 	be_end_uses(env.uses);
 	obstack_free(&env.obst, NULL);
 }