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