X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillbelady2.c;h=6abbbd5227ee83d39b37d0403ab6340de7400304;hb=7fc5212efdd0faf06fed3850760ca319bdc66afc;hp=48d677caa958dc8159fed7ca3c75eece56aac154;hpb=18814151f8c0ea17b2a7bf84c82ee3c2e66d6a6b;p=libfirm

diff --git a/ir/be/bespillbelady2.c b/ir/be/bespillbelady2.c
index 48d677caa..6abbbd522 100644
--- a/ir/be/bespillbelady2.c
+++ b/ir/be/bespillbelady2.c
@@ -101,7 +101,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 /**
  * An association between a node and a point in time.
  */
-typedef struct _loc_t {
+typedef struct loc_t {
   ir_node *irn;        /**< A node. */
   unsigned time;       /**< A use time.
 						 In the global pass this is used
@@ -110,12 +110,12 @@ typedef struct _loc_t {
 						*/
 } loc_t;
 
-typedef struct _workset_t {
-	int len;			/**< current length */
-	loc_t vals[0];		/**< inlined array of the values/distances in this working set */
+typedef struct workset_t {
+	int len;            /**< current length */
+	loc_t vals[0];      /**< inlined array of the values/distances in this working set */
 } workset_t;
 
-typedef struct _belady_env_t {
+typedef struct belady_env_t {
 	struct obstack ob;
 	ir_graph *irg;
 	const dfs_t *dfs;
@@ -126,12 +126,12 @@ typedef struct _belady_env_t {
 
 	ir_node **blocks;            /**< Array of all blocks. */
 	int n_blocks;                /**< Number of blocks in the graph. */
-	int n_regs;			         /**< number of regs in this reg-class */
-	workset_t *ws;		         /**< the main workset used while processing a block. ob-allocated */
-	ir_node *instr;		         /**< current instruction */
-	int instr_nr;     	         /**< current instruction number (relative to block start) */
+	int n_regs;                  /**< number of regs in this reg-class */
+	workset_t *ws;               /**< the main workset used while processing a block. ob-allocated */
+	ir_node *instr;              /**< current instruction */
+	int instr_nr;                /**< current instruction number (relative to block start) */
 
-	spill_env_t *senv;	         /**< see bespill.h */
+	spill_env_t *senv;           /**< see bespill.h */
 	bitset_t *spilled;           /**< bitset to keep all the irns which have already been spilled. */
 	ir_nodeset_t *extra_spilled; /** All nodes for which a special spill location has been computed. */
 } belady_env_t;
@@ -139,8 +139,8 @@ typedef struct _belady_env_t {
 
 static int loc_compare(const void *a, const void *b)
 {
-	const loc_t *p = a;
-	const loc_t *q = b;
+	const loc_t *p = (const loc_t*)a;
+	const loc_t *q = (const loc_t*)b;
 	return (p->time > q->time) - (p->time < q->time);
 }
 
@@ -255,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)
 
@@ -267,9 +267,9 @@ static inline int workset_get_index(const workset_t *ws, const ir_node *val)
 #define workset_sort(ws) qsort((ws)->vals, (ws)->len, sizeof((ws)->vals[0]), loc_compare);
 #define workset_contains(ws, n) (workset_get_index(ws, n) >= 0)
 
-typedef struct _bring_in_t bring_in_t;
+typedef struct bring_in_t bring_in_t;
 
-typedef struct _block_info_t {
+typedef struct block_info_t {
 	belady_env_t *bel;
 	ir_node *bl;
 	int id;
@@ -295,7 +295,7 @@ typedef struct _block_info_t {
 
 } block_info_t;
 
-static inline void *new_block_info(belady_env_t *bel, int id)
+static inline block_info_t *new_block_info(belady_env_t *bel, int id)
 {
 	ir_node      *bl  = bel->blocks[id];
 	block_info_t *res = OALLOCZ(&bel->ob, block_info_t);
@@ -323,32 +323,24 @@ static inline ir_node *block_info_get_last_ins(block_info_t *bi)
 	return bi->last_ins;
 }
 
-typedef struct _next_use_t {
+typedef struct next_use_t {
 	unsigned is_first_use : 1; /**< Indicate that this use is the first
 								 in the block. Needed to identify
 								 transport in values for the global
 								 pass. */
 	sched_timestep_t step;     /**< The time step of the use. */
 	ir_node *irn;
-	struct _next_use_t *next;  /**< The next use int this block
+	struct next_use_t *next;   /**< The next use int this block
 								 or NULL. */
 } next_use_t;
 
-static void *next_use_init(ir_phase *phase, const ir_node *irn, void *old)
-{
-	(void) phase;
-	(void) irn;
-	(void) old;
-	return NULL;
-}
-
 static void build_next_uses(block_info_t *bi)
 {
 	ir_node *irn;
 
 	sched_renumber(bi->bl);
 
-	phase_init(&bi->next_uses, bi->bel->irg, next_use_init);
+	phase_init(&bi->next_uses, bi->bel->irg, phase_irn_init_default);
 	sched_foreach_reverse(bi->bl, irn) {
 		int i;
 
@@ -357,8 +349,8 @@ static void build_next_uses(block_info_t *bi)
 
 		for (i = get_irn_arity(irn) - 1; i >= 0; --i) {
 			ir_node *op = get_irn_n(irn, i);
-			next_use_t *curr = phase_get_irn_data(&bi->next_uses, op);
-			next_use_t *use  = phase_alloc(&bi->next_uses, sizeof(use[0]));
+			next_use_t *curr = (next_use_t*)phase_get_irn_data(&bi->next_uses, op);
+			next_use_t *use  = (next_use_t*)phase_alloc(&bi->next_uses, sizeof(use[0]));
 
 			use->is_first_use = 1;
 			use->step         = sched_get_time_step(irn);
@@ -375,7 +367,10 @@ static void build_next_uses(block_info_t *bi)
 	}
 }
 
-#define get_current_use(bi, irn) 	 phase_get_irn_data(&(bi)->next_uses, (irn))
+static inline next_use_t *get_current_use(block_info_t *bi, const ir_node *node)
+{
+	return (next_use_t*)phase_get_irn_data(&bi->next_uses, node);
+}
 
 static inline void advance_current_use(block_info_t *bi, const ir_node *irn)
 {
@@ -387,8 +382,8 @@ static inline void advance_current_use(block_info_t *bi, const ir_node *irn)
 
 static __attribute__((unused)) int block_freq_gt(const void *a, const void *b)
 {
-	const ir_node * const *p = a;
-	const ir_node * const *q = b;
+	const ir_node * const *p = (const ir_node**)a;
+	const ir_node * const *q = (const ir_node**)b;
 	block_info_t *pi = get_block_info(*p);
 	block_info_t *qi = get_block_info(*q);
 	double diff = qi->exec_freq - pi->exec_freq;
@@ -397,8 +392,8 @@ static __attribute__((unused)) int block_freq_gt(const void *a, const void *b)
 
 static int block_freq_dfs_gt(const void *a, const void *b)
 {
-	const ir_node * const *p = a;
-	const ir_node * const *q = b;
+	const ir_node * const *p = (const ir_node**)a;
+	const ir_node * const *q = (const ir_node**)b;
 	block_info_t *pi = get_block_info(*p);
 	block_info_t *qi = get_block_info(*q);
 	double diff;
@@ -427,7 +422,7 @@ static int block_freq_dfs_gt(const void *a, const void *b)
   Data structures to represent bring in variables.
 */
 
-struct _bring_in_t {
+struct bring_in_t {
 	ir_node *irn;              /**< The node to bring in. */
 	block_info_t *bi;          /**< The block to which bring in should happen. */
 	int pressure_so_far;       /**< The maximal pressure till the first use of irn in bl. */
@@ -659,8 +654,8 @@ static void displace(block_info_t *bi, workset_t *new_vals, int is_usage)
  */
 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;
+	block_info_t  *block_info = new_block_info(env, id);
+	const ir_node *block      = block_info->bl;
 
 	workset_t *new_vals;
 	ir_node *irn;
@@ -782,22 +777,22 @@ enum {
 	irn_act_live_through
 };
 
-typedef struct _block_state_t {
-	struct _block_state_t *next;
-	struct _block_state_t *next_intern;
+typedef struct block_state_t {
+	struct block_state_t *next;
+	struct block_state_t *next_intern;
 	block_info_t *bi;
 	int pressure;
 	workset_t *end_state;
 } block_state_t;
 
-typedef struct _irn_action_t {
-	struct _irn_action_t *next;
+typedef struct irn_action_t {
+	struct irn_action_t *next;
 	ir_node *irn;
 	const ir_node *bl;
 	int act;
 } irn_action_t;
 
-typedef struct _global_end_state_t {
+typedef struct global_end_state_t {
 	belady_env_t *env;
 	bitset_t *succ_phis;
 	bitset_t *committed;
@@ -1388,7 +1383,7 @@ static bring_in_t **determine_global_order(belady_env_t *env)
 	}
 
 	obstack_ptr_grow(&env->ob, NULL);
-	res = obstack_finish(&env->ob);
+	res = (bring_in_t**)obstack_finish(&env->ob);
 	qsort(res, n, sizeof(res[0]), bring_in_cmp);
 	return res;
 }
@@ -1458,7 +1453,7 @@ static void global_assign(belady_env_t *env)
 
 static void collect_blocks(ir_node *bl, void *data)
 {
-	belady_env_t *env = data;
+	belady_env_t *env = (belady_env_t*)data;
 	++env->n_blocks;
 	obstack_ptr_grow(&env->ob, bl);
 }
@@ -1477,7 +1472,7 @@ static void be_spill_belady(ir_graph *irg, const arch_register_class_t *cls)
 	int i, n_regs;
 
 	/* some special classes contain only ignore regs, nothing to do then */
-	n_regs = cls->n_regs - be_put_ignore_regs(irg, cls, NULL);
+	n_regs = be_get_n_allocatable_regs(irg, cls);
 	if (n_regs == 0)
 		return;
 
@@ -1500,7 +1495,7 @@ static void be_spill_belady(ir_graph *irg, const arch_register_class_t *cls)
 
 	irg_block_walk_graph(irg, NULL, collect_blocks, &env);
 	obstack_ptr_grow(&env.ob, NULL);
-	env.blocks = obstack_finish(&env.ob);
+	env.blocks = (ir_node**)obstack_finish(&env.ob);
 
 	/* renumbering in the blocks gives nicer debug output as number are smaller. */
 #ifdef DEBUG_libfirm