X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbelive_t.h;h=27b27123412197c431b651b612c6f9aa6cf7772b;hb=34e3b8d50bce639e760da7233524a4db85c80290;hp=4f49293822821731a7e2190a75ba261a1518873b;hpb=65a52a96e8ab7ed601d7f98c516d37c46b674b4a;p=libfirm diff --git a/ir/be/belive_t.h b/ir/be/belive_t.h index 4f4929382..27b271234 100644 --- a/ir/be/belive_t.h +++ b/ir/be/belive_t.h @@ -1,20 +1,6 @@ /* - * 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. */ /** @@ -22,120 +8,114 @@ * @brief Internal headers for liveness analysis. * @author Sebastian Hack * @date 06.12.2004 - * @version $Id$ */ #ifndef FIRM_BE_BELIVE_T_H #define FIRM_BE_BELIVE_T_H -#include "irgraph_t.h" -#include "irphase_t.h" +#include +#include "irnodehashmap.h" #include "irhooks.h" -#include "dfs.h" -#include "statev.h" - -#include "pset.h" -#include "bitset.h" - +#include "irlivechk.h" #include "belive.h" +#include "bearch.h" -#define USE_LIVE_CHK - -#ifdef USE_LIVE_CHK -#include "irlivechk.h" -#endif +#define be_is_live_in(lv, bl, irn) _be_is_live_xxx(lv, bl, irn, be_lv_state_in) +#define be_is_live_end(lv, bl, irn) _be_is_live_xxx(lv, bl, irn, be_lv_state_end) +#define be_is_live_out(lv, bl, irn) _be_is_live_xxx(lv, bl, irn, be_lv_state_out) -struct _be_lv_t { - ir_phase ph; - ir_graph *irg; - dfs_t *dfs; - bitset_t *nodes; - hook_entry_t hook_info; -#ifdef USE_LIVE_CHK - lv_chk_t *lvc; -#endif +struct be_lv_t { + ir_nodehashmap_t map; + struct obstack obst; + bool sets_valid; + ir_graph *irg; + lv_chk_t *lvc; }; -struct _be_lv_info_node_t { - unsigned idx; +typedef struct be_lv_info_node_t be_lv_info_node_t; +struct be_lv_info_node_t { + ir_node *node; unsigned flags; }; -struct _be_lv_info_head_t { +struct be_lv_info_head_t { unsigned n_members; unsigned n_size; }; -struct _be_lv_info_t { - union { - struct _be_lv_info_head_t head; - struct _be_lv_info_node_t node; - } u; +union be_lv_info_t { + struct be_lv_info_head_t head; + struct be_lv_info_node_t node; }; -static inline int _be_lv_next_irn(const struct _be_lv_t *lv, const ir_node *bl, unsigned flags, int i) -{ - struct _be_lv_info_t *arr = phase_get_irn_data(&lv->ph, bl); +be_lv_info_node_t *be_lv_get(const be_lv_t *li, const ir_node *block, + const ir_node *irn); - if (arr) { - int n_members = (int) arr[0].u.head.n_members; +static inline unsigned _be_is_live_xxx(const be_lv_t *li, const ir_node *block, + const ir_node *irn, unsigned flags) +{ + unsigned res; - while(i < n_members) { - if(arr[i + 1].u.node.flags & flags) { - return i; - } - ++i; - } + if (li->sets_valid) { + be_lv_info_node_t *info = be_lv_get(li, block, irn); + res = info != NULL ? (info->flags & flags) != 0 : 0; + } else { + res = (lv_chk_bl_xxx(li->lvc, block, irn) & flags) != 0; } - return -1; + return res; } -static inline ir_node *_be_lv_get_irn(const struct _be_lv_t *lv, const ir_node *bl, int i) +typedef struct lv_iterator_t { - struct _be_lv_info_t *arr = phase_get_irn_data(&lv->ph, bl); - return get_idx_irn(lv->irg, arr[i + 1].u.node.idx); -} + be_lv_info_t *info; + size_t i; +} lv_iterator_t; -struct _be_lv_info_node_t *be_lv_get(const struct _be_lv_t *li, const ir_node *bl, const ir_node *irn); - -static inline int _be_is_live_xxx(const struct _be_lv_t *li, const ir_node *block, const ir_node *irn, unsigned flags) +static inline lv_iterator_t be_lv_iteration_begin(const be_lv_t *lv, + const ir_node *block) { - int res; - - if (li->nodes) { - struct _be_lv_info_node_t *info = be_lv_get(li, block, irn); - res = info ? (info->flags & flags) != 0 : 0; - } - -#ifdef USE_LIVE_CHK - else - res = (lv_chk_bl_xxx(li->lvc, block, irn) & flags) != 0; -#endif /* USE_LIVE_CHK */ - + lv_iterator_t res; + res.info = ir_nodehashmap_get(be_lv_info_t, &lv->map, block); + res.i = res.info != NULL ? res.info[0].head.n_members : 0; return res; } -#define be_lv_foreach(lv, bl, flags, i) \ - for (i = _be_lv_next_irn(lv, bl, flags, 0); i >= 0; i = _be_lv_next_irn(lv, bl, flags, i + 1)) - - -static inline pset *_be_lv_pset_put(const struct _be_lv_t *lv, const ir_node *block, int state, pset *s) +static inline ir_node *be_lv_iteration_next(lv_iterator_t *iterator, be_lv_state_t flags) { - int i; - be_lv_foreach(lv, block, state, i) - pset_insert_ptr(s, _be_lv_get_irn(lv, block, i)); - return s; + while (iterator->i != 0) { + const be_lv_info_t *info = iterator->info + iterator->i--; + if (info->node.flags & flags) + return info->node.node; + } + return NULL; } -#define be_lv_get_irn(lv, bl, i) _be_lv_get_irn(lv, bl, i) -#define be_lv_pset_put_in(lv, bl, s) _be_lv_pset_put(lv, bl, be_lv_state_in, s) -#define be_lv_pset_put_out(lv, bl, s) _be_lv_pset_put(lv, bl, be_lv_state_out, s) -#define be_lv_pset_put_end(lv, bl, s) _be_lv_pset_put(lv, bl, be_lv_state_end, s) +static inline ir_node *be_lv_iteration_cls_next(lv_iterator_t *iterator, be_lv_state_t flags, const arch_register_class_t *cls) +{ + while (iterator->i != 0) { + const be_lv_info_t *info = iterator->info + iterator->i--; + if (!(info->node.flags & flags)) + continue; + + ir_node *node = info->node.node; + ir_mode *mode = get_irn_mode(node); + if (!mode_is_datab(mode)) + continue; + if (!arch_irn_consider_in_reg_alloc(cls, node)) + continue; + return node; + } + return NULL; +} -#define be_is_live_in(lv, bl, irn) _be_is_live_xxx(lv, bl, irn, be_lv_state_in) -#define be_is_live_end(lv, bl, irn) _be_is_live_xxx(lv, bl, irn, be_lv_state_end) -#define be_is_live_out(lv, bl, irn) _be_is_live_xxx(lv, bl, irn, be_lv_state_out) +#define be_lv_foreach(lv, block, flags, node) \ + for (bool once = true; once;) \ + for (lv_iterator_t iter = be_lv_iteration_begin((lv), (block)); once; once = false) \ + for (ir_node *node; (node = be_lv_iteration_next(&iter, (flags))) != NULL;) -#define be_lv_has_info_about(lv, irn) bitset_is_set((lv)->nodes, get_irn_idx(irn)) +#define be_lv_foreach_cls(lv, block, flags, cls, node) \ + for (bool once = true; once;) \ + for (lv_iterator_t iter = be_lv_iteration_begin((lv), (block)); once; once = false) \ + for (ir_node *node; (node = be_lv_iteration_cls_next(&iter, (flags), (cls))) != NULL;) #endif