tree-flow.h revision 225736
1139790Simp/* Data and Control Flow Analysis for Trees. 2738Sache Copyright (C) 2001, 2003, 2004, 2005 Free Software Foundation, Inc. 34Srgrimes Contributed by Diego Novillo <dnovillo@redhat.com> 4738Sache 5738SacheThis file is part of GCC. 6106323Smdodd 74SrgrimesGCC is free software; you can redistribute it and/or modify 84Srgrimesit under the terms of the GNU General Public License as published by 9115703Sobrienthe Free Software Foundation; either version 2, or (at your option) 10115703Sobrienany later version. 11115703Sobrien 122056SwollmanGCC is distributed in the hope that it will be useful, 132056Swollmanbut WITHOUT ANY WARRANTY; without even the implied warranty of 142056SwollmanMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1561994SmsmithGNU General Public License for more details. 162056Swollman 1712675SjulianYou should have received a copy of the GNU General Public License 1852843Sphkalong with GCC; see the file COPYING. If not, write to 1960038Sphkthe Free Software Foundation, 51 Franklin Street, Fifth Floor, 207090SbdeBoston, MA 02110-1301, USA. */ 21152306Sru 224Srgrimes#ifndef _TREE_FLOW_H 2312675Sjulian#define _TREE_FLOW_H 1 2412675Sjulian 2512675Sjulian#include "bitmap.h" 2612675Sjulian#include "hard-reg-set.h" 2712502Sjulian#include "basic-block.h" 2847625Sphk#include "hashtab.h" 29126080Sphk#include "tree-gimple.h" 30126080Sphk#include "tree-ssa-operands.h" 31111815Sphk#include "cgraph.h" 32111815Sphk#include "ipa-reference.h" 33111815Sphk 34111815Sphk/* Forward declare structures for the garbage collector GTY markers. */ 35111815Sphk#ifndef GCC_BASIC_BLOCK_H 3647625Sphkstruct edge_def; 3712675Sjuliantypedef struct edge_def *edge; 3869774Sphkstruct basic_block_def; 3960038Sphktypedef struct basic_block_def *basic_block; 40179004Sphk#endif 41179004Sphk 424Srgrimes/* True if the code is in ssa form. */ 4319174Sbdeextern bool in_ssa_p; 444Srgrimes 454Srgrimestypedef struct 464Srgrimes{ 474Srgrimes htab_t htab; 4819174Sbde PTR *slot; 494Srgrimes PTR *limit; 504Srgrimes} htab_iterator; 514Srgrimes 524Srgrimes/* Iterate through the elements of hashtable HTAB, using htab_iterator ITER, 53766Sache storing each element in RESULT, which is of type TYPE. */ 54766Sache#define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \ 554Srgrimes for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \ 56170278Sbrian !end_htab_p (&(ITER)); \ 57170278Sbrian RESULT = (TYPE) next_htab_element (&(ITER))) 5892765Salfred 5992765Salfred/*--------------------------------------------------------------------------- 6092765Salfred Attributes for SSA_NAMEs. 6112854Sbde 62179004Sphk NOTE: These structures are stored in struct tree_ssa_name 63179004Sphk but are only used by the tree optimizers, so it makes better sense 64179004Sphk to declare them here to avoid recompiling unrelated files when 6517232Sjoerg making changes. 66179004Sphk---------------------------------------------------------------------------*/ 674Srgrimes 68179004Sphk/* Aliasing information for SSA_NAMEs representing pointer variables. */ 694Srgrimesstruct ptr_info_def GTY(()) 70179004Sphk{ 71179004Sphk /* Nonzero if points-to analysis couldn't determine where this pointer 728288Sdg is pointing to. */ 734Srgrimes unsigned int pt_anything : 1; 74179004Sphk 754Srgrimes /* Nonzero if the value of this pointer escapes the current function. */ 764Srgrimes unsigned int value_escapes_p : 1; 77179004Sphk 78179004Sphk /* Nonzero if this pointer is dereferenced. */ 791393Ssos unsigned int is_dereferenced : 1; 80179004Sphk 81179004Sphk /* Nonzero if this pointer points to a global variable. */ 82179004Sphk unsigned int pt_global_mem : 1; 83179004Sphk 84179004Sphk /* Nonzero if this pointer points to NULL. */ 8517232Sjoerg unsigned int pt_null : 1; 86179004Sphk 87179004Sphk /* Set of variables that this pointer may point to. */ 88179004Sphk bitmap pt_vars; 894Srgrimes 90179004Sphk /* If this pointer has been dereferenced, and points-to information is 91179004Sphk more precise than type-based aliasing, indirect references to this 92179004Sphk pointer will be represented by this memory tag, instead of the type 93179004Sphk tag computed by TBAA. */ 94179004Sphk tree name_mem_tag; 95179004Sphk 96179004Sphk /* Mask of reasons this pointer's value escapes the function */ 97179004Sphk unsigned int escape_mask; 98179004Sphk}; 99179004Sphk 100179004Sphk 1014Srgrimes/*--------------------------------------------------------------------------- 1024Srgrimes Tree annotations stored in tree_common.ann 103179004Sphk---------------------------------------------------------------------------*/ 104179004Sphkenum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, FUNCTION_ANN, STMT_ANN }; 105179004Sphk 10617232Sjoergstruct tree_ann_common_d GTY(()) 107179004Sphk{ 1084Srgrimes /* Annotation type. */ 109179004Sphk enum tree_ann_type type; 110170278Sbrian 111179004Sphk /* Auxiliary info specific to a pass. At all times, this 112179004Sphk should either point to valid data or be NULL. */ 113179004Sphk PTR GTY ((skip (""))) aux; 114179004Sphk 115179004Sphk /* The value handle for this expression. Used by GVN-PRE. */ 1164Srgrimes tree GTY((skip)) value_handle; 117179004Sphk}; 1184Srgrimes 119179004Sphk/* It is advantageous to avoid things like life analysis for variables which 120179004Sphk do not need PHI nodes. This enum describes whether or not a particular 121179004Sphk variable may need a PHI node. */ 1224Srgrimes 1234Srgrimesenum need_phi_state { 124179004Sphk /* This is the default. If we are still in this state after finding 125179004Sphk all the definition and use sites, then we will assume the variable 1264Srgrimes needs PHI nodes. This is probably an overly conservative assumption. */ 127738Sache NEED_PHI_STATE_UNKNOWN, 128738Sache 1294Srgrimes /* This state indicates that we have seen one or more sets of the 1304Srgrimes variable in a single basic block and that the sets dominate all 1314Srgrimes uses seen so far. If after finding all definition and use sites 1324Srgrimes we are still in this state, then the variable does not need any 133229157Smdf PHI nodes. */ 1344Srgrimes NEED_PHI_STATE_NO, 135229157Smdf 1364Srgrimes /* This state indicates that we have either seen multiple definitions of 1374Srgrimes the variable in multiple blocks, or that we encountered a use in a 1384Srgrimes block that was not dominated by the block containing the set(s) of 1394Srgrimes this variable. This variable is assumed to need PHI nodes. */ 1404Srgrimes NEED_PHI_STATE_MAYBE 1414Srgrimes}; 1424Srgrimes 1434Srgrimesstruct subvar; 1444Srgrimestypedef struct subvar *subvar_t; 1454Srgrimes 1464Srgrimes/* This structure represents a fake sub-variable for a structure field. */ 1474Srgrimesstruct subvar GTY(()) 1484Srgrimes{ 1494Srgrimes /* Fake variable. */ 1504Srgrimes tree var; 1514Srgrimes 1524Srgrimes /* Next subvar for this structure. */ 1534Srgrimes subvar_t next; 1544Srgrimes}; 1554Srgrimes 1564Srgrimesstruct var_ann_d GTY(()) 1574Srgrimes{ 1584Srgrimes struct tree_ann_common_d common; 1594Srgrimes 1604Srgrimes /* Used by the out of SSA pass to determine whether this variable has 1614Srgrimes been seen yet or not. */ 1624Srgrimes unsigned out_of_ssa_tag : 1; 1634Srgrimes 1644Srgrimes /* Used when building root_var structures in tree_ssa_live.[ch]. */ 1654Srgrimes unsigned root_var_processed : 1; 1664Srgrimes 1674Srgrimes /* Nonzero if this variable is in the alias set of another variable. */ 1684Srgrimes unsigned is_aliased : 1; 1694Srgrimes 1704Srgrimes /* Nonzero if this variable was used after SSA optimizations were 1714Srgrimes applied. We set this when translating out of SSA form. */ 1724Srgrimes unsigned used : 1; 1734Srgrimes 1744Srgrimes /* This field indicates whether or not the variable may need PHI nodes. 1754Srgrimes See the enum's definition for more detailed information about the 1764Srgrimes states. */ 1774Srgrimes ENUM_BITFIELD (need_phi_state) need_phi_state : 2; 1784Srgrimes 1794Srgrimes /* Used during operand processing to determine if this variable is already 1804Srgrimes in the vuse list. */ 1814Srgrimes unsigned in_vuse_list : 1; 1824Srgrimes 1834Srgrimes /* Used during operand processing to determine if this variable is already 1844Srgrimes in the v_may_def list. */ 1854Srgrimes unsigned in_v_may_def_list : 1; 1864Srgrimes 18717232Sjoerg /* An artificial variable representing the memory location pointed-to by 18817232Sjoerg all the pointer symbols that flow-insensitive alias analysis 1894Srgrimes (mostly type-based) considers to be aliased. If the variable is 1904Srgrimes not a pointer or if it is never dereferenced, this must be NULL. */ 191170280Sbrian tree symbol_mem_tag; 1924Srgrimes 1934Srgrimes /* Variables that may alias this variable. */ 1944Srgrimes VEC(tree, gc) *may_aliases; 1954Srgrimes 1964Srgrimes /* Used when going out of SSA form to indicate which partition this 1974Srgrimes variable represents storage for. */ 198179004Sphk unsigned partition; 199179004Sphk 200179004Sphk /* Used by the root-var object in tree-ssa-live.[ch]. */ 20117232Sjoerg unsigned root_index; 202179004Sphk 2034Srgrimes /* During into-ssa and the dominator optimizer, this field holds the 204179004Sphk current version of this variable (an SSA_NAME). */ 2054Srgrimes tree current_def; 206179004Sphk 207179004Sphk /* If this variable is a structure, this fields holds a list of 208179004Sphk symbols representing each of the fields of the structure. */ 209179004Sphk subvar_t subvars; 210179004Sphk 211179004Sphk /* Mask of values saying the reasons why this variable has escaped 2124Srgrimes the function. */ 213179004Sphk unsigned int escape_mask; 214179004Sphk}; 2158288Sdg 216179004Sphkstruct function_ann_d GTY(()) 217179004Sphk{ 218179004Sphk struct tree_ann_common_d common; 219179004Sphk 220179004Sphk /* Pointer to the structure that contains the sets of global 221179004Sphk variables modified by function calls. This field is only used 2224Srgrimes for FUNCTION_DECLs. */ 2234Srgrimes ipa_reference_vars_info_t GTY ((skip)) reference_vars_info; 224179004Sphk}; 2254Srgrimes 2264Srgrimestypedef struct immediate_use_iterator_d 2274Srgrimes{ 228179004Sphk /* This is the current use the iterator is processing. */ 229179004Sphk ssa_use_operand_t *imm_use; 230179004Sphk /* This marks the last use in the list (use node from SSA_NAME) */ 231179004Sphk ssa_use_operand_t *end_p; 2324Srgrimes /* This node is inserted and used to mark the end of the uses for a stmt. */ 2334Srgrimes ssa_use_operand_t iter_node; 234179004Sphk /* This is the next ssa_name to visit. IMM_USE may get removed before 235179004Sphk the next one is traversed to, so it must be cached early. */ 236179004Sphk ssa_use_operand_t *next_imm_name; 23717232Sjoerg} imm_use_iterator; 238179004Sphk 2394Srgrimes 240179004Sphk/* Use this iterator when simply looking at stmts. Adding, deleting or 2414Srgrimes modifying stmts will cause this iterator to malfunction. */ 2424Srgrimes 2434Srgrimes#define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ 244179004Sphk for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ 245179004Sphk !end_readonly_imm_use_p (&(ITER)); \ 246179004Sphk (DEST) = next_readonly_imm_use (&(ITER))) 2474Srgrimes 2484Srgrimes/* Use this iterator to visit each stmt which has a use of SSAVAR. */ 249179004Sphk 2504Srgrimes#define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ 2514Srgrimes for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ 252179004Sphk !end_imm_use_stmt_p (&(ITER)); \ 253179004Sphk (STMT) = next_imm_use_stmt (&(ITER))) 254179004Sphk 255179004Sphk/* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to 256179004Sphk do so will result in leaving a iterator marker node in the immediate 257179004Sphk use list, and nothing good will come from that. */ 258179004Sphk#define BREAK_FROM_IMM_USE_STMT(ITER) \ 259179004Sphk { \ 260179004Sphk end_imm_use_stmt_traverse (&(ITER)); \ 261179004Sphk break; \ 2624Srgrimes } 263179004Sphk 264179004Sphk 265179004Sphk/* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to 266179004Sphk get access to each occurrence of ssavar on the stmt returned by 267179004Sphk that iterator.. for instance: 268179004Sphk 269179004Sphk FOR_EACH_IMM_USE_STMT (stmt, iter, var) 270179004Sphk { 271179004Sphk FOR_EACH_IMM_USE_ON_STMT (use_p, iter) 272179004Sphk { 2734Srgrimes SET_USE (use_p) = blah; 274179004Sphk } 275179004Sphk update_stmt (stmt); 276179004Sphk } */ 277179004Sphk 278179004Sphk#define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ 279179004Sphk for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ 280179004Sphk !end_imm_use_on_stmt_p (&(ITER)); \ 281179004Sphk (DEST) = next_imm_use_on_stmt (&(ITER))) 282179004Sphk 283179004Sphk 284179004Sphk 2854Srgrimesstruct stmt_ann_d GTY(()) 286179004Sphk{ 287179004Sphk struct tree_ann_common_d common; 288179004Sphk 289179004Sphk /* Nonzero if the statement has been modified (meaning that the operands 290179004Sphk need to be scanned again). */ 291179004Sphk unsigned modified : 1; 292179004Sphk 293179004Sphk /* Nonzero if the statement makes references to volatile storage. */ 2944Srgrimes unsigned has_volatile_ops : 1; 295179004Sphk 296179004Sphk /* Nonzero if the statement makes a function call that may clobber global 297179004Sphk and local addressable variables. */ 298179004Sphk unsigned makes_clobbering_call : 1; 2994Srgrimes 300179004Sphk /* Basic block that contains this statement. */ 301179004Sphk basic_block bb; 302179004Sphk 303179004Sphk /* Operand cache for stmt. */ 304179004Sphk struct stmt_operands_d GTY ((skip (""))) operands; 3054Srgrimes 306179004Sphk /* Set of variables that have had their address taken in the statement. */ 307179004Sphk bitmap addresses_taken; 308179004Sphk 309179004Sphk /* Unique identifier for this statement. These ID's are to be created 310179004Sphk by each pass on an as-needed basis in any order convenient for the 311179004Sphk pass which needs statement UIDs. */ 312179004Sphk unsigned int uid; 3134Srgrimes 314179004Sphk /* Linked list of histograms for value-based profiling. This is really a 315179004Sphk struct histogram_value*. We use void* to avoid having to export that 316738Sache everywhere, and to avoid having to put it in GC memory. */ 317179004Sphk 318179004Sphk void * GTY ((skip (""))) histograms; 319179004Sphk}; 320179004Sphk 321179004Sphkunion tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)"))) 322179004Sphk{ 323179004Sphk struct tree_ann_common_d GTY((tag ("TREE_ANN_COMMON"))) common; 324179004Sphk struct var_ann_d GTY((tag ("VAR_ANN"))) vdecl; 325179004Sphk struct function_ann_d GTY((tag ("FUNCTION_ANN"))) fdecl; 326179004Sphk struct stmt_ann_d GTY((tag ("STMT_ANN"))) stmt; 327179004Sphk}; 328179004Sphk 329179004Sphkextern GTY(()) VEC(tree,gc) *modified_noreturn_calls; 330179004Sphk 331179004Sphktypedef union tree_ann_d *tree_ann_t; 332179004Sphktypedef struct var_ann_d *var_ann_t; 333179004Sphktypedef struct function_ann_d *function_ann_t; 334179004Sphktypedef struct stmt_ann_d *stmt_ann_t; 335179004Sphktypedef struct tree_ann_common_d *tree_ann_common_t; 336179004Sphk 337179004Sphkstatic inline tree_ann_common_t tree_common_ann (tree); 338179004Sphkstatic inline tree_ann_common_t get_tree_common_ann (tree); 339179004Sphkstatic inline var_ann_t var_ann (tree); 340179004Sphkstatic inline var_ann_t get_var_ann (tree); 341179004Sphkstatic inline function_ann_t function_ann (tree); 342179004Sphkstatic inline function_ann_t get_function_ann (tree); 343179004Sphkstatic inline stmt_ann_t stmt_ann (tree); 344179004Sphkstatic inline stmt_ann_t get_stmt_ann (tree); 345179004Sphkstatic inline enum tree_ann_type ann_type (tree_ann_t); 346179004Sphkstatic inline basic_block bb_for_stmt (tree); 347179004Sphkextern void set_bb_for_stmt (tree, basic_block); 348179004Sphkstatic inline bool noreturn_call_p (tree); 349179004Sphkstatic inline void update_stmt (tree); 350179004Sphkstatic inline bool stmt_modified_p (tree); 351179004Sphkstatic inline VEC(tree, gc) *may_aliases (tree); 352179004Sphkstatic inline int get_lineno (tree); 353179004Sphkstatic inline const char *get_filename (tree); 354179004Sphkstatic inline bool is_exec_stmt (tree); 355179004Sphkstatic inline bool is_label_stmt (tree); 356179004Sphkstatic inline bitmap addresses_taken (tree); 357179004Sphk 358179004Sphk/*--------------------------------------------------------------------------- 359179004Sphk Structure representing predictions in tree level. 360179004Sphk---------------------------------------------------------------------------*/ 361179004Sphkstruct edge_prediction GTY((chain_next ("%h.ep_next"))) 362179004Sphk{ 363179004Sphk struct edge_prediction *ep_next; 364179004Sphk edge ep_edge; 365179004Sphk enum br_predictor ep_predictor; 366179004Sphk int ep_probability; 367179004Sphk}; 368179004Sphk 369179004Sphk/* Accessors for basic block annotations. */ 370179004Sphkstatic inline tree phi_nodes (basic_block); 371179004Sphkstatic inline void set_phi_nodes (basic_block, tree); 372179004Sphk 373179004Sphk/*--------------------------------------------------------------------------- 374179004Sphk Global declarations 375179004Sphk---------------------------------------------------------------------------*/ 376179004Sphkstruct int_tree_map GTY(()) 377179004Sphk{ 378179004Sphk 379179004Sphk unsigned int uid; 380179004Sphk tree to; 381179004Sphk}; 382179004Sphk 383179004Sphkextern unsigned int int_tree_map_hash (const void *); 384179004Sphkextern int int_tree_map_eq (const void *, const void *); 385179004Sphk 386179004Sphktypedef struct 387179004Sphk{ 388179004Sphk htab_iterator hti; 389179004Sphk} referenced_var_iterator; 390179004Sphk 391179004Sphk 392179004Sphk/* This macro loops over all the referenced vars, one at a time, putting the 393179004Sphk current var in VAR. Note: You are not allowed to add referenced variables 394179004Sphk to the hashtable while using this macro. Doing so may cause it to behave 395179004Sphk erratically. */ 396179004Sphk 397179004Sphk#define FOR_EACH_REFERENCED_VAR(VAR, ITER) \ 398179004Sphk for ((VAR) = first_referenced_var (&(ITER)); \ 399179004Sphk !end_referenced_vars_p (&(ITER)); \ 400179004Sphk (VAR) = next_referenced_var (&(ITER))) 4014Srgrimes 4024Srgrimes 4034Srgrimestypedef struct 404179004Sphk{ 405179004Sphk int i; 4064Srgrimes} safe_referenced_var_iterator; 4074Srgrimes 4084Srgrimes/* This macro loops over all the referenced vars, one at a time, putting the 4094Srgrimes current var in VAR. You are allowed to add referenced variables during the 410738Sache execution of this macro, however, the macro will not iterate over them. It 41160038Sphk requires a temporary vector of trees, VEC, whose lifetime is controlled by 4124Srgrimes the caller. The purpose of the vector is to temporarily store the 413105224Sphk referenced_variables hashtable so that adding referenced variables does not 41483366Sjulian affect the hashtable. */ 415130585Sphk 416179004Sphk#define FOR_EACH_REFERENCED_VAR_SAFE(VAR, VEC, ITER) \ 417179004Sphk for ((ITER).i = 0, fill_referenced_var_vec (&(VEC)); \ 41883366Sjulian VEC_iterate (tree, (VEC), (ITER).i, (VAR)); \ 4194Srgrimes (ITER).i++) 4204Srgrimes 421179004Sphk/* Array of all variables referenced in the function. */ 4224Srgrimesextern GTY((param_is (struct int_tree_map))) htab_t referenced_vars; 4234Srgrimes 424187683Sed/* Default defs for undefined symbols. */ 425179004Sphkextern GTY((param_is (struct int_tree_map))) htab_t default_defs; 426179004Sphk 427738Sacheextern tree referenced_var_lookup (unsigned int); 428179004Sphkextern bool referenced_var_check_and_insert (tree); 429738Sache#define num_referenced_vars htab_elements (referenced_vars) 430179004Sphk#define referenced_var(i) referenced_var_lookup (i) 431179004Sphk 432179004Sphk/* Array of all SSA_NAMEs used in the function. */ 433179004Sphkextern GTY(()) VEC(tree,gc) *ssa_names; 434179004Sphk 4354Srgrimes#define num_ssa_names (VEC_length (tree, ssa_names)) 4364Srgrimes#define ssa_name(i) (VEC_index (tree, ssa_names, (i))) 437105224Sphk 43817232Sjoerg/* Artificial variable used to model the effects of function calls. */ 439130585Sphkextern GTY(()) tree global_var; 440179004Sphk 441179004Sphk/* Artificial variable used to model the effects of nonlocal 4424Srgrimes variables. */ 4434Srgrimesextern GTY(()) tree nonlocal_all; 444194990Skib 44549982Sbillf/* Call clobbered variables in the function. If bit I is set, then 4464Srgrimes REFERENCED_VARS (I) is call-clobbered. */ 447187683Sedextern bitmap call_clobbered_vars; 448187683Sed 449179004Sphk/* Addressable variables in the function. If bit I is set, then 450179004Sphk REFERENCED_VARS (I) has had its address taken. */ 451179004Sphkextern bitmap addressable_vars; 452179004Sphk 453179004Sphk/* 'true' after aliases have been computed (see compute_may_aliases). */ 4544Srgrimesextern bool aliases_computed_p; 455179004Sphk 456179004Sphk/* Macros for showing usage statistics. */ 457179004Sphk#define SCALE(x) ((unsigned long) ((x) < 1024*10 \ 458179004Sphk ? (x) \ 459179004Sphk : ((x) < 1024*1024*10 \ 460179004Sphk ? (x) / 1024 \ 461179004Sphk : (x) / (1024*1024)))) 462179004Sphk 46317803Speter#define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) 4644Srgrimes 4654Srgrimes#define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y)) 466105224Sphk 46783366Sjulian/*--------------------------------------------------------------------------- 468130585Sphk Block iterators 469179004Sphk---------------------------------------------------------------------------*/ 470179004Sphk 471179004Sphktypedef struct { 4724Srgrimes tree_stmt_iterator tsi; 4734Srgrimes basic_block bb; 474179004Sphk} block_stmt_iterator; 4754Srgrimes 4764Srgrimesstatic inline block_stmt_iterator bsi_start (basic_block); 477187683Sedstatic inline block_stmt_iterator bsi_last (basic_block); 478187683Sedstatic inline block_stmt_iterator bsi_after_labels (basic_block); 479187683Sedblock_stmt_iterator bsi_for_stmt (tree); 480187683Sedstatic inline bool bsi_end_p (block_stmt_iterator); 481187683Sedstatic inline void bsi_next (block_stmt_iterator *); 4824Srgrimesstatic inline void bsi_prev (block_stmt_iterator *); 4834Srgrimesstatic inline tree bsi_stmt (block_stmt_iterator); 484105224Sphkstatic inline tree * bsi_stmt_ptr (block_stmt_iterator); 48583366Sjulian 486130585Sphkextern void bsi_remove (block_stmt_iterator *, bool); 487179004Sphkextern void bsi_move_before (block_stmt_iterator *, block_stmt_iterator *); 488179004Sphkextern void bsi_move_after (block_stmt_iterator *, block_stmt_iterator *); 489179004Sphkextern void bsi_move_to_bb_end (block_stmt_iterator *, basic_block); 490179004Sphk 4914Srgrimesenum bsi_iterator_update 4924Srgrimes{ 493179004Sphk /* Note that these are intentionally in the same order as TSI_FOO. They 494179004Sphk mean exactly the same as their TSI_* counterparts. */ 4954Srgrimes BSI_NEW_STMT, 4964Srgrimes BSI_SAME_STMT, 497187683Sed BSI_CHAIN_START, 498179004Sphk BSI_CHAIN_END, 4994Srgrimes BSI_CONTINUE_LINKING 500179004Sphk}; 501179004Sphk 502179004Sphkextern void bsi_insert_before (block_stmt_iterator *, tree, 503179004Sphk enum bsi_iterator_update); 504179004Sphkextern void bsi_insert_after (block_stmt_iterator *, tree, 505179004Sphk enum bsi_iterator_update); 506179004Sphk 507179004Sphkextern void bsi_replace (const block_stmt_iterator *, tree, bool); 508179004Sphk 5094Srgrimes/*--------------------------------------------------------------------------- 510179004Sphk OpenMP Region Tree 511179004Sphk---------------------------------------------------------------------------*/ 512179004Sphk 513179004Sphk/* Parallel region information. Every parallel and workshare 514179004Sphk directive is enclosed between two markers, the OMP_* directive 515179004Sphk and a corresponding OMP_RETURN statement. */ 516179004Sphk 517179004Sphkstruct omp_region 518179004Sphk{ 519179004Sphk /* The enclosing region. */ 520179004Sphk struct omp_region *outer; 521179004Sphk 522179004Sphk /* First child region. */ 523179004Sphk struct omp_region *inner; 5244Srgrimes 525179004Sphk /* Next peer region. */ 5264Srgrimes struct omp_region *next; 5274Srgrimes 528177648Sphk /* Block containing the omp directive as its last stmt. */ 529177648Sphk basic_block entry; 53061994Smsmith 531177648Sphk /* Block containing the OMP_RETURN as its last stmt. */ 53261994Smsmith basic_block exit; 53361994Smsmith 534177648Sphk /* Block containing the OMP_CONTINUE as its last stmt. */ 53561994Smsmith basic_block cont; 536177648Sphk 537106070Smdodd /* If this is a combined parallel+workshare region, this is a list 538177648Sphk of additional arguments needed by the combined parallel+workshare 539177648Sphk library call. */ 540177648Sphk tree ws_args; 541177648Sphk 542177648Sphk /* The code for the omp directive of this region. */ 543177648Sphk enum tree_code type; 544177648Sphk 545177648Sphk /* Schedule kind, only used for OMP_FOR type regions. */ 546177648Sphk enum omp_clause_schedule_kind sched_kind; 547177648Sphk 548177648Sphk /* True if this is a combined parallel+workshare region. */ 549106070Smdodd bool is_combined_parallel; 550177648Sphk}; 55161994Smsmith 55261994Smsmithextern struct omp_region *root_omp_region; 553177648Sphkextern struct omp_region *new_omp_region (basic_block, enum tree_code, 554 struct omp_region *); 555extern void free_omp_regions (void); 556 557/*--------------------------------------------------------------------------- 558 Function prototypes 559---------------------------------------------------------------------------*/ 560/* In tree-cfg.c */ 561 562/* Location to track pending stmt for edge insertion. */ 563#define PENDING_STMT(e) ((e)->insns.t) 564 565extern void delete_tree_cfg_annotations (void); 566extern void disband_implicit_edges (void); 567extern bool stmt_ends_bb_p (tree); 568extern bool is_ctrl_stmt (tree); 569extern bool is_ctrl_altering_stmt (tree); 570extern bool computed_goto_p (tree); 571extern bool simple_goto_p (tree); 572extern bool tree_can_make_abnormal_goto (tree); 573extern basic_block single_noncomplex_succ (basic_block bb); 574extern void tree_dump_bb (basic_block, FILE *, int); 575extern void debug_tree_bb (basic_block); 576extern basic_block debug_tree_bb_n (int); 577extern void dump_tree_cfg (FILE *, int); 578extern void debug_tree_cfg (int); 579extern void dump_cfg_stats (FILE *); 580extern void debug_cfg_stats (void); 581extern void debug_loop_ir (void); 582extern void print_loop_ir (FILE *); 583extern void cleanup_dead_labels (void); 584extern void group_case_labels (void); 585extern tree first_stmt (basic_block); 586extern tree last_stmt (basic_block); 587extern tree *last_stmt_ptr (basic_block); 588extern tree last_and_only_stmt (basic_block); 589extern edge find_taken_edge (basic_block, tree); 590extern basic_block label_to_block_fn (struct function *, tree); 591#define label_to_block(t) (label_to_block_fn (cfun, t)) 592extern void bsi_insert_on_edge (edge, tree); 593extern basic_block bsi_insert_on_edge_immediate (edge, tree); 594extern void bsi_commit_one_edge_insert (edge, basic_block *); 595extern void bsi_commit_edge_inserts (void); 596extern void notice_special_calls (tree); 597extern void clear_special_calls (void); 598extern void verify_stmts (void); 599extern tree tree_block_label (basic_block); 600extern void extract_true_false_edges_from_block (basic_block, edge *, edge *); 601extern bool tree_duplicate_sese_region (edge, edge, basic_block *, unsigned, 602 basic_block *); 603extern void add_phi_args_after_copy_bb (basic_block); 604extern void add_phi_args_after_copy (basic_block *, unsigned); 605extern bool tree_purge_dead_abnormal_call_edges (basic_block); 606extern bool tree_purge_dead_eh_edges (basic_block); 607extern bool tree_purge_all_dead_eh_edges (bitmap); 608extern tree gimplify_val (block_stmt_iterator *, tree, tree); 609extern tree gimplify_build1 (block_stmt_iterator *, enum tree_code, 610 tree, tree); 611extern tree gimplify_build2 (block_stmt_iterator *, enum tree_code, 612 tree, tree, tree); 613extern tree gimplify_build3 (block_stmt_iterator *, enum tree_code, 614 tree, tree, tree, tree); 615extern void init_empty_tree_cfg (void); 616extern void fold_cond_expr_cond (void); 617extern void make_abnormal_goto_edges (basic_block, bool); 618extern void replace_uses_by (tree, tree); 619extern void start_recording_case_labels (void); 620extern void end_recording_case_labels (void); 621extern basic_block move_sese_region_to_fn (struct function *, basic_block, 622 basic_block); 623 624/* In tree-cfgcleanup.c */ 625extern bool cleanup_tree_cfg (void); 626extern void cleanup_tree_cfg_loop (void); 627 628/* In tree-pretty-print.c. */ 629extern void dump_generic_bb (FILE *, basic_block, int, int); 630 631/* In tree-dfa.c */ 632extern var_ann_t create_var_ann (tree); 633extern function_ann_t create_function_ann (tree); 634extern stmt_ann_t create_stmt_ann (tree); 635extern tree_ann_common_t create_tree_common_ann (tree); 636extern void dump_dfa_stats (FILE *); 637extern void debug_dfa_stats (void); 638extern void debug_referenced_vars (void); 639extern void dump_referenced_vars (FILE *); 640extern void dump_variable (FILE *, tree); 641extern void debug_variable (tree); 642extern void dump_subvars_for (FILE *, tree); 643extern void debug_subvars_for (tree); 644extern tree get_virtual_var (tree); 645extern void add_referenced_var (tree); 646extern void mark_new_vars_to_rename (tree); 647extern void find_new_referenced_vars (tree *); 648 649extern tree make_rename_temp (tree, const char *); 650extern void set_default_def (tree, tree); 651extern tree default_def (tree); 652extern tree default_def_fn (struct function *, tree); 653 654/* In tree-phinodes.c */ 655extern void reserve_phi_args_for_new_edge (basic_block); 656extern tree create_phi_node (tree, basic_block); 657extern void add_phi_arg (tree, tree, edge); 658extern void remove_phi_args (edge); 659extern void remove_phi_node (tree, tree); 660extern tree phi_reverse (tree); 661 662/* In gimple-low.c */ 663extern void record_vars_into (tree, tree); 664extern void record_vars (tree); 665extern bool block_may_fallthru (tree); 666 667/* In tree-ssa-alias.c */ 668extern void dump_may_aliases_for (FILE *, tree); 669extern void debug_may_aliases_for (tree); 670extern void dump_alias_info (FILE *); 671extern void debug_alias_info (void); 672extern void dump_points_to_info (FILE *); 673extern void debug_points_to_info (void); 674extern void dump_points_to_info_for (FILE *, tree); 675extern void debug_points_to_info_for (tree); 676extern bool may_be_aliased (tree); 677extern bool is_aliased_with (tree, tree); 678extern bool may_aliases_intersect (tree, tree); 679extern struct ptr_info_def *get_ptr_info (tree); 680extern void new_type_alias (tree, tree, tree); 681extern void count_uses_and_derefs (tree, tree, unsigned *, unsigned *, bool *); 682static inline subvar_t get_subvars_for_var (tree); 683static inline tree get_subvar_at (tree, unsigned HOST_WIDE_INT); 684static inline bool ref_contains_array_ref (tree); 685static inline bool array_ref_contains_indirect_ref (tree); 686extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, 687 HOST_WIDE_INT *, HOST_WIDE_INT *); 688static inline bool var_can_have_subvars (tree); 689static inline bool overlap_subvar (unsigned HOST_WIDE_INT, 690 unsigned HOST_WIDE_INT, 691 tree, bool *); 692 693/* Call-back function for walk_use_def_chains(). At each reaching 694 definition, a function with this prototype is called. */ 695typedef bool (*walk_use_def_chains_fn) (tree, tree, void *); 696 697 698/* In tree-ssa.c */ 699extern void init_tree_ssa (void); 700extern edge ssa_redirect_edge (edge, basic_block); 701extern void flush_pending_stmts (edge); 702extern bool tree_ssa_useless_type_conversion (tree); 703extern bool tree_ssa_useless_type_conversion_1 (tree, tree); 704extern void verify_ssa (bool); 705extern void delete_tree_ssa (void); 706extern void register_new_def (tree, VEC(tree,heap) **); 707extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); 708extern bool stmt_references_memory_p (tree); 709 710/* In tree-into-ssa.c */ 711void update_ssa (unsigned); 712void delete_update_ssa (void); 713void register_new_name_mapping (tree, tree); 714tree create_new_def_for (tree, tree, def_operand_p); 715bool need_ssa_update_p (void); 716bool name_registered_for_update_p (tree); 717bitmap ssa_names_to_replace (void); 718void release_ssa_name_after_update_ssa (tree name); 719void compute_global_livein (bitmap, bitmap); 720tree duplicate_ssa_name (tree, tree); 721void mark_sym_for_renaming (tree); 722void mark_set_for_renaming (bitmap); 723tree get_current_def (tree); 724void set_current_def (tree, tree); 725 726/* In tree-ssa-ccp.c */ 727bool fold_stmt (tree *); 728bool fold_stmt_inplace (tree); 729tree widen_bitfield (tree, tree, tree); 730 731/* In tree-vrp.c */ 732tree vrp_evaluate_conditional (tree, tree); 733void simplify_stmt_using_ranges (tree); 734 735/* In tree-ssa-dom.c */ 736extern void dump_dominator_optimization_stats (FILE *); 737extern void debug_dominator_optimization_stats (void); 738int loop_depth_of_name (tree); 739 740/* In tree-ssa-copy.c */ 741extern void merge_alias_info (tree, tree); 742extern void propagate_value (use_operand_p, tree); 743extern void propagate_tree_value (tree *, tree); 744extern void replace_exp (use_operand_p, tree); 745extern bool may_propagate_copy (tree, tree); 746extern bool may_propagate_copy_into_asm (tree); 747 748/* Affine iv. */ 749 750typedef struct 751{ 752 /* Iv = BASE + STEP * i. */ 753 tree base, step; 754 755 /* True if this iv does not overflow. */ 756 bool no_overflow; 757} affine_iv; 758 759/* Description of number of iterations of a loop. All the expressions inside 760 the structure can be evaluated at the end of the loop's preheader 761 (and due to ssa form, also anywhere inside the body of the loop). */ 762 763struct tree_niter_desc 764{ 765 tree assumptions; /* The boolean expression. If this expression evaluates 766 to false, then the other fields in this structure 767 should not be used; there is no guarantee that they 768 will be correct. */ 769 tree may_be_zero; /* The boolean expression. If it evaluates to true, 770 the loop will exit in the first iteration (i.e. 771 its latch will not be executed), even if the niter 772 field says otherwise. */ 773 tree niter; /* The expression giving the number of iterations of 774 a loop (provided that assumptions == true and 775 may_be_zero == false), more precisely the number 776 of executions of the latch of the loop. */ 777 tree additional_info; /* The boolean expression. Sometimes we use additional 778 knowledge to simplify the other expressions 779 contained in this structure (for example the 780 knowledge about value ranges of operands on entry to 781 the loop). If this is a case, conjunction of such 782 condition is stored in this field, so that we do not 783 lose the information: for example if may_be_zero 784 is (n <= 0) and niter is (unsigned) n, we know 785 that the number of iterations is at most 786 MAX_SIGNED_INT. However if the (n <= 0) assumption 787 is eliminated (by looking at the guard on entry of 788 the loop), then the information would be lost. */ 789 790 /* The simplified shape of the exit condition. The loop exits if 791 CONTROL CMP BOUND is false, where CMP is one of NE_EXPR, 792 LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is 793 LE_EXPR and negative if CMP is GE_EXPR. This information is used 794 by loop unrolling. */ 795 affine_iv control; 796 tree bound; 797 enum tree_code cmp; 798}; 799 800/* In tree-vectorizer.c */ 801void vectorize_loops (struct loops *); 802extern bool vect_can_force_dr_alignment_p (tree, unsigned int); 803extern tree get_vectype_for_scalar_type (tree); 804 805/* In tree-ssa-phiopt.c */ 806bool empty_block_p (basic_block); 807 808/* In tree-ssa-loop*.c */ 809 810void tree_ssa_lim (struct loops *); 811unsigned int tree_ssa_unswitch_loops (struct loops *); 812unsigned int canonicalize_induction_variables (struct loops *); 813unsigned int tree_unroll_loops_completely (struct loops *, bool); 814unsigned int tree_ssa_prefetch_arrays (struct loops *); 815unsigned int remove_empty_loops (struct loops *); 816void tree_ssa_iv_optimize (struct loops *); 817 818bool number_of_iterations_exit (struct loop *, edge, 819 struct tree_niter_desc *niter, bool); 820tree find_loop_niter (struct loop *, edge *); 821tree loop_niter_by_eval (struct loop *, edge); 822tree find_loop_niter_by_eval (struct loop *, edge *); 823void estimate_numbers_of_iterations (struct loops *); 824bool scev_probably_wraps_p (tree, tree, tree, struct loop *, bool); 825bool convert_affine_scev (struct loop *, tree, tree *, tree *, tree, bool); 826 827bool nowrap_type_p (tree); 828enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; 829enum ev_direction scev_direction (tree); 830 831void free_numbers_of_iterations_estimates (struct loops *); 832void free_numbers_of_iterations_estimates_loop (struct loop *); 833void rewrite_into_loop_closed_ssa (bitmap, unsigned); 834void verify_loop_closed_ssa (void); 835void loop_commit_inserts (void); 836bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *); 837void create_iv (tree, tree, tree, struct loop *, block_stmt_iterator *, bool, 838 tree *, tree *); 839void split_loop_exit_edge (edge); 840unsigned force_expr_to_var_cost (tree); 841basic_block bsi_insert_on_edge_immediate_loop (edge, tree); 842void standard_iv_increment_position (struct loop *, block_stmt_iterator *, 843 bool *); 844basic_block ip_end_pos (struct loop *); 845basic_block ip_normal_pos (struct loop *); 846bool tree_duplicate_loop_to_header_edge (struct loop *, edge, struct loops *, 847 unsigned int, sbitmap, 848 edge, edge *, 849 unsigned int *, int); 850struct loop *tree_ssa_loop_version (struct loops *, struct loop *, tree, 851 basic_block *); 852tree expand_simple_operations (tree); 853void substitute_in_loop_info (struct loop *, tree, tree); 854edge single_dom_exit (struct loop *); 855bool can_unroll_loop_p (struct loop *loop, unsigned factor, 856 struct tree_niter_desc *niter); 857void tree_unroll_loop (struct loops *, struct loop *, unsigned, 858 edge, struct tree_niter_desc *); 859bool contains_abnormal_ssa_name_p (tree); 860 861/* In tree-ssa-threadedge.c */ 862extern bool potentially_threadable_block (basic_block); 863extern void thread_across_edge (tree, edge, bool, 864 VEC(tree, heap) **, tree (*) (tree, tree)); 865 866/* In tree-ssa-loop-im.c */ 867/* The possibilities of statement movement. */ 868 869enum move_pos 870 { 871 MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */ 872 MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement 873 become executed -- memory accesses, ... */ 874 MOVE_POSSIBLE /* Unlimited movement. */ 875 }; 876extern enum move_pos movement_possibility (tree); 877 878/* The reasons a variable may escape a function. */ 879enum escape_type 880 { 881 NO_ESCAPE = 0, /* Doesn't escape. */ 882 ESCAPE_STORED_IN_GLOBAL = 1 << 1, 883 ESCAPE_TO_ASM = 1 << 2, /* Passed by address to an assembly 884 statement. */ 885 ESCAPE_TO_CALL = 1 << 3, /* Escapes to a function call. */ 886 ESCAPE_BAD_CAST = 1 << 4, /* Cast from pointer to integer */ 887 ESCAPE_TO_RETURN = 1 << 5, /* Returned from function. */ 888 ESCAPE_TO_PURE_CONST = 1 << 6, /* Escapes to a pure or constant 889 function call. */ 890 ESCAPE_IS_GLOBAL = 1 << 7, /* Is a global variable. */ 891 ESCAPE_IS_PARM = 1 << 8, /* Is an incoming function parameter. */ 892 ESCAPE_UNKNOWN = 1 << 9 /* We believe it escapes for some reason 893 not enumerated above. */ 894 }; 895 896/* In tree-flow-inline.h */ 897static inline bool is_call_clobbered (tree); 898static inline void mark_call_clobbered (tree, unsigned int); 899static inline void set_is_used (tree); 900static inline bool unmodifiable_var_p (tree); 901 902/* In tree-eh.c */ 903extern void make_eh_edges (tree); 904extern bool tree_could_trap_p (tree); 905extern bool tree_could_throw_p (tree); 906extern bool tree_can_throw_internal (tree); 907extern bool tree_can_throw_external (tree); 908extern int lookup_stmt_eh_region (tree); 909extern void add_stmt_to_eh_region (tree, int); 910extern bool remove_stmt_from_eh_region (tree); 911extern bool maybe_clean_or_replace_eh_stmt (tree, tree); 912 913/* In tree-ssa-pre.c */ 914void add_to_value (tree, tree); 915void debug_value_expressions (tree); 916void print_value_expressions (FILE *, tree); 917 918 919/* In tree-vn.c */ 920bool expressions_equal_p (tree, tree); 921tree get_value_handle (tree); 922hashval_t vn_compute (tree, hashval_t); 923void sort_vuses (VEC (tree, gc) *); 924tree vn_lookup_or_add (tree, tree); 925tree vn_lookup_or_add_with_vuses (tree, VEC (tree, gc) *); 926void vn_add (tree, tree); 927void vn_add_with_vuses (tree, tree, VEC (tree, gc) *); 928tree vn_lookup (tree, tree); 929tree vn_lookup_with_vuses (tree, VEC (tree, gc) *); 930void vn_init (void); 931void vn_delete (void); 932 933/* In tree-ssa-sink.c */ 934bool is_hidden_global_store (tree); 935 936/* In tree-sra.c */ 937void insert_edge_copies (tree, basic_block); 938void sra_insert_before (block_stmt_iterator *, tree); 939void sra_insert_after (block_stmt_iterator *, tree); 940void sra_init_cache (void); 941bool sra_type_can_be_decomposed_p (tree); 942 943/* In tree-loop-linear.c */ 944extern void linear_transform_loops (struct loops *); 945 946/* In tree-ssa-loop-ivopts.c */ 947bool expr_invariant_in_loop_p (struct loop *, tree); 948bool multiplier_allowed_in_address_p (HOST_WIDE_INT); 949unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode); 950 951/* In tree-ssa-threadupdate.c. */ 952extern bool thread_through_all_blocks (void); 953extern void register_jump_thread (edge, edge); 954 955/* In gimplify.c */ 956tree force_gimple_operand (tree, tree *, bool, tree); 957tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree); 958 959/* In tree-ssa-structalias.c */ 960bool find_what_p_points_to (tree); 961 962/* In tree-ssa-live.c */ 963extern void remove_unused_locals (void); 964 965/* In tree-ssa-address.c */ 966 967/* Affine combination of trees. We keep track of at most MAX_AFF_ELTS elements 968 to make things simpler; this is sufficient in most cases. */ 969 970#define MAX_AFF_ELTS 8 971 972struct affine_tree_combination 973{ 974 /* Type of the result of the combination. */ 975 tree type; 976 977 /* Mask modulo that the operations are performed. */ 978 unsigned HOST_WIDE_INT mask; 979 980 /* Constant offset. */ 981 unsigned HOST_WIDE_INT offset; 982 983 /* Number of elements of the combination. */ 984 unsigned n; 985 986 /* Elements and their coefficients. */ 987 tree elts[MAX_AFF_ELTS]; 988 unsigned HOST_WIDE_INT coefs[MAX_AFF_ELTS]; 989 990 /* Remainder of the expression. */ 991 tree rest; 992}; 993 994/* Description of a memory address. */ 995 996struct mem_address 997{ 998 tree symbol, base, index, step, offset; 999}; 1000 1001tree create_mem_ref (block_stmt_iterator *, tree, 1002 struct affine_tree_combination *); 1003rtx addr_for_mem_ref (struct mem_address *, bool); 1004void get_address_description (tree, struct mem_address *); 1005tree maybe_fold_tmr (tree); 1006 1007/* This structure is simply used during pushing fields onto the fieldstack 1008 to track the offset of the field, since bitpos_of_field gives it relative 1009 to its immediate containing type, and we want it relative to the ultimate 1010 containing object. */ 1011 1012struct fieldoff 1013{ 1014 tree type; 1015 tree size; 1016 tree decl; 1017 HOST_WIDE_INT offset; 1018}; 1019typedef struct fieldoff fieldoff_s; 1020 1021DEF_VEC_O(fieldoff_s); 1022DEF_VEC_ALLOC_O(fieldoff_s,heap); 1023int push_fields_onto_fieldstack (tree, VEC(fieldoff_s,heap) **, 1024 HOST_WIDE_INT, bool *); 1025void sort_fieldstack (VEC(fieldoff_s,heap) *); 1026 1027void init_alias_heapvars (void); 1028void delete_alias_heapvars (void); 1029 1030#include "tree-flow-inline.h" 1031 1032void swap_tree_operands (tree, tree *, tree *); 1033 1034extern void recalculate_used_alone (void); 1035extern bool updating_used_alone; 1036#endif /* _TREE_FLOW_H */ 1037