X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur.c;h=af9fd5ef7049e658d4119db349a452bc106ccf32;hb=501a13c6429ecb1de1cbb274782e67fa0030b970;hp=1dfb38f878367304eaaba3e1dcd432aaa3a7a2af;hpb=719b0dc8377fc55decc4629bf5e523104a82b76f;p=libfirm diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c index 1dfb38f87..af9fd5ef7 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,20 +36,18 @@ #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_t.h" #include "becopystat.h" -#include "bitset.h" +#include "benodesets.h" +#include "beintlive_t.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 @@ -38,7 +56,7 @@ static firm_dbg_module_t *dbg = NULL; #define SLOTS_CHANGED_NODES 32 #define list_entry_queue(lh) list_entry(lh, qnode_t, queue) -#define HASH_CONFLICT(c) (HASH_PTR(c.n1) ^ HASH_PTR(c.n2)) +#define HASH_CONFLICT(c) (nodeset_hash(c.n1) ^ nodeset_hash(c.n2)) /** * Modeling additional conflicts between nodes. NOT live range interference @@ -53,26 +71,34 @@ typedef struct _conflict_t { */ typedef struct _node_stat_t { ir_node *irn; - int new_color; - int pinned_local :1; + int new_color; + int pinned_local :1; } node_stat_t; /** * Represents a node in the optimization queue. */ typedef struct _qnode_t { - 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. */ + 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, 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; @@ -126,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)); } /** @@ -138,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)); } /** @@ -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; @@ -510,7 +537,6 @@ static void ou_optimize(unit_t *ou) { 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) @@ -578,7 +605,9 @@ static void ou_optimize(unit_t *ou) { 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,6 +615,5 @@ int co_solve_heuristic(copy_opt_t *co) { ou_optimize(curr); del_pset(pinned_global); - return 0; }