]>
Commit | Line | Data |
---|---|---|
402209ff | 1 | /* Control flow graph building code for GNU compiler. |
5624e564 | 2 | Copyright (C) 1987-2015 Free Software Foundation, Inc. |
402209ff JH |
3 | |
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify it under | |
7 | the terms of the GNU General Public License as published by the Free | |
9dcd6f09 | 8 | Software Foundation; either version 3, or (at your option) any later |
402209ff JH |
9 | version. |
10 | ||
11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 | for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ | |
402209ff | 19 | |
402209ff JH |
20 | \f |
21 | #include "config.h" | |
22 | #include "system.h" | |
4977bab6 | 23 | #include "coretypes.h" |
c7131fb2 | 24 | #include "backend.h" |
9fdcd34e | 25 | #include "cfghooks.h" |
40e23961 | 26 | #include "alias.h" |
402209ff JH |
27 | #include "tree.h" |
28 | #include "rtl.h" | |
60393bbc AM |
29 | #include "cfgrtl.h" |
30 | #include "cfganal.h" | |
31 | #include "cfgbuild.h" | |
60393bbc AM |
32 | #include "regs.h" |
33 | #include "flags.h" | |
402209ff | 34 | #include "except.h" |
36566b39 PK |
35 | #include "insn-config.h" |
36 | #include "expmed.h" | |
37 | #include "dojump.h" | |
38 | #include "explow.h" | |
39 | #include "calls.h" | |
40 | #include "emit-rtl.h" | |
41 | #include "varasm.h" | |
42 | #include "stmt.h" | |
1d65f45c | 43 | #include "expr.h" |
718f9c0f | 44 | #include "diagnostic-core.h" |
402209ff | 45 | #include "timevar.h" |
4891442b | 46 | |
2df6cea5 | 47 | static void make_edges (basic_block, basic_block, int); |
a6ee1a15 | 48 | static void make_label_edge (sbitmap, basic_block, rtx, int); |
d329e058 AJ |
49 | static void find_bb_boundaries (basic_block); |
50 | static void compute_outgoing_frequencies (basic_block); | |
4891442b | 51 | \f |
9cd56be1 JH |
52 | /* Return true if insn is something that should be contained inside basic |
53 | block. */ | |
54 | ||
8f62128d | 55 | bool |
eefc72ed | 56 | inside_basic_block_p (const rtx_insn *insn) |
9cd56be1 JH |
57 | { |
58 | switch (GET_CODE (insn)) | |
59 | { | |
60 | case CODE_LABEL: | |
61 | /* Avoid creating of basic block for jumptables. */ | |
4891442b | 62 | return (NEXT_INSN (insn) == 0 |
6388c738 | 63 | || ! JUMP_TABLE_DATA_P (NEXT_INSN (insn))); |
9cd56be1 JH |
64 | |
65 | case JUMP_INSN: | |
9cd56be1 JH |
66 | case CALL_INSN: |
67 | case INSN: | |
b5b8b0ac | 68 | case DEBUG_INSN: |
9cd56be1 JH |
69 | return true; |
70 | ||
39718607 | 71 | case JUMP_TABLE_DATA: |
9cd56be1 JH |
72 | case BARRIER: |
73 | case NOTE: | |
74 | return false; | |
75 | ||
76 | default: | |
341c100f | 77 | gcc_unreachable (); |
9cd56be1 JH |
78 | } |
79 | } | |
80 | ||
4891442b RK |
81 | /* Return true if INSN may cause control flow transfer, so it should be last in |
82 | the basic block. */ | |
9cd56be1 | 83 | |
4a69cf79 | 84 | bool |
43f9bab0 | 85 | control_flow_insn_p (const rtx_insn *insn) |
9cd56be1 | 86 | { |
9cd56be1 JH |
87 | switch (GET_CODE (insn)) |
88 | { | |
f87c27b4 KH |
89 | case NOTE: |
90 | case CODE_LABEL: | |
b5b8b0ac | 91 | case DEBUG_INSN: |
f87c27b4 KH |
92 | return false; |
93 | ||
94 | case JUMP_INSN: | |
39718607 | 95 | return true; |
f87c27b4 KH |
96 | |
97 | case CALL_INSN: | |
baf8706c JH |
98 | /* Noreturn and sibling call instructions terminate the basic blocks |
99 | (but only if they happen unconditionally). */ | |
100 | if ((SIBLING_CALL_P (insn) | |
101 | || find_reg_note (insn, REG_NORETURN, 0)) | |
102 | && GET_CODE (PATTERN (insn)) != COND_EXEC) | |
103 | return true; | |
1d65f45c | 104 | |
f87c27b4 | 105 | /* Call insn may return to the nonlocal goto handler. */ |
1d65f45c RH |
106 | if (can_nonlocal_goto (insn)) |
107 | return true; | |
108 | break; | |
f87c27b4 KH |
109 | |
110 | case INSN: | |
d47a8b83 EB |
111 | /* Treat trap instructions like noreturn calls (same provision). */ |
112 | if (GET_CODE (PATTERN (insn)) == TRAP_IF | |
113 | && XEXP (PATTERN (insn), 0) == const1_rtx) | |
114 | return true; | |
8f4f502f | 115 | if (!cfun->can_throw_non_call_exceptions) |
1d65f45c RH |
116 | return false; |
117 | break; | |
f87c27b4 | 118 | |
39718607 | 119 | case JUMP_TABLE_DATA: |
f87c27b4 | 120 | case BARRIER: |
39718607 | 121 | /* It is nonsense to reach this when looking for the |
c22cacf3 MS |
122 | end of basic block, but before dead code is eliminated |
123 | this may happen. */ | |
f87c27b4 KH |
124 | return false; |
125 | ||
126 | default: | |
341c100f | 127 | gcc_unreachable (); |
9cd56be1 | 128 | } |
1d65f45c RH |
129 | |
130 | return can_throw_internal (insn); | |
9cd56be1 | 131 | } |
402209ff | 132 | |
402209ff JH |
133 | \f |
134 | /* Create an edge between two basic blocks. FLAGS are auxiliary information | |
135 | about the edge that is accumulated between calls. */ | |
136 | ||
137 | /* Create an edge from a basic block to a label. */ | |
138 | ||
139 | static void | |
a6ee1a15 | 140 | make_label_edge (sbitmap edge_cache, basic_block src, rtx label, int flags) |
402209ff | 141 | { |
341c100f | 142 | gcc_assert (LABEL_P (label)); |
402209ff JH |
143 | |
144 | /* If the label was never emitted, this insn is junk, but avoid a | |
145 | crash trying to refer to BLOCK_FOR_INSN (label). This can happen | |
146 | as a result of a syntax error and a diagnostic has already been | |
147 | printed. */ | |
148 | ||
149 | if (INSN_UID (label) == 0) | |
150 | return; | |
151 | ||
7ded4467 | 152 | cached_make_edge (edge_cache, src, BLOCK_FOR_INSN (label), flags); |
402209ff JH |
153 | } |
154 | ||
155 | /* Create the edges generated by INSN in REGION. */ | |
156 | ||
12c3874e | 157 | void |
a6ee1a15 | 158 | rtl_make_eh_edge (sbitmap edge_cache, basic_block src, rtx insn) |
402209ff | 159 | { |
1d65f45c | 160 | eh_landing_pad lp = get_eh_landing_pad_from_rtx (insn); |
402209ff | 161 | |
1d65f45c RH |
162 | if (lp) |
163 | { | |
e67d1102 | 164 | rtx_insn *label = lp->landing_pad; |
402209ff | 165 | |
1d65f45c RH |
166 | /* During initial rtl generation, use the post_landing_pad. */ |
167 | if (label == NULL) | |
168 | { | |
169 | gcc_assert (lp->post_landing_pad); | |
170 | label = label_rtx (lp->post_landing_pad); | |
171 | } | |
402209ff | 172 | |
1d65f45c RH |
173 | make_label_edge (edge_cache, src, label, |
174 | EDGE_ABNORMAL | EDGE_EH | |
175 | | (CALL_P (insn) ? EDGE_ABNORMAL_CALL : 0)); | |
176 | } | |
402209ff | 177 | } |
4891442b | 178 | |
55b18c19 KH |
179 | /* States of basic block as seen by find_many_sub_basic_blocks. */ |
180 | enum state { | |
181 | /* Basic blocks created via split_block belong to this state. | |
182 | make_edges will examine these basic blocks to see if we need to | |
183 | create edges going out of them. */ | |
184 | BLOCK_NEW = 0, | |
185 | ||
186 | /* Basic blocks that do not need examining belong to this state. | |
187 | These blocks will be left intact. In particular, make_edges will | |
188 | not create edges going out of these basic blocks. */ | |
189 | BLOCK_ORIGINAL, | |
190 | ||
191 | /* Basic blocks that may need splitting (due to a label appearing in | |
192 | the middle, etc) belong to this state. After splitting them, | |
0fa2e4df | 193 | make_edges will create edges going out of them as needed. */ |
55b18c19 KH |
194 | BLOCK_TO_SPLIT |
195 | }; | |
5e91f7a3 KH |
196 | |
197 | #define STATE(BB) (enum state) ((size_t) (BB)->aux) | |
198 | #define SET_STATE(BB, STATE) ((BB)->aux = (void *) (size_t) (STATE)) | |
199 | ||
200 | /* Used internally by purge_dead_tablejump_edges, ORed into state. */ | |
201 | #define BLOCK_USED_BY_TABLEJUMP 32 | |
202 | #define FULL_STATE(BB) ((size_t) (BB)->aux) | |
203 | ||
55b18c19 KH |
204 | /* Identify the edges going out of basic blocks between MIN and MAX, |
205 | inclusive, that have their states set to BLOCK_NEW or | |
206 | BLOCK_TO_SPLIT. | |
402209ff | 207 | |
55b18c19 KH |
208 | UPDATE_P should be nonzero if we are updating CFG and zero if we |
209 | are building CFG from scratch. */ | |
402209ff JH |
210 | |
211 | static void | |
2df6cea5 | 212 | make_edges (basic_block min, basic_block max, int update_p) |
402209ff | 213 | { |
e0082a72 | 214 | basic_block bb; |
a6ee1a15 | 215 | sbitmap edge_cache = NULL; |
402209ff | 216 | |
402209ff JH |
217 | /* Heavy use of computed goto in machine-generated code can lead to |
218 | nearly fully-connected CFGs. In that case we spend a significant | |
219 | amount of time searching the edge lists for duplicates. */ | |
cb91fab0 | 220 | if (forced_labels || cfun->cfg->max_jumptable_ents > 100) |
8b1c6fd7 | 221 | edge_cache = sbitmap_alloc (last_basic_block_for_fn (cfun)); |
402209ff | 222 | |
e0082a72 ZD |
223 | /* By nature of the way these get numbered, ENTRY_BLOCK_PTR->next_bb block |
224 | is always the entry. */ | |
fefa31b5 DM |
225 | if (min == ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb) |
226 | make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), min, EDGE_FALLTHRU); | |
402209ff | 227 | |
e0082a72 | 228 | FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb) |
402209ff | 229 | { |
3bbd5815 | 230 | rtx_insn *insn; |
402209ff | 231 | enum rtx_code code; |
623a66fa | 232 | edge e; |
a6ee1a15 | 233 | edge_iterator ei; |
402209ff | 234 | |
5e91f7a3 KH |
235 | if (STATE (bb) == BLOCK_ORIGINAL) |
236 | continue; | |
237 | ||
a6ee1a15 KH |
238 | /* If we have an edge cache, cache edges going out of BB. */ |
239 | if (edge_cache) | |
240 | { | |
f61e445a | 241 | bitmap_clear (edge_cache); |
a6ee1a15 KH |
242 | if (update_p) |
243 | { | |
244 | FOR_EACH_EDGE (e, ei, bb->succs) | |
fefa31b5 | 245 | if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)) |
d7c028c0 | 246 | bitmap_set_bit (edge_cache, e->dest->index); |
a6ee1a15 KH |
247 | } |
248 | } | |
249 | ||
4b4bf941 | 250 | if (LABEL_P (BB_HEAD (bb)) |
a813c111 | 251 | && LABEL_ALT_ENTRY_P (BB_HEAD (bb))) |
fefa31b5 | 252 | cached_make_edge (NULL, ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, 0); |
402209ff JH |
253 | |
254 | /* Examine the last instruction of the block, and discover the | |
255 | ways we can leave the block. */ | |
256 | ||
a813c111 | 257 | insn = BB_END (bb); |
402209ff JH |
258 | code = GET_CODE (insn); |
259 | ||
260 | /* A branch. */ | |
261 | if (code == JUMP_INSN) | |
262 | { | |
263 | rtx tmp; | |
8942ee0f | 264 | rtx_jump_table_data *table; |
402209ff | 265 | |
402209ff JH |
266 | /* Recognize a non-local goto as a branch outside the |
267 | current function. */ | |
1d65f45c | 268 | if (find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX)) |
402209ff JH |
269 | ; |
270 | ||
e1233a7d | 271 | /* Recognize a tablejump and do the right thing. */ |
8942ee0f | 272 | else if (tablejump_p (insn, NULL, &table)) |
402209ff | 273 | { |
95c43227 | 274 | rtvec vec = table->get_labels (); |
402209ff JH |
275 | int j; |
276 | ||
402209ff JH |
277 | for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j) |
278 | make_label_edge (edge_cache, bb, | |
279 | XEXP (RTVEC_ELT (vec, j), 0), 0); | |
280 | ||
281 | /* Some targets (eg, ARM) emit a conditional jump that also | |
282 | contains the out-of-range target. Scan for these and | |
283 | add an edge if necessary. */ | |
284 | if ((tmp = single_set (insn)) != NULL | |
285 | && SET_DEST (tmp) == pc_rtx | |
286 | && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE | |
287 | && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF) | |
288 | make_label_edge (edge_cache, bb, | |
a827d9b1 | 289 | LABEL_REF_LABEL (XEXP (SET_SRC (tmp), 2)), 0); |
402209ff JH |
290 | } |
291 | ||
292 | /* If this is a computed jump, then mark it as reaching | |
2df6cea5 | 293 | everything on the forced_labels list. */ |
402209ff JH |
294 | else if (computed_jump_p (insn)) |
295 | { | |
e8c038ca DM |
296 | for (rtx_insn_list *x = forced_labels; x; x = x->next ()) |
297 | make_label_edge (edge_cache, bb, x->insn (), EDGE_ABNORMAL); | |
402209ff JH |
298 | } |
299 | ||
300 | /* Returns create an exit out. */ | |
301 | else if (returnjump_p (insn)) | |
fefa31b5 | 302 | cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0); |
402209ff | 303 | |
1c384bf1 RH |
304 | /* Recognize asm goto and do the right thing. */ |
305 | else if ((tmp = extract_asm_operands (PATTERN (insn))) != NULL) | |
306 | { | |
307 | int i, n = ASM_OPERANDS_LABEL_LENGTH (tmp); | |
308 | for (i = 0; i < n; ++i) | |
309 | make_label_edge (edge_cache, bb, | |
310 | XEXP (ASM_OPERANDS_LABEL (tmp, i), 0), 0); | |
311 | } | |
312 | ||
402209ff JH |
313 | /* Otherwise, we have a plain conditional or unconditional jump. */ |
314 | else | |
315 | { | |
341c100f | 316 | gcc_assert (JUMP_LABEL (insn)); |
402209ff JH |
317 | make_label_edge (edge_cache, bb, JUMP_LABEL (insn), 0); |
318 | } | |
319 | } | |
320 | ||
4891442b RK |
321 | /* If this is a sibling call insn, then this is in effect a combined call |
322 | and return, and so we need an edge to the exit block. No need to | |
323 | worry about EH edges, since we wouldn't have created the sibling call | |
324 | in the first place. */ | |
402209ff | 325 | if (code == CALL_INSN && SIBLING_CALL_P (insn)) |
fefa31b5 | 326 | cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR_FOR_FN (cfun), |
792bb204 | 327 | EDGE_SIBCALL | EDGE_ABNORMAL); |
402209ff JH |
328 | |
329 | /* If this is a CALL_INSN, then mark it as reaching the active EH | |
330 | handler for this CALL_INSN. If we're handling non-call | |
331 | exceptions then any insn can reach any of the active handlers. | |
402209ff | 332 | Also mark the CALL_INSN as reaching any nonlocal goto handler. */ |
8f4f502f | 333 | else if (code == CALL_INSN || cfun->can_throw_non_call_exceptions) |
402209ff JH |
334 | { |
335 | /* Add any appropriate EH edges. */ | |
6de9cd9a | 336 | rtl_make_eh_edge (edge_cache, bb, insn); |
402209ff | 337 | |
0a35513e | 338 | if (code == CALL_INSN) |
402209ff | 339 | { |
1d65f45c | 340 | if (can_nonlocal_goto (insn)) |
0a35513e AH |
341 | { |
342 | /* ??? This could be made smarter: in some cases it's | |
343 | possible to tell that certain calls will not do a | |
344 | nonlocal goto. For example, if the nested functions | |
345 | that do the nonlocal gotos do not have their addresses | |
346 | taken, then only calls to those functions or to other | |
347 | nested functions that use them could possibly do | |
348 | nonlocal gotos. */ | |
b5241a5a | 349 | for (rtx_insn_list *x = nonlocal_goto_handler_labels; |
2382940b DM |
350 | x; |
351 | x = x->next ()) | |
b5241a5a | 352 | make_label_edge (edge_cache, bb, x->insn (), |
0a35513e AH |
353 | EDGE_ABNORMAL | EDGE_ABNORMAL_CALL); |
354 | } | |
355 | ||
356 | if (flag_tm) | |
357 | { | |
358 | rtx note; | |
359 | for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) | |
360 | if (REG_NOTE_KIND (note) == REG_TM) | |
361 | make_label_edge (edge_cache, bb, XEXP (note, 0), | |
362 | EDGE_ABNORMAL | EDGE_ABNORMAL_CALL); | |
363 | } | |
402209ff JH |
364 | } |
365 | } | |
366 | ||
367 | /* Find out if we can drop through to the next block. */ | |
26f74aa3 | 368 | insn = NEXT_INSN (insn); |
fefa31b5 | 369 | e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)); |
9ff3d2de JL |
370 | if (e && e->flags & EDGE_FALLTHRU) |
371 | insn = NULL; | |
372 | ||
26f74aa3 | 373 | while (insn |
4b4bf941 | 374 | && NOTE_P (insn) |
a38e7aa5 | 375 | && NOTE_KIND (insn) != NOTE_INSN_BASIC_BLOCK) |
26f74aa3 JH |
376 | insn = NEXT_INSN (insn); |
377 | ||
6be85b25 | 378 | if (!insn) |
fefa31b5 DM |
379 | cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR_FOR_FN (cfun), |
380 | EDGE_FALLTHRU); | |
381 | else if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)) | |
402209ff | 382 | { |
6be85b25 | 383 | if (insn == BB_HEAD (bb->next_bb)) |
f6366fc7 | 384 | cached_make_edge (edge_cache, bb, bb->next_bb, EDGE_FALLTHRU); |
402209ff JH |
385 | } |
386 | } | |
387 | ||
388 | if (edge_cache) | |
f61e445a | 389 | sbitmap_free (edge_cache); |
402209ff JH |
390 | } |
391 | \f | |
0210ae14 JJ |
392 | static void |
393 | mark_tablejump_edge (rtx label) | |
394 | { | |
395 | basic_block bb; | |
396 | ||
397 | gcc_assert (LABEL_P (label)); | |
398 | /* See comment in make_label_edge. */ | |
399 | if (INSN_UID (label) == 0) | |
400 | return; | |
401 | bb = BLOCK_FOR_INSN (label); | |
402 | SET_STATE (bb, FULL_STATE (bb) | BLOCK_USED_BY_TABLEJUMP); | |
403 | } | |
404 | ||
405 | static void | |
95c43227 | 406 | purge_dead_tablejump_edges (basic_block bb, rtx_jump_table_data *table) |
0210ae14 | 407 | { |
3bbd5815 DM |
408 | rtx_insn *insn = BB_END (bb); |
409 | rtx tmp; | |
0210ae14 JJ |
410 | rtvec vec; |
411 | int j; | |
412 | edge_iterator ei; | |
413 | edge e; | |
414 | ||
95c43227 | 415 | vec = table->get_labels (); |
0210ae14 JJ |
416 | |
417 | for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j) | |
418 | mark_tablejump_edge (XEXP (RTVEC_ELT (vec, j), 0)); | |
419 | ||
420 | /* Some targets (eg, ARM) emit a conditional jump that also | |
421 | contains the out-of-range target. Scan for these and | |
422 | add an edge if necessary. */ | |
423 | if ((tmp = single_set (insn)) != NULL | |
424 | && SET_DEST (tmp) == pc_rtx | |
425 | && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE | |
426 | && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF) | |
a827d9b1 | 427 | mark_tablejump_edge (LABEL_REF_LABEL (XEXP (SET_SRC (tmp), 2))); |
0210ae14 JJ |
428 | |
429 | for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); ) | |
430 | { | |
431 | if (FULL_STATE (e->dest) & BLOCK_USED_BY_TABLEJUMP) | |
c22cacf3 MS |
432 | SET_STATE (e->dest, FULL_STATE (e->dest) |
433 | & ~(size_t) BLOCK_USED_BY_TABLEJUMP); | |
0210ae14 | 434 | else if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH))) |
c22cacf3 MS |
435 | { |
436 | remove_edge (e); | |
437 | continue; | |
438 | } | |
0210ae14 JJ |
439 | ei_next (&ei); |
440 | } | |
441 | } | |
442 | ||
b932f770 JH |
443 | /* Scan basic block BB for possible BB boundaries inside the block |
444 | and create new basic blocks in the progress. */ | |
445 | ||
446 | static void | |
d329e058 | 447 | find_bb_boundaries (basic_block bb) |
402209ff | 448 | { |
0210ae14 | 449 | basic_block orig_bb = bb; |
3bbd5815 DM |
450 | rtx_insn *insn = BB_HEAD (bb); |
451 | rtx_insn *end = BB_END (bb), *x; | |
8942ee0f | 452 | rtx_jump_table_data *table; |
3bbd5815 | 453 | rtx_insn *flow_transfer_insn = NULL; |
f068df3f | 454 | edge fallthru = NULL; |
402209ff | 455 | |
a813c111 | 456 | if (insn == BB_END (bb)) |
402209ff JH |
457 | return; |
458 | ||
4b4bf941 | 459 | if (LABEL_P (insn)) |
402209ff JH |
460 | insn = NEXT_INSN (insn); |
461 | ||
462 | /* Scan insn chain and try to find new basic block boundaries. */ | |
463 | while (1) | |
464 | { | |
465 | enum rtx_code code = GET_CODE (insn); | |
f068df3f | 466 | |
1d65f45c RH |
467 | /* In case we've previously seen an insn that effects a control |
468 | flow transfer, split the block. */ | |
469 | if ((flow_transfer_insn || code == CODE_LABEL) | |
470 | && inside_basic_block_p (insn)) | |
402209ff | 471 | { |
f068df3f RH |
472 | fallthru = split_block (bb, PREV_INSN (insn)); |
473 | if (flow_transfer_insn) | |
a7b87f73 | 474 | { |
1130d5e3 | 475 | BB_END (bb) = flow_transfer_insn; |
a7b87f73 ZD |
476 | |
477 | /* Clean up the bb field for the insns between the blocks. */ | |
478 | for (x = NEXT_INSN (flow_transfer_insn); | |
479 | x != BB_HEAD (fallthru->dest); | |
480 | x = NEXT_INSN (x)) | |
481 | if (!BARRIER_P (x)) | |
482 | set_block_for_insn (x, NULL); | |
483 | } | |
4891442b | 484 | |
f068df3f RH |
485 | bb = fallthru->dest; |
486 | remove_edge (fallthru); | |
3bbd5815 | 487 | flow_transfer_insn = NULL; |
1d65f45c | 488 | if (code == CODE_LABEL && LABEL_ALT_ENTRY_P (insn)) |
fefa31b5 | 489 | make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, 0); |
402209ff | 490 | } |
79876307 RH |
491 | else if (code == BARRIER) |
492 | { | |
493 | /* __builtin_unreachable () may cause a barrier to be emitted in | |
494 | the middle of a BB. We need to split it in the same manner as | |
495 | if the barrier were preceded by a control_flow_insn_p insn. */ | |
496 | if (!flow_transfer_insn) | |
497 | flow_transfer_insn = prev_nonnote_insn_bb (insn); | |
498 | } | |
79876307 | 499 | |
27b4689f RH |
500 | if (control_flow_insn_p (insn)) |
501 | flow_transfer_insn = insn; | |
402209ff JH |
502 | if (insn == end) |
503 | break; | |
504 | insn = NEXT_INSN (insn); | |
505 | } | |
506 | ||
507 | /* In case expander replaced normal insn by sequence terminating by | |
508 | return and barrier, or possibly other sequence not behaving like | |
509 | ordinary jump, we need to take care and move basic block boundary. */ | |
f068df3f | 510 | if (flow_transfer_insn) |
a7b87f73 | 511 | { |
1130d5e3 | 512 | BB_END (bb) = flow_transfer_insn; |
a7b87f73 ZD |
513 | |
514 | /* Clean up the bb field for the insns that do not belong to BB. */ | |
515 | x = flow_transfer_insn; | |
516 | while (x != end) | |
517 | { | |
518 | x = NEXT_INSN (x); | |
519 | if (!BARRIER_P (x)) | |
520 | set_block_for_insn (x, NULL); | |
521 | } | |
522 | } | |
402209ff JH |
523 | |
524 | /* We've possibly replaced the conditional jump by conditional jump | |
525 | followed by cleanup at fallthru edge, so the outgoing edges may | |
526 | be dead. */ | |
527 | purge_dead_edges (bb); | |
0210ae14 JJ |
528 | |
529 | /* purge_dead_edges doesn't handle tablejump's, but if we have split the | |
530 | basic block, we might need to kill some edges. */ | |
531 | if (bb != orig_bb && tablejump_p (BB_END (bb), NULL, &table)) | |
532 | purge_dead_tablejump_edges (bb, table); | |
b932f770 JH |
533 | } |
534 | ||
535 | /* Assume that frequency of basic block B is known. Compute frequencies | |
536 | and probabilities of outgoing edges. */ | |
537 | ||
538 | static void | |
d329e058 | 539 | compute_outgoing_frequencies (basic_block b) |
b932f770 JH |
540 | { |
541 | edge e, f; | |
628f6a4e | 542 | edge_iterator ei; |
4891442b | 543 | |
628f6a4e | 544 | if (EDGE_COUNT (b->succs) == 2) |
b932f770 | 545 | { |
a813c111 | 546 | rtx note = find_reg_note (BB_END (b), REG_BR_PROB, NULL); |
b932f770 JH |
547 | int probability; |
548 | ||
87022a6b JH |
549 | if (note) |
550 | { | |
e5af9ddd | 551 | probability = XINT (note, 0); |
87022a6b JH |
552 | e = BRANCH_EDGE (b); |
553 | e->probability = probability; | |
8ddb5a29 | 554 | e->count = apply_probability (b->count, probability); |
87022a6b JH |
555 | f = FALLTHRU_EDGE (b); |
556 | f->probability = REG_BR_PROB_BASE - probability; | |
557 | f->count = b->count - e->count; | |
558 | return; | |
559 | } | |
a4da41e1 ER |
560 | else |
561 | { | |
562 | guess_outgoing_edge_probabilities (b); | |
563 | } | |
b932f770 | 564 | } |
a4da41e1 | 565 | else if (single_succ_p (b)) |
b932f770 | 566 | { |
c5cbcccf | 567 | e = single_succ_edge (b); |
b932f770 JH |
568 | e->probability = REG_BR_PROB_BASE; |
569 | e->count = b->count; | |
87022a6b | 570 | return; |
b932f770 | 571 | } |
a4da41e1 ER |
572 | else |
573 | { | |
574 | /* We rely on BBs with more than two successors to have sane probabilities | |
575 | and do not guess them here. For BBs terminated by switch statements | |
576 | expanded to jump-table jump, we have done the right thing during | |
577 | expansion. For EH edges, we still guess the probabilities here. */ | |
578 | bool complex_edge = false; | |
579 | FOR_EACH_EDGE (e, ei, b->succs) | |
580 | if (e->flags & EDGE_COMPLEX) | |
581 | { | |
582 | complex_edge = true; | |
583 | break; | |
584 | } | |
585 | if (complex_edge) | |
586 | guess_outgoing_edge_probabilities (b); | |
587 | } | |
588 | ||
87022a6b | 589 | if (b->count) |
628f6a4e | 590 | FOR_EACH_EDGE (e, ei, b->succs) |
8ddb5a29 | 591 | e->count = apply_probability (b->count, e->probability); |
b932f770 JH |
592 | } |
593 | ||
55b18c19 KH |
594 | /* Assume that some pass has inserted labels or control flow |
595 | instructions within a basic block. Split basic blocks as needed | |
596 | and create edges. */ | |
b932f770 JH |
597 | |
598 | void | |
d329e058 | 599 | find_many_sub_basic_blocks (sbitmap blocks) |
b932f770 | 600 | { |
e0082a72 | 601 | basic_block bb, min, max; |
b932f770 | 602 | |
11cd3bed | 603 | FOR_EACH_BB_FN (bb, cfun) |
e0082a72 | 604 | SET_STATE (bb, |
d7c028c0 | 605 | bitmap_bit_p (blocks, bb->index) ? BLOCK_TO_SPLIT : BLOCK_ORIGINAL); |
b932f770 | 606 | |
11cd3bed | 607 | FOR_EACH_BB_FN (bb, cfun) |
e0082a72 ZD |
608 | if (STATE (bb) == BLOCK_TO_SPLIT) |
609 | find_bb_boundaries (bb); | |
b932f770 | 610 | |
11cd3bed | 611 | FOR_EACH_BB_FN (bb, cfun) |
e0082a72 | 612 | if (STATE (bb) != BLOCK_ORIGINAL) |
b932f770 | 613 | break; |
4891442b | 614 | |
e0082a72 | 615 | min = max = bb; |
fefa31b5 | 616 | for (; bb != EXIT_BLOCK_PTR_FOR_FN (cfun); bb = bb->next_bb) |
e0082a72 ZD |
617 | if (STATE (bb) != BLOCK_ORIGINAL) |
618 | max = bb; | |
402209ff JH |
619 | |
620 | /* Now re-scan and wire in all edges. This expect simple (conditional) | |
621 | jumps at the end of each new basic blocks. */ | |
2df6cea5 | 622 | make_edges (min, max, 1); |
402209ff JH |
623 | |
624 | /* Update branch probabilities. Expect only (un)conditional jumps | |
625 | to be created with only the forward edges. */ | |
0a6a6ac9 | 626 | if (profile_status_for_fn (cfun) != PROFILE_ABSENT) |
87022a6b JH |
627 | FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb) |
628 | { | |
629 | edge e; | |
628f6a4e | 630 | edge_iterator ei; |
87022a6b JH |
631 | |
632 | if (STATE (bb) == BLOCK_ORIGINAL) | |
633 | continue; | |
634 | if (STATE (bb) == BLOCK_NEW) | |
635 | { | |
636 | bb->count = 0; | |
637 | bb->frequency = 0; | |
628f6a4e | 638 | FOR_EACH_EDGE (e, ei, bb->preds) |
87022a6b JH |
639 | { |
640 | bb->count += e->count; | |
641 | bb->frequency += EDGE_FREQUENCY (e); | |
642 | } | |
643 | } | |
4891442b | 644 | |
87022a6b JH |
645 | compute_outgoing_frequencies (bb); |
646 | } | |
4891442b | 647 | |
11cd3bed | 648 | FOR_EACH_BB_FN (bb, cfun) |
e0082a72 | 649 | SET_STATE (bb, 0); |
b932f770 | 650 | } |