X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillbelady2.c;h=4b2386fa9acce7599b7e96a61735c19bec339e59;hb=5ddb95b789dd1acbc59e04f6771085a544483545;hp=bdc99fc7dd403cd3de68c716f771779f82e59578;hpb=6a4b9102668449bea6e3c0905df74f7ffff2768b;p=libfirm

diff --git a/ir/be/bespillbelady2.c b/ir/be/bespillbelady2.c
index bdc99fc7d..4b2386fa9 100644
--- a/ir/be/bespillbelady2.c
+++ b/ir/be/bespillbelady2.c
@@ -58,7 +58,7 @@
 #include "besched.h"
 #include "beirgmod.h"
 #include "belive_t.h"
-#include "benode_t.h"
+#include "benode.h"
 #include "bechordal_t.h"
 #include "bespill.h"
 #include "beloopana.h"
@@ -148,7 +148,7 @@ static inline void workset_print(const workset_t *w)
 {
 	int i;
 
-	for(i = 0; i < w->len; ++i) {
+	for (i = 0; i < w->len; ++i) {
 		ir_fprintf(stderr, "%+F %d\n", w->vals[i].irn, w->vals[i].time);
 	}
 }
@@ -156,14 +156,16 @@ static inline void workset_print(const workset_t *w)
 /**
  * Alloc a new workset on obstack @p ob with maximum size @p max
  */
-static inline workset_t *new_workset(belady_env_t *env, struct obstack *ob) {
+static inline workset_t *new_workset(belady_env_t *env, struct obstack *ob)
+{
 	return OALLOCFZ(ob, workset_t, vals, env->n_regs);
 }
 
 /**
  * Alloc a new instance on obstack and make it equal to @param ws
  */
-static inline workset_t *workset_clone(belady_env_t *env, struct obstack *ob, workset_t *ws) {
+static inline workset_t *workset_clone(belady_env_t *env, struct obstack *ob, workset_t *ws)
+{
 	workset_t *res = OALLOCF(ob, workset_t, vals, env->n_regs);
 	memcpy(res, ws, sizeof(*res) + (env->n_regs)*sizeof(res->vals[0]));
 	return res;
@@ -173,7 +175,8 @@ static inline workset_t *workset_clone(belady_env_t *env, struct obstack *ob, wo
  * Do NOT alloc anything. Make @param tgt equal to @param src.
  * returns @param tgt for convenience
  */
-static inline workset_t *workset_copy(belady_env_t *env, workset_t *tgt, workset_t *src) {
+static inline workset_t *workset_copy(belady_env_t *env, workset_t *tgt, workset_t *src)
+{
 	size_t size = sizeof(*src) + (env->n_regs)*sizeof(src->vals[0]);
 	memcpy(tgt, src, size);
 	return tgt;
@@ -184,7 +187,8 @@ static inline workset_t *workset_copy(belady_env_t *env, workset_t *tgt, workset
  * @param count locations given at memory @param locs.
  * Set the length of @param ws to count.
  */
-static inline void workset_bulk_fill(workset_t *workset, int count, const loc_t *locs) {
+static inline void workset_bulk_fill(workset_t *workset, int count, const loc_t *locs)
+{
 	workset->len = count;
 	memcpy(&(workset->vals[0]), locs, count * sizeof(locs[0]));
 }
@@ -193,7 +197,8 @@ static inline void workset_bulk_fill(workset_t *workset, int count, const loc_t
  * Inserts the value @p val into the workset, iff it is not
  * already contained. The workset must not be full.
  */
-static inline void workset_insert(belady_env_t *env, workset_t *ws, ir_node *val) {
+static inline void workset_insert(belady_env_t *env, workset_t *ws, ir_node *val)
+{
 	int i;
 	/* check for current regclass */
 	if (!arch_irn_consider_in_reg_alloc(env->cls, val)) {
@@ -202,7 +207,7 @@ static inline void workset_insert(belady_env_t *env, workset_t *ws, ir_node *val
 	}
 
 	/* check if val is already contained */
-	for(i=0; i<ws->len; ++i)
+	for (i=0; i<ws->len; ++i)
 		if (ws->vals[i].irn == val)
 			return;
 
@@ -214,16 +219,18 @@ static inline void workset_insert(belady_env_t *env, workset_t *ws, ir_node *val
 /**
  * Removes all entries from this workset
  */
-static inline void workset_clear(workset_t *ws) {
+static inline void workset_clear(workset_t *ws)
+{
 	ws->len = 0;
 }
 
 /**
  * Removes the value @p val from the workset if present.
  */
-static inline void workset_remove(workset_t *ws, ir_node *val) {
+static inline void workset_remove(workset_t *ws, ir_node *val)
+{
 	int i;
-	for(i=0; i<ws->len; ++i) {
+	for (i=0; i<ws->len; ++i) {
 		if (ws->vals[i].irn == val) {
 			ws->vals[i] = ws->vals[--ws->len];
 			return;
@@ -231,9 +238,10 @@ static inline void workset_remove(workset_t *ws, ir_node *val) {
 	}
 }
 
-static inline int workset_get_index(const workset_t *ws, const ir_node *val) {
+static inline int workset_get_index(const workset_t *ws, const ir_node *val)
+{
 	int i;
-	for(i=0; i<ws->len; ++i) {
+	for (i=0; i<ws->len; ++i) {
 		if (ws->vals[i].irn == val)
 			return i;
 	}
@@ -247,7 +255,7 @@ static inline int workset_get_index(const workset_t *ws, const ir_node *val) {
  * @p v  A variable to put the current value in
  * @p i  An integer for internal use
  */
-#define workset_foreach(ws, v, i)	for(i=0; \
+#define workset_foreach(ws, v, i)	for (i=0; \
 										v=(i < ws->len) ? ws->vals[i].irn : NULL, i < ws->len; \
 										++i)
 
@@ -340,7 +348,7 @@ static void build_next_uses(block_info_t *bi)
 
 	sched_renumber(bi->bl);
 
-	phase_init(&bi->next_uses, "next uses", bi->bel->irg, PHASE_DEFAULT_GROWTH, next_use_init, NULL);
+	phase_init(&bi->next_uses, bi->bel->irg, next_use_init);
 	sched_foreach_reverse(bi->bl, irn) {
 		int i;
 
@@ -498,7 +506,7 @@ static inline unsigned get_curr_distance(block_info_t *bi, const ir_node *irn, i
 	assert(!arch_irn_is_ignore(irn));
 
 	/* We have to keep non-spillable nodes in the working set */
-	if(flags & arch_irn_flags_dont_spill)
+	if (flags & arch_irn_flags_dont_spill)
 		return 0;
 
 	if (!is_usage && use && use->step == curr_step)
@@ -552,7 +560,8 @@ static inline int is_transport_in(const ir_node *bl, const ir_node *irn)
  * @p is_usage indicates that the values in new_vals are used (not defined)
  * In this case reloads must be performed
  */
-static void displace(block_info_t *bi, workset_t *new_vals, int is_usage) {
+static void displace(block_info_t *bi, workset_t *new_vals, int is_usage)
+{
 	belady_env_t *env       = bi->bel;
 	workset_t    *ws        = env->ws;
 	ir_node     **to_insert = ALLOCAN(ir_node*, env->n_regs);
@@ -648,7 +657,8 @@ static void displace(block_info_t *bi, workset_t *new_vals, int is_usage) {
  * whether it is used from a register or is reloaded
  * before the use.
  */
-static void belady(belady_env_t *env, int id) {
+static void belady(belady_env_t *env, int id)
+{
 	block_info_t *block_info = new_block_info(env, id);
 	const ir_node *block     = block_info->bl;
 
@@ -686,7 +696,7 @@ static void belady(belady_env_t *env, int id) {
 
 		/* allocate all values _used_ by this instruction */
 		workset_clear(new_vals);
-		for(i = 0, arity = get_irn_arity(irn); i < arity; ++i) {
+		for (i = 0, arity = get_irn_arity(irn); i < arity; ++i) {
 			workset_insert(env, new_vals, get_irn_n(irn, i));
 		}
 		DBG((dbg, DBG_DECIDE, "\t* uses\n"));
@@ -698,7 +708,7 @@ static void belady(belady_env_t *env, int id) {
 		 * augmenting the pressure. Note, that a variable is dead
 		 * if it has no further use in this block and is *not* live end
 		 */
-		for(i = 0, arity = get_irn_arity(irn); i < arity; ++i) {
+		for (i = 0, arity = get_irn_arity(irn); i < arity; ++i) {
 			ir_node *op = get_irn_n(irn, i);
 			next_use_t *use = get_current_use(block_info, op);
 
@@ -734,7 +744,7 @@ static void belady(belady_env_t *env, int id) {
 		env->instr_nr++;
 	}
 
-	phase_free(&block_info->next_uses);
+	phase_deinit(&block_info->next_uses);
 
 	/* Remember end-workset for this block */
 	block_info->ws_end = workset_clone(env, &env->ob, env->ws);
@@ -1461,7 +1471,7 @@ static void collect_blocks(ir_node *bl, void *data)
  * @param birg  The backend graph
  * @param cls   The register class to spill
  */
-void be_spill_belady(be_irg_t *birg, const arch_register_class_t *cls)
+static void be_spill_belady(be_irg_t *birg, const arch_register_class_t *cls)
 {
 	ir_graph *irg = be_get_birg_irg(birg);
 	belady_env_t env;
@@ -1469,7 +1479,7 @@ void be_spill_belady(be_irg_t *birg, const arch_register_class_t *cls)
 
 	/* some special classes contain only ignore regs, nothing to do then */
 	n_regs = cls->n_regs - be_put_ignore_regs(birg, cls, NULL);
-	if(n_regs == 0)
+	if (n_regs == 0)
 		return;
 
 	be_clear_links(irg);
@@ -1524,6 +1534,7 @@ void be_spill_belady(be_irg_t *birg, const arch_register_class_t *cls)
 	obstack_free(&env.ob, NULL);
 }
 
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spillbelady2);
 void be_init_spillbelady2(void)
 {
 	lc_opt_entry_t *be_grp    = lc_opt_get_grp(firm_opt_get_root(), "be");
@@ -1538,5 +1549,3 @@ void be_init_spillbelady2(void)
 	be_register_spiller("belady2", &belady_spiller);
 	FIRM_DBG_REGISTER(dbg, "firm.be.spill.belady2");
 }
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spillbelady2);