rework ASM node, it always has a memory input now

[libfirm] / ir / be / bespilldaemel.c

diff --git a/ir/be/bespilldaemel.c b/ir/be/bespilldaemel.c
index f015f6e..8e22bb4 100644 (file)
--- a/ir/be/bespilldaemel.c
+++ b/ir/be/bespilldaemel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -22,7 +22,6 @@
  * @brief       Naive spilling algorithm
  * @author      Matthias Braun
  * @date        20.09.2005
- * @version     $Id: bespillbelady.c 13913 2007-05-18 12:48:56Z matze $
  * @brief
  *   This implements a naive spilling algorithm. It is designed to produce
  *   similar effects to the spill decisions produced by traditional graph
@@ -57,7 +56,7 @@
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
 static spill_env_t                 *spill_env;
-static int                          n_regs;
+static unsigned                     n_regs;
 static const arch_register_class_t *cls;
 static const be_lv_t               *lv;
 static bitset_t                    *spilled_nodes;
@@ -70,18 +69,16 @@ struct spill_candidate_t {
 
 static int compare_spill_candidates_desc(const void *d1, const void *d2)
 {
-       const spill_candidate_t *c1 = d1;
-       const spill_candidate_t *c2 = d2;
+       const spill_candidate_t *c1 = (const spill_candidate_t*)d1;
+       const spill_candidate_t *c2 = (const spill_candidate_t*)d2;
 
        return (int) (c1->costs - c2->costs);
 }
 
 static double get_spill_costs(ir_node *node)
 {
-       const ir_edge_t *edge;
-       ir_node         *spill_place = skip_Proj(node);
-       double           costs       = be_get_spill_costs(spill_env, node,
-                                                         spill_place);
+       ir_node *spill_place = skip_Proj(node);
+       double   costs       = be_get_spill_costs(spill_env, node, spill_place);
 
        foreach_out_edge(node, edge) {
                ir_node *use = get_edge_src_irn(edge);
@@ -109,8 +106,6 @@ static double get_spill_costs(ir_node *node)
  */
 static void spill_node(ir_node *node)
 {
-       const ir_edge_t *edge;
-
        DBG((dbg, LEVEL_3, "\tspilling %+F\n", node));
 
        foreach_out_edge(node, edge) {
@@ -135,7 +130,7 @@ static void spill_node(ir_node *node)
 
 static unsigned get_value_width(const ir_node *node)
 {
-       const arch_register_req_t *req = arch_get_register_req_out(node);
+       const arch_register_req_t *req = arch_get_irn_register_req(node);
        return req->width;
 }
 
@@ -145,16 +140,15 @@ static unsigned get_value_width(const ir_node *node)
  */
 static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node)
 {
-       size_t                 n_live_nodes     = ir_nodeset_size(live_nodes);
-       size_t                 values_defined   = 0;
-       size_t                 free_regs_needed = 0;
-       spill_candidate_t     *candidates;
-       ir_nodeset_iterator_t  iter;
-       size_t                 i, arity;
-       int                    spills_needed;
-       size_t                 cand_idx;
-       ir_node               *n;
-       ir_node               *value;
+       size_t             n_live_nodes     = ir_nodeset_size(live_nodes);
+       size_t             values_defined   = 0;
+       size_t             free_regs_needed = 0;
+       spill_candidate_t *candidates;
+       int                i, arity;
+       size_t             c;
+       int                spills_needed;
+       size_t             cand_idx;
+       ir_node           *value;
 
        be_foreach_definition(node, cls, value,
                assert(req_->width >= 1);
@@ -184,17 +178,17 @@ static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node)
        candidates = ALLOCAN(spill_candidate_t, n_live_nodes);
 
        /* construct array with spill candidates and calculate their costs */
-       i = 0;
+       c = 0;
        foreach_ir_nodeset(live_nodes, n, iter) {
-               spill_candidate_t *candidate = & candidates[i];
+               spill_candidate_t *candidate = & candidates[c];
 
                assert(!bitset_is_set(spilled_nodes, get_irn_idx(n)));
 
                candidate->node  = n;
                candidate->costs = get_spill_costs(n);
-               ++i;
+               ++c;
        }
-       assert(i == n_live_nodes);
+       assert(c == n_live_nodes);
 
        /* sort spill candidates */
        qsort(candidates, n_live_nodes, sizeof(candidates[0]),
@@ -267,9 +261,6 @@ static void add_uses(ir_node *node, ir_nodeset_t *nodeset)
 static __attribute__((unused))
 void print_nodeset(ir_nodeset_t *nodeset)
 {
-       ir_nodeset_iterator_t  iter;
-       ir_node               *node;
-
        foreach_ir_nodeset(nodeset, node, iter) {
                ir_fprintf(stderr, "%+F ", node);
        }
@@ -282,13 +273,11 @@ void print_nodeset(ir_nodeset_t *nodeset)
  */
 static void spill_block(ir_node *block, void *data)
 {
-       ir_nodeset_t           live_nodes;
-       ir_nodeset_iterator_t  iter;
-       ir_node               *node;
-       int                    n_phi_values_spilled;
-       int                    regpressure;
-       int                    live_nodes_pressure;
-       int                    phi_spills_needed;
+       ir_nodeset_t live_nodes;
+       int          n_phi_values_spilled;
+       int          regpressure;
+       int          live_nodes_pressure;
+       int          phi_spills_needed;
        (void) data;
 
        DBG((dbg, LEVEL_1, "spilling block %+F\n", block));
@@ -365,11 +354,11 @@ static void spill_block(ir_node *block, void *data)
 
 static void be_spill_daemel(ir_graph *irg, const arch_register_class_t *new_cls)
 {
-       n_regs = new_cls->n_regs - be_put_ignore_regs(irg, new_cls, NULL);
+       n_regs = be_get_n_allocatable_regs(irg, new_cls);
        if (n_regs == 0)
                return;
 
-       be_liveness_assure_sets(be_assure_liveness(irg));
+       be_assure_live_sets(irg);
 
        spill_env     = be_new_spill_env(irg);
        cls           = new_cls;
@@ -386,7 +375,7 @@ static void be_spill_daemel(ir_graph *irg, const arch_register_class_t *new_cls)
        be_delete_spill_env(spill_env);
 }
 
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_daemelspill);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_daemelspill)
 void be_init_daemelspill(void)
 {
        static be_spiller_t daemel_spiller = {