Mercurial > hg > CbC > CbC_gcc
annotate gcc/basic-block.h @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
| author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 22 Mar 2011 17:18:12 +0900 |
| parents | b7f97abdc517 |
| children | 04ced10e8804 |
| rev | line source |
|---|---|
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1 /* Define control flow data structures for the CFG. |
| 0 | 2 Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
| 0 | 4 |
| 5 This file is part of GCC. | |
| 6 | |
| 7 GCC is free software; you can redistribute it and/or modify it under | |
| 8 the terms of the GNU General Public License as published by the Free | |
| 9 Software Foundation; either version 3, or (at your option) any later | |
| 10 version. | |
| 11 | |
| 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with GCC; see the file COPYING3. If not see | |
| 19 <http://www.gnu.org/licenses/>. */ | |
| 20 | |
| 21 #ifndef GCC_BASIC_BLOCK_H | |
| 22 #define GCC_BASIC_BLOCK_H | |
| 23 | |
| 24 #include "predict.h" | |
| 25 #include "vec.h" | |
| 26 #include "function.h" | |
| 27 | |
| 28 /* Type we use to hold basic block counters. Should be at least | |
| 29 64bit. Although a counter cannot be negative, we use a signed | |
| 30 type, because erroneous negative counts can be generated when the | |
| 31 flow graph is manipulated by various optimizations. A signed type | |
| 32 makes those easy to detect. */ | |
| 33 typedef HOST_WIDEST_INT gcov_type; | |
| 34 | |
| 35 /* Control flow edge information. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
36 struct GTY(()) edge_def { |
| 0 | 37 /* The two blocks at the ends of the edge. */ |
| 38 struct basic_block_def *src; | |
| 39 struct basic_block_def *dest; | |
| 40 | |
| 41 /* Instructions queued on the edge. */ | |
| 42 union edge_def_insns { | |
| 43 gimple_seq GTY ((tag ("true"))) g; | |
| 44 rtx GTY ((tag ("false"))) r; | |
| 45 } GTY ((desc ("current_ir_type () == IR_GIMPLE"))) insns; | |
| 46 | |
| 47 /* Auxiliary info specific to a pass. */ | |
| 48 PTR GTY ((skip (""))) aux; | |
| 49 | |
| 50 /* Location of any goto implicit in the edge and associated BLOCK. */ | |
| 51 tree goto_block; | |
| 52 location_t goto_locus; | |
| 53 | |
| 54 /* The index number corresponding to this edge in the edge vector | |
| 55 dest->preds. */ | |
| 56 unsigned int dest_idx; | |
| 57 | |
| 58 int flags; /* see EDGE_* below */ | |
| 59 int probability; /* biased by REG_BR_PROB_BASE */ | |
| 60 gcov_type count; /* Expected number of executions calculated | |
| 61 in profile.c */ | |
| 62 }; | |
| 63 | |
| 64 DEF_VEC_P(edge); | |
| 65 DEF_VEC_ALLOC_P(edge,gc); | |
| 66 DEF_VEC_ALLOC_P(edge,heap); | |
| 67 | |
| 68 #define EDGE_FALLTHRU 1 /* 'Straight line' flow */ | |
| 69 #define EDGE_ABNORMAL 2 /* Strange flow, like computed | |
| 70 label, or eh */ | |
| 71 #define EDGE_ABNORMAL_CALL 4 /* Call with abnormal exit | |
| 72 like an exception, or sibcall */ | |
| 73 #define EDGE_EH 8 /* Exception throw */ | |
| 74 #define EDGE_FAKE 16 /* Not a real edge (profile.c) */ | |
| 75 #define EDGE_DFS_BACK 32 /* A backwards edge */ | |
| 76 #define EDGE_CAN_FALLTHRU 64 /* Candidate for straight line | |
| 77 flow. */ | |
| 78 #define EDGE_IRREDUCIBLE_LOOP 128 /* Part of irreducible loop. */ | |
| 79 #define EDGE_SIBCALL 256 /* Edge from sibcall to exit. */ | |
| 80 #define EDGE_LOOP_EXIT 512 /* Exit of a loop. */ | |
| 81 #define EDGE_TRUE_VALUE 1024 /* Edge taken when controlling | |
| 82 predicate is nonzero. */ | |
| 83 #define EDGE_FALSE_VALUE 2048 /* Edge taken when controlling | |
| 84 predicate is zero. */ | |
| 85 #define EDGE_EXECUTABLE 4096 /* Edge is executable. Only | |
| 86 valid during SSA-CCP. */ | |
| 87 #define EDGE_CROSSING 8192 /* Edge crosses between hot | |
| 88 and cold sections, when we | |
| 89 do partitioning. */ | |
| 90 #define EDGE_ALL_FLAGS 16383 | |
| 91 | |
| 92 #define EDGE_COMPLEX (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH) | |
| 93 | |
| 94 /* Counter summary from the last set of coverage counts read by | |
| 95 profile.c. */ | |
| 96 extern const struct gcov_ctr_summary *profile_info; | |
| 97 | |
| 98 /* Declared in cfgloop.h. */ | |
| 99 struct loop; | |
| 100 | |
| 101 /* Declared in tree-flow.h. */ | |
| 102 struct rtl_bb_info; | |
| 103 | |
| 104 /* A basic block is a sequence of instructions with only entry and | |
| 105 only one exit. If any one of the instructions are executed, they | |
| 106 will all be executed, and in sequence from first to last. | |
| 107 | |
| 108 There may be COND_EXEC instructions in the basic block. The | |
| 109 COND_EXEC *instructions* will be executed -- but if the condition | |
| 110 is false the conditionally executed *expressions* will of course | |
| 111 not be executed. We don't consider the conditionally executed | |
| 112 expression (which might have side-effects) to be in a separate | |
| 113 basic block because the program counter will always be at the same | |
| 114 location after the COND_EXEC instruction, regardless of whether the | |
| 115 condition is true or not. | |
| 116 | |
| 117 Basic blocks need not start with a label nor end with a jump insn. | |
| 118 For example, a previous basic block may just "conditionally fall" | |
| 119 into the succeeding basic block, and the last basic block need not | |
| 120 end with a jump insn. Block 0 is a descendant of the entry block. | |
| 121 | |
| 122 A basic block beginning with two labels cannot have notes between | |
| 123 the labels. | |
| 124 | |
| 125 Data for jump tables are stored in jump_insns that occur in no | |
| 126 basic block even though these insns can follow or precede insns in | |
| 127 basic blocks. */ | |
| 128 | |
| 129 /* Basic block information indexed by block number. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
130 struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_def { |
| 0 | 131 /* The edges into and out of the block. */ |
| 132 VEC(edge,gc) *preds; | |
| 133 VEC(edge,gc) *succs; | |
| 134 | |
| 135 /* Auxiliary info specific to a pass. */ | |
| 136 PTR GTY ((skip (""))) aux; | |
| 137 | |
| 138 /* Innermost loop containing the block. */ | |
| 139 struct loop *loop_father; | |
| 140 | |
| 141 /* The dominance and postdominance information node. */ | |
| 142 struct et_node * GTY ((skip (""))) dom[2]; | |
| 143 | |
| 144 /* Previous and next blocks in the chain. */ | |
| 145 struct basic_block_def *prev_bb; | |
| 146 struct basic_block_def *next_bb; | |
| 147 | |
| 148 union basic_block_il_dependent { | |
| 149 struct gimple_bb_info * GTY ((tag ("0"))) gimple; | |
| 150 struct rtl_bb_info * GTY ((tag ("1"))) rtl; | |
| 151 } GTY ((desc ("((%1.flags & BB_RTL) != 0)"))) il; | |
| 152 | |
| 153 /* Expected number of executions: calculated in profile.c. */ | |
| 154 gcov_type count; | |
| 155 | |
| 156 /* The index of this block. */ | |
| 157 int index; | |
| 158 | |
| 159 /* The loop depth of this block. */ | |
| 160 int loop_depth; | |
| 161 | |
| 162 /* Expected frequency. Normalized to be in range 0 to BB_FREQ_MAX. */ | |
| 163 int frequency; | |
| 164 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
165 /* The discriminator for this block. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
166 int discriminator; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
167 |
| 0 | 168 /* Various flags. See BB_* below. */ |
| 169 int flags; | |
| 170 }; | |
| 171 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
172 struct GTY(()) rtl_bb_info { |
| 0 | 173 /* The first and last insns of the block. */ |
| 174 rtx head_; | |
| 175 rtx end_; | |
| 176 | |
| 177 /* In CFGlayout mode points to insn notes/jumptables to be placed just before | |
| 178 and after the block. */ | |
| 179 rtx header; | |
| 180 rtx footer; | |
| 181 | |
| 182 /* This field is used by the bb-reorder and tracer passes. */ | |
| 183 int visited; | |
| 184 }; | |
| 185 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
186 struct GTY(()) gimple_bb_info { |
| 0 | 187 /* Sequence of statements in this block. */ |
| 188 gimple_seq seq; | |
| 189 | |
| 190 /* PHI nodes for this block. */ | |
| 191 gimple_seq phi_nodes; | |
| 192 }; | |
| 193 | |
| 194 DEF_VEC_P(basic_block); | |
| 195 DEF_VEC_ALLOC_P(basic_block,gc); | |
| 196 DEF_VEC_ALLOC_P(basic_block,heap); | |
| 197 | |
| 198 #define BB_FREQ_MAX 10000 | |
| 199 | |
| 200 /* Masks for basic_block.flags. | |
| 201 | |
| 202 BB_HOT_PARTITION and BB_COLD_PARTITION should be preserved throughout | |
| 203 the compilation, so they are never cleared. | |
| 204 | |
| 205 All other flags may be cleared by clear_bb_flags(). It is generally | |
| 206 a bad idea to rely on any flags being up-to-date. */ | |
| 207 | |
| 208 enum bb_flags | |
| 209 { | |
| 210 /* Only set on blocks that have just been created by create_bb. */ | |
| 211 BB_NEW = 1 << 0, | |
| 212 | |
| 213 /* Set by find_unreachable_blocks. Do not rely on this being set in any | |
| 214 pass. */ | |
| 215 BB_REACHABLE = 1 << 1, | |
| 216 | |
| 217 /* Set for blocks in an irreducible loop by loop analysis. */ | |
| 218 BB_IRREDUCIBLE_LOOP = 1 << 2, | |
| 219 | |
| 220 /* Set on blocks that may actually not be single-entry single-exit block. */ | |
| 221 BB_SUPERBLOCK = 1 << 3, | |
| 222 | |
| 223 /* Set on basic blocks that the scheduler should not touch. This is used | |
| 224 by SMS to prevent other schedulers from messing with the loop schedule. */ | |
| 225 BB_DISABLE_SCHEDULE = 1 << 4, | |
| 226 | |
| 227 /* Set on blocks that should be put in a hot section. */ | |
| 228 BB_HOT_PARTITION = 1 << 5, | |
| 229 | |
| 230 /* Set on blocks that should be put in a cold section. */ | |
| 231 BB_COLD_PARTITION = 1 << 6, | |
| 232 | |
| 233 /* Set on block that was duplicated. */ | |
| 234 BB_DUPLICATED = 1 << 7, | |
| 235 | |
| 236 /* Set if the label at the top of this block is the target of a non-local goto. */ | |
| 237 BB_NON_LOCAL_GOTO_TARGET = 1 << 8, | |
| 238 | |
| 239 /* Set on blocks that are in RTL format. */ | |
| 240 BB_RTL = 1 << 9 , | |
| 241 | |
| 242 /* Set on blocks that are forwarder blocks. | |
| 243 Only used in cfgcleanup.c. */ | |
| 244 BB_FORWARDER_BLOCK = 1 << 10, | |
| 245 | |
| 246 /* Set on blocks that cannot be threaded through. | |
| 247 Only used in cfgcleanup.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
|
248 BB_NONTHREADABLE_BLOCK = 1 << 11, |
|
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
|
249 |
|
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
|
250 /* Set on blocks that were modified in some way. This bit is set in |
|
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
|
251 df_set_bb_dirty, but not cleared by df_analyze, so it can be used |
|
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
|
252 to test whether a block has been modified prior to a df_analyze |
|
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
|
253 call. */ |
|
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
|
254 BB_MODIFIED = 1 << 12 |
| 0 | 255 }; |
| 256 | |
| 257 /* Dummy flag for convenience in the hot/cold partitioning code. */ | |
| 258 #define BB_UNPARTITIONED 0 | |
| 259 | |
| 260 /* Partitions, to be used when partitioning hot and cold basic blocks into | |
| 261 separate sections. */ | |
| 262 #define BB_PARTITION(bb) ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) | |
| 263 #define BB_SET_PARTITION(bb, part) do { \ | |
| 264 basic_block bb_ = (bb); \ | |
| 265 bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) \ | |
| 266 | (part)); \ | |
| 267 } while (0) | |
| 268 | |
| 269 #define BB_COPY_PARTITION(dstbb, srcbb) \ | |
| 270 BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb)) | |
| 271 | |
| 272 /* State of dominance information. */ | |
| 273 | |
| 274 enum dom_state | |
| 275 { | |
| 276 DOM_NONE, /* Not computed at all. */ | |
| 277 DOM_NO_FAST_QUERY, /* The data is OK, but the fast query data are not usable. */ | |
| 278 DOM_OK /* Everything is ok. */ | |
| 279 }; | |
| 280 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
281 /* What sort of profiling information we have. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
282 enum profile_status_d |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
283 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
284 PROFILE_ABSENT, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
285 PROFILE_GUESSED, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
286 PROFILE_READ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
287 }; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
288 |
| 0 | 289 /* A structure to group all the per-function control flow graph data. |
| 290 The x_* prefixing is necessary because otherwise references to the | |
| 291 fields of this struct are interpreted as the defines for backward | |
| 292 source compatibility following the definition of this struct. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
293 struct GTY(()) control_flow_graph { |
| 0 | 294 /* Block pointers for the exit and entry of a function. |
| 295 These are always the head and tail of the basic block list. */ | |
| 296 basic_block x_entry_block_ptr; | |
| 297 basic_block x_exit_block_ptr; | |
| 298 | |
| 299 /* Index by basic block number, get basic block struct info. */ | |
| 300 VEC(basic_block,gc) *x_basic_block_info; | |
| 301 | |
| 302 /* Number of basic blocks in this flow graph. */ | |
| 303 int x_n_basic_blocks; | |
| 304 | |
| 305 /* Number of edges in this flow graph. */ | |
| 306 int x_n_edges; | |
| 307 | |
| 308 /* The first free basic block number. */ | |
| 309 int x_last_basic_block; | |
| 310 | |
|
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
|
311 /* UIDs for LABEL_DECLs. */ |
|
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
|
312 int last_label_uid; |
|
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
|
313 |
| 0 | 314 /* Mapping of labels to their associated blocks. At present |
| 315 only used for the gimple CFG. */ | |
| 316 VEC(basic_block,gc) *x_label_to_block_map; | |
| 317 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
318 enum profile_status_d x_profile_status; |
| 0 | 319 |
| 320 /* Whether the dominators and the postdominators are available. */ | |
| 321 enum dom_state x_dom_computed[2]; | |
| 322 | |
| 323 /* Number of basic blocks in the dominance tree. */ | |
| 324 unsigned x_n_bbs_in_dom_tree[2]; | |
| 325 | |
| 326 /* Maximal number of entities in the single jumptable. Used to estimate | |
| 327 final flowgraph size. */ | |
| 328 int max_jumptable_ents; | |
| 329 }; | |
| 330 | |
| 331 /* Defines for accessing the fields of the CFG structure for function FN. */ | |
| 332 #define ENTRY_BLOCK_PTR_FOR_FUNCTION(FN) ((FN)->cfg->x_entry_block_ptr) | |
| 333 #define EXIT_BLOCK_PTR_FOR_FUNCTION(FN) ((FN)->cfg->x_exit_block_ptr) | |
| 334 #define basic_block_info_for_function(FN) ((FN)->cfg->x_basic_block_info) | |
| 335 #define n_basic_blocks_for_function(FN) ((FN)->cfg->x_n_basic_blocks) | |
| 336 #define n_edges_for_function(FN) ((FN)->cfg->x_n_edges) | |
| 337 #define last_basic_block_for_function(FN) ((FN)->cfg->x_last_basic_block) | |
| 338 #define label_to_block_map_for_function(FN) ((FN)->cfg->x_label_to_block_map) | |
| 339 #define profile_status_for_function(FN) ((FN)->cfg->x_profile_status) | |
| 340 | |
| 341 #define BASIC_BLOCK_FOR_FUNCTION(FN,N) \ | |
| 342 (VEC_index (basic_block, basic_block_info_for_function(FN), (N))) | |
| 343 #define SET_BASIC_BLOCK_FOR_FUNCTION(FN,N,BB) \ | |
| 344 (VEC_replace (basic_block, basic_block_info_for_function(FN), (N), (BB))) | |
| 345 | |
| 346 /* Defines for textual backward source compatibility. */ | |
| 347 #define ENTRY_BLOCK_PTR (cfun->cfg->x_entry_block_ptr) | |
| 348 #define EXIT_BLOCK_PTR (cfun->cfg->x_exit_block_ptr) | |
| 349 #define basic_block_info (cfun->cfg->x_basic_block_info) | |
| 350 #define n_basic_blocks (cfun->cfg->x_n_basic_blocks) | |
| 351 #define n_edges (cfun->cfg->x_n_edges) | |
| 352 #define last_basic_block (cfun->cfg->x_last_basic_block) | |
| 353 #define label_to_block_map (cfun->cfg->x_label_to_block_map) | |
| 354 #define profile_status (cfun->cfg->x_profile_status) | |
| 355 | |
| 356 #define BASIC_BLOCK(N) (VEC_index (basic_block, basic_block_info, (N))) | |
| 357 #define SET_BASIC_BLOCK(N,BB) (VEC_replace (basic_block, basic_block_info, (N), (BB))) | |
| 358 | |
| 359 /* For iterating over basic blocks. */ | |
| 360 #define FOR_BB_BETWEEN(BB, FROM, TO, DIR) \ | |
| 361 for (BB = FROM; BB != TO; BB = BB->DIR) | |
| 362 | |
| 363 #define FOR_EACH_BB_FN(BB, FN) \ | |
| 364 FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb) | |
| 365 | |
| 366 #define FOR_EACH_BB(BB) FOR_EACH_BB_FN (BB, cfun) | |
| 367 | |
| 368 #define FOR_EACH_BB_REVERSE_FN(BB, FN) \ | |
| 369 FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb) | |
| 370 | |
| 371 #define FOR_EACH_BB_REVERSE(BB) FOR_EACH_BB_REVERSE_FN(BB, cfun) | |
| 372 | |
| 373 /* For iterating over insns in basic block. */ | |
| 374 #define FOR_BB_INSNS(BB, INSN) \ | |
| 375 for ((INSN) = BB_HEAD (BB); \ | |
| 376 (INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \ | |
| 377 (INSN) = NEXT_INSN (INSN)) | |
| 378 | |
| 379 /* For iterating over insns in basic block when we might remove the | |
| 380 current insn. */ | |
| 381 #define FOR_BB_INSNS_SAFE(BB, INSN, CURR) \ | |
| 382 for ((INSN) = BB_HEAD (BB), (CURR) = (INSN) ? NEXT_INSN ((INSN)): NULL; \ | |
| 383 (INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \ | |
| 384 (INSN) = (CURR), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
385 |
| 0 | 386 #define FOR_BB_INSNS_REVERSE(BB, INSN) \ |
| 387 for ((INSN) = BB_END (BB); \ | |
| 388 (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \ | |
| 389 (INSN) = PREV_INSN (INSN)) | |
| 390 | |
| 391 #define FOR_BB_INSNS_REVERSE_SAFE(BB, INSN, CURR) \ | |
| 392 for ((INSN) = BB_END (BB),(CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL; \ | |
| 393 (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \ | |
| 394 (INSN) = (CURR), (CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL) | |
| 395 | |
| 396 /* Cycles through _all_ basic blocks, even the fake ones (entry and | |
| 397 exit block). */ | |
| 398 | |
| 399 #define FOR_ALL_BB(BB) \ | |
| 400 for (BB = ENTRY_BLOCK_PTR; BB; BB = BB->next_bb) | |
| 401 | |
| 402 #define FOR_ALL_BB_FN(BB, FN) \ | |
| 403 for (BB = ENTRY_BLOCK_PTR_FOR_FUNCTION (FN); BB; BB = BB->next_bb) | |
| 404 | |
| 405 | |
| 406 /* Stuff for recording basic block info. */ | |
| 407 | |
| 408 #define BB_HEAD(B) (B)->il.rtl->head_ | |
| 409 #define BB_END(B) (B)->il.rtl->end_ | |
| 410 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
411 /* Special block numbers [markers] for entry and exit. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
412 Neither of them is supposed to hold actual statements. */ |
| 0 | 413 #define ENTRY_BLOCK (0) |
| 414 #define EXIT_BLOCK (1) | |
| 415 | |
| 416 /* The two blocks that are always in the cfg. */ | |
| 417 #define NUM_FIXED_BLOCKS (2) | |
| 418 | |
| 419 #define set_block_for_insn(INSN, BB) (BLOCK_FOR_INSN (INSN) = BB) | |
| 420 | |
| 421 extern void compute_bb_for_insn (void); | |
| 422 extern unsigned int free_bb_for_insn (void); | |
| 423 extern void update_bb_for_insn (basic_block); | |
| 424 | |
| 425 extern void insert_insn_on_edge (rtx, edge); | |
| 426 basic_block split_edge_and_insert (edge, rtx); | |
| 427 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
428 extern void commit_one_edge_insertion (edge e); |
| 0 | 429 extern void commit_edge_insertions (void); |
| 430 | |
| 431 extern void remove_fake_edges (void); | |
| 432 extern void remove_fake_exit_edges (void); | |
| 433 extern void add_noreturn_fake_exit_edges (void); | |
| 434 extern void connect_infinite_loops_to_exit (void); | |
| 435 extern edge unchecked_make_edge (basic_block, basic_block, int); | |
| 436 extern edge cached_make_edge (sbitmap, basic_block, basic_block, int); | |
| 437 extern edge make_edge (basic_block, basic_block, int); | |
| 438 extern edge make_single_succ_edge (basic_block, basic_block, int); | |
| 439 extern void remove_edge_raw (edge); | |
| 440 extern void redirect_edge_succ (edge, basic_block); | |
| 441 extern edge redirect_edge_succ_nodup (edge, basic_block); | |
| 442 extern void redirect_edge_pred (edge, basic_block); | |
| 443 extern basic_block create_basic_block_structure (rtx, rtx, rtx, basic_block); | |
| 444 extern void clear_bb_flags (void); | |
| 445 extern int post_order_compute (int *, bool, bool); | |
| 446 extern int inverted_post_order_compute (int *); | |
| 447 extern int pre_and_rev_post_order_compute (int *, int *, bool); | |
| 448 extern int dfs_enumerate_from (basic_block, int, | |
| 449 bool (*)(const_basic_block, const void *), | |
| 450 basic_block *, int, const 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
|
451 extern void compute_dominance_frontiers (struct bitmap_head_def *); |
|
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
|
452 extern bitmap compute_idf (bitmap, struct bitmap_head_def *); |
| 0 | 453 extern void dump_bb_info (basic_block, bool, bool, int, const char *, FILE *); |
| 454 extern void dump_edge_info (FILE *, edge, int); | |
| 455 extern void brief_dump_cfg (FILE *); | |
| 456 extern void clear_edges (void); | |
| 457 extern void scale_bbs_frequencies_int (basic_block *, int, int, int); | |
| 458 extern void scale_bbs_frequencies_gcov_type (basic_block *, int, gcov_type, | |
| 459 gcov_type); | |
| 460 | |
| 461 /* Structure to group all of the information to process IF-THEN and | |
| 462 IF-THEN-ELSE blocks for the conditional execution support. This | |
| 463 needs to be in a public file in case the IFCVT macros call | |
| 464 functions passing the ce_if_block data structure. */ | |
| 465 | |
| 466 typedef struct ce_if_block | |
| 467 { | |
| 468 basic_block test_bb; /* First test block. */ | |
| 469 basic_block then_bb; /* THEN block. */ | |
| 470 basic_block else_bb; /* ELSE block or NULL. */ | |
| 471 basic_block join_bb; /* Join THEN/ELSE blocks. */ | |
| 472 basic_block last_test_bb; /* Last bb to hold && or || tests. */ | |
| 473 int num_multiple_test_blocks; /* # of && and || basic blocks. */ | |
| 474 int num_and_and_blocks; /* # of && blocks. */ | |
| 475 int num_or_or_blocks; /* # of || blocks. */ | |
| 476 int num_multiple_test_insns; /* # of insns in && and || blocks. */ | |
| 477 int and_and_p; /* Complex test is &&. */ | |
| 478 int num_then_insns; /* # of insns in THEN block. */ | |
| 479 int num_else_insns; /* # of insns in ELSE block. */ | |
| 480 int pass; /* Pass number. */ | |
| 481 | |
| 482 #ifdef IFCVT_EXTRA_FIELDS | |
| 483 IFCVT_EXTRA_FIELDS /* Any machine dependent fields. */ | |
| 484 #endif | |
| 485 | |
| 486 } ce_if_block_t; | |
| 487 | |
| 488 /* This structure maintains an edge list vector. */ | |
| 489 struct edge_list | |
| 490 { | |
| 491 int num_blocks; | |
| 492 int num_edges; | |
| 493 edge *index_to_edge; | |
| 494 }; | |
| 495 | |
| 496 /* The base value for branch probability notes and edge probabilities. */ | |
| 497 #define REG_BR_PROB_BASE 10000 | |
| 498 | |
| 499 /* This is the value which indicates no edge is present. */ | |
| 500 #define EDGE_INDEX_NO_EDGE -1 | |
| 501 | |
| 502 /* EDGE_INDEX returns an integer index for an edge, or EDGE_INDEX_NO_EDGE | |
| 503 if there is no edge between the 2 basic blocks. */ | |
| 504 #define EDGE_INDEX(el, pred, succ) (find_edge_index ((el), (pred), (succ))) | |
| 505 | |
| 506 /* INDEX_EDGE_PRED_BB and INDEX_EDGE_SUCC_BB return a pointer to the basic | |
| 507 block which is either the pred or succ end of the indexed edge. */ | |
| 508 #define INDEX_EDGE_PRED_BB(el, index) ((el)->index_to_edge[(index)]->src) | |
| 509 #define INDEX_EDGE_SUCC_BB(el, index) ((el)->index_to_edge[(index)]->dest) | |
| 510 | |
| 511 /* INDEX_EDGE returns a pointer to the edge. */ | |
| 512 #define INDEX_EDGE(el, index) ((el)->index_to_edge[(index)]) | |
| 513 | |
| 514 /* Number of edges in the compressed edge list. */ | |
| 515 #define NUM_EDGES(el) ((el)->num_edges) | |
| 516 | |
| 517 /* BB is assumed to contain conditional jump. Return the fallthru edge. */ | |
| 518 #define FALLTHRU_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \ | |
| 519 ? EDGE_SUCC ((bb), 0) : EDGE_SUCC ((bb), 1)) | |
| 520 | |
| 521 /* BB is assumed to contain conditional jump. Return the branch edge. */ | |
| 522 #define BRANCH_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \ | |
| 523 ? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0)) | |
| 524 | |
| 525 /* Return expected execution frequency of the edge E. */ | |
| 526 #define EDGE_FREQUENCY(e) (((e)->src->frequency \ | |
| 527 * (e)->probability \ | |
| 528 + REG_BR_PROB_BASE / 2) \ | |
| 529 / REG_BR_PROB_BASE) | |
| 530 | |
| 531 /* Return nonzero if edge is critical. */ | |
| 532 #define EDGE_CRITICAL_P(e) (EDGE_COUNT ((e)->src->succs) >= 2 \ | |
| 533 && EDGE_COUNT ((e)->dest->preds) >= 2) | |
| 534 | |
| 535 #define EDGE_COUNT(ev) VEC_length (edge, (ev)) | |
| 536 #define EDGE_I(ev,i) VEC_index (edge, (ev), (i)) | |
| 537 #define EDGE_PRED(bb,i) VEC_index (edge, (bb)->preds, (i)) | |
| 538 #define EDGE_SUCC(bb,i) VEC_index (edge, (bb)->succs, (i)) | |
| 539 | |
| 540 /* Returns true if BB has precisely one successor. */ | |
| 541 | |
| 542 static inline bool | |
| 543 single_succ_p (const_basic_block bb) | |
| 544 { | |
| 545 return EDGE_COUNT (bb->succs) == 1; | |
| 546 } | |
| 547 | |
| 548 /* Returns true if BB has precisely one predecessor. */ | |
| 549 | |
| 550 static inline bool | |
| 551 single_pred_p (const_basic_block bb) | |
| 552 { | |
| 553 return EDGE_COUNT (bb->preds) == 1; | |
| 554 } | |
| 555 | |
| 556 /* Returns the single successor edge of basic block BB. Aborts if | |
| 557 BB does not have exactly one successor. */ | |
| 558 | |
| 559 static inline edge | |
| 560 single_succ_edge (const_basic_block bb) | |
| 561 { | |
|
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
|
562 gcc_checking_assert (single_succ_p (bb)); |
| 0 | 563 return EDGE_SUCC (bb, 0); |
| 564 } | |
| 565 | |
| 566 /* Returns the single predecessor edge of basic block BB. Aborts | |
| 567 if BB does not have exactly one predecessor. */ | |
| 568 | |
| 569 static inline edge | |
| 570 single_pred_edge (const_basic_block bb) | |
| 571 { | |
|
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
|
572 gcc_checking_assert (single_pred_p (bb)); |
| 0 | 573 return EDGE_PRED (bb, 0); |
| 574 } | |
| 575 | |
| 576 /* Returns the single successor block of basic block BB. Aborts | |
| 577 if BB does not have exactly one successor. */ | |
| 578 | |
| 579 static inline basic_block | |
| 580 single_succ (const_basic_block bb) | |
| 581 { | |
| 582 return single_succ_edge (bb)->dest; | |
| 583 } | |
| 584 | |
| 585 /* Returns the single predecessor block of basic block BB. Aborts | |
| 586 if BB does not have exactly one predecessor.*/ | |
| 587 | |
| 588 static inline basic_block | |
| 589 single_pred (const_basic_block bb) | |
| 590 { | |
| 591 return single_pred_edge (bb)->src; | |
| 592 } | |
| 593 | |
| 594 /* Iterator object for edges. */ | |
| 595 | |
| 596 typedef struct { | |
| 597 unsigned index; | |
| 598 VEC(edge,gc) **container; | |
| 599 } edge_iterator; | |
| 600 | |
| 601 static inline VEC(edge,gc) * | |
| 602 ei_container (edge_iterator i) | |
| 603 { | |
|
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
|
604 gcc_checking_assert (i.container); |
| 0 | 605 return *i.container; |
| 606 } | |
| 607 | |
| 608 #define ei_start(iter) ei_start_1 (&(iter)) | |
| 609 #define ei_last(iter) ei_last_1 (&(iter)) | |
| 610 | |
| 611 /* Return an iterator pointing to the start of an edge vector. */ | |
| 612 static inline edge_iterator | |
| 613 ei_start_1 (VEC(edge,gc) **ev) | |
| 614 { | |
| 615 edge_iterator i; | |
| 616 | |
| 617 i.index = 0; | |
| 618 i.container = ev; | |
| 619 | |
| 620 return i; | |
| 621 } | |
| 622 | |
| 623 /* Return an iterator pointing to the last element of an edge | |
| 624 vector. */ | |
| 625 static inline edge_iterator | |
| 626 ei_last_1 (VEC(edge,gc) **ev) | |
| 627 { | |
| 628 edge_iterator i; | |
| 629 | |
| 630 i.index = EDGE_COUNT (*ev) - 1; | |
| 631 i.container = ev; | |
| 632 | |
| 633 return i; | |
| 634 } | |
| 635 | |
| 636 /* Is the iterator `i' at the end of the sequence? */ | |
| 637 static inline bool | |
| 638 ei_end_p (edge_iterator i) | |
| 639 { | |
| 640 return (i.index == EDGE_COUNT (ei_container (i))); | |
| 641 } | |
| 642 | |
| 643 /* Is the iterator `i' at one position before the end of the | |
| 644 sequence? */ | |
| 645 static inline bool | |
| 646 ei_one_before_end_p (edge_iterator i) | |
| 647 { | |
| 648 return (i.index + 1 == EDGE_COUNT (ei_container (i))); | |
| 649 } | |
| 650 | |
| 651 /* Advance the iterator to the next element. */ | |
| 652 static inline void | |
| 653 ei_next (edge_iterator *i) | |
| 654 { | |
|
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
|
655 gcc_checking_assert (i->index < EDGE_COUNT (ei_container (*i))); |
| 0 | 656 i->index++; |
| 657 } | |
| 658 | |
| 659 /* Move the iterator to the previous element. */ | |
| 660 static inline void | |
| 661 ei_prev (edge_iterator *i) | |
| 662 { | |
|
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
|
663 gcc_checking_assert (i->index > 0); |
| 0 | 664 i->index--; |
| 665 } | |
| 666 | |
| 667 /* Return the edge pointed to by the iterator `i'. */ | |
| 668 static inline edge | |
| 669 ei_edge (edge_iterator i) | |
| 670 { | |
| 671 return EDGE_I (ei_container (i), i.index); | |
| 672 } | |
| 673 | |
| 674 /* Return an edge pointed to by the iterator. Do it safely so that | |
| 675 NULL is returned when the iterator is pointing at the end of the | |
| 676 sequence. */ | |
| 677 static inline edge | |
| 678 ei_safe_edge (edge_iterator i) | |
| 679 { | |
| 680 return !ei_end_p (i) ? ei_edge (i) : NULL; | |
| 681 } | |
| 682 | |
| 683 /* Return 1 if we should continue to iterate. Return 0 otherwise. | |
| 684 *Edge P is set to the next edge if we are to continue to iterate | |
| 685 and NULL otherwise. */ | |
| 686 | |
| 687 static inline bool | |
| 688 ei_cond (edge_iterator ei, edge *p) | |
| 689 { | |
| 690 if (!ei_end_p (ei)) | |
| 691 { | |
| 692 *p = ei_edge (ei); | |
| 693 return 1; | |
| 694 } | |
| 695 else | |
| 696 { | |
| 697 *p = NULL; | |
| 698 return 0; | |
| 699 } | |
| 700 } | |
| 701 | |
| 702 /* This macro serves as a convenient way to iterate each edge in a | |
| 703 vector of predecessor or successor edges. It must not be used when | |
| 704 an element might be removed during the traversal, otherwise | |
| 705 elements will be missed. Instead, use a for-loop like that shown | |
| 706 in the following pseudo-code: | |
| 707 | |
| 708 FOR (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); ) | |
| 709 { | |
| 710 IF (e != taken_edge) | |
| 711 remove_edge (e); | |
| 712 ELSE | |
| 713 ei_next (&ei); | |
| 714 } | |
| 715 */ | |
| 716 | |
| 717 #define FOR_EACH_EDGE(EDGE,ITER,EDGE_VEC) \ | |
| 718 for ((ITER) = ei_start ((EDGE_VEC)); \ | |
| 719 ei_cond ((ITER), &(EDGE)); \ | |
| 720 ei_next (&(ITER))) | |
| 721 | |
| 722 struct edge_list * create_edge_list (void); | |
| 723 void free_edge_list (struct edge_list *); | |
| 724 void print_edge_list (FILE *, struct edge_list *); | |
| 725 void verify_edge_list (FILE *, struct edge_list *); | |
| 726 int find_edge_index (struct edge_list *, basic_block, basic_block); | |
| 727 edge find_edge (basic_block, basic_block); | |
| 728 | |
| 729 #define CLEANUP_EXPENSIVE 1 /* Do relatively expensive optimizations | |
| 730 except for edge forwarding */ | |
| 731 #define CLEANUP_CROSSJUMP 2 /* Do crossjumping. */ | |
| 732 #define CLEANUP_POST_REGSTACK 4 /* We run after reg-stack and need | |
| 733 to care REG_DEAD notes. */ | |
| 734 #define CLEANUP_THREADING 8 /* Do jump threading. */ | |
| 735 #define CLEANUP_NO_INSN_DEL 16 /* Do not try to delete trivially dead | |
| 736 insns. */ | |
| 737 #define CLEANUP_CFGLAYOUT 32 /* Do cleanup in cfglayout mode. */ | |
| 738 | |
| 739 /* In lcm.c */ | |
| 740 extern struct edge_list *pre_edge_lcm (int, sbitmap *, sbitmap *, | |
| 741 sbitmap *, sbitmap *, sbitmap **, | |
| 742 sbitmap **); | |
| 743 extern struct edge_list *pre_edge_rev_lcm (int, sbitmap *, | |
| 744 sbitmap *, sbitmap *, | |
| 745 sbitmap *, sbitmap **, | |
| 746 sbitmap **); | |
| 747 extern void compute_available (sbitmap *, sbitmap *, sbitmap *, sbitmap *); | |
| 748 | |
| 749 /* In predict.c */ | |
| 750 extern bool maybe_hot_bb_p (const_basic_block); | |
| 751 extern bool maybe_hot_edge_p (edge); | |
| 752 extern bool probably_never_executed_bb_p (const_basic_block); | |
| 753 extern bool optimize_bb_for_size_p (const_basic_block); | |
| 754 extern bool optimize_bb_for_speed_p (const_basic_block); | |
| 755 extern bool optimize_edge_for_size_p (edge); | |
| 756 extern bool optimize_edge_for_speed_p (edge); | |
| 757 extern bool optimize_loop_for_size_p (struct loop *); | |
| 758 extern bool optimize_loop_for_speed_p (struct loop *); | |
| 759 extern bool optimize_loop_nest_for_size_p (struct loop *); | |
| 760 extern bool optimize_loop_nest_for_speed_p (struct loop *); | |
| 761 extern bool gimple_predicted_by_p (const_basic_block, enum br_predictor); | |
| 762 extern bool rtl_predicted_by_p (const_basic_block, enum br_predictor); | |
| 763 extern void gimple_predict_edge (edge, enum br_predictor, int); | |
| 764 extern void rtl_predict_edge (edge, enum br_predictor, int); | |
| 765 extern void predict_edge_def (edge, enum br_predictor, enum prediction); | |
| 766 extern void guess_outgoing_edge_probabilities (basic_block); | |
| 767 extern void remove_predictions_associated_with_edge (edge); | |
| 768 extern bool edge_probability_reliable_p (const_edge); | |
| 769 extern bool br_prob_note_reliable_p (const_rtx); | |
| 770 extern bool predictable_edge_p (edge); | |
| 771 | |
| 772 /* In cfg.c */ | |
| 773 extern void init_flow (struct function *); | |
| 774 extern void debug_bb (basic_block); | |
| 775 extern basic_block debug_bb_n (int); | |
| 776 extern void expunge_block (basic_block); | |
| 777 extern void link_block (basic_block, basic_block); | |
| 778 extern void unlink_block (basic_block); | |
| 779 extern void compact_blocks (void); | |
| 780 extern basic_block alloc_block (void); | |
| 781 extern void alloc_aux_for_blocks (int); | |
| 782 extern void clear_aux_for_blocks (void); | |
| 783 extern void free_aux_for_blocks (void); | |
| 784 extern void alloc_aux_for_edges (int); | |
| 785 extern void clear_aux_for_edges (void); | |
| 786 extern void free_aux_for_edges (void); | |
| 787 | |
| 788 /* In cfganal.c */ | |
| 789 extern void find_unreachable_blocks (void); | |
| 790 extern bool forwarder_block_p (const_basic_block); | |
| 791 extern bool can_fallthru (basic_block, basic_block); | |
| 792 extern bool could_fall_through (basic_block, basic_block); | |
| 793 extern void flow_nodes_print (const char *, const_sbitmap, FILE *); | |
| 794 extern void flow_edge_list_print (const char *, const edge *, int, FILE *); | |
| 795 | |
| 796 /* In cfgrtl.c */ | |
| 797 extern basic_block force_nonfallthru (edge); | |
| 798 extern rtx block_label (basic_block); | |
| 799 extern bool purge_all_dead_edges (void); | |
| 800 extern bool purge_dead_edges (basic_block); | |
| 801 | |
| 802 /* In cfgbuild.c. */ | |
| 803 extern void find_many_sub_basic_blocks (sbitmap); | |
| 804 extern void rtl_make_eh_edge (sbitmap, basic_block, rtx); | |
| 805 | |
| 806 /* In cfgcleanup.c. */ | |
| 807 extern bool cleanup_cfg (int); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
808 extern int flow_find_cross_jump (basic_block, basic_block, rtx *, rtx *); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
809 extern int flow_find_head_matching_sequence (basic_block, basic_block, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
810 rtx *, rtx *, int); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
811 |
| 0 | 812 extern bool delete_unreachable_blocks (void); |
| 813 | |
| 814 extern bool mark_dfs_back_edges (void); | |
| 815 extern void set_edge_can_fallthru_flag (void); | |
| 816 extern void update_br_prob_note (basic_block); | |
| 817 extern void fixup_abnormal_edges (void); | |
| 818 extern bool inside_basic_block_p (const_rtx); | |
| 819 extern bool control_flow_insn_p (const_rtx); | |
| 820 extern rtx get_last_bb_insn (basic_block); | |
| 821 | |
| 822 /* In bb-reorder.c */ | |
| 823 extern void reorder_basic_blocks (void); | |
| 824 | |
| 825 /* In dominance.c */ | |
| 826 | |
| 827 enum cdi_direction | |
| 828 { | |
| 829 CDI_DOMINATORS = 1, | |
| 830 CDI_POST_DOMINATORS = 2 | |
| 831 }; | |
| 832 | |
| 833 extern enum dom_state dom_info_state (enum cdi_direction); | |
| 834 extern void set_dom_info_availability (enum cdi_direction, enum dom_state); | |
| 835 extern bool dom_info_available_p (enum cdi_direction); | |
| 836 extern void calculate_dominance_info (enum cdi_direction); | |
| 837 extern void free_dominance_info (enum cdi_direction); | |
| 838 extern basic_block nearest_common_dominator (enum cdi_direction, | |
| 839 basic_block, basic_block); | |
| 840 extern basic_block nearest_common_dominator_for_set (enum cdi_direction, | |
| 841 bitmap); | |
| 842 extern void set_immediate_dominator (enum cdi_direction, basic_block, | |
| 843 basic_block); | |
| 844 extern basic_block get_immediate_dominator (enum cdi_direction, basic_block); | |
| 845 extern bool dominated_by_p (enum cdi_direction, const_basic_block, const_basic_block); | |
| 846 extern VEC (basic_block, heap) *get_dominated_by (enum cdi_direction, basic_block); | |
| 847 extern VEC (basic_block, heap) *get_dominated_by_region (enum cdi_direction, | |
| 848 basic_block *, | |
| 849 unsigned); | |
|
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 extern VEC (basic_block, heap) *get_dominated_to_depth (enum cdi_direction, |
|
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 basic_block, int); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
852 extern VEC (basic_block, heap) *get_all_dominated_blocks (enum cdi_direction, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
853 basic_block); |
| 0 | 854 extern void add_to_dominance_info (enum cdi_direction, basic_block); |
| 855 extern void delete_from_dominance_info (enum cdi_direction, basic_block); | |
| 856 basic_block recompute_dominator (enum cdi_direction, basic_block); | |
| 857 extern void redirect_immediate_dominators (enum cdi_direction, basic_block, | |
| 858 basic_block); | |
| 859 extern void iterate_fix_dominators (enum cdi_direction, | |
| 860 VEC (basic_block, heap) *, bool); | |
| 861 extern void verify_dominators (enum cdi_direction); | |
| 862 extern basic_block first_dom_son (enum cdi_direction, basic_block); | |
| 863 extern basic_block next_dom_son (enum cdi_direction, basic_block); | |
| 864 unsigned bb_dom_dfs_in (enum cdi_direction, basic_block); | |
| 865 unsigned bb_dom_dfs_out (enum cdi_direction, basic_block); | |
| 866 | |
| 867 extern edge try_redirect_by_replacing_jump (edge, basic_block, bool); | |
| 868 extern void break_superblocks (void); | |
| 869 extern void relink_block_chain (bool); | |
| 870 extern void check_bb_profile (basic_block, FILE *); | |
| 871 extern void update_bb_profile_for_threading (basic_block, int, gcov_type, edge); | |
| 872 extern void init_rtl_bb_info (basic_block); | |
| 873 | |
| 874 extern void initialize_original_copy_tables (void); | |
| 875 extern void free_original_copy_tables (void); | |
| 876 extern void set_bb_original (basic_block, basic_block); | |
| 877 extern basic_block get_bb_original (basic_block); | |
| 878 extern void set_bb_copy (basic_block, basic_block); | |
| 879 extern basic_block get_bb_copy (basic_block); | |
| 880 void set_loop_copy (struct loop *, struct loop *); | |
| 881 struct loop *get_loop_copy (struct loop *); | |
| 882 | |
| 883 #include "cfghooks.h" | |
| 884 | |
| 885 /* Return true when one of the predecessor edges of BB is marked with EDGE_EH. */ | |
| 886 static inline bool | |
| 887 bb_has_eh_pred (basic_block bb) | |
| 888 { | |
| 889 edge e; | |
| 890 edge_iterator ei; | |
| 891 | |
| 892 FOR_EACH_EDGE (e, ei, bb->preds) | |
| 893 { | |
| 894 if (e->flags & EDGE_EH) | |
| 895 return true; | |
| 896 } | |
| 897 return false; | |
| 898 } | |
| 899 | |
| 900 /* Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL. */ | |
| 901 static inline bool | |
| 902 bb_has_abnormal_pred (basic_block bb) | |
| 903 { | |
| 904 edge e; | |
| 905 edge_iterator ei; | |
| 906 | |
| 907 FOR_EACH_EDGE (e, ei, bb->preds) | |
| 908 { | |
| 909 if (e->flags & EDGE_ABNORMAL) | |
| 910 return true; | |
| 911 } | |
| 912 return false; | |
| 913 } | |
| 914 | |
|
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
|
915 /* Return the fallthru edge in EDGES if it exists, NULL otherwise. */ |
|
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
|
916 static inline edge |
|
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
|
917 find_fallthru_edge (VEC(edge,gc) *edges) |
|
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
|
918 { |
|
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
|
919 edge e; |
|
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
|
920 edge_iterator ei; |
|
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
|
921 |
|
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
|
922 FOR_EACH_EDGE (e, ei, edges) |
|
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
|
923 if (e->flags & EDGE_FALLTHRU) |
|
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
|
924 break; |
|
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
|
925 |
|
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
|
926 return e; |
|
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
|
927 } |
|
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
|
928 |
| 0 | 929 /* In cfgloopmanip.c. */ |
| 930 extern edge mfb_kj_edge; | |
| 931 extern bool mfb_keep_just (edge); | |
| 932 | |
| 933 /* In cfgexpand.c. */ | |
| 934 extern void rtl_profile_for_bb (basic_block); | |
| 935 extern void rtl_profile_for_edge (edge); | |
| 936 extern void default_rtl_profile (void); | |
| 937 | |
| 938 #endif /* GCC_BASIC_BLOCK_H */ |