X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fana%2Firbackedge.c;h=6607f216f22c9f325b299eb4a40d5eba485f20ab;hb=2232b14b4acf810ae96a69d1d2a33cf150b695d9;hp=f11c9b32e6151683b9864db7dd396e36bb84b857;hpb=d8980dc3f6aa9413c879261d77b04529a0916fd8;p=libfirm diff --git a/ir/ana/irbackedge.c b/ir/ana/irbackedge.c index f11c9b32e..6607f216f 100644 --- a/ir/ana/irbackedge.c +++ b/ir/ana/irbackedge.c @@ -1,20 +1,39 @@ -/* Copyright (C) 2002 by Universitaet Karlsruhe -* All rights reserved. -* -* Authors: Goetz Lindenmaier -* -* irbackedges.c Access function for backedges. -* -*/ +/* + * Copyright (C) 1995-2011 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. + */ -/* $Id$ */ +/** + * @file + * @brief Access function for backedges. + * @author Goetz Lindenmaier + * @date 7.2002 + * @version $Id$ + */ +#include "config.h" #include "irnode_t.h" +#include "irgraph_t.h" #include "array.h" #include "irbackedge_t.h" +#include "raw_bitset.h" /*--------------------------------------------------------------------*/ -/* Backedge information. * */ +/* Backedge information. */ /*--------------------------------------------------------------------*/ @@ -25,128 +44,126 @@ * Does not assert whether the backarray is correct -- use * very careful! */ -static INLINE int *mere_get_backarray(ir_node *n) { - switch(get_irn_opcode(n)) { - case iro_Block: - if (!get_Block_matured(n)) return NULL; - if (interprocedural_view && n->attr.block.in_cg) { - assert(n->attr.block.cg_backedge && "backedge array not allocated!"); - return n->attr.block.cg_backedge; - } else { - assert(n->attr.block.backedge && "backedge array not allocated!"); - return n->attr.block.backedge; - } - break; - case iro_Phi: - assert(n->attr.phi_backedge && "backedge array not allocated!"); - return n->attr.phi_backedge; - break; - case iro_Filter: - if (interprocedural_view) { - assert(n->attr.filter.backedge && "backedge array not allocated!"); - return n->attr.filter.backedge; - } - break; - default: ; - } - return NULL; +static bitset_t *mere_get_backarray(const ir_node *n) +{ + switch (get_irn_opcode(n)) { + case iro_Block: + if (!get_Block_matured(n)) return NULL; + + assert(n->attr.block.backedge && "backedge array not allocated!"); + return n->attr.block.backedge; + case iro_Phi: + assert(n->attr.phi.u.backedge && "backedge array not allocated!"); + return n->attr.phi.u.backedge; + default: + break; + } + return NULL; } /** * Returns backarray if the node can have backedges, else returns * NULL. */ -static INLINE int *get_backarray(ir_node *n) { - int *ba = mere_get_backarray(n); - - if (ba) { - int bal = ARR_LEN(ba); /* avoid makro expansion in assertion. */ - int inl = ARR_LEN(get_irn_in(n)) -1; /* Use get_irn_in -- sensitive to view! */ - assert(bal == inl && "backedge array with faulty length"); - } - - return ba; +static bitset_t *get_backarray(const ir_node *n) +{ + bitset_t *ba = mere_get_backarray(n); + +#ifndef NDEBUG + if (ba) { + size_t bal = bitset_size(ba); /* avoid macro expansion in assertion. */ + size_t inl = get_irn_arity(n); + assert(bal == inl && "backedge array with faulty length"); + } +#endif + + return ba; } +#ifndef NDEBUG /** - * Returns true if node has no backarray, or - * if size of backarray == size of in array. + * Returns non-zero if node has no backarray, or + * if size of backarray == size of in array. */ -static INLINE bool legal_backarray (ir_node *n) { - int *ba = mere_get_backarray(n); - if (ba && (ARR_LEN(ba) != ARR_LEN(get_irn_in(n))-1)) /* Use get_irn_in -- sensitive to view! */ - return false; - return true; +static int legal_backarray(const ir_node *n) +{ + bitset_t *ba = mere_get_backarray(n); + if (ba && (bitset_size(ba) != (unsigned) get_irn_arity(n))) + return 0; + return 1; } - - -INLINE void fix_backedges(struct obstack *obst, ir_node *n) { - opcode opc = get_irn_opcode(n); - int *arr = mere_get_backarray(n); - if (ARR_LEN(arr) == ARR_LEN(get_irn_in(n))-1) - return; - if (ARR_LEN(arr) != ARR_LEN(get_irn_in(n))-1) { - arr = new_backedge_arr(obst, ARR_LEN(get_irn_in(n))-1); - if (opc == iro_Phi) n->attr.phi_backedge = arr; - if ((opc == iro_Block) && !interprocedural_view) - n->attr.block.backedge = arr; - if ((opc == iro_Block) && interprocedural_view) - n->attr.block.cg_backedge = arr; - if (opc == iro_Filter) n->attr.filter.backedge = arr; - return; - } - assert(legal_backarray(n)); - /* @@@ more efficient in memory consumption, not possible with - array implementation. - if (ARR_LEN(arr) < ARR_LEN(get_irn_in(n))-1) { - ARR_SETLEN(int, arr, ARR_LEN(get_irn_in(n))-1); - }*/ +#endif + +void fix_backedges(struct obstack *obst, ir_node *n) +{ + bitset_t *arr = mere_get_backarray(n); + unsigned opc; + int arity; + + if (! arr) + return; + + arity = get_irn_arity(n); + if (bitset_size(arr) != (unsigned) arity) { + arr = new_backedge_arr(obst, arity); + + opc = get_irn_opcode(n); + if (opc == iro_Phi) + n->attr.phi.u.backedge = arr; + else if (opc == iro_Block) { + n->attr.block.backedge = arr; + } + } + + assert(legal_backarray(n)); } -/** Returns true if the predesessor pos is a backedge. */ -bool is_backedge (ir_node *n, int pos) { - int *ba = get_backarray (n); - if (ba) return ba[pos]; - return false; +/* Returns non-zero if the predecessor pos is a backedge. */ +int is_backedge(const ir_node *n, int pos) +{ + bitset_t *ba = get_backarray(n); + if (ba) + return bitset_is_set(ba, pos); + return 0; } -/** Remarks that edge pos is a backedge. */ -void set_backedge (ir_node *n, int pos) { - int *ba = get_backarray (n); - assert(ba && "can only set backedges at Phi, Filter, Block nodes."); - ba[pos] = 1; +/* Remarks that edge pos is a backedge. */ +void set_backedge(ir_node *n, int pos) +{ + bitset_t *ba = get_backarray(n); + assert(ba && "can only set backedges at Phi, Block nodes."); + bitset_set(ba, pos); } -/** Remarks that edge pos is a backedge. */ -void set_not_backedge (ir_node *n, int pos) { - int *ba = get_backarray (n); - assert(ba && "can only set backedges at Phi, Filter, Block nodes."); - ba[pos] = 0; +/* Remarks that edge pos is a backedge. */ +void set_not_backedge(ir_node *n, int pos) +{ + bitset_t *ba = get_backarray(n); + assert(ba && "can only set backedges at Phi, Block nodes."); + bitset_clear(ba, pos); } -/** Returns true if n has backedges. */ -bool has_backedges (ir_node *n) { - int i; - int *ba = get_backarray (n); - if (ba) - for (i = 0; i < get_irn_arity(n); i++) - if (ba[i]) return true; - return false; +/* Returns non-zero if n has backedges. */ +int has_backedges(const ir_node *n) +{ + bitset_t *ba = get_backarray(n); + if (ba != NULL) { + return !bitset_is_empty(ba); + } + return 0; } /** Sets all backedge information to zero. */ -void clear_backedges (ir_node *n) { - int i, rem = interprocedural_view; - int *ba; - interprocedural_view = 0; - ba = get_backarray (n); - if (ba) - for (i = 0; i < get_irn_arity(n); i++) - ba[i] = 0; - interprocedural_view = 1; - ba = get_backarray (n); - if (ba) - for (i = 0; i < get_irn_arity(n); i++) - ba[i] = 0; - interprocedural_view = rem; +void clear_backedges(ir_node *n) +{ + bitset_t *ba = get_backarray(n); + if (ba != NULL) { + bitset_clear_all(ba); + } +} + +/* Allocate a new backedge array on the obstack for given size. */ +bitset_t *new_backedge_arr(struct obstack *obst, size_t size) +{ + return bitset_obstack_alloc(obst, size); }