Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-flow.h @ 108:7ad14f446135
add CbC-example/rectypeTest/
| author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Thu, 14 Jun 2012 20:30:24 +0900 |
| parents | f6334be47118 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Data and Control Flow Analysis for Trees. |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2 Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 |
| 0 | 3 Free Software Foundation, Inc. |
| 4 Contributed by Diego Novillo <dnovillo@redhat.com> | |
| 5 | |
| 6 This file is part of GCC. | |
| 7 | |
| 8 GCC is free software; you can redistribute it and/or modify | |
| 9 it under the terms of the GNU General Public License as published by | |
| 10 the Free Software Foundation; either version 3, or (at your option) | |
| 11 any later version. | |
| 12 | |
| 13 GCC is distributed in the hope that it will be useful, | |
| 14 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 16 GNU General Public License for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with GCC; see the file COPYING3. If not see | |
| 20 <http://www.gnu.org/licenses/>. */ | |
| 21 | |
| 22 #ifndef _TREE_FLOW_H | |
| 23 #define _TREE_FLOW_H 1 | |
| 24 | |
| 25 #include "bitmap.h" | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
26 #include "sbitmap.h" |
| 0 | 27 #include "basic-block.h" |
| 28 #include "hashtab.h" | |
| 29 #include "gimple.h" | |
| 30 #include "tree-ssa-operands.h" | |
| 31 #include "cgraph.h" | |
| 32 #include "ipa-reference.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
33 #include "tree-ssa-alias.h" |
| 0 | 34 |
| 35 | |
| 36 /* Gimple dataflow datastructure. All publicly available fields shall have | |
| 37 gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable | |
| 38 fields should have gimple_set accessor. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
39 struct GTY(()) gimple_df { |
| 0 | 40 /* Array of all variables referenced in the function. */ |
| 41 htab_t GTY((param_is (union tree_node))) referenced_vars; | |
| 42 | |
| 43 /* A vector of all the noreturn calls passed to modify_stmt. | |
| 44 cleanup_control_flow uses it to detect cases where a mid-block | |
| 45 indirect call has been turned into a noreturn call. When this | |
| 46 happens, all the instructions after the call are no longer | |
| 47 reachable and must be deleted as dead. */ | |
| 48 VEC(gimple,gc) *modified_noreturn_calls; | |
| 49 | |
| 50 /* Array of all SSA_NAMEs used in the function. */ | |
| 51 VEC(tree,gc) *ssa_names; | |
| 52 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
53 /* Artificial variable used for the virtual operand FUD chain. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
54 tree vop; |
| 0 | 55 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
56 /* The PTA solution for the ESCAPED artificial variable. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
57 struct pt_solution escaped; |
| 0 | 58 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
59 /* A map of decls to artificial ssa-names that point to the partition |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
60 of the decl. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
61 struct pointer_map_t * GTY((skip(""))) decls_to_pointers; |
| 0 | 62 |
| 63 /* Free list of SSA_NAMEs. */ | |
| 64 tree free_ssanames; | |
| 65 | |
| 66 /* Hashtable holding definition for symbol. If this field is not NULL, it | |
| 67 means that the first reference to this variable in the function is a | |
| 68 USE or a VUSE. In those cases, the SSA renamer creates an SSA name | |
| 69 for this variable with an empty defining statement. */ | |
| 70 htab_t GTY((param_is (union tree_node))) default_defs; | |
| 71 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
72 /* Symbols whose SSA form needs to be updated or created for the first |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
73 time. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
74 bitmap syms_to_rename; |
| 0 | 75 |
| 76 /* True if the code is in ssa form. */ | |
| 77 unsigned int in_ssa_p : 1; | |
| 78 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
79 /* True if IPA points-to information was computed for this function. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
80 unsigned int ipa_pta : 1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
81 |
| 0 | 82 struct ssa_operands ssa_operands; |
| 83 }; | |
| 84 | |
| 85 /* Accessors for internal use only. Generic code should use abstraction | |
| 86 provided by tree-flow-inline.h or specific modules. */ | |
| 87 #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames | |
| 88 #define SSANAMES(fun) (fun)->gimple_df->ssa_names | |
| 89 #define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls | |
| 90 #define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
91 #define SYMS_TO_RENAME(fun) (fun)->gimple_df->syms_to_rename |
| 0 | 92 |
| 93 typedef struct | |
| 94 { | |
| 95 htab_t htab; | |
| 96 PTR *slot; | |
| 97 PTR *limit; | |
| 98 } htab_iterator; | |
| 99 | |
| 100 /* Iterate through the elements of hashtable HTAB, using htab_iterator ITER, | |
| 101 storing each element in RESULT, which is of type TYPE. */ | |
| 102 #define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \ | |
| 103 for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \ | |
| 104 !end_htab_p (&(ITER)); \ | |
| 105 RESULT = (TYPE) next_htab_element (&(ITER))) | |
| 106 | |
| 107 /*--------------------------------------------------------------------------- | |
| 108 Attributes for SSA_NAMEs. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
109 |
| 0 | 110 NOTE: These structures are stored in struct tree_ssa_name |
| 111 but are only used by the tree optimizers, so it makes better sense | |
| 112 to declare them here to avoid recompiling unrelated files when | |
| 113 making changes. | |
| 114 ---------------------------------------------------------------------------*/ | |
| 115 | |
| 116 /* Aliasing information for SSA_NAMEs representing pointer variables. */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
117 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
118 struct GTY(()) ptr_info_def |
| 0 | 119 { |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
120 /* The points-to solution. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
121 struct pt_solution pt; |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
122 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
123 /* Alignment and misalignment of the pointer in bytes. Together |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
124 align and misalign specify low known bits of the pointer. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
125 ptr & (align - 1) == misalign. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
126 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
127 /* The power-of-two byte alignment of the object this pointer |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
128 points into. This is usually DECL_ALIGN_UNIT for decls and |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
129 MALLOC_ABI_ALIGNMENT for allocated storage. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
130 unsigned int align; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
131 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
132 /* The byte offset this pointer differs from the above alignment. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
133 unsigned int misalign; |
| 0 | 134 }; |
| 135 | |
| 136 | |
| 137 /* It is advantageous to avoid things like life analysis for variables which | |
| 138 do not need PHI nodes. This enum describes whether or not a particular | |
| 139 variable may need a PHI node. */ | |
| 140 | |
| 141 enum need_phi_state { | |
| 142 /* This is the default. If we are still in this state after finding | |
| 143 all the definition and use sites, then we will assume the variable | |
| 144 needs PHI nodes. This is probably an overly conservative assumption. */ | |
| 145 NEED_PHI_STATE_UNKNOWN, | |
| 146 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
147 /* This state indicates that we have seen one or more sets of the |
| 0 | 148 variable in a single basic block and that the sets dominate all |
| 149 uses seen so far. If after finding all definition and use sites | |
| 150 we are still in this state, then the variable does not need any | |
| 151 PHI nodes. */ | |
| 152 NEED_PHI_STATE_NO, | |
| 153 | |
| 154 /* This state indicates that we have either seen multiple definitions of | |
| 155 the variable in multiple blocks, or that we encountered a use in a | |
| 156 block that was not dominated by the block containing the set(s) of | |
| 157 this variable. This variable is assumed to need PHI nodes. */ | |
| 158 NEED_PHI_STATE_MAYBE | |
| 159 }; | |
| 160 | |
| 161 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
162 struct GTY(()) var_ann_d { |
| 0 | 163 /* Used when building base variable structures in a var_map. */ |
| 164 unsigned base_var_processed : 1; | |
| 165 | |
| 166 /* Nonzero if this variable was used after SSA optimizations were | |
| 167 applied. We set this when translating out of SSA form. */ | |
| 168 unsigned used : 1; | |
| 169 | |
| 170 /* This field indicates whether or not the variable may need PHI nodes. | |
| 171 See the enum's definition for more detailed information about the | |
| 172 states. */ | |
| 173 ENUM_BITFIELD (need_phi_state) need_phi_state : 2; | |
| 174 | |
| 175 /* True for HEAP artificial variables. These variables represent | |
| 176 the memory area allocated by a call to malloc. */ | |
| 177 unsigned is_heapvar : 1; | |
| 178 | |
| 179 /* Used by var_map for the base index of ssa base variables. */ | |
| 180 unsigned base_index; | |
| 181 | |
| 182 /* During into-ssa and the dominator optimizer, this field holds the | |
| 183 current version of this variable (an SSA_NAME). */ | |
| 184 tree current_def; | |
| 185 }; | |
| 186 | |
| 187 | |
| 188 /* Immediate use lists are used to directly access all uses for an SSA | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
189 name and get pointers to the statement for each use. |
| 0 | 190 |
| 191 The structure ssa_use_operand_d consists of PREV and NEXT pointers | |
| 192 to maintain the list. A USE pointer, which points to address where | |
| 193 the use is located and a LOC pointer which can point to the | |
| 194 statement where the use is located, or, in the case of the root | |
| 195 node, it points to the SSA name itself. | |
| 196 | |
| 197 The list is anchored by an occurrence of ssa_operand_d *in* the | |
| 198 ssa_name node itself (named 'imm_uses'). This node is uniquely | |
| 199 identified by having a NULL USE pointer. and the LOC pointer | |
| 200 pointing back to the ssa_name node itself. This node forms the | |
| 201 base for a circular list, and initially this is the only node in | |
| 202 the list. | |
| 203 | |
| 204 Fast iteration allows each use to be examined, but does not allow | |
| 205 any modifications to the uses or stmts. | |
| 206 | |
| 207 Normal iteration allows insertion, deletion, and modification. the | |
| 208 iterator manages this by inserting a marker node into the list | |
| 209 immediately before the node currently being examined in the list. | |
| 210 this marker node is uniquely identified by having null stmt *and* a | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
211 null use pointer. |
| 0 | 212 |
| 213 When iterating to the next use, the iteration routines check to see | |
| 214 if the node after the marker has changed. if it has, then the node | |
| 215 following the marker is now the next one to be visited. if not, the | |
| 216 marker node is moved past that node in the list (visualize it as | |
| 217 bumping the marker node through the list). this continues until | |
| 218 the marker node is moved to the original anchor position. the | |
| 219 marker node is then removed from the list. | |
| 220 | |
| 221 If iteration is halted early, the marker node must be removed from | |
| 222 the list before continuing. */ | |
| 223 typedef struct immediate_use_iterator_d | |
| 224 { | |
| 225 /* This is the current use the iterator is processing. */ | |
| 226 ssa_use_operand_t *imm_use; | |
| 227 /* This marks the last use in the list (use node from SSA_NAME) */ | |
| 228 ssa_use_operand_t *end_p; | |
| 229 /* This node is inserted and used to mark the end of the uses for a stmt. */ | |
| 230 ssa_use_operand_t iter_node; | |
| 231 /* This is the next ssa_name to visit. IMM_USE may get removed before | |
| 232 the next one is traversed to, so it must be cached early. */ | |
| 233 ssa_use_operand_t *next_imm_name; | |
| 234 } imm_use_iterator; | |
| 235 | |
| 236 | |
| 237 /* Use this iterator when simply looking at stmts. Adding, deleting or | |
| 238 modifying stmts will cause this iterator to malfunction. */ | |
| 239 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
240 #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ |
| 0 | 241 for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ |
| 242 !end_readonly_imm_use_p (&(ITER)); \ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
243 (void) ((DEST) = next_readonly_imm_use (&(ITER)))) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
244 |
| 0 | 245 /* Use this iterator to visit each stmt which has a use of SSAVAR. */ |
| 246 | |
| 247 #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ | |
| 248 for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ | |
| 249 !end_imm_use_stmt_p (&(ITER)); \ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
250 (void) ((STMT) = next_imm_use_stmt (&(ITER)))) |
| 0 | 251 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
252 /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to |
| 0 | 253 do so will result in leaving a iterator marker node in the immediate |
| 254 use list, and nothing good will come from that. */ | |
| 255 #define BREAK_FROM_IMM_USE_STMT(ITER) \ | |
| 256 { \ | |
| 257 end_imm_use_stmt_traverse (&(ITER)); \ | |
| 258 break; \ | |
| 259 } | |
| 260 | |
| 261 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
262 /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to |
| 0 | 263 get access to each occurrence of ssavar on the stmt returned by |
| 264 that iterator.. for instance: | |
| 265 | |
| 266 FOR_EACH_IMM_USE_STMT (stmt, iter, var) | |
| 267 { | |
| 268 FOR_EACH_IMM_USE_ON_STMT (use_p, iter) | |
| 269 { | |
| 270 SET_USE (use_p, blah); | |
| 271 } | |
| 272 update_stmt (stmt); | |
| 273 } */ | |
| 274 | |
| 275 #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ | |
| 276 for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ | |
| 277 !end_imm_use_on_stmt_p (&(ITER)); \ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
278 (void) ((DEST) = next_imm_use_on_stmt (&(ITER)))) |
| 0 | 279 |
| 280 | |
| 281 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
282 typedef struct var_ann_d *var_ann_t; |
| 0 | 283 |
| 284 static inline var_ann_t var_ann (const_tree); | |
| 285 static inline var_ann_t get_var_ann (tree); | |
| 286 static inline void update_stmt (gimple); | |
| 287 static inline int get_lineno (const_gimple); | |
| 288 | |
| 289 /* Accessors for basic block annotations. */ | |
| 290 static inline gimple_seq phi_nodes (const_basic_block); | |
| 291 static inline void set_phi_nodes (basic_block, gimple_seq); | |
| 292 | |
| 293 /*--------------------------------------------------------------------------- | |
| 294 Global declarations | |
| 295 ---------------------------------------------------------------------------*/ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
296 struct int_tree_map { |
| 0 | 297 unsigned int uid; |
| 298 tree to; | |
| 299 }; | |
| 300 | |
| 301 extern unsigned int int_tree_map_hash (const void *); | |
| 302 extern int int_tree_map_eq (const void *, const void *); | |
| 303 | |
| 304 extern unsigned int uid_decl_map_hash (const void *); | |
| 305 extern int uid_decl_map_eq (const void *, const void *); | |
| 306 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
307 typedef struct |
| 0 | 308 { |
| 309 htab_iterator hti; | |
| 310 } referenced_var_iterator; | |
| 311 | |
| 312 /* This macro loops over all the referenced vars, one at a time, putting the | |
| 313 current var in VAR. Note: You are not allowed to add referenced variables | |
| 314 to the hashtable while using this macro. Doing so may cause it to behave | |
| 315 erratically. */ | |
| 316 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
317 #define FOR_EACH_REFERENCED_VAR(FN, VAR, ITER) \ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
318 for ((VAR) = first_referenced_var ((FN), &(ITER)); \ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
319 !end_referenced_vars_p (&(ITER)); \ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
320 (VAR) = next_referenced_var (&(ITER))) |
| 0 | 321 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
322 extern tree referenced_var_lookup (struct function *, unsigned int); |
| 0 | 323 extern bool referenced_var_check_and_insert (tree); |
| 324 #define num_referenced_vars htab_elements (gimple_referenced_vars (cfun)) | |
| 325 | |
| 326 #define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names)) | |
| 327 #define ssa_name(i) (VEC_index (tree, cfun->gimple_df->ssa_names, (i))) | |
| 328 | |
| 329 /* Macros for showing usage statistics. */ | |
| 330 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \ | |
| 331 ? (x) \ | |
| 332 : ((x) < 1024*1024*10 \ | |
| 333 ? (x) / 1024 \ | |
| 334 : (x) / (1024*1024)))) | |
| 335 | |
| 336 #define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) | |
| 337 | |
| 338 #define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y)) | |
| 339 | |
| 340 /*--------------------------------------------------------------------------- | |
| 341 OpenMP Region Tree | |
| 342 ---------------------------------------------------------------------------*/ | |
| 343 | |
| 344 /* Parallel region information. Every parallel and workshare | |
| 345 directive is enclosed between two markers, the OMP_* directive | |
| 346 and a corresponding OMP_RETURN statement. */ | |
| 347 | |
| 348 struct omp_region | |
| 349 { | |
| 350 /* The enclosing region. */ | |
| 351 struct omp_region *outer; | |
| 352 | |
| 353 /* First child region. */ | |
| 354 struct omp_region *inner; | |
| 355 | |
| 356 /* Next peer region. */ | |
| 357 struct omp_region *next; | |
| 358 | |
| 359 /* Block containing the omp directive as its last stmt. */ | |
| 360 basic_block entry; | |
| 361 | |
| 362 /* Block containing the OMP_RETURN as its last stmt. */ | |
| 363 basic_block exit; | |
| 364 | |
| 365 /* Block containing the OMP_CONTINUE as its last stmt. */ | |
| 366 basic_block cont; | |
| 367 | |
| 368 /* If this is a combined parallel+workshare region, this is a list | |
| 369 of additional arguments needed by the combined parallel+workshare | |
| 370 library call. */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
371 VEC(tree,gc) *ws_args; |
| 0 | 372 |
| 373 /* The code for the omp directive of this region. */ | |
| 374 enum gimple_code type; | |
| 375 | |
| 376 /* Schedule kind, only used for OMP_FOR type regions. */ | |
| 377 enum omp_clause_schedule_kind sched_kind; | |
| 378 | |
| 379 /* True if this is a combined parallel+workshare region. */ | |
| 380 bool is_combined_parallel; | |
| 381 }; | |
| 382 | |
| 383 extern struct omp_region *root_omp_region; | |
| 384 extern struct omp_region *new_omp_region (basic_block, enum gimple_code, | |
| 385 struct omp_region *); | |
| 386 extern void free_omp_regions (void); | |
| 387 void omp_expand_local (basic_block); | |
| 388 extern tree find_omp_clause (tree, enum omp_clause_code); | |
| 389 tree copy_var_decl (tree, tree, tree); | |
| 390 | |
| 391 /*--------------------------------------------------------------------------- | |
| 392 Function prototypes | |
| 393 ---------------------------------------------------------------------------*/ | |
| 394 /* In tree-cfg.c */ | |
| 395 | |
| 396 /* Location to track pending stmt for edge insertion. */ | |
| 397 #define PENDING_STMT(e) ((e)->insns.g) | |
| 398 | |
| 399 extern void delete_tree_cfg_annotations (void); | |
| 400 extern bool stmt_ends_bb_p (gimple); | |
| 401 extern bool is_ctrl_stmt (gimple); | |
| 402 extern bool is_ctrl_altering_stmt (gimple); | |
| 403 extern bool simple_goto_p (gimple); | |
| 404 extern bool stmt_can_make_abnormal_goto (gimple); | |
| 405 extern basic_block single_noncomplex_succ (basic_block bb); | |
| 406 extern void gimple_dump_bb (basic_block, FILE *, int, int); | |
| 407 extern void gimple_debug_bb (basic_block); | |
| 408 extern basic_block gimple_debug_bb_n (int); | |
| 409 extern void gimple_dump_cfg (FILE *, int); | |
| 410 extern void gimple_debug_cfg (int); | |
| 411 extern void dump_cfg_stats (FILE *); | |
| 412 extern void dot_cfg (void); | |
| 413 extern void debug_cfg_stats (void); | |
| 414 extern void debug_loops (int); | |
| 415 extern void debug_loop (struct loop *, int); | |
| 416 extern void debug_loop_num (unsigned, int); | |
| 417 extern void print_loops (FILE *, int); | |
| 418 extern void print_loops_bb (FILE *, basic_block, int, int); | |
| 419 extern void cleanup_dead_labels (void); | |
| 420 extern void group_case_labels (void); | |
| 421 extern gimple first_stmt (basic_block); | |
| 422 extern gimple last_stmt (basic_block); | |
| 423 extern gimple last_and_only_stmt (basic_block); | |
| 424 extern edge find_taken_edge (basic_block, tree); | |
| 425 extern basic_block label_to_block_fn (struct function *, tree); | |
| 426 #define label_to_block(t) (label_to_block_fn (cfun, t)) | |
| 427 extern void notice_special_calls (gimple); | |
| 428 extern void clear_special_calls (void); | |
| 429 extern void verify_stmts (void); | |
| 430 extern void verify_gimple (void); | |
| 431 extern void verify_types_in_gimple_seq (gimple_seq); | |
| 432 extern tree gimple_block_label (basic_block); | |
| 433 extern void extract_true_false_edges_from_block (basic_block, edge *, edge *); | |
| 434 extern bool gimple_duplicate_sese_region (edge, edge, basic_block *, unsigned, | |
| 435 basic_block *); | |
| 436 extern bool gimple_duplicate_sese_tail (edge, edge, basic_block *, unsigned, | |
| 437 basic_block *); | |
| 438 extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit, | |
| 439 VEC(basic_block,heap) **bbs_p); | |
| 440 extern void add_phi_args_after_copy_bb (basic_block); | |
| 441 extern void add_phi_args_after_copy (basic_block *, unsigned, edge); | |
| 442 extern bool gimple_purge_dead_eh_edges (basic_block); | |
| 443 extern bool gimple_purge_all_dead_eh_edges (const_bitmap); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
444 extern bool gimple_purge_dead_abnormal_call_edges (basic_block); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
445 extern bool gimple_purge_all_dead_abnormal_call_edges (const_bitmap); |
| 0 | 446 extern tree gimplify_build1 (gimple_stmt_iterator *, enum tree_code, |
| 447 tree, tree); | |
| 448 extern tree gimplify_build2 (gimple_stmt_iterator *, enum tree_code, | |
| 449 tree, tree, tree); | |
| 450 extern tree gimplify_build3 (gimple_stmt_iterator *, enum tree_code, | |
| 451 tree, tree, tree, tree); | |
| 452 extern void init_empty_tree_cfg (void); | |
| 453 extern void init_empty_tree_cfg_for_function (struct function *); | |
| 454 extern void fold_cond_expr_cond (void); | |
| 455 extern void make_abnormal_goto_edges (basic_block, bool); | |
| 456 extern void replace_uses_by (tree, tree); | |
| 457 extern void start_recording_case_labels (void); | |
| 458 extern void end_recording_case_labels (void); | |
| 459 extern basic_block move_sese_region_to_fn (struct function *, basic_block, | |
| 460 basic_block, tree); | |
| 461 void remove_edge_and_dominated_blocks (edge); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
462 bool tree_node_can_be_shared (tree); |
| 0 | 463 |
| 464 /* In tree-cfgcleanup.c */ | |
| 465 extern bitmap cfgcleanup_altered_bbs; | |
| 466 extern bool cleanup_tree_cfg (void); | |
| 467 | |
| 468 /* In tree-pretty-print.c. */ | |
| 469 extern void dump_generic_bb (FILE *, basic_block, int, int); | |
| 470 extern int op_code_prio (enum tree_code); | |
| 471 extern int op_prio (const_tree); | |
| 472 extern const char *op_symbol_code (enum tree_code); | |
| 473 | |
| 474 /* In tree-dfa.c */ | |
| 475 extern var_ann_t create_var_ann (tree); | |
| 476 extern void renumber_gimple_stmt_uids (void); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
477 extern void renumber_gimple_stmt_uids_in_blocks (basic_block *, int); |
| 0 | 478 extern void dump_dfa_stats (FILE *); |
| 479 extern void debug_dfa_stats (void); | |
| 480 extern void debug_referenced_vars (void); | |
| 481 extern void dump_referenced_vars (FILE *); | |
| 482 extern void dump_variable (FILE *, tree); | |
| 483 extern void debug_variable (tree); | |
| 484 extern tree get_virtual_var (tree); | |
| 485 extern bool add_referenced_var (tree); | |
| 486 extern void remove_referenced_var (tree); | |
| 487 extern void mark_symbols_for_renaming (gimple); | |
| 488 extern void find_new_referenced_vars (gimple); | |
| 489 extern tree make_rename_temp (tree, const char *); | |
| 490 extern void set_default_def (tree, tree); | |
| 491 extern tree gimple_default_def (struct function *, tree); | |
| 492 extern bool stmt_references_abnormal_ssa_name (gimple); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
493 extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
494 HOST_WIDE_INT *, HOST_WIDE_INT *); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
495 extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
496 extern void find_referenced_vars_in (gimple); |
| 0 | 497 |
| 498 /* In tree-phinodes.c */ | |
| 499 extern void reserve_phi_args_for_new_edge (basic_block); | |
| 500 extern void add_phi_node_to_bb (gimple phi, basic_block bb); | |
| 501 extern gimple make_phi_node (tree var, int len); | |
| 502 extern gimple create_phi_node (tree, basic_block); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
503 extern void add_phi_arg (gimple, tree, edge, source_location); |
| 0 | 504 extern void remove_phi_args (edge); |
| 505 extern void remove_phi_node (gimple_stmt_iterator *, bool); | |
| 506 extern void remove_phi_nodes (basic_block); | |
| 507 extern void init_phinodes (void); | |
| 508 extern void fini_phinodes (void); | |
| 509 extern void release_phi_node (gimple); | |
| 510 #ifdef GATHER_STATISTICS | |
| 511 extern void phinodes_print_statistics (void); | |
| 512 #endif | |
| 513 | |
| 514 /* In gimple-low.c */ | |
| 515 extern void record_vars_into (tree, tree); | |
| 516 extern void record_vars (tree); | |
| 517 extern bool gimple_seq_may_fallthru (gimple_seq); | |
| 518 extern bool gimple_stmt_may_fallthru (gimple); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
519 extern bool gimple_check_call_args (gimple); |
| 0 | 520 |
| 521 | |
| 522 /* In tree-ssa.c */ | |
| 523 | |
| 524 /* Mapping for redirected edges. */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
525 struct _edge_var_map { |
| 0 | 526 tree result; /* PHI result. */ |
| 527 tree def; /* PHI arg definition. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
528 source_location locus; /* PHI arg location. */ |
| 0 | 529 }; |
| 530 typedef struct _edge_var_map edge_var_map; | |
| 531 | |
| 532 DEF_VEC_O(edge_var_map); | |
| 533 DEF_VEC_ALLOC_O(edge_var_map, heap); | |
| 534 | |
| 535 /* A vector of var maps. */ | |
| 536 typedef VEC(edge_var_map, heap) *edge_var_map_vector; | |
| 537 | |
| 538 extern void init_tree_ssa (struct function *); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
539 extern void redirect_edge_var_map_add (edge, tree, tree, source_location); |
| 0 | 540 extern void redirect_edge_var_map_clear (edge); |
| 541 extern void redirect_edge_var_map_dup (edge, edge); | |
| 542 extern edge_var_map_vector redirect_edge_var_map_vector (edge); | |
| 543 extern void redirect_edge_var_map_destroy (void); | |
| 544 | |
| 545 extern edge ssa_redirect_edge (edge, basic_block); | |
| 546 extern void flush_pending_stmts (edge); | |
| 547 extern void verify_ssa (bool); | |
| 548 extern void delete_tree_ssa (void); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
549 extern bool ssa_undefined_value_p (tree); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
550 extern void warn_uninit (tree, const char *, void *); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
551 extern unsigned int warn_uninitialized_vars (bool); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
552 extern void execute_update_addresses_taken (void); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
553 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
554 /* Call-back function for walk_use_def_chains(). At each reaching |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
555 definition, a function with this prototype is called. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
556 typedef bool (*walk_use_def_chains_fn) (tree, gimple, void *); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
557 |
| 0 | 558 extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); |
| 559 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
560 void insert_debug_temps_for_defs (gimple_stmt_iterator *); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
561 void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
562 void release_defs_bitset (bitmap toremove); |
| 0 | 563 |
| 564 /* In tree-into-ssa.c */ | |
| 565 void update_ssa (unsigned); | |
| 566 void delete_update_ssa (void); | |
| 567 void register_new_name_mapping (tree, tree); | |
| 568 tree create_new_def_for (tree, gimple, def_operand_p); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
569 bool need_ssa_update_p (struct function *); |
| 0 | 570 bool name_mappings_registered_p (void); |
| 571 bool name_registered_for_update_p (tree); | |
| 572 bitmap ssa_names_to_replace (void); | |
| 573 void release_ssa_name_after_update_ssa (tree); | |
| 574 void compute_global_livein (bitmap, bitmap); | |
| 575 void mark_sym_for_renaming (tree); | |
| 576 void mark_set_for_renaming (bitmap); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
577 bool symbol_marked_for_renaming (tree); |
| 0 | 578 tree get_current_def (tree); |
| 579 void set_current_def (tree, tree); | |
| 580 | |
| 581 /* In tree-ssanames.c */ | |
| 582 extern void init_ssanames (struct function *, int); | |
| 583 extern void fini_ssanames (void); | |
| 584 extern tree make_ssa_name_fn (struct function *, tree, gimple); | |
| 585 extern tree duplicate_ssa_name (tree, gimple); | |
| 586 extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *); | |
| 587 extern void release_ssa_name (tree); | |
| 588 extern void release_defs (gimple); | |
| 589 extern void replace_ssa_name_symbol (tree, tree); | |
| 590 | |
| 591 #ifdef GATHER_STATISTICS | |
| 592 extern void ssanames_print_statistics (void); | |
| 593 #endif | |
| 594 | |
| 595 /* In tree-ssa-ccp.c */ | |
| 596 tree fold_const_aggregate_ref (tree); | |
| 597 | |
| 598 /* In tree-ssa-dom.c */ | |
| 599 extern void dump_dominator_optimization_stats (FILE *); | |
| 600 extern void debug_dominator_optimization_stats (void); | |
| 601 int loop_depth_of_name (tree); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
602 tree degenerate_phi_result (gimple); |
| 0 | 603 |
| 604 /* In tree-ssa-copy.c */ | |
| 605 extern void propagate_value (use_operand_p, tree); | |
| 606 extern void propagate_tree_value (tree *, tree); | |
| 607 extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); | |
| 608 extern void replace_exp (use_operand_p, tree); | |
| 609 extern bool may_propagate_copy (tree, tree); | |
| 610 extern bool may_propagate_copy_into_stmt (gimple, tree); | |
| 611 extern bool may_propagate_copy_into_asm (tree); | |
| 612 | |
| 613 /* Affine iv. */ | |
| 614 | |
| 615 typedef struct | |
| 616 { | |
| 617 /* Iv = BASE + STEP * i. */ | |
| 618 tree base, step; | |
| 619 | |
| 620 /* True if this iv does not overflow. */ | |
| 621 bool no_overflow; | |
| 622 } affine_iv; | |
| 623 | |
| 624 /* Description of number of iterations of a loop. All the expressions inside | |
| 625 the structure can be evaluated at the end of the loop's preheader | |
| 626 (and due to ssa form, also anywhere inside the body of the loop). */ | |
| 627 | |
| 628 struct tree_niter_desc | |
| 629 { | |
| 630 tree assumptions; /* The boolean expression. If this expression evaluates | |
| 631 to false, then the other fields in this structure | |
| 632 should not be used; there is no guarantee that they | |
| 633 will be correct. */ | |
| 634 tree may_be_zero; /* The boolean expression. If it evaluates to true, | |
| 635 the loop will exit in the first iteration (i.e. | |
| 636 its latch will not be executed), even if the niter | |
| 637 field says otherwise. */ | |
| 638 tree niter; /* The expression giving the number of iterations of | |
| 639 a loop (provided that assumptions == true and | |
| 640 may_be_zero == false), more precisely the number | |
| 641 of executions of the latch of the loop. */ | |
| 642 double_int max; /* The upper bound on the number of iterations of | |
| 643 the loop. */ | |
| 644 | |
| 645 /* The simplified shape of the exit condition. The loop exits if | |
| 646 CONTROL CMP BOUND is false, where CMP is one of NE_EXPR, | |
| 647 LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is | |
| 648 LE_EXPR and negative if CMP is GE_EXPR. This information is used | |
| 649 by loop unrolling. */ | |
| 650 affine_iv control; | |
| 651 tree bound; | |
| 652 enum tree_code cmp; | |
| 653 }; | |
| 654 | |
| 655 /* In tree-ssa-phiopt.c */ | |
| 656 bool empty_block_p (basic_block); | |
| 657 basic_block *blocks_in_phiopt_order (void); | |
| 658 | |
| 659 /* In tree-ssa-loop*.c */ | |
| 660 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
661 unsigned int tree_ssa_lim (void); |
| 0 | 662 unsigned int tree_ssa_unswitch_loops (void); |
| 663 unsigned int canonicalize_induction_variables (void); | |
| 664 unsigned int tree_unroll_loops_completely (bool, bool); | |
| 665 unsigned int tree_ssa_prefetch_arrays (void); | |
| 666 void tree_ssa_iv_optimize (void); | |
| 667 unsigned tree_predictive_commoning (void); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
668 tree canonicalize_loop_ivs (struct loop *, tree *, bool); |
| 0 | 669 bool parallelize_loops (void); |
| 670 | |
| 671 bool loop_only_exit_p (const struct loop *, const_edge); | |
| 672 bool number_of_iterations_exit (struct loop *, edge, | |
| 673 struct tree_niter_desc *niter, bool); | |
| 674 tree find_loop_niter (struct loop *, edge *); | |
| 675 tree loop_niter_by_eval (struct loop *, edge); | |
| 676 tree find_loop_niter_by_eval (struct loop *, edge *); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
677 void estimate_numbers_of_iterations (bool); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
678 bool array_at_struct_end_p (tree); |
| 0 | 679 bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool); |
| 680 bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool); | |
| 681 | |
| 682 bool nowrap_type_p (tree); | |
| 683 enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; | |
| 684 enum ev_direction scev_direction (const_tree); | |
| 685 | |
| 686 void free_numbers_of_iterations_estimates (void); | |
| 687 void free_numbers_of_iterations_estimates_loop (struct loop *); | |
| 688 void rewrite_into_loop_closed_ssa (bitmap, unsigned); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
689 void verify_loop_closed_ssa (bool); |
| 0 | 690 bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *); |
| 691 void create_iv (tree, tree, tree, struct loop *, gimple_stmt_iterator *, bool, | |
| 692 tree *, tree *); | |
| 693 basic_block split_loop_exit_edge (edge); | |
| 694 void standard_iv_increment_position (struct loop *, gimple_stmt_iterator *, | |
| 695 bool *); | |
| 696 basic_block ip_end_pos (struct loop *); | |
| 697 basic_block ip_normal_pos (struct loop *); | |
| 698 bool gimple_duplicate_loop_to_header_edge (struct loop *, edge, | |
| 699 unsigned int, sbitmap, | |
| 700 edge, VEC (edge, heap) **, | |
| 701 int); | |
| 702 struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *, edge); | |
| 703 void rename_variables_in_loop (struct loop *); | |
| 704 void rename_variables_in_bb (basic_block bb); | |
| 705 struct loop *tree_ssa_loop_version (struct loop *, tree, | |
| 706 basic_block *); | |
| 707 tree expand_simple_operations (tree); | |
| 708 void substitute_in_loop_info (struct loop *, tree, tree); | |
| 709 edge single_dom_exit (struct loop *); | |
| 710 bool can_unroll_loop_p (struct loop *loop, unsigned factor, | |
| 711 struct tree_niter_desc *niter); | |
| 712 void tree_unroll_loop (struct loop *, unsigned, | |
| 713 edge, struct tree_niter_desc *); | |
| 714 typedef void (*transform_callback)(struct loop *, void *); | |
| 715 void tree_transform_and_unroll_loop (struct loop *, unsigned, | |
| 716 edge, struct tree_niter_desc *, | |
| 717 transform_callback, void *); | |
| 718 bool contains_abnormal_ssa_name_p (tree); | |
| 719 bool stmt_dominates_stmt_p (gimple, gimple); | |
| 720 void mark_virtual_ops_for_renaming (gimple); | |
| 721 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
722 /* In tree-ssa-dce.c */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
723 void mark_virtual_phi_result_for_renaming (gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
724 |
| 0 | 725 /* In tree-ssa-threadedge.c */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
726 extern void threadedge_initialize_values (void); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
727 extern void threadedge_finalize_values (void); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
728 extern VEC(tree,heap) *ssa_name_values; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
729 #define SSA_NAME_VALUE(x) \ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
730 (SSA_NAME_VERSION(x) < VEC_length(tree, ssa_name_values) \ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
731 ? VEC_index(tree, ssa_name_values, SSA_NAME_VERSION(x)) \ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
732 : NULL_TREE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
733 extern void set_ssa_name_value (tree, tree); |
| 0 | 734 extern bool potentially_threadable_block (basic_block); |
| 735 extern void thread_across_edge (gimple, edge, bool, | |
| 736 VEC(tree, heap) **, tree (*) (gimple, gimple)); | |
| 737 | |
| 738 /* In tree-ssa-loop-im.c */ | |
| 739 /* The possibilities of statement movement. */ | |
| 740 | |
| 741 enum move_pos | |
| 742 { | |
| 743 MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */ | |
| 744 MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement | |
| 745 become executed -- memory accesses, ... */ | |
| 746 MOVE_POSSIBLE /* Unlimited movement. */ | |
| 747 }; | |
| 748 extern enum move_pos movement_possibility (gimple); | |
| 749 char *get_lsm_tmp_name (tree, unsigned); | |
| 750 | |
| 751 /* In tree-flow-inline.h */ | |
| 752 static inline void set_is_used (tree); | |
| 753 static inline bool unmodifiable_var_p (const_tree); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
754 static inline bool ref_contains_array_ref (const_tree); |
| 0 | 755 |
| 756 /* In tree-eh.c */ | |
| 757 extern void make_eh_edges (gimple); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
758 extern bool make_eh_dispatch_edges (gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
759 extern edge redirect_eh_edge (edge, basic_block); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
760 extern void redirect_eh_dispatch_edge (gimple, edge, basic_block); |
| 0 | 761 extern bool tree_could_trap_p (tree); |
| 762 extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool, | |
| 763 bool, tree, bool *); | |
| 764 extern bool operation_could_trap_p (enum tree_code, bool, bool, tree); | |
| 765 extern bool stmt_could_throw_p (gimple); | |
| 766 extern bool tree_could_throw_p (tree); | |
| 767 extern bool stmt_can_throw_internal (gimple); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
768 extern bool stmt_can_throw_external (gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
769 extern void add_stmt_to_eh_lp_fn (struct function *, gimple, int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
770 extern void add_stmt_to_eh_lp (gimple, int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
771 extern bool remove_stmt_from_eh_lp (gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
772 extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
773 extern int lookup_stmt_eh_lp_fn (struct function *, gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
774 extern int lookup_stmt_eh_lp (gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
775 extern bool maybe_clean_eh_stmt_fn (struct function *, gimple); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
776 extern bool maybe_clean_eh_stmt (gimple); |
| 0 | 777 extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
778 extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
779 struct function *, gimple, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
780 struct pointer_map_t *, int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
781 extern bool maybe_duplicate_eh_stmt (gimple, gimple); |
| 0 | 782 extern bool verify_eh_edges (gimple); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
783 extern bool verify_eh_dispatch_edge (gimple); |
| 0 | 784 |
| 785 /* In tree-ssa-pre.c */ | |
| 786 struct pre_expr_d; | |
| 787 void add_to_value (unsigned int, struct pre_expr_d *); | |
| 788 void debug_value_expressions (unsigned int); | |
| 789 void print_value_expressions (FILE *, unsigned int); | |
| 790 | |
| 791 /* In tree-ssa-sink.c */ | |
| 792 bool is_hidden_global_store (gimple); | |
| 793 | |
| 794 /* In tree-loop-linear.c */ | |
| 795 extern void linear_transform_loops (void); | |
| 796 extern unsigned perfect_loop_nest_depth (struct loop *); | |
| 797 | |
| 798 /* In graphite.c */ | |
| 799 extern void graphite_transform_loops (void); | |
| 800 | |
| 801 /* In tree-data-ref.c */ | |
| 802 extern void tree_check_data_deps (void); | |
| 803 | |
| 804 /* In tree-ssa-loop-ivopts.c */ | |
| 805 bool expr_invariant_in_loop_p (struct loop *, tree); | |
| 806 bool stmt_invariant_in_loop_p (struct loop *, gimple); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
807 bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
808 addr_space_t); |
| 0 | 809 unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
810 bool may_be_nonaddressable_p (tree expr); |
| 0 | 811 |
| 812 /* In tree-ssa-threadupdate.c. */ | |
| 813 extern bool thread_through_all_blocks (bool); | |
| 814 extern void register_jump_thread (edge, edge); | |
| 815 | |
| 816 /* In gimplify.c */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
817 tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree); |
| 0 | 818 tree force_gimple_operand (tree, gimple_seq *, bool, tree); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
819 tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
820 gimple_predicate, tree, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
821 bool, enum gsi_iterator_update); |
| 0 | 822 tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree, |
| 823 bool, enum gsi_iterator_update); | |
| 824 tree gimple_fold_indirect_ref (tree); | |
| 825 | |
| 826 /* In tree-ssa-live.c */ | |
| 827 extern void remove_unused_locals (void); | |
| 828 extern void dump_scope_blocks (FILE *, int); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
829 extern void debug_scope_blocks (int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
830 extern void debug_scope_block (tree, int); |
| 0 | 831 |
| 832 /* In tree-ssa-address.c */ | |
| 833 | |
| 834 /* Description of a memory address. */ | |
| 835 | |
| 836 struct mem_address | |
| 837 { | |
| 838 tree symbol, base, index, step, offset; | |
| 839 }; | |
| 840 | |
| 841 struct affine_tree_combination; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
842 tree create_mem_ref (gimple_stmt_iterator *, tree, |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
843 struct affine_tree_combination *, tree, tree, tree, bool); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
844 rtx addr_for_mem_ref (struct mem_address *, addr_space_t, bool); |
| 0 | 845 void get_address_description (tree, struct mem_address *); |
| 846 tree maybe_fold_tmr (tree); | |
| 847 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
848 unsigned int execute_free_datastructures (void); |
| 0 | 849 unsigned int execute_fixup_cfg (void); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
850 bool fixup_noreturn_call (gimple stmt); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
851 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
852 /* In ipa-pure-const.c */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
853 void warn_function_noreturn (tree); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
854 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
855 /* In tree-ssa-ter.c */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
856 bool stmt_is_replaceable_p (gimple); |
| 0 | 857 |
| 858 #include "tree-flow-inline.h" | |
| 859 | |
| 860 void swap_tree_operands (gimple, tree *, tree *); | |
| 861 | |
| 862 #endif /* _TREE_FLOW_H */ |