X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firbackedge.c;h=d0aca0e1f283d6b5cf4fbd98849a88eac8eca5b6;hb=3aeb68ad2fefc380a05eccba1a8105ddbbd4ab21;hp=0b3bc8219db5ded85603b0ef4be4496c527d9a74;hpb=f57a7ef2f9c161fc1815dd10098d61bb4259eb5f;p=libfirm diff --git a/ir/ana/irbackedge.c b/ir/ana/irbackedge.c index 0b3bc8219..d0aca0e1f 100644 --- a/ir/ana/irbackedge.c +++ b/ir/ana/irbackedge.c @@ -1,144 +1,162 @@ -/* Copyright (C) 2002 by Universitaet Karlsruhe -* All rights reserved. -* -* Authors: Goetz Lindenmaier -* -* irbackedges.c Access function for backedges. -* -*/ - -/* $Id$ */ +/* + * 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. + */ + +/** + * @file + * @brief Access function for backedges. + * @author Goetz Lindenmaier + * @date 7.2002 + */ +#include "config.h" #include "irnode_t.h" +#include "irgraph_t.h" #include "array.h" #include "irbackedge_t.h" - -/**********************************************************************/ -/** Backedge information. **/ -/**********************************************************************/ - - -/* Returns backarray if the node can have backedges. Else returns - NULL. 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; +#include "raw_bitset.h" + +/*--------------------------------------------------------------------*/ +/* Backedge information. */ +/*--------------------------------------------------------------------*/ + + +/** + * Returns backarray if the node can have backedges, else returns + * NULL. + * + * Does not assert whether the backarray is correct -- use + * very careful! + */ +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; +/** + * Returns backarray if the node can have backedges, else returns + * NULL. + */ +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; } -/* returns true 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; +#ifndef NDEBUG +/** + * Returns non-zero if node has no backarray, or + * if size of backarray == size of in array. + */ +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; +} +#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)); } - -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); - //} +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; } -/* 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; +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_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; +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); } -/* 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; +int has_backedges(const ir_node *n) +{ + bitset_t *ba = get_backarray(n); + if (ba != NULL) { + return !bitset_is_empty(ba); + } + return 0; } -/* 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; +void clear_backedges(ir_node *n) +{ + bitset_t *ba = get_backarray(n); + if (ba != NULL) { + bitset_clear_all(ba); + } } -/* 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; +bitset_t *new_backedge_arr(struct obstack *obst, size_t size) +{ + return bitset_obstack_alloc(obst, size); }