X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeschedrss.c;h=5ab8513c2c56c417ff1b748e931a12dec30cdabb;hb=59528405f7e6b495a3092ff206e4ca4626869ddc;hp=c6de58376342556de8c339f99290a5d9e2885d50;hpb=81d4cf5aeab4d0c0bc2a5e7c461d58ee7a7522d6;p=libfirm diff --git a/ir/be/beschedrss.c b/ir/be/beschedrss.c index c6de58376..5ab8513c2 100644 --- a/ir/be/beschedrss.c +++ b/ir/be/beschedrss.c @@ -28,9 +28,7 @@ * as described in: Sid-Ahmed-Ali Touati * Register Saturation in Superscalar and VLIW Codes */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include @@ -47,6 +45,7 @@ #include "irtools.h" #include "irbitset.h" #include "irprintf.h" +#include "irnodeset.h" #include "bipartite.h" #include "hungarian.h" #include "plist.h" @@ -57,8 +56,9 @@ #include "beabi.h" #include "bemodule.h" #include "benode_t.h" -#include "besched_t.h" -#include "beirg_t.h" +#include "besched.h" +#include "beirg.h" +#include "belive.h" #include "lc_opts.h" #include "lc_opts_enum.h" @@ -435,19 +435,20 @@ static void debug_vcg_dump_kill(rss_t *rss) { } /* Dumps the potential killing DAG (PKG) as vcg. */ -static void debug_vcg_dump_pkg(rss_t *rss, ir_nodeset_t *max_ac, int iteration) { +static void debug_vcg_dump_pkg(rss_t *rss, ir_nodeset_t *max_ac, int iteration) +{ FILE *f; char file_name[256]; - char *suffix = alloca(32); + char suffix[32]; static const char suffix1[] = "-RSS-PKG.vcg"; static const char suffix2[] = "-RSS-PKG-MAXAC.vcg"; plist_element_t *el; if (! max_ac) { - snprintf(suffix, 32, "%s", suffix1); + snprintf(suffix, sizeof(suffix), "%s", suffix1); } else { - snprintf(suffix, 32, "-%02d%s", iteration, suffix2); + snprintf(suffix, sizeof(suffix), "-%02d%s", iteration, suffix2); } build_file_name(rss, suffix, strlen(suffix) + 1, file_name, sizeof(file_name)); @@ -633,7 +634,7 @@ static void collect_descendants(rss_t *rss, rss_irn_t *rirn, ir_node *irn, int * ir_node *user = get_edge_src_irn(edge); /* skip ignore nodes as they do not really contribute to register pressure */ - if (arch_irn_is(rss->arch_env, user, ignore)) + if (arch_irn_is_ignore(user)) continue; /* @@ -648,8 +649,7 @@ static void collect_descendants(rss_t *rss, rss_irn_t *rirn, ir_node *irn, int * } if (is_Proj(user)) { - - //if (arch_get_irn_reg_class(rss->arch_env, user, -1) == rss->cls) + //if (arch_get_irn_reg_class_out(user) == rss->cls) collect_descendants(rss, rirn, user, got_sink, cur_desc_walk); } else { @@ -682,7 +682,8 @@ static void collect_single_consumer(rss_t *rss, rss_irn_t *rss_irn, ir_node *con assert(! is_Proj(consumer) && "Cannot handle Projs"); if (! is_Phi(consumer) && ! is_Block(consumer) && get_nodes_block(consumer) == block) { - if (! arch_irn_is(rss->arch_env, consumer, ignore) && ! plist_has_value(rss_irn->consumer_list, consumer)) { + if (!arch_irn_is_ignore(consumer) && + !plist_has_value(rss_irn->consumer_list, consumer)) { plist_insert_back(rss_irn->consumer_list, consumer); DBG((rss->dbg, LEVEL_2, "\t\tconsumer %+F\n", consumer)); } @@ -717,7 +718,7 @@ static void collect_consumer(rss_t *rss, rss_irn_t *rss_irn, ir_node *irn, int * ir_node *consumer = get_edge_src_irn(edge); if (is_Proj(consumer)) { - //if (arch_get_irn_reg_class(rss->arch_env, consumer, -1) == rss->cls) + //if (arch_get_irn_reg_class_out(consumer) == rss->cls) collect_consumer(rss, rss_irn, consumer, got_sink); } else @@ -1245,7 +1246,7 @@ static void compute_killing_function(rss_t *rss) { /** * Adds the edge src -> tgt to the dvg. Checks if reverse edge is already there (asserts). */ -static INLINE void add_dvg_edge(rss_t *rss, dvg_t *dvg, const ir_node *src, const ir_node *tgt, int have_source) { +static inline void add_dvg_edge(rss_t *rss, dvg_t *dvg, const ir_node *src, const ir_node *tgt, int have_source) { rss_edge_t *dvg_edge; rss_edge_t key; @@ -1348,7 +1349,7 @@ static void compute_dvg(rss_t *rss, dvg_t *dvg) { static void update_dvg(rss_t *rss, dvg_t *dvg, rss_irn_t *src, rss_irn_t *tgt) { int i, j, idx; rss_edge_t *edge; - rss_edge_t **arr = alloca(pset_count(dvg->edges) * sizeof(arr[0])); + rss_edge_t **arr = ALLOCAN(rss_edge_t*, pset_count(dvg->edges)); /* Add an edge from serialization target to serialization src: @@ -1455,9 +1456,9 @@ static void build_dvg_pkiller_list(rss_t *rss, dvg_t *dvg) { */ static ir_nodeset_t *compute_maximal_antichain(rss_t *rss, dvg_t *dvg, int iteration) { int n = ir_nodeset_size(&dvg->nodes); - int *assignment = alloca(n * sizeof(assignment[0])); - int *assignment_rev = alloca(n * sizeof(assignment_rev[0])); - int *idx_map = alloca(n * sizeof(idx_map[0])); + int *assignment = ALLOCAN(int, n); + int *assignment_rev = ALLOCAN(int, n); + int *idx_map = ALLOCAN(int, n); hungarian_problem_t *bp; ir_nodeset_t *values, *temp; ir_nodeset_iterator_t iter; @@ -1470,7 +1471,7 @@ static ir_nodeset_t *compute_maximal_antichain(rss_t *rss, dvg_t *dvg, int itera if (pset_count(dvg->edges) == 0) return NULL; - bp = hungarian_new(n, n, 1, HUNGARIAN_MATCH_NORMAL); + bp = hungarian_new(n, n, HUNGARIAN_MATCH_NORMAL); /* At first, we build an index map for the nodes in the DVG, @@ -1568,7 +1569,7 @@ static ir_nodeset_t *compute_maximal_antichain(rss_t *rss, dvg_t *dvg, int itera DBG((rss->dbg, LEVEL_3, "\t\t\t%3d -> %3d %3d -> %3d\n", i, assignment[i], i, assignment_rev[i])); } - values = xmalloc(sizeof(values[0])); + values = XMALLOC(ir_nodeset_t); ir_nodeset_init_size(values, 10); cur_chain = 0; /* Construction of the minimal chain partition */ @@ -1646,7 +1647,7 @@ static ir_nodeset_t *compute_maximal_antichain(rss_t *rss, dvg_t *dvg, int itera free(temp); } - temp = xmalloc(sizeof(temp[0])); + temp = XMALLOC(ir_nodeset_t); ir_nodeset_init_size(temp, 10); /* Select all nodes from current value set, having another node in the set as descendant. */ @@ -1719,7 +1720,7 @@ static serialization_t *compute_best_admissible_serialization(rss_t *rss, ir_nod int n = ir_nodeset_size(sat_vals); int n_idx = ARR_LEN_SAFE(rss->idx_map); int i = 0; - ir_node **val_arr = alloca(n * sizeof(val_arr[0])); + ir_node **val_arr = ALLOCAN(ir_node*, n); bitset_t *bs_sv = bitset_alloca(n_idx); bitset_t *bs_vdesc = bitset_alloca(n_idx); bitset_t *bs_tmp = bitset_alloca(n_idx); @@ -1962,7 +1963,7 @@ static void perform_value_serialization_heuristic(rss_t *rss) { pset *ser_set = new_pset(cmp_rss_edges, 20); /* available_regs = R = |arch_non_ignore_regs cut ~abi_ignore_regs| */ - arch_put_non_ignore_regs(rss->arch_env, rss->cls, arch_nonign_bs); + arch_put_non_ignore_regs(rss->cls, arch_nonign_bs); be_abi_put_ignore_regs(rss->abi, rss->cls, abi_ign_bs); bitset_andnot(arch_nonign_bs, abi_ign_bs); available_regs = bitset_popcnt(arch_nonign_bs); @@ -2073,7 +2074,7 @@ static void process_block(ir_node *block, void *env) { /* Get all live value at end of Block having current register class */ ir_nodeset_init(&rss->live_block); - be_liveness_end_of_block(rss->liveness, rss->arch_env, rss->cls, rss->block, &rss->live_block); + be_liveness_end_of_block(rss->liveness, rss->cls, rss->block, &rss->live_block); /* reset the list of interesting nodes */ plist_clear(rss->nodes); @@ -2112,7 +2113,8 @@ static void process_block(ir_node *block, void *env) { if (be_is_Keep(irn)) continue; - if (! arch_irn_is(rss->arch_env, irn, ignore) && arch_get_irn_reg_class(rss->arch_env, irn, -1) == cls) { + if (!arch_irn_is_ignore(irn) && + arch_get_irn_reg_class_out(irn) == cls) { plist_insert_back(rss->nodes, skip_Proj(irn)); } //} @@ -2168,7 +2170,7 @@ void rss_schedule_preparation(be_irg_t *birg) { rss.h = heights_new(irg); rss.nodes = plist_new(); rss.opts = &rss_options; - rss.liveness = be_liveness(birg); + rss.liveness = be_liveness(irg); be_liveness_assure_sets(rss.liveness); irg_block_walk_graph(irg, NULL, process_block, &rss); heights_free(rss.h);