Bug Summary

File:build/gcc/cfghooks.c
Warning:line 1398, column 7
Value stored to 'bb' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cfghooks.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-sRI0zx.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c
1/* Hooks for cfg representation specific functions.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <s.pop@laposte.net>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "backend.h"
25#include "rtl.h"
26#include "cfghooks.h"
27#include "timevar.h"
28#include "pretty-print.h"
29#include "diagnostic-core.h"
30#include "dumpfile.h"
31#include "cfganal.h"
32#include "tree-ssa.h"
33#include "cfgloop.h"
34
35/* Disable warnings about missing quoting in GCC diagnostics. */
36#if __GNUC__4 >= 10
37# pragma GCC diagnostic push
38# pragma GCC diagnostic ignored "-Wformat-diag"
39#endif
40
41/* A pointer to one of the hooks containers. */
42static struct cfg_hooks *cfg_hooks;
43
44/* Initialization of functions specific to the rtl IR. */
45void
46rtl_register_cfg_hooks (void)
47{
48 cfg_hooks = &rtl_cfg_hooks;
49}
50
51/* Initialization of functions specific to the rtl IR. */
52void
53cfg_layout_rtl_register_cfg_hooks (void)
54{
55 cfg_hooks = &cfg_layout_rtl_cfg_hooks;
56}
57
58/* Initialization of functions specific to the tree IR. */
59
60void
61gimple_register_cfg_hooks (void)
62{
63 cfg_hooks = &gimple_cfg_hooks;
64}
65
66struct cfg_hooks
67get_cfg_hooks (void)
68{
69 return *cfg_hooks;
70}
71
72void
73set_cfg_hooks (struct cfg_hooks new_cfg_hooks)
74{
75 *cfg_hooks = new_cfg_hooks;
76}
77
78/* Returns current ir type. */
79
80enum ir_type
81current_ir_type (void)
82{
83 if (cfg_hooks == &gimple_cfg_hooks)
84 return IR_GIMPLE;
85 else if (cfg_hooks == &rtl_cfg_hooks)
86 return IR_RTL_CFGRTL;
87 else if (cfg_hooks == &cfg_layout_rtl_cfg_hooks)
88 return IR_RTL_CFGLAYOUT;
89 else
90 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 90, __FUNCTION__))
;
91}
92
93/* Verify the CFG consistency.
94
95 Currently it does following: checks edge and basic block list correctness
96 and calls into IL dependent checking then. */
97
98DEBUG_FUNCTION__attribute__ ((__used__)) void
99verify_flow_info (void)
100{
101 size_t *edge_checksum;
102 int err = 0;
103 basic_block bb, last_bb_seen;
104 basic_block *last_visited;
105
106 timevar_push (TV_CFG_VERIFY);
107 last_visited = XCNEWVEC (basic_block, last_basic_block_for_fn (cfun))((basic_block *) xcalloc (((((cfun + 0))->cfg->x_last_basic_block
)), sizeof (basic_block)))
;
108 edge_checksum = XCNEWVEC (size_t, last_basic_block_for_fn (cfun))((size_t *) xcalloc (((((cfun + 0))->cfg->x_last_basic_block
)), sizeof (size_t)))
;
109
110 /* Check bb chain & numbers. */
111 last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr);
112 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb, NULL, next_bb)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr)->next_bb
; bb != nullptr; bb = bb->next_bb)
113 {
114 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
115 && bb != BASIC_BLOCK_FOR_FN (cfun, bb->index)((*(((cfun + 0))->cfg->x_basic_block_info))[(bb->index
)])
)
116 {
117 error ("bb %d on wrong place", bb->index);
118 err = 1;
119 }
120
121 if (bb->prev_bb != last_bb_seen)
122 {
123 error ("prev_bb of %d should be %d, not %d",
124 bb->index, last_bb_seen->index, bb->prev_bb->index);
125 err = 1;
126 }
127
128 last_bb_seen = bb;
129 }
130
131 /* Now check the basic blocks (boundaries etc.) */
132 FOR_EACH_BB_REVERSE_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_exit_block_ptr->prev_bb
; bb != ((cfun + 0))->cfg->x_entry_block_ptr; bb = bb->
prev_bb)
133 {
134 int n_fallthru = 0;
135 edge e;
136 edge_iterator ei;
137
138 if (bb->loop_father != NULLnullptr && current_loops((cfun + 0)->x_current_loops) == NULLnullptr)
139 {
140 error ("verify_flow_info: Block %i has loop_father, but there are no loops",
141 bb->index);
142 err = 1;
143 }
144 if (bb->loop_father == NULLnullptr && current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
145 {
146 error ("verify_flow_info: Block %i lacks loop_father", bb->index);
147 err = 1;
148 }
149
150 if (!bb->count.verify ())
151 {
152 error ("verify_flow_info: Wrong count of block %i", bb->index);
153 err = 1;
154 }
155 /* FIXME: Graphite and SLJL and target code still tends to produce
156 edges with no probability. */
157 if (profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) >= PROFILE_GUESSED
158 && !bb->count.initialized_p () && !flag_graphiteglobal_options.x_flag_graphite && 0)
159 {
160 error ("verify_flow_info: Missing count of block %i", bb->index);
161 err = 1;
162 }
163
164 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
165 {
166 if (last_visited [e->dest->index] == bb)
167 {
168 error ("verify_flow_info: Duplicate edge %i->%i",
169 e->src->index, e->dest->index);
170 err = 1;
171 }
172 /* FIXME: Graphite and SLJL and target code still tends to produce
173 edges with no probability. */
174 if (profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) >= PROFILE_GUESSED
175 && !e->probability.initialized_p () && !flag_graphiteglobal_options.x_flag_graphite && 0)
176 {
177 error ("Uninitialized probability of edge %i->%i", e->src->index,
178 e->dest->index);
179 err = 1;
180 }
181 if (!e->probability.verify ())
182 {
183 error ("verify_flow_info: Wrong probability of edge %i->%i",
184 e->src->index, e->dest->index);
185 err = 1;
186 }
187
188 last_visited [e->dest->index] = bb;
189
190 if (e->flags & EDGE_FALLTHRU)
191 n_fallthru++;
192
193 if (e->src != bb)
194 {
195 error ("verify_flow_info: Basic block %d succ edge is corrupted",
196 bb->index);
197 fprintf (stderrstderr, "Predecessor: ");
198 dump_edge_info (stderrstderr, e, TDF_DETAILS, 0);
199 fprintf (stderrstderr, "\nSuccessor: ");
200 dump_edge_info (stderrstderr, e, TDF_DETAILS, 1);
201 fprintf (stderrstderr, "\n");
202 err = 1;
203 }
204
205 edge_checksum[e->dest->index] += (size_t) e;
206 }
207 if (n_fallthru > 1)
208 {
209 error ("wrong amount of branch edges after unconditional jump %i", bb->index);
210 err = 1;
211 }
212
213 FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
214 {
215 if (e->dest != bb)
216 {
217 error ("basic block %d pred edge is corrupted", bb->index);
218 fputs ("Predecessor: ", stderrstderr);
219 dump_edge_info (stderrstderr, e, TDF_DETAILS, 0);
220 fputs ("\nSuccessor: ", stderrstderr);
221 dump_edge_info (stderrstderr, e, TDF_DETAILS, 1);
222 fputc ('\n', stderrstderr);
223 err = 1;
224 }
225
226 if (ei.index != e->dest_idx)
227 {
228 error ("basic block %d pred edge is corrupted", bb->index);
229 error ("its dest_idx should be %d, not %d",
230 ei.index, e->dest_idx);
231 fputs ("Predecessor: ", stderrstderr);
232 dump_edge_info (stderrstderr, e, TDF_DETAILS, 0);
233 fputs ("\nSuccessor: ", stderrstderr);
234 dump_edge_info (stderrstderr, e, TDF_DETAILS, 1);
235 fputc ('\n', stderrstderr);
236 err = 1;
237 }
238
239 edge_checksum[e->dest->index] -= (size_t) e;
240 }
241 }
242
243 /* Complete edge checksumming for ENTRY and EXIT. */
244 {
245 edge e;
246 edge_iterator ei;
247
248 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)for ((ei) = ei_start_1 (&(((((cfun + 0))->cfg->x_entry_block_ptr
)->succs))); ei_cond ((ei), &(e)); ei_next (&(ei))
)
249 edge_checksum[e->dest->index] += (size_t) e;
250
251 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)for ((ei) = ei_start_1 (&(((((cfun + 0))->cfg->x_exit_block_ptr
)->preds))); ei_cond ((ei), &(e)); ei_next (&(ei))
)
252 edge_checksum[e->dest->index] -= (size_t) e;
253 }
254
255 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb !=
nullptr; bb = bb->next_bb)
256 if (edge_checksum[bb->index])
257 {
258 error ("basic block %i edge lists are corrupted", bb->index);
259 err = 1;
260 }
261
262 /* Clean up. */
263 free (last_visited);
264 free (edge_checksum);
265
266 if (cfg_hooks->verify_flow_info)
267 err |= cfg_hooks->verify_flow_info ();
268 if (err)
269 internal_error ("verify_flow_info failed");
270 timevar_pop (TV_CFG_VERIFY);
271}
272
273/* Print out one basic block BB to file OUTF. INDENT is printed at the
274 start of each new line. FLAGS are the TDF_* flags in dumpfile.h.
275
276 This function takes care of the purely graph related information.
277 The cfg hook for the active representation should dump
278 representation-specific information. */
279
280void
281dump_bb (FILE *outf, basic_block bb, int indent, dump_flags_t flags)
282{
283 if (flags & TDF_BLOCKS)
284 dump_bb_info (outf, bb, indent, flags, true, false);
285 if (cfg_hooks->dump_bb)
286 cfg_hooks->dump_bb (outf, bb, indent, flags);
287 if (flags & TDF_BLOCKS)
288 dump_bb_info (outf, bb, indent, flags, false, true);
289 fputc ('\n', outf);
290}
291
292DEBUG_FUNCTION__attribute__ ((__used__)) void
293debug (basic_block_def &ref)
294{
295 dump_bb (stderrstderr, &ref, 0, TDF_NONE);
296}
297
298DEBUG_FUNCTION__attribute__ ((__used__)) void
299debug (basic_block_def *ptr)
300{
301 if (ptr)
302 debug (*ptr);
303 else
304 fprintf (stderrstderr, "<nil>\n");
305}
306
307static void
308debug_slim (basic_block ptr)
309{
310 fprintf (stderrstderr, "<basic_block %p (%d)>", (void *) ptr, ptr->index);
311}
312
313DEFINE_DEBUG_VEC (basic_block_def *)template void debug_helper (vec<basic_block_def *> &
); template void debug_helper (vec<basic_block_def *, va_gc
> &); __attribute__ ((__used__)) void debug (vec<basic_block_def
*> &ref) { debug_helper <basic_block_def *> (ref
); } __attribute__ ((__used__)) void debug (vec<basic_block_def
*> *ptr) { if (ptr) debug (*ptr); else fprintf (stderr, "<nil>\n"
); } __attribute__ ((__used__)) void debug (vec<basic_block_def
*, va_gc> &ref) { debug_helper <basic_block_def *>
(ref); } __attribute__ ((__used__)) void debug (vec<basic_block_def
*, va_gc> *ptr) { if (ptr) debug (*ptr); else fprintf (stderr
, "<nil>\n"); }
314DEFINE_DEBUG_HASH_SET (basic_block_def *)template void debug_helper (hash_set<basic_block_def *>
&); __attribute__ ((__used__)) void debug (hash_set<basic_block_def
*> &ref) { debug_helper <basic_block_def *> (ref
); } __attribute__ ((__used__)) void debug (hash_set<basic_block_def
*> *ptr) { if (ptr) debug (*ptr); else fprintf (stderr, "<nil>\n"
); }
315
316/* Dumps basic block BB to pretty-printer PP, for use as a label of
317 a DOT graph record-node. The implementation of this hook is
318 expected to write the label to the stream that is attached to PP.
319 Field separators between instructions are pipe characters printed
320 verbatim. Instructions should be written with some characters
321 escaped, using pp_write_text_as_dot_label_to_stream(). */
322
323void
324dump_bb_for_graph (pretty_printer *pp, basic_block bb)
325{
326 if (!cfg_hooks->dump_bb_for_graph)
327 internal_error ("%s does not support dump_bb_for_graph",
328 cfg_hooks->name);
329 /* TODO: Add pretty printer for counter. */
330 if (bb->count.initialized_p ())
331 pp_printf (pp, "COUNT:" "%" PRId64"l" "d", bb->count.to_gcov_type ());
332 pp_write_text_to_stream (pp);
333 if (!(dump_flags & TDF_SLIM))
334 cfg_hooks->dump_bb_for_graph (pp, bb);
335}
336
337/* Dump the complete CFG to FILE. FLAGS are the TDF_* flags in dumpfile.h. */
338void
339dump_flow_info (FILE *file, dump_flags_t flags)
340{
341 basic_block bb;
342
343 fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks),
344 n_edges_for_fn (cfun)(((cfun + 0))->cfg->x_n_edges));
345 FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
= bb->next_bb)
346 dump_bb (file, bb, 0, flags);
347
348 putc ('\n', file);
349}
350
351/* Like above, but dump to stderr. To be called from debuggers. */
352void debug_flow_info (void);
353DEBUG_FUNCTION__attribute__ ((__used__)) void
354debug_flow_info (void)
355{
356 dump_flow_info (stderrstderr, TDF_DETAILS);
357}
358
359/* Redirect edge E to the given basic block DEST and update underlying program
360 representation. Returns edge representing redirected branch (that may not
361 be equivalent to E in the case of duplicate edges being removed) or NULL
362 if edge is not easily redirectable for whatever reason. */
363
364edge
365redirect_edge_and_branch (edge e, basic_block dest)
366{
367 edge ret;
368
369 if (!cfg_hooks->redirect_edge_and_branch)
370 internal_error ("%s does not support redirect_edge_and_branch",
371 cfg_hooks->name);
372
373 ret = cfg_hooks->redirect_edge_and_branch (e, dest);
374
375 /* If RET != E, then either the redirection failed, or the edge E
376 was removed since RET already lead to the same destination. */
377 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr && ret == e)
378 rescan_loop_exit (e, false, false);
379
380 return ret;
381}
382
383/* Returns true if it is possible to remove the edge E by redirecting it
384 to the destination of the other edge going from its source. */
385
386bool
387can_remove_branch_p (const_edge e)
388{
389 if (!cfg_hooks->can_remove_branch_p)
390 internal_error ("%s does not support can_remove_branch_p",
391 cfg_hooks->name);
392
393 if (EDGE_COUNT (e->src->succs)vec_safe_length (e->src->succs) != 2)
394 return false;
395
396 return cfg_hooks->can_remove_branch_p (e);
397}
398
399/* Removes E, by redirecting it to the destination of the other edge going
400 from its source. Can_remove_branch_p must be true for E, hence this
401 operation cannot fail. */
402
403void
404remove_branch (edge e)
405{
406 edge other;
407 basic_block src = e->src;
408 int irr;
409
410 gcc_assert (EDGE_COUNT (e->src->succs) == 2)((void)(!(vec_safe_length (e->src->succs) == 2) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 410, __FUNCTION__), 0 : 0))
;
411
412 other = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)(*(src)->succs)[((*(src)->succs)[(0)] == e)];
413 irr = other->flags & EDGE_IRREDUCIBLE_LOOP;
414
415 e = redirect_edge_and_branch (e, other->dest);
416 gcc_assert (e != NULL)((void)(!(e != nullptr) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 416, __FUNCTION__), 0 : 0))
;
417
418 e->flags &= ~EDGE_IRREDUCIBLE_LOOP;
419 e->flags |= irr;
420}
421
422/* Removes edge E from cfg. Unlike remove_branch, it does not update IL. */
423
424void
425remove_edge (edge e)
426{
427 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
428 {
429 rescan_loop_exit (e, false, true);
430
431 /* Removal of an edge inside an irreducible region or which leads
432 to an irreducible region can turn the region into a natural loop.
433 In that case, ask for the loop structure fixups.
434
435 FIXME: Note that LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS is not always
436 set, so always ask for fixups when removing an edge in that case. */
437 if (!loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
438 || (e->flags & EDGE_IRREDUCIBLE_LOOP)
439 || (e->dest->flags & BB_IRREDUCIBLE_LOOP))
440 loops_state_set (LOOPS_NEED_FIXUP);
441 }
442
443 /* This is probably not needed, but it doesn't hurt. */
444 /* FIXME: This should be called via a remove_edge hook. */
445 if (current_ir_type () == IR_GIMPLE)
446 redirect_edge_var_map_clear (e);
447
448 remove_edge_raw (e);
449}
450
451/* Like redirect_edge_succ but avoid possible duplicate edge. */
452
453edge
454redirect_edge_succ_nodup (edge e, basic_block new_succ)
455{
456 edge s;
457
458 s = find_edge (e->src, new_succ);
459 if (s && s != e)
460 {
461 s->flags |= e->flags;
462 s->probability += e->probability;
463 /* FIXME: This should be called via a hook and only for IR_GIMPLE. */
464 redirect_edge_var_map_dup (s, e);
465 remove_edge (e);
466 e = s;
467 }
468 else
469 redirect_edge_succ (e, new_succ);
470
471 return e;
472}
473
474/* Redirect the edge E to basic block DEST even if it requires creating
475 of a new basic block; then it returns the newly created basic block.
476 Aborts when redirection is impossible. */
477
478basic_block
479redirect_edge_and_branch_force (edge e, basic_block dest)
480{
481 basic_block ret, src = e->src;
482
483 if (!cfg_hooks->redirect_edge_and_branch_force)
484 internal_error ("%s does not support redirect_edge_and_branch_force",
485 cfg_hooks->name);
486
487 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
488 rescan_loop_exit (e, false, true);
489
490 ret = cfg_hooks->redirect_edge_and_branch_force (e, dest);
491
492 if (ret != NULLnullptr && dom_info_available_p (CDI_DOMINATORS))
493 set_immediate_dominator (CDI_DOMINATORS, ret, src);
494
495 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
496 {
497 if (ret != NULLnullptr)
498 {
499 class loop *loop
500 = find_common_loop (single_pred (ret)->loop_father,
501 single_succ (ret)->loop_father);
502 add_bb_to_loop (ret, loop);
503 }
504 else if (find_edge (src, dest) == e)
505 rescan_loop_exit (e, true, false);
506 }
507
508 return ret;
509}
510
511/* Splits basic block BB after the specified instruction I (but at least after
512 the labels). If I is NULL, splits just after labels. The newly created edge
513 is returned. The new basic block is created just after the old one. */
514
515static edge
516split_block_1 (basic_block bb, void *i)
517{
518 basic_block new_bb;
519 edge res;
520
521 if (!cfg_hooks->split_block)
522 internal_error ("%s does not support split_block", cfg_hooks->name);
523
524 new_bb = cfg_hooks->split_block (bb, i);
525 if (!new_bb)
526 return NULLnullptr;
527
528 new_bb->count = bb->count;
529 new_bb->discriminator = bb->discriminator;
530
531 if (dom_info_available_p (CDI_DOMINATORS))
532 {
533 redirect_immediate_dominators (CDI_DOMINATORS, bb, new_bb);
534 set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
535 }
536
537 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
538 {
539 edge_iterator ei;
540 edge e;
541 add_bb_to_loop (new_bb, bb->loop_father);
542 /* Identify all loops bb may have been the latch of and adjust them. */
543 FOR_EACH_EDGE (e, ei, new_bb->succs)for ((ei) = ei_start_1 (&((new_bb->succs))); ei_cond (
(ei), &(e)); ei_next (&(ei)))
544 if (e->dest->loop_father->latch == bb)
545 e->dest->loop_father->latch = new_bb;
546 }
547
548 res = make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
549
550 if (bb->flags & BB_IRREDUCIBLE_LOOP)
551 {
552 new_bb->flags |= BB_IRREDUCIBLE_LOOP;
553 res->flags |= EDGE_IRREDUCIBLE_LOOP;
554 }
555
556 return res;
557}
558
559edge
560split_block (basic_block bb, gimple *i)
561{
562 return split_block_1 (bb, i);
563}
564
565edge
566split_block (basic_block bb, rtx i)
567{
568 return split_block_1 (bb, i);
569}
570
571/* Splits block BB just after labels. The newly created edge is returned. */
572
573edge
574split_block_after_labels (basic_block bb)
575{
576 return split_block_1 (bb, NULLnullptr);
577}
578
579/* Moves block BB immediately after block AFTER. Returns false if the
580 movement was impossible. */
581
582bool
583move_block_after (basic_block bb, basic_block after)
584{
585 bool ret;
586
587 if (!cfg_hooks->move_block_after)
588 internal_error ("%s does not support move_block_after", cfg_hooks->name);
589
590 ret = cfg_hooks->move_block_after (bb, after);
591
592 return ret;
593}
594
595/* Deletes the basic block BB. */
596
597void
598delete_basic_block (basic_block bb)
599{
600 if (!cfg_hooks->delete_basic_block)
601 internal_error ("%s does not support delete_basic_block", cfg_hooks->name);
602
603 cfg_hooks->delete_basic_block (bb);
604
605 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
606 {
607 class loop *loop = bb->loop_father;
608
609 /* If we remove the header or the latch of a loop, mark the loop for
610 removal. */
611 if (loop->latch == bb
612 || loop->header == bb)
613 mark_loop_for_removal (loop);
614
615 remove_bb_from_loops (bb);
616 }
617
618 /* Remove the edges into and out of this block. Note that there may
619 indeed be edges in, if we are removing an unreachable loop. */
620 while (EDGE_COUNT (bb->preds)vec_safe_length (bb->preds) != 0)
621 remove_edge (EDGE_PRED (bb, 0)(*(bb)->preds)[(0)]);
622 while (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) != 0)
623 remove_edge (EDGE_SUCC (bb, 0)(*(bb)->succs)[(0)]);
624
625 if (dom_info_available_p (CDI_DOMINATORS))
626 delete_from_dominance_info (CDI_DOMINATORS, bb);
627 if (dom_info_available_p (CDI_POST_DOMINATORS))
628 delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
629
630 /* Remove the basic block from the array. */
631 expunge_block (bb);
632}
633
634/* Splits edge E and returns the newly created basic block. */
635
636basic_block
637split_edge (edge e)
638{
639 basic_block ret;
640 profile_count count = e->count ();
641 edge f;
642 bool irr = (e->flags & EDGE_IRREDUCIBLE_LOOP) != 0;
643 bool back = (e->flags & EDGE_DFS_BACK) != 0;
644 class loop *loop;
645 basic_block src = e->src, dest = e->dest;
646
647 if (!cfg_hooks->split_edge)
648 internal_error ("%s does not support split_edge", cfg_hooks->name);
649
650 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
651 rescan_loop_exit (e, false, true);
652
653 ret = cfg_hooks->split_edge (e);
654 ret->count = count;
655 single_succ_edge (ret)->probability = profile_probability::always ();
656
657 if (irr)
658 {
659 ret->flags |= BB_IRREDUCIBLE_LOOP;
660 single_pred_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
661 single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
662 }
663 if (back)
664 {
665 single_pred_edge (ret)->flags &= ~EDGE_DFS_BACK;
666 single_succ_edge (ret)->flags |= EDGE_DFS_BACK;
667 }
668
669 if (dom_info_available_p (CDI_DOMINATORS))
670 set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret));
671
672 if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
673 {
674 /* There are two cases:
675
676 If the immediate dominator of e->dest is not e->src, it
677 remains unchanged.
678
679 If immediate dominator of e->dest is e->src, it may become
680 ret, provided that all other predecessors of e->dest are
681 dominated by e->dest. */
682
683 if (get_immediate_dominator (CDI_DOMINATORS, single_succ (ret))
684 == single_pred (ret))
685 {
686 edge_iterator ei;
687 FOR_EACH_EDGE (f, ei, single_succ (ret)->preds)for ((ei) = ei_start_1 (&((single_succ (ret)->preds)))
; ei_cond ((ei), &(f)); ei_next (&(ei)))
688 {
689 if (f == single_succ_edge (ret))
690 continue;
691
692 if (!dominated_by_p (CDI_DOMINATORS, f->src,
693 single_succ (ret)))
694 break;
695 }
696
697 if (!f)
698 set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret);
699 }
700 }
701
702 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
703 {
704 loop = find_common_loop (src->loop_father, dest->loop_father);
705 add_bb_to_loop (ret, loop);
706
707 /* If we split the latch edge of loop adjust the latch block. */
708 if (loop->latch == src
709 && loop->header == dest)
710 loop->latch = ret;
711 }
712
713 return ret;
714}
715
716/* Creates a new basic block just after the basic block AFTER.
717 HEAD and END are the first and the last statement belonging
718 to the block. If both are NULL, an empty block is created. */
719
720static basic_block
721create_basic_block_1 (void *head, void *end, basic_block after)
722{
723 basic_block ret;
724
725 if (!cfg_hooks->create_basic_block)
726 internal_error ("%s does not support create_basic_block", cfg_hooks->name);
727
728 ret = cfg_hooks->create_basic_block (head, end, after);
729
730 if (dom_info_available_p (CDI_DOMINATORS))
731 add_to_dominance_info (CDI_DOMINATORS, ret);
732 if (dom_info_available_p (CDI_POST_DOMINATORS))
733 add_to_dominance_info (CDI_POST_DOMINATORS, ret);
734
735 return ret;
736}
737
738basic_block
739create_basic_block (gimple_seq seq, basic_block after)
740{
741 return create_basic_block_1 (seq, NULLnullptr, after);
742}
743
744basic_block
745create_basic_block (rtx head, rtx end, basic_block after)
746{
747 return create_basic_block_1 (head, end, after);
748}
749
750
751/* Creates an empty basic block just after basic block AFTER. */
752
753basic_block
754create_empty_bb (basic_block after)
755{
756 return create_basic_block_1 (NULLnullptr, NULLnullptr, after);
757}
758
759/* Checks whether we may merge blocks BB1 and BB2. */
760
761bool
762can_merge_blocks_p (basic_block bb1, basic_block bb2)
763{
764 bool ret;
765
766 if (!cfg_hooks->can_merge_blocks_p)
767 internal_error ("%s does not support can_merge_blocks_p", cfg_hooks->name);
768
769 ret = cfg_hooks->can_merge_blocks_p (bb1, bb2);
770
771 return ret;
772}
773
774void
775predict_edge (edge e, enum br_predictor predictor, int probability)
776{
777 if (!cfg_hooks->predict_edge)
778 internal_error ("%s does not support predict_edge", cfg_hooks->name);
779
780 cfg_hooks->predict_edge (e, predictor, probability);
781}
782
783bool
784predicted_by_p (const_basic_block bb, enum br_predictor predictor)
785{
786 if (!cfg_hooks->predict_edge)
787 internal_error ("%s does not support predicted_by_p", cfg_hooks->name);
788
789 return cfg_hooks->predicted_by_p (bb, predictor);
790}
791
792/* Merges basic block B into basic block A. */
793
794void
795merge_blocks (basic_block a, basic_block b)
796{
797 edge e;
798 edge_iterator ei;
799
800 if (!cfg_hooks->merge_blocks)
801 internal_error ("%s does not support merge_blocks", cfg_hooks->name);
802
803 cfg_hooks->merge_blocks (a, b);
804
805 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
806 {
807 /* If the block we merge into is a loop header do nothing unless ... */
808 if (a->loop_father->header == a)
809 {
810 /* ... we merge two loop headers, in which case we kill
811 the inner loop. */
812 if (b->loop_father->header == b)
813 mark_loop_for_removal (b->loop_father);
814 }
815 /* If we merge a loop header into its predecessor, update the loop
816 structure. */
817 else if (b->loop_father->header == b)
818 {
819 remove_bb_from_loops (a);
820 add_bb_to_loop (a, b->loop_father);
821 a->loop_father->header = a;
822 }
823 /* If we merge a loop latch into its predecessor, update the loop
824 structure. */
825 if (b->loop_father->latch
826 && b->loop_father->latch == b)
827 b->loop_father->latch = a;
828 remove_bb_from_loops (b);
829 }
830
831 /* Normally there should only be one successor of A and that is B, but
832 partway though the merge of blocks for conditional_execution we'll
833 be merging a TEST block with THEN and ELSE successors. Free the
834 whole lot of them and hope the caller knows what they're doing. */
835
836 while (EDGE_COUNT (a->succs)vec_safe_length (a->succs) != 0)
837 remove_edge (EDGE_SUCC (a, 0)(*(a)->succs)[(0)]);
838
839 /* Adjust the edges out of B for the new owner. */
840 FOR_EACH_EDGE (e, ei, b->succs)for ((ei) = ei_start_1 (&((b->succs))); ei_cond ((ei),
&(e)); ei_next (&(ei)))
841 {
842 e->src = a;
843 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
844 {
845 /* If b was a latch, a now is. */
846 if (e->dest->loop_father->latch == b)
847 e->dest->loop_father->latch = a;
848 rescan_loop_exit (e, true, false);
849 }
850 }
851 a->succs = b->succs;
852 a->flags |= b->flags;
853
854 /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
855 b->preds = b->succs = NULLnullptr;
856
857 if (dom_info_available_p (CDI_DOMINATORS))
858 redirect_immediate_dominators (CDI_DOMINATORS, b, a);
859
860 if (dom_info_available_p (CDI_DOMINATORS))
861 delete_from_dominance_info (CDI_DOMINATORS, b);
862 if (dom_info_available_p (CDI_POST_DOMINATORS))
863 delete_from_dominance_info (CDI_POST_DOMINATORS, b);
864
865 expunge_block (b);
866}
867
868/* Split BB into entry part and the rest (the rest is the newly created block).
869 Redirect those edges for that REDIRECT_EDGE_P returns true to the entry
870 part. Returns the edge connecting the entry part to the rest. */
871
872edge
873make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
874 void (*new_bb_cbk) (basic_block))
875{
876 edge e, fallthru;
877 edge_iterator ei;
878 basic_block dummy, jump;
879 class loop *loop, *ploop, *cloop;
880
881 if (!cfg_hooks->make_forwarder_block)
882 internal_error ("%s does not support make_forwarder_block",
883 cfg_hooks->name);
884
885 fallthru = split_block_after_labels (bb);
886 dummy = fallthru->src;
887 dummy->count = profile_count::zero ();
888 bb = fallthru->dest;
889
890 /* Redirect back edges we want to keep. */
891 for (ei = ei_start (dummy->preds)ei_start_1 (&(dummy->preds)); (e = ei_safe_edge (ei)); )
892 {
893 basic_block e_src;
894
895 if (redirect_edge_p (e))
896 {
897 dummy->count += e->count ();
898 ei_next (&ei);
899 continue;
900 }
901
902 e_src = e->src;
903 jump = redirect_edge_and_branch_force (e, bb);
904 if (jump != NULLnullptr)
905 {
906 /* If we redirected the loop latch edge, the JUMP block now acts like
907 the new latch of the loop. */
908 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr
909 && dummy->loop_father != NULLnullptr
910 && dummy->loop_father->header == dummy
911 && dummy->loop_father->latch == e_src)
912 dummy->loop_father->latch = jump;
913
914 if (new_bb_cbk != NULLnullptr)
915 new_bb_cbk (jump);
916 }
917 }
918
919 if (dom_info_available_p (CDI_DOMINATORS))
920 {
921 vec<basic_block> doms_to_fix;
922 doms_to_fix.create (2);
923 doms_to_fix.quick_push (dummy);
924 doms_to_fix.quick_push (bb);
925 iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, false);
926 doms_to_fix.release ();
927 }
928
929 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
930 {
931 /* If we do not split a loop header, then both blocks belong to the
932 same loop. In case we split loop header and do not redirect the
933 latch edge to DUMMY, then DUMMY belongs to the outer loop, and
934 BB becomes the new header. If latch is not recorded for the loop,
935 we leave this updating on the caller (this may only happen during
936 loop analysis). */
937 loop = dummy->loop_father;
938 if (loop->header == dummy
939 && loop->latch != NULLnullptr
940 && find_edge (loop->latch, dummy) == NULLnullptr)
941 {
942 remove_bb_from_loops (dummy);
943 loop->header = bb;
944
945 cloop = loop;
946 FOR_EACH_EDGE (e, ei, dummy->preds)for ((ei) = ei_start_1 (&((dummy->preds))); ei_cond ((
ei), &(e)); ei_next (&(ei)))
947 {
948 cloop = find_common_loop (cloop, e->src->loop_father);
949 }
950 add_bb_to_loop (dummy, cloop);
951 }
952
953 /* In case we split loop latch, update it. */
954 for (ploop = loop; ploop; ploop = loop_outer (ploop))
955 if (ploop->latch == dummy)
956 ploop->latch = bb;
957 }
958
959 cfg_hooks->make_forwarder_block (fallthru);
960
961 return fallthru;
962}
963
964/* Try to make the edge fallthru. */
965
966void
967tidy_fallthru_edge (edge e)
968{
969 if (cfg_hooks->tidy_fallthru_edge)
970 cfg_hooks->tidy_fallthru_edge (e);
971}
972
973/* Fix up edges that now fall through, or rather should now fall through
974 but previously required a jump around now deleted blocks. Simplify
975 the search by only examining blocks numerically adjacent, since this
976 is how they were created.
977
978 ??? This routine is currently RTL specific. */
979
980void
981tidy_fallthru_edges (void)
982{
983 basic_block b, c;
984
985 if (!cfg_hooks->tidy_fallthru_edge)
986 return;
987
988 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
989 return;
990
991 FOR_BB_BETWEEN (b, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,for (b = (((cfun + 0))->cfg->x_entry_block_ptr)->next_bb
; b != (((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb
; b = b->next_bb)
992 EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb, next_bb)for (b = (((cfun + 0))->cfg->x_entry_block_ptr)->next_bb
; b != (((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb
; b = b->next_bb)
993 {
994 edge s;
995
996 c = b->next_bb;
997
998 /* We care about simple conditional or unconditional jumps with
999 a single successor.
1000
1001 If we had a conditional branch to the next instruction when
1002 CFG was built, then there will only be one out edge for the
1003 block which ended with the conditional branch (since we do
1004 not create duplicate edges).
1005
1006 Furthermore, the edge will be marked as a fallthru because we
1007 merge the flags for the duplicate edges. So we do not want to
1008 check that the edge is not a FALLTHRU edge. */
1009
1010 if (single_succ_p (b))
1011 {
1012 s = single_succ_edge (b);
1013 if (! (s->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
)
)
1014 && s->dest == c
1015 && !(JUMP_P (BB_END (b))(((enum rtx_code) ((b)->il.x.rtl->end_)->code) == JUMP_INSN
)
&& CROSSING_JUMP_P (BB_END (b))(__extension__ ({ __typeof (((b)->il.x.rtl->end_)) const
_rtx = (((b)->il.x.rtl->end_)); if (((enum rtx_code) (
_rtx)->code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1015, __FUNCTION__); _rtx; })->jump)
))
1016 tidy_fallthru_edge (s);
1017 }
1018 }
1019}
1020
1021/* Edge E is assumed to be fallthru edge. Emit needed jump instruction
1022 (and possibly create new basic block) to make edge non-fallthru.
1023 Return newly created BB or NULL if none. */
1024
1025basic_block
1026force_nonfallthru (edge e)
1027{
1028 basic_block ret, src = e->src;
1029
1030 if (!cfg_hooks->force_nonfallthru)
1031 internal_error ("%s does not support force_nonfallthru",
1032 cfg_hooks->name);
1033
1034 ret = cfg_hooks->force_nonfallthru (e);
1035 if (ret != NULLnullptr)
1036 {
1037 if (dom_info_available_p (CDI_DOMINATORS))
1038 set_immediate_dominator (CDI_DOMINATORS, ret, src);
1039
1040 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
1041 {
1042 basic_block pred = single_pred (ret);
1043 basic_block succ = single_succ (ret);
1044 class loop *loop
1045 = find_common_loop (pred->loop_father, succ->loop_father);
1046 rescan_loop_exit (e, false, true);
1047 add_bb_to_loop (ret, loop);
1048
1049 /* If we split the latch edge of loop adjust the latch block. */
1050 if (loop->latch == pred
1051 && loop->header == succ)
1052 loop->latch = ret;
1053 }
1054 }
1055
1056 return ret;
1057}
1058
1059/* Returns true if we can duplicate basic block BB. */
1060
1061bool
1062can_duplicate_block_p (const_basic_block bb)
1063{
1064 if (!cfg_hooks->can_duplicate_block_p)
1065 internal_error ("%s does not support can_duplicate_block_p",
1066 cfg_hooks->name);
1067
1068 if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr) || bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
1069 return false;
1070
1071 return cfg_hooks->can_duplicate_block_p (bb);
1072}
1073
1074/* Duplicates basic block BB and redirects edge E to it. Returns the
1075 new basic block. The new basic block is placed after the basic block
1076 AFTER. */
1077
1078basic_block
1079duplicate_block (basic_block bb, edge e, basic_block after, copy_bb_data *id)
1080{
1081 edge s, n;
1082 basic_block new_bb;
1083 profile_count new_count = e ? e->count (): profile_count::uninitialized ();
1084 edge_iterator ei;
1085
1086 if (!cfg_hooks->duplicate_block)
1087 internal_error ("%s does not support duplicate_block",
1088 cfg_hooks->name);
1089
1090 if (bb->count < new_count)
1091 new_count = bb->count;
1092
1093 gcc_checking_assert (can_duplicate_block_p (bb))((void)(!(can_duplicate_block_p (bb)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1093, __FUNCTION__), 0 : 0))
;
1094
1095 new_bb = cfg_hooks->duplicate_block (bb, id);
1096 if (after)
1097 move_block_after (new_bb, after);
1098
1099 new_bb->flags = (bb->flags & ~BB_DUPLICATED);
1100 FOR_EACH_EDGE (s, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(s)); ei_next (&(ei)))
1101 {
1102 /* Since we are creating edges from a new block to successors
1103 of another block (which therefore are known to be disjoint), there
1104 is no need to actually check for duplicated edges. */
1105 n = unchecked_make_edge (new_bb, s->dest, s->flags);
1106 n->probability = s->probability;
1107 n->aux = s->aux;
1108 }
1109
1110 if (e)
1111 {
1112 new_bb->count = new_count;
1113 bb->count -= new_count;
1114
1115 redirect_edge_and_branch_force (e, new_bb);
1116 }
1117 else
1118 new_bb->count = bb->count;
1119
1120 set_bb_original (new_bb, bb);
1121 set_bb_copy (bb, new_bb);
1122
1123 /* Add the new block to the copy of the loop of BB, or directly to the loop
1124 of BB if the loop is not being copied. */
1125 if (current_loops((cfun + 0)->x_current_loops) != NULLnullptr)
1126 {
1127 class loop *cloop = bb->loop_father;
1128 class loop *copy = get_loop_copy (cloop);
1129 /* If we copied the loop header block but not the loop
1130 we have created a loop with multiple entries. Ditch the loop,
1131 add the new block to the outer loop and arrange for a fixup. */
1132 if (!copy
1133 && cloop->header == bb)
1134 {
1135 add_bb_to_loop (new_bb, loop_outer (cloop));
1136 mark_loop_for_removal (cloop);
1137 }
1138 else
1139 {
1140 add_bb_to_loop (new_bb, copy ? copy : cloop);
1141 /* If we copied the loop latch block but not the loop, adjust
1142 loop state. */
1143 if (!copy
1144 && cloop->latch == bb)
1145 {
1146 cloop->latch = NULLnullptr;
1147 loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
1148 }
1149 }
1150 }
1151
1152 return new_bb;
1153}
1154
1155/* Return 1 if BB ends with a call, possibly followed by some
1156 instructions that must stay with the call, 0 otherwise. */
1157
1158bool
1159block_ends_with_call_p (basic_block bb)
1160{
1161 if (!cfg_hooks->block_ends_with_call_p)
1162 internal_error ("%s does not support block_ends_with_call_p", cfg_hooks->name);
1163
1164 return (cfg_hooks->block_ends_with_call_p) (bb);
1165}
1166
1167/* Return 1 if BB ends with a conditional branch, 0 otherwise. */
1168
1169bool
1170block_ends_with_condjump_p (const_basic_block bb)
1171{
1172 if (!cfg_hooks->block_ends_with_condjump_p)
1173 internal_error ("%s does not support block_ends_with_condjump_p",
1174 cfg_hooks->name);
1175
1176 return (cfg_hooks->block_ends_with_condjump_p) (bb);
1177}
1178
1179/* Add fake edges to the function exit for any non constant and non noreturn
1180 calls, volatile inline assembly in the bitmap of blocks specified by
1181 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
1182 that were split.
1183
1184 The goal is to expose cases in which entering a basic block does not imply
1185 that all subsequent instructions must be executed. */
1186
1187int
1188flow_call_edges_add (sbitmap blocks)
1189{
1190 if (!cfg_hooks->flow_call_edges_add)
1191 internal_error ("%s does not support flow_call_edges_add",
1192 cfg_hooks->name);
1193
1194 return (cfg_hooks->flow_call_edges_add) (blocks);
1195}
1196
1197/* This function is called immediately after edge E is added to the
1198 edge vector E->dest->preds. */
1199
1200void
1201execute_on_growing_pred (edge e)
1202{
1203 if (! (e->dest->flags & BB_DUPLICATED)
1204 && cfg_hooks->execute_on_growing_pred)
1205 cfg_hooks->execute_on_growing_pred (e);
1206}
1207
1208/* This function is called immediately before edge E is removed from
1209 the edge vector E->dest->preds. */
1210
1211void
1212execute_on_shrinking_pred (edge e)
1213{
1214 if (! (e->dest->flags & BB_DUPLICATED)
1215 && cfg_hooks->execute_on_shrinking_pred)
1216 cfg_hooks->execute_on_shrinking_pred (e);
1217}
1218
1219/* This is used inside loop versioning when we want to insert
1220 stmts/insns on the edges, which have a different behavior
1221 in tree's and in RTL, so we made a CFG hook. */
1222void
1223lv_flush_pending_stmts (edge e)
1224{
1225 if (cfg_hooks->flush_pending_stmts)
1226 cfg_hooks->flush_pending_stmts (e);
1227}
1228
1229/* Loop versioning uses the duplicate_loop_to_header_edge to create
1230 a new version of the loop basic-blocks, the parameters here are
1231 exactly the same as in duplicate_loop_to_header_edge or
1232 tree_duplicate_loop_to_header_edge; while in tree-ssa there is
1233 additional work to maintain ssa information that's why there is
1234 a need to call the tree_duplicate_loop_to_header_edge rather
1235 than duplicate_loop_to_header_edge when we are in tree mode. */
1236bool
1237cfg_hook_duplicate_loop_to_header_edge (class loop *loop, edge e,
1238 unsigned int ndupl,
1239 sbitmap wont_exit, edge orig,
1240 vec<edge> *to_remove,
1241 int flags)
1242{
1243 gcc_assert (cfg_hooks->cfg_hook_duplicate_loop_to_header_edge)((void)(!(cfg_hooks->cfg_hook_duplicate_loop_to_header_edge
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1243, __FUNCTION__), 0 : 0))
;
1244 return cfg_hooks->cfg_hook_duplicate_loop_to_header_edge (loop, e,
1245 ndupl, wont_exit,
1246 orig, to_remove,
1247 flags);
1248}
1249
1250/* Conditional jumps are represented differently in trees and RTL,
1251 this hook takes a basic block that is known to have a cond jump
1252 at its end and extracts the taken and not taken edges out of it
1253 and store it in E1 and E2 respectively. */
1254void
1255extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
1256{
1257 gcc_assert (cfg_hooks->extract_cond_bb_edges)((void)(!(cfg_hooks->extract_cond_bb_edges) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1257, __FUNCTION__), 0 : 0))
;
1258 cfg_hooks->extract_cond_bb_edges (b, e1, e2);
1259}
1260
1261/* Responsible for updating the ssa info (PHI nodes) on the
1262 new condition basic block that guards the versioned loop. */
1263void
1264lv_adjust_loop_header_phi (basic_block first, basic_block second,
1265 basic_block new_block, edge e)
1266{
1267 if (cfg_hooks->lv_adjust_loop_header_phi)
1268 cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e);
1269}
1270
1271/* Conditions in trees and RTL are different so we need
1272 a different handling when we add the condition to the
1273 versioning code. */
1274void
1275lv_add_condition_to_bb (basic_block first, basic_block second,
1276 basic_block new_block, void *cond)
1277{
1278 gcc_assert (cfg_hooks->lv_add_condition_to_bb)((void)(!(cfg_hooks->lv_add_condition_to_bb) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1278, __FUNCTION__), 0 : 0))
;
1279 cfg_hooks->lv_add_condition_to_bb (first, second, new_block, cond);
1280}
1281
1282/* Checks whether all N blocks in BBS array can be copied. */
1283bool
1284can_copy_bbs_p (basic_block *bbs, unsigned n)
1285{
1286 unsigned i;
1287 edge e;
1288 int ret = true;
1289
1290 for (i = 0; i < n; i++)
1291 bbs[i]->flags |= BB_DUPLICATED;
1292
1293 for (i = 0; i < n; i++)
1294 {
1295 /* In case we should redirect abnormal edge during duplication, fail. */
1296 edge_iterator ei;
1297 FOR_EACH_EDGE (e, ei, bbs[i]->succs)for ((ei) = ei_start_1 (&((bbs[i]->succs))); ei_cond (
(ei), &(e)); ei_next (&(ei)))
1298 if ((e->flags & EDGE_ABNORMAL)
1299 && (e->dest->flags & BB_DUPLICATED))
1300 {
1301 ret = false;
1302 goto end;
1303 }
1304
1305 if (!can_duplicate_block_p (bbs[i]))
1306 {
1307 ret = false;
1308 break;
1309 }
1310 }
1311
1312end:
1313 for (i = 0; i < n; i++)
1314 bbs[i]->flags &= ~BB_DUPLICATED;
1315
1316 return ret;
1317}
1318
1319/* Duplicates N basic blocks stored in array BBS. Newly created basic blocks
1320 are placed into array NEW_BBS in the same order. Edges from basic blocks
1321 in BBS are also duplicated and copies of those that lead into BBS are
1322 redirected to appropriate newly created block. The function assigns bbs
1323 into loops (copy of basic block bb is assigned to bb->loop_father->copy
1324 loop, so this must be set up correctly in advance)
1325
1326 If UPDATE_DOMINANCE is true then this function updates dominators locally
1327 (LOOPS structure that contains the information about dominators is passed
1328 to enable this), otherwise it does not update the dominator information
1329 and it assumed that the caller will do this, perhaps by destroying and
1330 recreating it instead of trying to do an incremental update like this
1331 function does when update_dominance is true.
1332
1333 BASE is the superloop to that basic block belongs; if its header or latch
1334 is copied, we do not set the new blocks as header or latch.
1335
1336 Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
1337 also in the same order.
1338
1339 Newly created basic blocks are put after the basic block AFTER in the
1340 instruction stream, and the order of the blocks in BBS array is preserved. */
1341
1342void
1343copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
1344 edge *edges, unsigned num_edges, edge *new_edges,
1345 class loop *base, basic_block after, bool update_dominance)
1346{
1347 unsigned i, j;
1348 basic_block bb, new_bb, dom_bb;
1349 edge e;
1350 copy_bb_data id;
1351
1352 /* Mark the blocks to be copied. This is used by edge creation hooks
1353 to decide whether to reallocate PHI nodes capacity to avoid reallocating
1354 PHIs in the set of source BBs. */
1355 for (i = 0; i < n; i++)
1356 bbs[i]->flags |= BB_DUPLICATED;
1357
1358 /* Duplicate bbs, update dominators, assign bbs to loops. */
1359 for (i = 0; i < n; i++)
1360 {
1361 /* Duplicate. */
1362 bb = bbs[i];
1363 new_bb = new_bbs[i] = duplicate_block (bb, NULLnullptr, after, &id);
1364 after = new_bb;
1365 if (bb->loop_father)
1366 {
1367 /* Possibly set loop header. */
1368 if (bb->loop_father->header == bb && bb->loop_father != base)
1369 new_bb->loop_father->header = new_bb;
1370 /* Or latch. */
1371 if (bb->loop_father->latch == bb && bb->loop_father != base)
1372 new_bb->loop_father->latch = new_bb;
1373 }
1374 }
1375
1376 /* Set dominators. */
1377 if (update_dominance)
1378 {
1379 for (i = 0; i < n; i++)
1380 {
1381 bb = bbs[i];
1382 new_bb = new_bbs[i];
1383
1384 dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
1385 if (dom_bb->flags & BB_DUPLICATED)
1386 {
1387 dom_bb = get_bb_copy (dom_bb);
1388 set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
1389 }
1390 }
1391 }
1392
1393 /* Redirect edges. */
1394 for (i = 0; i < n; i++)
1395 {
1396 edge_iterator ei;
1397 new_bb = new_bbs[i];
1398 bb = bbs[i];
Value stored to 'bb' is never read
1399
1400 FOR_EACH_EDGE (e, ei, new_bb->succs)for ((ei) = ei_start_1 (&((new_bb->succs))); ei_cond (
(ei), &(e)); ei_next (&(ei)))
1401 {
1402 if (!(e->dest->flags & BB_DUPLICATED))
1403 continue;
1404 redirect_edge_and_branch_force (e, get_bb_copy (e->dest));
1405 }
1406 }
1407 for (j = 0; j < num_edges; j++)
1408 {
1409 if (!edges[j])
1410 new_edges[j] = NULLnullptr;
1411 else
1412 {
1413 basic_block src = edges[j]->src;
1414 basic_block dest = edges[j]->dest;
1415 if (src->flags & BB_DUPLICATED)
1416 src = get_bb_copy (src);
1417 if (dest->flags & BB_DUPLICATED)
1418 dest = get_bb_copy (dest);
1419 new_edges[j] = find_edge (src, dest);
1420 }
1421 }
1422
1423 /* Clear information about duplicates. */
1424 for (i = 0; i < n; i++)
1425 bbs[i]->flags &= ~BB_DUPLICATED;
1426}
1427
1428/* Return true if BB contains only labels or non-executable
1429 instructions */
1430bool
1431empty_block_p (basic_block bb)
1432{
1433 gcc_assert (cfg_hooks->empty_block_p)((void)(!(cfg_hooks->empty_block_p) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1433, __FUNCTION__), 0 : 0))
;
1434 return cfg_hooks->empty_block_p (bb);
1435}
1436
1437/* Split a basic block if it ends with a conditional branch and if
1438 the other part of the block is not empty. */
1439basic_block
1440split_block_before_cond_jump (basic_block bb)
1441{
1442 gcc_assert (cfg_hooks->split_block_before_cond_jump)((void)(!(cfg_hooks->split_block_before_cond_jump) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1442, __FUNCTION__), 0 : 0))
;
1443 return cfg_hooks->split_block_before_cond_jump (bb);
1444}
1445
1446/* Work-horse for passes.c:check_profile_consistency.
1447 Do book-keeping of the CFG for the profile consistency checker.
1448 Store the counting in RECORD. */
1449
1450void
1451profile_record_check_consistency (profile_record *record)
1452{
1453 basic_block bb;
1454 edge_iterator ei;
1455 edge e;
1456
1457 FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
= bb->next_bb)
1458 {
1459 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
1460 && profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_ABSENT)
1461 {
1462 profile_probability sum = profile_probability::never ();
1463 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
1464 sum += e->probability;
1465 if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs)
1466 && sum.differs_from_p (profile_probability::always ()))
1467 record->num_mismatched_freq_out++;
1468 profile_count lsum = profile_count::zero ();
1469 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
1470 lsum += e->count ();
1471 if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) && (lsum.differs_from_p (bb->count)))
1472 record->num_mismatched_count_out++;
1473 }
1474 if (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
1475 && profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_ABSENT)
1476 {
1477 profile_probability sum = profile_probability::never ();
1478 profile_count lsum = profile_count::zero ();
1479 FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
1480 {
1481 sum += e->probability;
1482 lsum += e->count ();
1483 }
1484 if (EDGE_COUNT (bb->preds)vec_safe_length (bb->preds)
1485 && sum.differs_from_p (profile_probability::always ()))
1486 record->num_mismatched_freq_in++;
1487 if (lsum.differs_from_p (bb->count))
1488 record->num_mismatched_count_in++;
1489 }
1490 if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
1491 || bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
1492 continue;
1493 gcc_assert (cfg_hooks->account_profile_record)((void)(!(cfg_hooks->account_profile_record) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1493, __FUNCTION__), 0 : 0))
;
1494 cfg_hooks->account_profile_record (bb, record);
1495 }
1496}
1497
1498/* Work-horse for passes.c:acount_profile.
1499 Do book-keeping of the CFG for the profile accounting.
1500 Store the counting in RECORD. */
1501
1502void
1503profile_record_account_profile (profile_record *record)
1504{
1505 basic_block bb;
1506
1507 FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
= bb->next_bb)
1508 {
1509 gcc_assert (cfg_hooks->account_profile_record)((void)(!(cfg_hooks->account_profile_record) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfghooks.c"
, 1509, __FUNCTION__), 0 : 0))
;
1510 cfg_hooks->account_profile_record (bb, record);
1511 }
1512}
1513
1514#if __GNUC__4 >= 10
1515# pragma GCC diagnostic pop
1516#endif