X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur.c;h=1afb06249a57bec350d8ede12318e6e8aa1a6bfd;hb=dfc341ac6f54b4b0922d605e28333be76f487c68;hp=42d40673e80477b577bc00f0e7de34ce2b7b0cd8;hpb=02ae66a3aad03968ce98244e723affdab1fac88e;p=libfirm diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c index 42d40673e..1afb06249 100644 --- a/ir/be/becopyheur.c +++ b/ir/be/becopyheur.c @@ -1,9 +1,29 @@ -/** - * Author: Daniel Grund - * Date: 12.04.2005 - * Copyright: (c) Universitaet Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. +/* + * Copyright (C) 1995-2007 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. + */ +/** + * @file + * @brief First simple copy minimization heuristics. + * @author Daniel Grund + * @date 12.04.2005 + * @version $Id$ + * * Heuristic for minimizing copies using a queue which holds 'qnodes' not yet * examined. A qnode has a 'target color', nodes out of the opt unit and * a 'conflict graph'. 'Conflict graph' = "Interference graph' + 'conflict edges' @@ -16,30 +36,27 @@ #include "config.h" #endif -#ifdef HAVE_ALLOCA_H -#include -#endif -#ifdef HAVE_MALLOC_H -#include -#endif - +#include "debug.h" +#include "bitset.h" +#include "raw_bitset.h" #include "xmalloc.h" -#include "becopyopt.h" + +#include "becopyopt_t.h" #include "becopystat.h" -#include "bitset.h" -#include "bearch.h" +#include "benodesets.h" +#include "bera.h" +#include "beirg_t.h" -static firm_dbg_module_t *dbg = NULL; +DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) #define SEARCH_FREE_COLORS -#define SLOTS_PINNED_GLOBAL 256 +#define SLOTS_PINNED_GLOBAL 64 #define SLOTS_CONFLICTS 8 #define SLOTS_CHANGED_NODES 32 -#define MIN(a,b) ((aqueue */ - const unit_t *ou; /**< the opt unit this qnode belongs to */ - int color; /**< target color */ - set *conflicts; /**< contains conflict_t's. All internal conflicts */ - int mis_costs; /**< costs of nodes/copies in the mis. */ - int mis_size; /**< size of the array below */ - ir_node **mis; /**< the nodes of unit_t->nodes[] being part of the max independent set */ - set *changed_nodes; /**< contains node_stat_t's. */ + struct list_head queue; /**< chaining of unit_t->queue */ + const unit_t *ou; /**< the opt unit this qnode belongs to */ + int color; /**< target color */ + set *conflicts; /**< contains conflict_t's. All internal conflicts */ + int mis_costs; /**< costs of nodes/copies in the mis. */ + int mis_size; /**< size of the array below */ + ir_node **mis; /**< the nodes of unit_t->nodes[] being part of the max independent set */ + set *changed_nodes; /**< contains node_stat_t's. */ } qnode_t; static pset *pinned_global; /**< optimized nodes should not be altered any more */ +static INLINE 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 + return values_interfere(env->birg->lv, a, b); +} + static int set_cmp_conflict_t(const void *x, const void *y, size_t size) { const conflict_t *xx = x; const conflict_t *yy = y; @@ -104,7 +129,7 @@ static INLINE void qnode_add_conflict(const qnode_t *qn, const ir_node *n1, cons static INLINE int qnode_are_conflicting(const qnode_t *qn, const ir_node *n1, const ir_node *n2) { conflict_t c; /* search for live range interference */ - if (n1!=n2 && nodes_interfere(qn->ou->co->chordal_env, n1, n2)) + if (n1!=n2 && nodes_interfere(qn->ou->co->cenv, n1, n2)) return 1; /* search for recoloring conflicts */ if ((int)n1 < (int)n2) { @@ -127,7 +152,7 @@ static int set_cmp_node_stat_t(const void *x, const void *y, size_t size) { static INLINE node_stat_t *qnode_find_node(const qnode_t *qn, ir_node *irn) { node_stat_t find; find.irn = irn; - return set_find(qn->changed_nodes, &find, sizeof(find), HASH_PTR(irn)); + return set_find(qn->changed_nodes, &find, sizeof(find), nodeset_hash(irn)); } /** @@ -139,7 +164,7 @@ static INLINE node_stat_t *qnode_find_or_insert_node(const qnode_t *qn, ir_node find.irn = irn; find.new_color = NO_COLOR; find.pinned_local = 0; - return set_insert(qn->changed_nodes, &find, sizeof(find), HASH_PTR(irn)); + return set_insert(qn->changed_nodes, &find, sizeof(find), nodeset_hash(irn)); } /** @@ -213,9 +238,10 @@ static INLINE void qnode_pin_local(const qnode_t *qn, ir_node *irn) { * */ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const ir_node *trigger) { - const be_chordal_env_t *chordal_env = qn->ou->co->chordal_env; - const arch_register_class_t *cls = chordal_env->cls; - const arch_env_t *arch_env = chordal_env->main_env->arch_env; + copy_opt_t *co = qn->ou->co; + const be_chordal_env_t *chordal_env = co->cenv; + const arch_register_class_t *cls = co->cls; + const arch_env_t *arch_env = co->aenv; int irn_col = qnode_get_new_color(qn, irn); ir_node *sub_res, *curr; be_ifg_t *ifg = chordal_env->ifg; @@ -242,18 +268,19 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const */ if (irn != trigger) { bitset_t *free_cols = bitset_alloca(cls->n_regs); - arch_register_req_t req; + const arch_register_req_t *req; ir_node *curr; int free_col; /* Get all possible colors */ - arch_put_non_ignore_regs(arch_env, cls, free_cols); + bitset_copy(free_cols, co->cenv->ignore_colors); + bitset_flip_all(free_cols); /* Exclude colors not assignable to the irn */ - arch_get_register_req(arch_env, &req, irn, -1); - if (arch_register_req_is(&req, limited)) { + req = arch_get_register_req(arch_env, irn, -1); + if (arch_register_req_is(req, limited)) { bitset_t *limited = bitset_alloca(cls->n_regs); - req.limited(req.limited_env, limited); + rbitset_copy_to_bitset(req->limited, limited); bitset_and(free_cols, limited); } @@ -455,7 +482,7 @@ static INLINE qnode_t *new_qnode(const unit_t *ou, int color) { qnode_t *qn = xmalloc(sizeof(*qn)); qn->ou = ou; qn->color = color; - qn->mis = malloc(ou->node_count * sizeof(*qn->mis)); + qn->mis = xmalloc(ou->node_count * sizeof(*qn->mis)); qn->conflicts = new_set(set_cmp_conflict_t, SLOTS_CONFLICTS); qn->changed_nodes = new_set(set_cmp_node_stat_t, SLOTS_CHANGED_NODES); return qn; @@ -507,10 +534,9 @@ static INLINE void ou_insert_qnode(unit_t *ou, qnode_t *qn) { static void ou_optimize(unit_t *ou) { int i; qnode_t *curr = NULL, *tmp; - arch_env_t *aenv = get_arch_env(ou->co); - const arch_register_class_t *cls = ou->co->chordal_env->cls; + const arch_env_t *aenv = ou->co->aenv; + const arch_register_class_t *cls = ou->co->cls; bitset_t *pos_regs = bitset_alloca(cls->n_regs); - bitset_t *ign_regs = bitset_alloca(cls->n_regs); DBG((dbg, LEVEL_1, "\tOptimizing unit:\n")); for (i=0; inode_count; ++i) @@ -522,8 +548,9 @@ static void ou_optimize(unit_t *ou) { arch_get_allocatable_regs(aenv, ou->nodes[0], -1, pos_regs); /* exclude ingore colors */ - arch_put_non_ignore_regs(aenv, cls, ign_regs); - bitset_and(pos_regs, ign_regs); + bitset_andnot(pos_regs, ou->co->cenv->ignore_colors); + + assert(bitset_popcnt(pos_regs) != 0 && "No register is allowed for this node !!?"); /* create new qnode */ bitset_foreach(pos_regs, i) @@ -576,9 +603,11 @@ static void ou_optimize(unit_t *ou) { free_qnode(curr); } -void co_heur_opt(copy_opt_t *co) { +int co_solve_heuristic(copy_opt_t *co) { unit_t *curr; - dbg = firm_dbg_register("ir.be.copyoptheur"); + FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur"); + + ASSERT_OU_AVAIL(co); pinned_global = pset_new_ptr(SLOTS_PINNED_GLOBAL); list_for_each_entry(unit_t, curr, &co->units, units) @@ -586,4 +615,5 @@ void co_heur_opt(copy_opt_t *co) { ou_optimize(curr); del_pset(pinned_global); + return 0; }