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