/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
- *
* This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
*/
/**
#include "debug.h"
#include "error.h"
-#include "execfreq.h"
+#include "execfreq_t.h"
#include "irdump_t.h"
#include "iredges_t.h"
#include "irgraph.h"
#include "irgwalk.h"
#include "irloop_t.h"
#include "irnode.h"
-#include "irprintf_t.h"
+#include "irprintf.h"
#include "irprog.h"
#include "irtools.h"
#include "pmap.h"
#include "bemodule.h"
#include "benode.h"
#include "besched.h"
-#include "bestatevent.h"
+#include "statev_t.h"
#include "beutil.h"
#include "lc_opts.h"
#undef QUICK_AND_DIRTY_HACK
-static int nodes_interfere(const be_chordal_env_t *env, const ir_node *a, const ir_node *b)
-{
- if (env->ifg)
- return be_ifg_connected(env->ifg, a, b);
- else {
- be_lv_t *lv = be_get_irg_liveness(env->irg);
- return be_values_interfere(lv, a, b);
- }
-}
-
-
/******************************************************************************
_____ _
/ ____| | |
copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, cost_fct_t get_costs)
{
- const char *s1, *s2, *s3;
- size_t len;
- copy_opt_t *co;
-
FIRM_DBG_REGISTER(dbg, "ir.be.copyopt");
- co = XMALLOCZ(copy_opt_t);
+ copy_opt_t *const co = XMALLOCZ(copy_opt_t);
co->cenv = chordal_env;
co->irg = chordal_env->irg;
co->cls = chordal_env->cls;
co->get_costs = get_costs;
-
- s1 = get_irp_name();
- s2 = get_entity_name(get_irg_entity(co->irg));
- s3 = chordal_env->cls->name;
- len = strlen(s1) + strlen(s2) + strlen(s3) + 5;
- co->name = XMALLOCN(char, len);
- snprintf(co->name, len, "%s__%s__%s", s1, s2, s3);
-
return co;
}
void free_copy_opt(copy_opt_t *co)
{
- xfree(co->name);
free(co);
}
*/
static int co_is_optimizable_root(ir_node *irn)
{
- const arch_register_req_t *req;
-
- if (arch_irn_is_ignore(irn))
+ arch_register_req_t const *const req = arch_get_irn_register_req(irn);
+ if (arch_register_req_is(req, ignore))
return 0;
if (is_Reg_Phi(irn) || is_Perm_Proj(irn))
return 1;
- req = arch_get_irn_register_req(irn);
- if (is_2addr_code(req))
+ if (arch_register_req_is(req, should_be_same))
return 1;
return 0;
return 1+cost;
}
+static ir_execfreq_int_factors factors;
+
/**
* Computes the costs of a copy according to execution frequency
* @param pos the argument position of arg in the root arguments
*/
static int co_get_costs_exec_freq(const ir_node *root, int pos)
{
- ir_graph *irg = get_irn_irg(root);
- ir_node *root_bl = get_nodes_block(root);
- ir_node *copy_bl
+ ir_node *root_bl = get_nodes_block(root);
+ ir_node *copy_bl
= is_Phi(root) ? get_Block_cfgpred_block(root_bl, pos) : root_bl;
- ir_exec_freq *exec_freq = be_get_irg_exec_freq(irg);
- int res = get_block_execfreq_ulong(exec_freq, copy_bl);
+ int res = get_block_execfreq_int(&factors, copy_bl);
/* don't allow values smaller than one. */
return res < 1 ? 1 : res;
* Determines a maximum weighted independent set with respect to
* the interference and conflict edges of all nodes in a qnode.
*/
-static int ou_max_ind_set_costs(unit_t *ou)
+static int ou_max_ind_set_costs(unit_t *const ou, be_lv_t const *const lv)
{
- be_chordal_env_t *chordal_env = ou->co->cenv;
ir_node **safe, **unsafe;
int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
bitset_t *curr;
- size_t pos;
int curr_weight, best_weight = 0;
/* assign the nodes into two groups.
for (o=1; o<ou->node_count; ++o) {
if (i==o)
continue;
- if (nodes_interfere(chordal_env, ou->nodes[i], ou->nodes[o])) {
+ if (be_values_interfere(lv, ou->nodes[i], ou->nodes[o])) {
unsafe_costs[unsafe_count] = ou->costs[i];
unsafe[unsafe_count] = ou->nodes[i];
++unsafe_count;
bitset_set(best, i);
/* check if it is a stable set */
for (o=bitset_next_set(best, 0); o!=-1 && o<i; o=bitset_next_set(best, o+1))
- if (nodes_interfere(chordal_env, unsafe[i], unsafe[o])) {
+ if (be_values_interfere(lv, unsafe[i], unsafe[o])) {
bitset_clear(best, i); /* clear the bit and try next one */
break;
}
/* check if curr is a stable set */
for (i=bitset_next_set(curr, 0); i!=-1; i=bitset_next_set(curr, i+1))
for (o=bitset_next_set(curr, i+1); o!=-1; o=bitset_next_set(curr, o+1)) /* !!!!! difference to qnode_max_ind_set(): NOT (curr, i) */
- if (nodes_interfere(chordal_env, unsafe[i], unsafe[o]))
+ if (be_values_interfere(lv, unsafe[i], unsafe[o]))
goto no_stable_set;
/* if we arrive here, we have a stable set */
/* Init a new unit */
unit = XMALLOCZ(unit_t);
- unit->co = co;
unit->node_count = 1;
INIT_LIST_HEAD(&unit->queue);
+ be_lv_t *const lv = be_get_irg_liveness(co->irg);
/* Phi with some/all of its arguments */
if (is_Reg_Phi(irn)) {
int i, arity;
assert(arch_get_irn_reg_class(arg) == co->cls && "Argument not in same register class.");
if (arg == irn)
continue;
- if (nodes_interfere(co->cenv, irn, arg)) {
+ if (be_values_interfere(lv, irn, arg)) {
unit->inevitable_costs += co->get_costs(irn, i);
continue;
}
unit->costs = XREALLOC(unit->costs, int, unit->node_count);
} else if (is_Perm_Proj(irn)) {
/* Proj of a perm with corresponding arg */
- assert(!nodes_interfere(co->cenv, irn, get_Perm_src(irn)));
+ assert(!be_values_interfere(lv, irn, get_Perm_src(irn)));
unit->nodes = XMALLOCN(ir_node*, 2);
unit->costs = XMALLOCN(int, 2);
unit->node_count = 2;
unit->nodes[0] = irn;
unit->nodes[1] = get_Perm_src(irn);
unit->costs[1] = co->get_costs(irn, -1);
- } else {
+ } else if (arch_register_req_is(req, should_be_same)) {
/* Src == Tgt of a 2-addr-code instruction */
- if (is_2addr_code(req)) {
- const unsigned other = req->other_same;
- int count = 0;
- int i;
+ const unsigned other = req->other_same;
+ int count = 0;
+ int i;
+
+ for (i = 0; (1U << i) <= other; ++i) {
+ if (other & (1U << i)) {
+ ir_node *o = get_irn_n(skip_Proj(irn), i);
+ if (arch_irn_is_ignore(o))
+ continue;
+ if (be_values_interfere(lv, irn, o))
+ continue;
+ ++count;
+ }
+ }
- for (i = 0; (1U << i) <= other; ++i) {
+ if (count != 0) {
+ int k = 0;
+ ++count;
+ unit->nodes = XMALLOCN(ir_node*, count);
+ unit->costs = XMALLOCN(int, count);
+ unit->node_count = count;
+ unit->nodes[k++] = irn;
+
+ for (i = 0; 1U << i <= other; ++i) {
if (other & (1U << i)) {
ir_node *o = get_irn_n(skip_Proj(irn), i);
- if (arch_irn_is_ignore(o))
- continue;
- if (nodes_interfere(co->cenv, irn, o))
- continue;
- ++count;
- }
- }
-
- if (count != 0) {
- int k = 0;
- ++count;
- unit->nodes = XMALLOCN(ir_node*, count);
- unit->costs = XMALLOCN(int, count);
- unit->node_count = count;
- unit->nodes[k++] = irn;
-
- for (i = 0; 1U << i <= other; ++i) {
- if (other & (1U << i)) {
- ir_node *o = get_irn_n(skip_Proj(irn), i);
- if (!arch_irn_is_ignore(o) &&
- !nodes_interfere(co->cenv, irn, o)) {
- unit->nodes[k] = o;
- unit->costs[k] = co->get_costs(irn, -1);
- ++k;
- }
+ if (!arch_irn_is_ignore(o) &&
+ !be_values_interfere(lv, irn, o)) {
+ unit->nodes[k] = o;
+ unit->costs[k] = co->get_costs(irn, -1);
+ ++k;
}
}
}
- } else {
- assert(0 && "This is not an optimizable node!");
}
+ } else {
+ assert(0 && "This is not an optimizable node!");
}
/* Insert the new unit at a position according to its costs */
}
/* Determine the minimal costs this unit will cause: min_nodes_costs */
- unit->min_nodes_costs += unit->all_nodes_costs - ou_max_ind_set_costs(unit);
+ unit->min_nodes_costs += unit->all_nodes_costs - ou_max_ind_set_costs(unit, lv);
/* Insert the new ou according to its sort_key */
tmp = &co->units;
while (tmp->next != &co->units && list_entry_units(tmp->next)->sort_key > unit->sort_key)
if (u1_has_constr != u2_has_constr)
return u2_has_constr - u1_has_constr;
- /* Now check, whether the two units are connected */
-#if 0
- for (i=0; i<u1->node_count; ++i)
- for (o=0; o<u2->node_count; ++o)
- if (u1->nodes[i] == u2->nodes[o])
- return 0;
-#endif
-
/* After all, the sort key decides. Greater keys come first. */
return u2->sort_key - u1->sort_key;
static void co_sort_units(copy_opt_t *co)
{
int i, count = 0, costs;
- unit_t *ou, **ous;
+ unit_t **ous;
/* get the number of ous, remove them form the list and fill the array */
list_for_each_entry(unit_t, ou, &co->units, units)
void co_free_ou_structure(copy_opt_t *co)
{
- unit_t *curr, *tmp;
ASSERT_OU_AVAIL(co);
list_for_each_entry_safe(unit_t, curr, tmp, &co->units, units) {
xfree(curr->nodes);
int co_get_max_copy_costs(const copy_opt_t *co)
{
int i, res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
int co_get_inevit_copy_costs(const copy_opt_t *co)
{
int res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
int co_get_copy_costs(const copy_opt_t *co)
{
int i, res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
int co_get_lower_bound(const copy_opt_t *co)
{
int res = 0;
- unit_t *curr;
ASSERT_OU_AVAIL(co);
void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
{
bitset_t *seen = bitset_malloc(get_irg_last_idx(co->irg));
- affinity_node_t *an;
memset(stat, 0, sizeof(stat[0]));
/* count affinity edges. */
+ be_lv_t *const lv = be_get_irg_liveness(co->irg);
co_gs_foreach_aff_node(co, an) {
- neighb_t *neigh;
stat->aff_nodes += 1;
bitset_set(seen, get_irn_idx(an->irn));
co_gs_foreach_neighb(an, neigh) {
stat->unsatisfied_edges += 1;
}
- if (nodes_interfere(co->cenv, an->irn, neigh->irn)) {
+ if (be_values_interfere(lv, an->irn, neigh->irn)) {
stat->aff_int += 1;
stat->inevit_costs += neigh->costs;
}
int allocnew = 1;
new_node.irn = n1;
- new_node.degree = 0;
new_node.neighbours = NULL;
node = set_insert(affinity_node_t, co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
nbr->next = node->neighbours;
node->neighbours = nbr;
- node->degree++;
}
/* now nbr points to n1's neighbour-entry of n2 */
static inline void add_edges(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs)
{
- if (! be_ifg_connected(co->cenv->ifg, n1, n2)) {
+ be_lv_t *const lv = be_get_irg_liveness(co->irg);
+ if (!be_values_interfere(lv, n1, n2)) {
add_edge(co, n1, n2, costs);
add_edge(co, n2, n1, costs);
}
if (get_irn_mode(irn) == mode_T)
return;
req = arch_get_irn_register_req(irn);
- if (req->cls != co->cls || arch_irn_is_ignore(irn))
+ if (req->cls != co->cls || arch_register_req_is(req, ignore))
return;
if (is_Reg_Phi(irn)) { /* Phis */
} else if (is_Perm_Proj(irn)) { /* Perms */
ir_node *arg = get_Perm_src(irn);
add_edges(co, irn, arg, co->get_costs(irn, -1));
- } else { /* 2-address code */
- if (is_2addr_code(req)) {
- const unsigned other = req->other_same;
- int i;
+ } else if (arch_register_req_is(req, should_be_same)) {
+ const unsigned other = req->other_same;
+ int i;
- for (i = 0; 1U << i <= other; ++i) {
- if (other & (1U << i)) {
- ir_node *other = get_irn_n(skip_Proj(irn), i);
- if (!arch_irn_is_ignore(other))
- add_edges(co, irn, other, co->get_costs(irn, -1));
- }
+ for (i = 0; 1U << i <= other; ++i) {
+ if (other & (1U << i)) {
+ ir_node *other = get_irn_n(skip_Proj(irn), i);
+ if (!arch_irn_is_ignore(other))
+ add_edges(co, irn, other, co->get_costs(irn, -1));
}
}
}
new_node.irn = irn;
n = set_find(affinity_node_t, co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
- if (n) {
- return (n->degree > 0);
- } else
- return 0;
+ return n && n->neighbours;
}
static int co_dump_appel_disjoint_constraints(const copy_opt_t *co, ir_node *a, ir_node *b)
ir_graph *irg = co->irg;
be_irg_t *birg = be_birg_from_irg(irg);
- ir_node *irn;
- nodes_iter_t it;
neighbours_iter_t nit;
int n, n_regs;
unsigned i;
*/
n = n_regs;
- be_ifg_foreach_node(ifg, &it, irn) {
+ be_ifg_foreach_node(ifg, irn) {
if (arch_irn_is_ignore(irn))
continue;
node_map[get_irn_idx(irn)] = n++;
fprintf(f, "%d %d\n", n, n_regs);
- be_ifg_foreach_node(ifg, &it, irn) {
- if (!arch_irn_is_ignore(irn)) {
- int idx = node_map[get_irn_idx(irn)];
- affinity_node_t *a = get_affinity_info(co, irn);
- const arch_register_req_t *req = arch_get_irn_register_req(irn);
- ir_node *adj;
-
- if (arch_register_req_is(req, limited)) {
- for (i = 0; i < co->cls->n_regs; ++i) {
- if (!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
- fprintf(f, "%d %d -1\n", color_map[i], idx);
- }
- }
+ be_ifg_foreach_node(ifg, irn) {
+ arch_register_req_t const *const req = arch_get_irn_register_req(irn);
+ if (arch_register_req_is(req, ignore))
+ continue;
- be_ifg_foreach_neighbour(ifg, &nit, irn, adj) {
- if (!arch_irn_is_ignore(adj) &&
- !co_dump_appel_disjoint_constraints(co, irn, adj)) {
- int adj_idx = node_map[get_irn_idx(adj)];
- if (idx < adj_idx)
- fprintf(f, "%d %d -1\n", idx, adj_idx);
- }
+ int idx = node_map[get_irn_idx(irn)];
+ affinity_node_t *a = get_affinity_info(co, irn);
+
+ if (arch_register_req_is(req, limited)) {
+ for (i = 0; i < co->cls->n_regs; ++i) {
+ if (!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
+ fprintf(f, "%d %d -1\n", color_map[i], idx);
}
+ }
- if (a) {
- neighb_t *n;
+ be_ifg_foreach_neighbour(ifg, &nit, irn, adj) {
+ if (!arch_irn_is_ignore(adj) &&
+ !co_dump_appel_disjoint_constraints(co, irn, adj)) {
+ int adj_idx = node_map[get_irn_idx(adj)];
+ if (idx < adj_idx)
+ fprintf(f, "%d %d -1\n", idx, adj_idx);
+ }
+ }
- co_gs_foreach_neighb(a, n) {
- if (!arch_irn_is_ignore(n->irn)) {
- int n_idx = node_map[get_irn_idx(n->irn)];
- if (idx < n_idx)
- fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
- }
+ if (a) {
+ co_gs_foreach_neighb(a, n) {
+ if (!arch_irn_is_ignore(n->irn)) {
+ int n_idx = node_map[get_irn_idx(n->irn)];
+ if (idx < n_idx)
+ fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
}
}
}
co_complete_stats(co, &before);
- be_stat_ev_ull("co_aff_nodes", before.aff_nodes);
- be_stat_ev_ull("co_aff_edges", before.aff_edges);
- be_stat_ev_ull("co_max_costs", before.max_costs);
- be_stat_ev_ull("co_inevit_costs", before.inevit_costs);
- be_stat_ev_ull("co_aff_int", before.aff_int);
+ stat_ev_ull("co_aff_nodes", before.aff_nodes);
+ stat_ev_ull("co_aff_edges", before.aff_edges);
+ stat_ev_ull("co_max_costs", before.max_costs);
+ stat_ev_ull("co_inevit_costs", before.inevit_costs);
+ stat_ev_ull("co_aff_int", before.aff_int);
- be_stat_ev_ull("co_init_costs", before.costs);
- be_stat_ev_ull("co_init_unsat", before.unsatisfied_edges);
+ stat_ev_ull("co_init_costs", before.costs);
+ stat_ev_ull("co_init_unsat", before.unsatisfied_edges);
if (dump_flags & DUMP_BEFORE) {
FILE *f = my_open(cenv, "", "-before.vcg");
/* do the stats and provide the current costs */
co_complete_stats(co, &stats);
- be_stat_ev_ull("co_prepare_costs", stats.costs);
+ stat_ev_ull("co_prepare_costs", stats.costs);
}
/* perform actual copy minimization */
was_optimal = selected_copyopt->copyopt(co);
ir_timer_stop(timer);
- be_stat_ev("co_time", ir_timer_elapsed_msec(timer));
- be_stat_ev_ull("co_optimal", was_optimal);
+ stat_ev_dbl("co_time", ir_timer_elapsed_msec(timer));
+ stat_ev_ull("co_optimal", was_optimal);
ir_timer_free(timer);
if (dump_flags & DUMP_AFTER) {
fclose(f);
}
- be_stat_ev_ull("co_after_costs", after.costs);
- be_stat_ev_ull("co_after_unsat", after.unsatisfied_edges);
+ stat_ev_ull("co_after_costs", after.costs);
+ stat_ev_ull("co_after_unsat", after.unsatisfied_edges);
co_free_graph_structure(co);
co_free_ou_structure(co);
projects / libfirm / blobdiff