#include "irtools.h"
#include "irbitset.h"
#include "irprintf.h"
+#include "irnodeset.h"
#include "bipartite.h"
#include "hungarian.h"
#include "plist.h"
#include "beabi.h"
#include "bemodule.h"
-#include "benode_t.h"
-#include "besched_t.h"
-#include "beirg_t.h"
+#include "benode.h"
+#include "besched.h"
+#include "beirg.h"
+#include "belive.h"
#include "lc_opts.h"
#include "lc_opts_enum.h"
}
/* 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));
ir_node *user = get_edge_src_irn(edge);
/* skip ignore nodes as they do not really contribute to register pressure */
- if (arch_irn_is(user, ignore))
+ if (arch_irn_is_ignore(user))
continue;
/*
assert(! is_Proj(consumer) && "Cannot handle Projs");
if (! is_Phi(consumer) && ! is_Block(consumer) && get_nodes_block(consumer) == block) {
- if (!arch_irn_is(consumer, ignore) &&
+ 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));
foreach_plist(rirn->pkiller_list, k_el) {
ir_node *pkiller = plist_element_get_value(k_el);
- rss_edge_t *ke = obstack_alloc(phase_obst(&rss->ph), sizeof(*ke));
+ rss_edge_t *ke = OALLOC(phase_obst(&rss->ph), rss_edge_t);
ke->src = irn;
ke->tgt = pkiller;
DBG((rss->dbg, LEVEL_2, "\t\t%+F choosen:\n", u_irn));
- cbc = obstack_alloc(phase_obst(&rss->ph), sizeof(*cbc));
+ cbc = OALLOC(phase_obst(&rss->ph), cbc_t);
cbc->nr = cur_num++;
/* initialize S_cb */
/* while X not empty */
while (ir_nodeset_size(&x) > 0) {
- child_t *t = obstack_alloc(&obst, sizeof(*t));
- memset(t, 0, sizeof(*t));
+ child_t *t = OALLOCZ(&obst, child_t);
t = select_child_max_cost(rss, &x, &y, t, cbc);
key.tgt = (ir_node *) tgt;
if (NULL != pset_find(dvg->edges, &key, HASH_RSS_EDGE(&key))) {
/* add the edge to the DVG */
- dvg_edge = obstack_alloc(phase_obst(&rss->ph), sizeof(*dvg_edge));
+ dvg_edge = OALLOC(phase_obst(&rss->ph), rss_edge_t);
dvg_edge->src = (ir_node *) src;
dvg_edge->tgt = (ir_node *) tgt;
There is an edge (u, v) in the DVG iff v is a descendant of the killer(u).
*/
if (BSEARCH_IRN_ARR(v_irn, u_kill->descendants)) {
- rss_edge_t *dvg_edge = obstack_alloc(phase_obst(&rss->ph), sizeof(*dvg_edge));
+ rss_edge_t *dvg_edge = OALLOC(phase_obst(&rss->ph), rss_edge_t);
rss_edge_t key;
/* insert the user into the DVG and append it to the user list of u */
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:
*/
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;
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,
int xj = idx_map[j];
ir_node *xj_irn = get_idx_irn(rss->irg, xj);
rss_irn_t *xj_rss = get_rss_irn(rss, xj_irn);
- chain_t *c = obstack_alloc(phase_obst(&rss->ph), sizeof(*c));
+ chain_t *c = OALLOC(phase_obst(&rss->ph), chain_t);
int source;
/* there was no source for j -> we have a source of a new chain */
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);
sat_vals = compute_maximal_antichain(rss, &dvg, iteration++);
while (sat_vals && (ir_nodeset_size(sat_vals) > available_regs)) {
serialization_t *ser, best_ser;
- rss_edge_t *edge = obstack_alloc(phase_obst(&rss->ph), sizeof(*edge));
+ rss_edge_t *edge = OALLOC(phase_obst(&rss->ph), rss_edge_t);
ir_node *dep_src, *dep_tgt;
best_ser.edge = edge;
*/
if (is_Proj(irn)) {
ir_node *pred = get_Proj_pred(irn);
- if (be_is_Barrier(pred) || is_Start(pred))
+ if (be_is_Barrier(pred) || be_is_Start(pred))
continue;
}
if (be_is_Keep(irn))
continue;
- if (!arch_irn_is(irn, ignore) &&
+ if (!arch_irn_is_ignore(irn) &&
arch_get_irn_reg_class_out(irn) == cls) {
plist_insert_back(rss->nodes, skip_Proj(irn));
}
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);
projects / libfirm / blobdiff