X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyopt_t.h;h=2519c648767407507c0eeaf19c8f3d599243a7e7;hb=69c991e03a0eb1b284e6d0c41623d340a8e26d16;hp=bee1e1598d705bad76f0fa40f6a2edd56d5b579f;hpb=94b02881010e09aabe313564771b2e99273c4196;p=libfirm diff --git a/ir/be/becopyopt_t.h b/ir/be/becopyopt_t.h index bee1e1598..2519c6487 100644 --- a/ir/be/becopyopt_t.h +++ b/ir/be/becopyopt_t.h @@ -1,18 +1,38 @@ -/** - * Author: Daniel Grund - * Date: 12.04.2005 - * Copyright: (c) Universitaet Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. +/* + * 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. * - * Internal header for copy optimization problem. + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. */ -#ifndef _BECOPYOPT_T_H -#define _BECOPYOPT_T_H +/** + * @file + * @brief Internal header for copy optimization problem. + * @author Daniel Grund + * @date 12.04.2005 + * @version $Id$ + */ +#ifndef FIRM_BE_BECOPYOPT_T_H +#define FIRM_BE_BECOPYOPT_T_H -#include +#include "obst.h" #include "list.h" -#include "bearch.h" +#include "set.h" +#include "irnode_t.h" + +#include "bearch_t.h" #include "bechordal_t.h" #include "becopyopt.h" @@ -20,39 +40,38 @@ * Data representing the problem of copy minimization. */ struct _copy_opt_t { - be_chordal_env_t *cenv; + be_chordal_env_t *cenv; const arch_register_class_t *cls; - const arch_env_t *aenv; - ir_graph *irg; - char *name; /**< ProgName__IrgName__RegClassName */ - cost_fct_t get_costs; /**< function ptr used to get costs for copies */ + ir_graph *irg; + char *name; /**< ProgName__IrgName__RegClassName */ + cost_fct_t get_costs; /**< function ptr used to get costs for copies */ /** Representation as optimization units */ - struct list_head units; /**< all units to optimize in specific order */ + struct list_head units; /**< all units to optimize in specific order */ /** Representation in graph structure. Only build on demand */ struct obstack obst; - set *nodes; + set *nodes; }; /* Helpers */ -#define get_irn_col(co, irn) arch_register_get_index(arch_get_irn_register((co)->aenv, irn)) -#define set_irn_col(co, irn, col) arch_set_irn_register((co)->aenv, irn, arch_register_for_index((co)->cls, col)) -#define is_curr_reg_class(co, irn) (arch_get_irn_reg_class((co)->aenv, irn, -1) == (co)->cls) +#define ASSERT_OU_AVAIL(co) assert((co)->units.next && "Representation as optimization-units not build") +#define ASSERT_GS_AVAIL(co) assert((co)->nodes && "Representation as graph not build") -#define MIN(a,b) ((acls, col)) #define list_entry_units(lh) list_entry(lh, unit_t, units) #define is_Reg_Phi(irn) (is_Phi(irn) && mode_is_data(get_irn_mode(irn))) -#define get_Perm_src(irn) (get_irn_n(get_Proj_pred(irn), get_Proj_proj(irn))) -#define is_Perm(arch_env, irn) (arch_irn_classify(arch_env, irn) == arch_irn_class_perm) -#define is_Perm_Proj(arch_env, irn) (is_Proj(irn) && is_Perm(arch_env, get_Proj_pred(irn))) - -#define is_2addr_code(arch_env, irn, req) (arch_get_register_req(arch_env, req, irn, -1)->type == arch_register_req_type_should_be_same) +#define get_Perm_src(irn) (get_irn_n(get_Proj_pred(irn), get_Proj_proj(irn))) +#define is_Perm_Proj(irn) (is_Proj(irn) && be_is_Perm(get_Proj_pred(irn))) +static inline int is_2addr_code(const arch_register_req_t *req) +{ + return (req->type & arch_register_req_type_should_be_same) != 0; +} /****************************************************************************** ____ _ _ _ _ _ _____ _ @@ -68,18 +87,18 @@ struct _copy_opt_t { #define MIS_HEUR_TRIGGER 8 typedef struct _unit_t { - struct list_head units; /**< chain for all units */ - copy_opt_t *co; /**< the copy opt this unit belongs to */ - int node_count; /**< size of the nodes array */ - ir_node **nodes; /**< [0] is the root-node, others are non interfering args of it. */ - int *costs; /**< costs[i] are incurred, if nodes[i] has a different color */ - int inevitable_costs; /**< sum of costs of all args interfering with root */ - int all_nodes_costs; /**< sum of all costs[i] */ - int min_nodes_costs; /**< a lower bound for the costs in costs[], determined by a max independent set */ - int sort_key; /**< maximum costs. controls the order of ou's in the struct list_head units. */ + struct list_head units; /**< chain for all units */ + copy_opt_t *co; /**< the copy opt this unit belongs to */ + int node_count; /**< size of the nodes array */ + ir_node **nodes; /**< [0] is the root-node, others are non interfering args of it. */ + int *costs; /**< costs[i] are incurred, if nodes[i] has a different color */ + int inevitable_costs; /**< sum of costs of all args interfering with root */ + int all_nodes_costs; /**< sum of all costs[i] */ + int min_nodes_costs; /**< a lower bound for the costs in costs[], determined by a max independent set */ + int sort_key; /**< maximum costs. controls the order of ou's in the struct list_head units. */ /* for heuristic */ - struct list_head queue; /**< list of qn's sorted by weight of qn-mis */ + struct list_head queue; /**< list of qn's sorted by weight of qn-mis */ } unit_t; @@ -96,26 +115,37 @@ typedef struct _unit_t { ******************************************************************************/ typedef struct _neighb_t neighb_t; -typedef struct _node_t node_t; - +typedef struct _affinity_node_t affinity_node_t; struct _neighb_t { - neighb_t *next; /** the next neighbour entry*/ - ir_node *irn; /** the neighbour itself */ - int costs; /** the costs of the edge (node_t->irn, neighb_t->irn) */ + neighb_t *next; /** the next neighbour entry*/ + const ir_node *irn; /** the neighbour itself */ + int costs; /** the costs of the edge (affinity_node_t->irn, neighb_t->irn) */ }; -struct _node_t { - ir_node *irn; /** a node with affinity edges */ - int count; /** number of affinity edges in the linked list below */ - neighb_t *neighbours; /** a linked list of all affinity neighbours */ +struct _affinity_node_t { + const ir_node *irn; /** a node with affinity edges */ + int degree; /** number of affinity edges in the linked list below */ + neighb_t *neighbours; /** a linked list of all affinity neighbours */ + void *data; /** stuff that is attachable. */ }; + +static inline affinity_node_t *get_affinity_info(const copy_opt_t *co, const ir_node *irn) { + affinity_node_t find; + + ASSERT_GS_AVAIL(co); + + find.irn = irn; + return set_find(co->nodes, &find, sizeof(find), hash_irn(irn)); +} + #define co_gs_nodes_begin(co) set_first((co)->nodes) #define co_gs_nodes_next(co) set_next((co)->nodes) #define co_gs_nodes_break(co) set_break((co)->nodes) -#define co_gs_foreach_node(co, node) for (node = co_gs_nodes_begin(co); node; node = co_gs_nodes_next(co)) -#define co_gs_foreach_neighb(node, neighb) for (neighb = node->neighbours; neighb; neighb = neighb->next) +#define co_gs_foreach_aff_node(co, aff_node) for (aff_node = co_gs_nodes_begin(co); aff_node; aff_node = co_gs_nodes_next(co)) +#define co_gs_foreach_neighb(aff_node, neighb) for (neighb = aff_node->neighbours; neighb; neighb = neighb->next) + -#endif +#endif /* FIRM_BE_BECOPYOPT_T_H */