/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/rtl.h

Bug Summary

File:	build/gcc/rtl.h
Warning:	line 1483, column 3 Returning null reference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cfgrtl.cc -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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-KUyBui.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc
/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc

→
1/* Control flow graph manipulation code for GNU compiler.
 Copyright (C) 1987-2023 Free Software Foundation, Inc.

4This file is part of GCC.

6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.

11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.

16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */

20/* This file contains low level functions to manipulate the CFG and analyze it
 that are aware of the RTL intermediate language.

 Available functionality:
   - Basic CFG/RTL manipulation API documented in cfghooks.h
   - CFG-aware instruction chain manipulation
delete_insn, delete_insn_chain
   - Edge splitting and committing to edges
insert_insn_on_edge, commit_edge_insertions
   - CFG updating after insn simplification
purge_dead_edges, purge_all_dead_edges
   - CFG fixing after coarse manipulation
fixup_abnormal_edges

 Functions not supposed for generic use:
   - Infrastructure to determine quickly basic block for insn
compute_bb_for_insn, update_bb_for_insn, set_block_for_insn,
   - Edge redirection with updating and optimizing of insn chain
block_label, tidy_fallthru_edge, force_nonfallthru  */
39
40#include "config.h"
41#include "system.h"
42#include "coretypes.h"
43#include "backend.h"
44#include "target.h"
45#include "rtl.h"
46#include "tree.h"
47#include "cfghooks.h"
48#include "df.h"
49#include "insn-config.h"
50#include "memmodel.h"
51#include "emit-rtl.h"
52#include "cfgrtl.h"
53#include "cfganal.h"
54#include "cfgbuild.h"
55#include "cfgcleanup.h"
56#include "bb-reorder.h"
57#include "rtl-error.h"
58#include "insn-attr.h"
59#include "dojump.h"
60#include "expr.h"
61#include "cfgloop.h"
62#include "tree-pass.h"
63#include "print-rtl.h"
64#include "rtl-iter.h"
65#include "gimplify.h"
66#include "profile.h"
67#include "sreal.h"

69/* Disable warnings about missing quoting in GCC diagnostics.  */
70#if __GNUC__4 >= 10
71#  pragma GCC diagnostic push
72#  pragma GCC diagnostic ignored "-Wformat-diag"
73#endif

75/* Holds the interesting leading and trailing notes for the function.
 Only applicable if the CFG is in cfglayout mode.  */
77static GTY(()) rtx_insn *cfg_layout_function_footer;
78static GTY(()) rtx_insn *cfg_layout_function_header;

80static rtx_insn *skip_insns_after_block (basic_block);
81static void record_effective_endpoints (void);
82static void fixup_reorder_chain (void);

84void verify_insn_chain (void);
85static void fixup_fallthru_exit_predecessor (void);
86static int can_delete_note_p (const rtx_note *);
87static int can_delete_label_p (const rtx_code_label *);
88static basic_block rtl_split_edge (edge);
89static bool rtl_move_block_after (basic_block, basic_block);
90static int rtl_verify_flow_info (void);
91static basic_block cfg_layout_split_block (basic_block, void *);
92static edge cfg_layout_redirect_edge_and_branch (edge, basic_block);
93static basic_block cfg_layout_redirect_edge_and_branch_force (edge, basic_block);
94static void cfg_layout_delete_block (basic_block);
95static void rtl_delete_block (basic_block);
96static basic_block rtl_redirect_edge_and_branch_force (edge, basic_block);
97static edge rtl_redirect_edge_and_branch (edge, basic_block);
98static basic_block rtl_split_block (basic_block, void *);
99static void rtl_dump_bb (FILE *, basic_block, int, dump_flags_t);
100static int rtl_verify_flow_info_1 (void);
101static void rtl_make_forwarder_block (edge);
102static bool rtl_bb_info_initialized_p (basic_block bb);
103
104/* Return true if NOTE is not one of the ones that must be kept paired,
 so that we may simply delete it.  */

107static int
108can_delete_note_p (const rtx_note *note)
109{
switch (NOTE_KIND (note)(((note)->u.fld[4]).rt_int))
  {
  case NOTE_INSN_DELETED:
  case NOTE_INSN_BASIC_BLOCK:
  case NOTE_INSN_EPILOGUE_BEG:
    return true;

  default:
    return false;
  }
120}

122/* True if a given label can be deleted.  */

124static int
125can_delete_label_p (const rtx_code_label *label)
126{
return (!LABEL_PRESERVE_P (label)(__extension__ ({ __typeof ((label)) const _rtx = ((label)); if
 (((enum rtx_code) (_rtx)->code) != CODE_LABEL && (
(enum rtx_code) (_rtx)->code) != NOTE) rtl_check_failed_flag
 ("LABEL_PRESERVE_P",_rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 127, __FUNCTION__); _rtx; })->in_struct)
 /* User declared labels must be preserved.  */
 && LABEL_NAME (label)(((label)->u.fld[6]).rt_str) == 0
 && !vec_safe_contains<rtx_insn *> (forced_labels((&x_rtl)->expr.x_forced_labels),
			     const_cast<rtx_code_label *> (label)));
132}

134/* Delete INSN by patching it out.  */

136void
137delete_insn (rtx_insn *insn)
138{
rtx note;
bool really_delete = true;

if (LABEL_P (insn)(((enum rtx_code) (insn)->code) == CODE_LABEL))
  {
    /* Some labels can't be directly removed from the INSN chain, as they
might be references via variables, constant pool etc.
Convert them to the special NOTE_INSN_DELETED_LABEL note.  */
    if (! can_delete_label_p (as_a <rtx_code_label *> (insn)))
{
 const char *name = LABEL_NAME (insn)(((insn)->u.fld[6]).rt_str);
 basic_block bb = BLOCK_FOR_INSN (insn);
 rtx_insn *bb_note = NEXT_INSN (insn);

 really_delete = false;
 PUT_CODE (insn, NOTE)((insn)->code = (NOTE));
 NOTE_KIND (insn)(((insn)->u.fld[4]).rt_int) = NOTE_INSN_DELETED_LABEL;
 NOTE_DELETED_LABEL_NAME (insn)(((insn)->u.fld[3]).rt_str) = name;

 /* If the note following the label starts a basic block, and the
    label is a member of the same basic block, interchange the two.  */
 if (bb_note != NULL_RTX(rtx) 0
     && NOTE_INSN_BASIC_BLOCK_P (bb_note)((((enum rtx_code) (bb_note)->code) == NOTE) && ((
(bb_note)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK)
     && bb != NULLnullptr
     && bb == BLOCK_FOR_INSN (bb_note))
   {
     reorder_insns_nobb (insn, insn, bb_note);
     BB_HEAD (bb)(bb)->il.x.head_ = bb_note;
     if (BB_END (bb)(bb)->il.x.rtl->end_ == bb_note)
BB_END (bb)(bb)->il.x.rtl->end_ = insn;
   }
}

    remove_node_from_insn_list (insn, &nonlocal_goto_handler_labels((&x_rtl)->x_nonlocal_goto_handler_labels));
  }

if (really_delete)
  {
    /* If this insn has already been deleted, something is very wrong.  */
    gcc_assert (!insn->deleted ())((void)(!(!insn->deleted ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 178, __FUNCTION__), 0 : 0));
    if (INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN)))
df_insn_delete (insn);
    remove_insn (insn);
    insn->set_deleted ();
  }

/* If deleting a jump, decrement the use count of the label.  Deleting
   the label itself should happen in the normal course of block merging.  */
if (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN))
  {
    if (JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx)
 && LABEL_P (JUMP_LABEL (insn))(((enum rtx_code) ((((insn)->u.fld[7]).rt_rtx))->code) ==
 CODE_LABEL))
LABEL_NUSES (JUMP_LABEL (insn))((((((insn)->u.fld[7]).rt_rtx))->u.fld[4]).rt_int)--;

    /* If there are more targets, remove them too.  */
    while ((note
     = find_reg_note (insn, REG_LABEL_TARGET, NULL_RTX(rtx) 0)) != NULL_RTX(rtx) 0
    && LABEL_P (XEXP (note, 0))(((enum rtx_code) ((((note)->u.fld[0]).rt_rtx))->code) ==
 CODE_LABEL))
{
 LABEL_NUSES (XEXP (note, 0))((((((note)->u.fld[0]).rt_rtx))->u.fld[4]).rt_int)--;
 remove_note (insn, note);
}
  }

/* Also if deleting any insn that references a label as an operand.  */
while ((note = find_reg_note (insn, REG_LABEL_OPERAND, NULL_RTX(rtx) 0)) != NULL_RTX(rtx) 0
&& LABEL_P (XEXP (note, 0))(((enum rtx_code) ((((note)->u.fld[0]).rt_rtx))->code) ==
 CODE_LABEL))
  {
    LABEL_NUSES (XEXP (note, 0))((((((note)->u.fld[0]).rt_rtx))->u.fld[4]).rt_int)--;
    remove_note (insn, note);
  }

if (rtx_jump_table_data *table = dyn_cast <rtx_jump_table_data *> (insn))
  {
    rtvec vec = table->get_labels ();
    int len = GET_NUM_ELEM (vec)((vec)->num_elem);
    int i;

    for (i = 0; i < len; i++)
{
 rtx label = XEXP (RTVEC_ELT (vec, i), 0)(((((vec)->elem[i]))->u.fld[0]).rt_rtx);

 /* When deleting code in bulk (e.g. removing many unreachable
    blocks) we can delete a label that's a target of the vector
    before deleting the vector itself.  */
 if (!NOTE_P (label)(((enum rtx_code) (label)->code) == NOTE))
   LABEL_NUSES (label)(((label)->u.fld[4]).rt_int)--;
}
  }
228}

230/* Like delete_insn but also purge dead edges from BB.
 Return true if any edges are eliminated.  */

233bool
234delete_insn_and_edges (rtx_insn *insn)
235{
bool purge = false;

if (NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) && BLOCK_FOR_INSN (insn))
  {
    basic_block bb = BLOCK_FOR_INSN (insn);
    if (BB_END (bb)(bb)->il.x.rtl->end_ == insn)
purge = true;
    else if (DEBUG_INSN_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == DEBUG_INSN
))
for (rtx_insn *dinsn = NEXT_INSN (insn);
    DEBUG_INSN_P (dinsn)(((enum rtx_code) (dinsn)->code) == DEBUG_INSN); dinsn = NEXT_INSN (dinsn))
 if (BB_END (bb)(bb)->il.x.rtl->end_ == dinsn)
   {
     purge = true;
     break;
   }
  }
delete_insn (insn);
if (purge)
  return purge_dead_edges (BLOCK_FOR_INSN (insn));
return false;
256}

258/* Unlink a chain of insns between START and FINISH, leaving notes
 that must be paired.  If CLEAR_BB is true, we set bb field for
 insns that cannot be removed to NULL.  */

262void
263delete_insn_chain (rtx start, rtx_insn *finish, bool clear_bb)
264{
/* Unchain the insns one by one.  It would be quicker to delete all of these
   with a single unchaining, rather than one at a time, but we need to keep
   the NOTE's.  */
rtx_insn *current = finish;
while (1)
  {
    rtx_insn *prev = PREV_INSN (current);
    if (NOTE_P (current)(((enum rtx_code) (current)->code) == NOTE) && !can_delete_note_p (as_a <rtx_note *> (current)))
;
    else
delete_insn (current);

    if (clear_bb && !current->deleted ())
set_block_for_insn (current, NULLnullptr);

    if (current == start)
break;
    current = prev;
  }
284}
285
286/* Create a new basic block consisting of the instructions between HEAD and END
 inclusive.  This function is designed to allow fast BB construction - reuses
 the note and basic block struct in BB_NOTE, if any and do not grow
 BASIC_BLOCK chain and should be used directly only by CFG construction code.
 END can be NULL in to create new empty basic block before HEAD.  Both END
 and HEAD can be NULL to create basic block at the end of INSN chain.
 AFTER is the basic block we should be put after.  */

294basic_block
295create_basic_block_structure (rtx_insn *head, rtx_insn *end, rtx_note *bb_note,
	      basic_block after)
297{
basic_block bb;

if (bb_note
    && (bb = NOTE_BASIC_BLOCK (bb_note)(((bb_note)->u.fld[3]).rt_bb)) != NULLnullptr
    && bb->aux == NULLnullptr)
  {
    /* If we found an existing note, thread it back onto the chain.  */

    rtx_insn *after;

    if (LABEL_P (head)(((enum rtx_code) (head)->code) == CODE_LABEL))
after = head;
    else
{
 after = PREV_INSN (head);
 head = bb_note;
}

    if (after != bb_note && NEXT_INSN (after) != bb_note)
reorder_insns_nobb (bb_note, bb_note, after);
  }
else
  {
    /* Otherwise we must create a note and a basic block structure.  */

    bb = alloc_block ();

    init_rtl_bb_info (bb);
    if (!head && !end)
head = end = bb_note
 = emit_note_after (NOTE_INSN_BASIC_BLOCK, get_last_insn ());
    else if (LABEL_P (head)(((enum rtx_code) (head)->code) == CODE_LABEL) && end)
{
 bb_note = emit_note_after (NOTE_INSN_BASIC_BLOCK, head);
 if (head == end)
   end = bb_note;
}
    else
{
 bb_note = emit_note_before (NOTE_INSN_BASIC_BLOCK, head);
 head = bb_note;
 if (!end)
   end = head;
}

    NOTE_BASIC_BLOCK (bb_note)(((bb_note)->u.fld[3]).rt_bb) = bb;
  }

/* Always include the bb note in the block.  */
if (NEXT_INSN (end) == bb_note)
  end = bb_note;

BB_HEAD (bb)(bb)->il.x.head_ = head;
BB_END (bb)(bb)->il.x.rtl->end_ = end;
bb->index = last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block)++;
bb->flags = BB_NEW | BB_RTL;
link_block (bb, after);
SET_BASIC_BLOCK_FOR_FN (cfun, bb->index, bb)((*(((cfun + 0))->cfg->x_basic_block_info))[(bb->index
)] = (bb));
df_bb_refs_record (bb->index, false);
update_bb_for_insn (bb);
BB_SET_PARTITION (bb, BB_UNPARTITIONED)do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags &
 ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (0)); } while (0);

/* Tag the block so that we know it has been used when considering
   other basic block notes.  */
bb->aux = bb;

return bb;
365}

367/* Create new basic block consisting of instructions in between HEAD and END
 and place it to the BB chain after block AFTER.  END can be NULL to
 create a new empty basic block before HEAD.  Both END and HEAD can be
 NULL to create basic block at the end of INSN chain.  */

372static basic_block
373rtl_create_basic_block (void *headp, void *endp, basic_block after)
374{
rtx_insn *head = (rtx_insn *) headp;
rtx_insn *end = (rtx_insn *) endp;
basic_block bb;

/* Grow the basic block array if needed.  */
if ((size_t) last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block)
    >= basic_block_info_for_fn (cfun)(((cfun + 0))->cfg->x_basic_block_info)->length ())
  vec_safe_grow_cleared (basic_block_info_for_fn (cfun)(((cfun + 0))->cfg->x_basic_block_info),
	   last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block) + 1);

n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks)++;

bb = create_basic_block_structure (head, end, NULLnullptr, after);
bb->aux = NULLnullptr;
return bb;
390}

392static basic_block
393cfg_layout_create_basic_block (void *head, void *end, basic_block after)
394{
basic_block newbb = rtl_create_basic_block (head, end, after);

return newbb;
398}
399
400/* Delete the insns in a (non-live) block.  We physically delete every
 non-deleted-note insn, and update the flow graph appropriately.

 Return nonzero if we deleted an exception handler.  */

405/* ??? Preserving all such notes strikes me as wrong.  It would be nice
 to post-process the stream to remove empty blocks, loops, ranges, etc.  */

408static void
409rtl_delete_block (basic_block b)
410{
rtx_insn *insn, *end;

/* If the head of this block is a CODE_LABEL, then it might be the
   label for an exception handler which can't be reached.  We need
   to remove the label from the exception_handler_label list.  */
insn = BB_HEAD (b)(b)->il.x.head_;

end = get_last_bb_insn (b);

/* Selectively delete the entire chain.  */
BB_HEAD (b)(b)->il.x.head_ = NULLnullptr;
delete_insn_chain (insn, end, true);


if (dump_file)
  fprintf (dump_file, "deleting block %d\n", b->index);
df_bb_delete (b->index);
428}
429
430/* Records the basic block struct in BLOCK_FOR_INSN for every insn.  */

432void
433compute_bb_for_insn (void)
434{
basic_block bb;

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    rtx_insn *end = BB_END (bb)(bb)->il.x.rtl->end_;
    rtx_insn *insn;

    for (insn = BB_HEAD (bb)(bb)->il.x.head_; ; insn = NEXT_INSN (insn))
{
 BLOCK_FOR_INSN (insn) = bb;
 if (insn == end)
   break;
}
  }
449}

451/* Release the basic_block_for_insn array.  */

453unsigned int
454free_bb_for_insn (void)
455{
rtx_insn *insn;
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
  if (!BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
    BLOCK_FOR_INSN (insn) = NULLnullptr;
return 0;
461}

463namespace {

465const pass_data pass_data_free_cfg =
466{
RTL_PASS, /* type */
"*free_cfg", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_NONE, /* tv_id */
0, /* properties_required */
0, /* properties_provided */
PROP_cfg(1 << 3), /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
476};

478class pass_free_cfg : public rtl_opt_pass
479{
480public:
pass_free_cfg (gcc::context *ctxt)
  : rtl_opt_pass (pass_data_free_cfg, ctxt)
{}

/* opt_pass methods: */
unsigned int execute (function *) final override;

488}; // class pass_free_cfg

490unsigned int
491pass_free_cfg::execute (function *)
492{
/* The resource.cc machinery uses DF but the CFG isn't guaranteed to be
   valid at that point so it would be too late to call df_analyze.  */
if (DELAY_SLOTS0 && optimizeglobal_options.x_optimize > 0 && flag_delayed_branchglobal_options.x_flag_delayed_branch)
  {
    df_note_add_problem ();
    df_analyze ();
  }

if (crtl(&x_rtl)->has_bb_partition)
  insert_section_boundary_note ();

free_bb_for_insn ();
return 0;
506}

508} // anon namespace

510rtl_opt_pass *
511make_pass_free_cfg (gcc::context *ctxt)
512{
return new pass_free_cfg (ctxt);
514}

516/* Return RTX to emit after when we want to emit code on the entry of function.  */
517rtx_insn *
518entry_of_function (void)
519{
return (n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks) > NUM_FIXED_BLOCKS(2) ?
 BB_HEAD (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb)((((cfun + 0))->cfg->x_entry_block_ptr)->next_bb)->
il.x.head_ : get_insns ());
522}

524/* Emit INSN at the entry point of the function, ensuring that it is only
 executed once per function.  */
526void
527emit_insn_at_entry (rtx insn)
528{
edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)ei_start_1 (&((((cfun + 0))->cfg->x_entry_block_ptr
)->succs));
edge e = ei_safe_edge (ei);
gcc_assert (e->flags & EDGE_FALLTHRU)((void)(!(e->flags & EDGE_FALLTHRU) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 531, __FUNCTION__), 0 : 0));

insert_insn_on_edge (insn, e);
commit_edge_insertions ();
535}

537/* Update BLOCK_FOR_INSN of insns between BEGIN and END
 (or BARRIER if found) and notify df of the bb change.
 The insn chain range is inclusive
 (i.e. both BEGIN and END will be updated. */

542static void
543update_bb_for_insn_chain (rtx_insn *begin, rtx_insn *end, basic_block bb)
544{
rtx_insn *insn;

end = NEXT_INSN (end);
for (insn = begin; insn != end; insn = NEXT_INSN (insn))
  if (!BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
    df_insn_change_bb (insn, bb);
551}

553/* Update BLOCK_FOR_INSN of insns in BB to BB,
 and notify df of the change.  */

556void
557update_bb_for_insn (basic_block bb)
558{
update_bb_for_insn_chain (BB_HEAD (bb)(bb)->il.x.head_, BB_END (bb)(bb)->il.x.rtl->end_, bb);
560}

562
563/* Like active_insn_p, except keep the return value use or clobber around
 even after reload.  */

566static bool
567flow_active_insn_p (const rtx_insn *insn)
568{
if (active_insn_p (insn))
  return true;

/* A clobber of the function return value exists for buggy
   programs that fail to return a value.  Its effect is to
   keep the return value from being live across the entire
   function.  If we allow it to be skipped, we introduce the
   possibility for register lifetime confusion.
   Similarly, keep a USE of the function return value, otherwise
   the USE is dropped and we could fail to thread jump if USE
   appears on some paths and not on others, see PR90257.  */
if ((GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == CLOBBER
     || GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == USE)
    && REG_P (XEXP (PATTERN (insn), 0))(((enum rtx_code) ((((PATTERN (insn))->u.fld[0]).rt_rtx))->
code) == REG)
    && REG_FUNCTION_VALUE_P (XEXP (PATTERN (insn), 0))(__extension__ ({ __typeof (((((PATTERN (insn))->u.fld[0])
.rt_rtx))) const _rtx = (((((PATTERN (insn))->u.fld[0]).rt_rtx
))); if (((enum rtx_code) (_rtx)->code) != REG && (
(enum rtx_code) (_rtx)->code) != PARALLEL) rtl_check_failed_flag
 ("REG_FUNCTION_VALUE_P",_rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 583, __FUNCTION__); _rtx; })->return_val))
  return true;

return false;
587}

589/* Return true if the block has no effect and only forwards control flow to
 its single destination.  */

592bool
593contains_no_active_insn_p (const_basic_block bb)
594{
rtx_insn *insn;

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)
    || !single_succ_p (bb)
    || (single_succ_edge (bb)->flags & EDGE_FAKE) != 0)
  return false;

for (insn = BB_HEAD (bb)(bb)->il.x.head_; insn != BB_END (bb)(bb)->il.x.rtl->end_; insn = NEXT_INSN (insn))
  if (INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN)) && flow_active_insn_p (insn))
    return false;

return (!INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN))
 || (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN) && simplejump_p (insn))
 || !flow_active_insn_p (insn));
610}

612/* Likewise, but protect loop latches, headers and preheaders.  */
613/* FIXME: Make this a cfg hook.  */

615bool
616forwarder_block_p (const_basic_block bb)
617{
if (!contains_no_active_insn_p (bb))
  return false;

/* Protect loop latches, headers and preheaders.  */
if (current_loops((cfun + 0)->x_current_loops))
  {
    basic_block dest;
    if (bb->loop_father->header == bb)
return false;
    dest = EDGE_SUCC (bb, 0)(*(bb)->succs)[(0)]->dest;
    if (dest->loop_father->header == dest)
return false;
  }

return true;
633}

635/* Return nonzero if we can reach target from src by falling through.  */
636/* FIXME: Make this a cfg hook, the result is only valid in cfgrtl mode.  */

638bool
639can_fallthru (basic_block src, basic_block target)
640{
rtx_insn *insn = BB_END (src)(src)->il.x.rtl->end_;
rtx_insn *insn2;
edge e;
edge_iterator ei;

if (target == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return true;
if (src->next_bb != target)
  return false;

/* ??? Later we may add code to move jump tables offline.  */
if (tablejump_p (insn, NULLnullptr, NULLnullptr))
  return false;

FOR_EACH_EDGE (e, ei, src->succs)for ((ei) = ei_start_1 (&((src->succs))); ei_cond ((ei
), &(e)); ei_next (&(ei)))
  if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
&& e->flags & EDGE_FALLTHRU)
    return false;

insn2 = BB_HEAD (target)(target)->il.x.head_;
if (!active_insn_p (insn2))
  insn2 = next_active_insn (insn2);

return next_active_insn (insn) == insn2;
665}

667/* Return nonzero if we could reach target from src by falling through,
 if the target was made adjacent.  If we already have a fall-through
 edge to the exit block, we can't do that.  */
670static bool
671could_fall_through (basic_block src, basic_block target)
672{
edge e;
edge_iterator ei;

if (target == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return true;
FOR_EACH_EDGE (e, ei, src->succs)for ((ei) = ei_start_1 (&((src->succs))); ei_cond ((ei
), &(e)); ei_next (&(ei)))
  if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
&& e->flags & EDGE_FALLTHRU)
    return 0;
return true;
683}
684
685/* Return the NOTE_INSN_BASIC_BLOCK of BB.  */
686rtx_note *
687bb_note (basic_block bb)
688{
rtx_insn *note;

note = BB_HEAD (bb)(bb)->il.x.head_;
if (LABEL_P (note)(((enum rtx_code) (note)->code) == CODE_LABEL))
  note = NEXT_INSN (note);

gcc_assert (NOTE_INSN_BASIC_BLOCK_P (note))((void)(!(((((enum rtx_code) (note)->code) == NOTE) &&
 (((note)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 695, __FUNCTION__), 0 : 0));
return as_a <rtx_note *> (note);
697}

699/* Return the INSN immediately following the NOTE_INSN_BASIC_BLOCK
 note associated with the BLOCK.  */

702static rtx_insn *
703first_insn_after_basic_block_note (basic_block block)
704{
rtx_insn *insn;

/* Get the first instruction in the block.  */
insn = BB_HEAD (block)(block)->il.x.head_;

if (insn == NULL_RTX(rtx) 0)
  return NULLnullptr;
if (LABEL_P (insn)(((enum rtx_code) (insn)->code) == CODE_LABEL))
  insn = NEXT_INSN (insn);
gcc_assert (NOTE_INSN_BASIC_BLOCK_P (insn))((void)(!(((((enum rtx_code) (insn)->code) == NOTE) &&
 (((insn)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 714, __FUNCTION__), 0 : 0));

return NEXT_INSN (insn);
717}

719/* Creates a new basic block just after basic block BB by splitting
 everything after specified instruction INSNP.  */

722static basic_block
723rtl_split_block (basic_block bb, void *insnp)
724{
basic_block new_bb;
rtx_insn *insn = (rtx_insn *) insnp;
edge e;
edge_iterator ei;

if (!insn)
  {
    insn = first_insn_after_basic_block_note (bb);

    if (insn)
{
 rtx_insn *next = insn;

 insn = PREV_INSN (insn);

 /* If the block contains only debug insns, insn would have
    been NULL in a non-debug compilation, and then we'd end
    up emitting a DELETED note.  For -fcompare-debug
    stability, emit the note too.  */
 if (insn != BB_END (bb)(bb)->il.x.rtl->end_
     && DEBUG_INSN_P (next)(((enum rtx_code) (next)->code) == DEBUG_INSN)
     && DEBUG_INSN_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == DEBUG_INSN
))
   {
     while (next != BB_END (bb)(bb)->il.x.rtl->end_ && DEBUG_INSN_P (next)(((enum rtx_code) (next)->code) == DEBUG_INSN))
next = NEXT_INSN (next);

     if (next == BB_END (bb)(bb)->il.x.rtl->end_)
emit_note_after (NOTE_INSN_DELETED, next);
   }
}
    else
insn = get_last_insn ();
  }

/* We probably should check type of the insn so that we do not create
   inconsistent cfg.  It is checked in verify_flow_info anyway, so do not
   bother.  */
if (insn == BB_END (bb)(bb)->il.x.rtl->end_)
  emit_note_after (NOTE_INSN_DELETED, insn);

/* Create the new basic block.  */
new_bb = create_basic_block (NEXT_INSN (insn), BB_END (bb)(bb)->il.x.rtl->end_, bb);
BB_COPY_PARTITION (new_bb, bb)do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags
 & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((bb)->flags
 & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while (0);
BB_END (bb)(bb)->il.x.rtl->end_ = insn;

/* Redirect the outgoing edges.  */
new_bb->succs = bb->succs;
bb->succs = NULLnullptr;
FOR_EACH_EDGE (e, ei, new_bb->succs)for ((ei) = ei_start_1 (&((new_bb->succs))); ei_cond (
(ei), &(e)); ei_next (&(ei)))
  e->src = new_bb;

/* The new block starts off being dirty.  */
df_set_bb_dirty (bb);
return new_bb;
779}

781/* Return true if LOC1 and LOC2 are equivalent for
 unique_locus_on_edge_between_p purposes.  */

784static bool
785loc_equal (location_t loc1, location_t loc2)
786{
if (loc1 == loc2)
  return true;

expanded_location loce1 = expand_location (loc1);
expanded_location loce2 = expand_location (loc2);

if (loce1.line != loce2.line
    || loce1.column != loce2.column
    || loce1.data != loce2.data)
  return false;
if (loce1.file == loce2.file)
  return true;
return (loce1.file != NULLnullptr
 && loce2.file != NULLnullptr
 && filename_cmp (loce1.file, loce2.file) == 0);
802}

804/* Return true if the single edge between blocks A and B is the only place
 in RTL which holds some unique locus.  */

807static bool
808unique_locus_on_edge_between_p (basic_block a, basic_block b)
809{
const location_t goto_locus = EDGE_SUCC (a, 0)(*(a)->succs)[(0)]->goto_locus;
rtx_insn *insn, *end;

if (LOCATION_LOCUS (goto_locus)((IS_ADHOC_LOC (goto_locus)) ? get_location_from_adhoc_loc (line_table
, goto_locus) : (goto_locus)) == UNKNOWN_LOCATION((location_t) 0))
  return false;

/* First scan block A backward.  */
insn = BB_END (a)(a)->il.x.rtl->end_;
end = PREV_INSN (BB_HEAD (a)(a)->il.x.head_);
while (insn != end && (!NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || !INSN_HAS_LOCATION (insn)))
  insn = PREV_INSN (insn);

if (insn != end && loc_equal (INSN_LOCATION (insn), goto_locus))
  return false;

/* Then scan block B forward.  */
insn = BB_HEAD (b)(b)->il.x.head_;
if (insn)
  {
    end = NEXT_INSN (BB_END (b)(b)->il.x.rtl->end_);
    while (insn != end && !NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)))
insn = NEXT_INSN (insn);

    if (insn != end && INSN_HAS_LOCATION (insn)
 && loc_equal (INSN_LOCATION (insn), goto_locus))
return false;
  }

return true;
839}

841/* If the single edge between blocks A and B is the only place in RTL which
 holds some unique locus, emit a nop with that locus between the blocks.  */

844static void
845emit_nop_for_unique_locus_between (basic_block a, basic_block b)
846{
if (!unique_locus_on_edge_between_p (a, b))
  return;

BB_END (a)(a)->il.x.rtl->end_ = emit_insn_after_noloc (gen_nop (), BB_END (a)(a)->il.x.rtl->end_, a);
INSN_LOCATION (BB_END (a)(a)->il.x.rtl->end_) = EDGE_SUCC (a, 0)(*(a)->succs)[(0)]->goto_locus;
852}

854/* Blocks A and B are to be merged into a single block A.  The insns
 are already contiguous.  */

857static void
858rtl_merge_blocks (basic_block a, basic_block b)
859{
/* If B is a forwarder block whose outgoing edge has no location, we'll
   propagate the locus of the edge between A and B onto it.  */
const bool forward_edge_locus
  = (b->flags & BB_FORWARDER_BLOCK) != 0
    && LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus)((IS_ADHOC_LOC ((*(b)->succs)[(0)]->goto_locus)) ? get_location_from_adhoc_loc
 (line_table, (*(b)->succs)[(0)]->goto_locus) : ((*(b)->
succs)[(0)]->goto_locus)) == UNKNOWN_LOCATION((location_t) 0);
rtx_insn *b_head = BB_HEAD (b)(b)->il.x.head_, *b_end = BB_END (b)(b)->il.x.rtl->end_, *a_end = BB_END (a)(a)->il.x.rtl->end_;
rtx_insn *del_first = NULLnullptr, *del_last = NULLnullptr;
rtx_insn *b_debug_start = b_end, *b_debug_end = b_end;
int b_empty = 0;

if (dump_file)
  fprintf (dump_file, "Merging block %d into block %d...\n", b->index,
    a->index);

while (DEBUG_INSN_P (b_end)(((enum rtx_code) (b_end)->code) == DEBUG_INSN))
  b_end = PREV_INSN (b_debug_start = b_end);

/* If there was a CODE_LABEL beginning B, delete it.  */
if (LABEL_P (b_head)(((enum rtx_code) (b_head)->code) == CODE_LABEL))
  {
    /* Detect basic blocks with nothing but a label.  This can happen
in particular at the end of a function.  */
    if (b_head == b_end)
b_empty = 1;

    del_first = del_last = b_head;
    b_head = NEXT_INSN (b_head);
  }

/* Delete the basic block note and handle blocks containing just that
   note.  */
if (NOTE_INSN_BASIC_BLOCK_P (b_head)((((enum rtx_code) (b_head)->code) == NOTE) && (((
b_head)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK))
  {
    if (b_head == b_end)
b_empty = 1;
    if (! del_last)
del_first = b_head;

    del_last = b_head;
    b_head = NEXT_INSN (b_head);
  }

/* If there was a jump out of A, delete it.  */
if (JUMP_P (a_end)(((enum rtx_code) (a_end)->code) == JUMP_INSN))
  {
    rtx_insn *prev;

    for (prev = PREV_INSN (a_end); ; prev = PREV_INSN (prev))
if (!NOTE_P (prev)(((enum rtx_code) (prev)->code) == NOTE)
   || NOTE_INSN_BASIC_BLOCK_P (prev)((((enum rtx_code) (prev)->code) == NOTE) && (((prev
)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK)
   || prev == BB_HEAD (a)(a)->il.x.head_)
 break;

    del_first = a_end;

    a_end = PREV_INSN (del_first);
  }
else if (BARRIER_P (NEXT_INSN (a_end))(((enum rtx_code) (NEXT_INSN (a_end))->code) == BARRIER))
  del_first = NEXT_INSN (a_end);

/* Delete everything marked above as well as crap that might be
   hanging out between the two blocks.  */
BB_END (a)(a)->il.x.rtl->end_ = a_end;
BB_HEAD (b)(b)->il.x.head_ = b_empty ? NULLnullptr : b_head;
delete_insn_chain (del_first, del_last, true);

/* If not optimizing, preserve the locus of the single edge between
   blocks A and B if necessary by emitting a nop.  */
if (!optimizeglobal_options.x_optimize
    && !forward_edge_locus
    && !DECL_IGNORED_P (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 930, __FUNCTION__))->decl_common.ignored_flag))
  {
    emit_nop_for_unique_locus_between (a, b);
    a_end = BB_END (a)(a)->il.x.rtl->end_;
  }

/* Reassociate the insns of B with A.  */
if (!b_empty)
  {
    update_bb_for_insn_chain (a_end, b_debug_end, a);

    BB_END (a)(a)->il.x.rtl->end_ = b_debug_end;
    BB_HEAD (b)(b)->il.x.head_ = NULLnullptr;
  }
else if (b_end != b_debug_end)
  {
    /* Move any deleted labels and other notes between the end of A
and the debug insns that make up B after the debug insns,
bringing the debug insns into A while keeping the notes after
the end of A.  */
    if (NEXT_INSN (a_end) != b_debug_start)
reorder_insns_nobb (NEXT_INSN (a_end), PREV_INSN (b_debug_start),
	    b_debug_end);
    update_bb_for_insn_chain (b_debug_start, b_debug_end, a);
    BB_END (a)(a)->il.x.rtl->end_ = b_debug_end;
  }

df_bb_delete (b->index);

if (forward_edge_locus)
  EDGE_SUCC (b, 0)(*(b)->succs)[(0)]->goto_locus = EDGE_SUCC (a, 0)(*(a)->succs)[(0)]->goto_locus;

if (dump_file)
  fprintf (dump_file, "Merged blocks %d and %d.\n", a->index, b->index);
964}


967/* Return true when block A and B can be merged.  */

969static bool
970rtl_can_merge_blocks (basic_block a, basic_block b)
971{
/* If we are partitioning hot/cold basic blocks, we don't want to
   mess up unconditional or indirect jumps that cross between hot
   and cold sections.

   Basic block partitioning may result in some jumps that appear to
   be optimizable (or blocks that appear to be mergeable), but which really
   must be left untouched (they are required to make it safely across
   partition boundaries).  See  the comments at the top of
   bb-reorder.cc:partition_hot_cold_basic_blocks for complete details.  */

if (BB_PARTITION (a)((a)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_PARTITION (b)((b)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
  return false;

/* Protect the loop latches.  */
if (current_loops((cfun + 0)->x_current_loops) && b->loop_father->latch == b)
  return false;

/* There must be exactly one edge in between the blocks.  */
return (single_succ_p (a)
 && single_succ (a) == b
 && single_pred_p (b)
 && a != b
 /* Must be simple edge.  */
 && !(single_succ_edge (a)->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
))
 && a->next_bb == b
 && a != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
 && b != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
 /* If the jump insn has side effects,
    we can't kill the edge.  */
 && (!JUMP_P (BB_END (a))(((enum rtx_code) ((a)->il.x.rtl->end_)->code) == JUMP_INSN
)
     || (reload_completed
  ? simplejump_p (BB_END (a)(a)->il.x.rtl->end_) : onlyjump_p (BB_END (a)(a)->il.x.rtl->end_))));
1004}
1005
1006/* Return the label in the head of basic block BLOCK.  Create one if it doesn't
 exist.  */

1009rtx_code_label *
1010block_label (basic_block block)
1011{
if (block == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return NULLnullptr;

if (!LABEL_P (BB_HEAD (block))(((enum rtx_code) ((block)->il.x.head_)->code) == CODE_LABEL
))
  {
    BB_HEAD (block)(block)->il.x.head_ = emit_label_before (gen_label_rtx (), BB_HEAD (block)(block)->il.x.head_);
  }

return as_a <rtx_code_label *> (BB_HEAD (block)(block)->il.x.head_);
1021}

1023/* Remove all barriers from BB_FOOTER of a BB.  */

1025static void
1026remove_barriers_from_footer (basic_block bb)
1027{
rtx_insn *insn = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;

/* Remove barriers but keep jumptables.  */
while (insn)
  {
    if (BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
{
 if (PREV_INSN (insn))
   SET_NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
 else
   BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = NEXT_INSN (insn);
 if (NEXT_INSN (insn))
   SET_PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
}
    if (LABEL_P (insn)(((enum rtx_code) (insn)->code) == CODE_LABEL))
return;
    insn = NEXT_INSN (insn);
  }
1046}

1048/* Attempt to perform edge redirection by replacing possibly complex jump
 instruction by unconditional jump or removing jump completely.  This can
 apply only if all edges now point to the same block.  The parameters and
 return values are equivalent to redirect_edge_and_branch.  */

1053edge
1054try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
1055{
basic_block src = e->src;
rtx_insn *insn = BB_END (src)(src)->il.x.rtl->end_;
rtx set;
int fallthru = 0;

/* If we are partitioning hot/cold basic blocks, we don't want to
   mess up unconditional or indirect jumps that cross between hot
   and cold sections.

   Basic block partitioning may result in some jumps that appear to
   be optimizable (or blocks that appear to be mergeable), but which really
   must be left untouched (they are required to make it safely across
   partition boundaries).  See  the comments at the top of
   bb-reorder.cc:partition_hot_cold_basic_blocks for complete details.  */

if (BB_PARTITION (src)((src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_PARTITION (target)((target)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)))
  return NULLnullptr;

/* We can replace or remove a complex jump only when we have exactly
   two edges.  Also, if we have exactly one outgoing edge, we can
   redirect that.  */
if (EDGE_COUNT (src->succs)vec_safe_length (src->succs) >= 3
    /* Verify that all targets will be TARGET.  Specifically, the
edge that is not E must also go to TARGET.  */
    || (EDGE_COUNT (src->succs)vec_safe_length (src->succs) == 2
 && EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)(*(src)->succs)[((*(src)->succs)[(0)] == e)]->dest != target))
  return NULLnullptr;

if (!onlyjump_p (insn))
  return NULLnullptr;
if ((!optimizeglobal_options.x_optimize || reload_completed) && tablejump_p (insn, NULLnullptr, NULLnullptr))
  return NULLnullptr;

/* Avoid removing branch with side effects.  */
set = single_set (insn);
if (!set || side_effects_p (set))
  return NULLnullptr;

/* See if we can create the fallthru edge.  */
if (in_cfglayout || can_fallthru (src, target))
  {
    if (dump_file)
fprintf (dump_file, "Removing jump %i.\n", INSN_UID (insn));
    fallthru = 1;

    /* Selectively unlink whole insn chain.  */
    if (in_cfglayout)
{
 delete_insn_chain (insn, BB_END (src)(src)->il.x.rtl->end_, false);
 remove_barriers_from_footer (src);
}
    else
delete_insn_chain (insn, PREV_INSN (BB_HEAD (target)(target)->il.x.head_), false);
  }

/* If this already is simplejump, redirect it.  */
else if (simplejump_p (insn))
  {
    if (e->dest == target)
return NULLnullptr;
    if (dump_file)
fprintf (dump_file, "Redirecting jump %i from %i to %i.\n",
 INSN_UID (insn), e->dest->index, target->index);
    if (!redirect_jump (as_a <rtx_jump_insn *> (insn),
	  block_label (target), 0))
{
 gcc_assert (target == EXIT_BLOCK_PTR_FOR_FN (cfun))((void)(!(target == (((cfun + 0))->cfg->x_exit_block_ptr
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1122, __FUNCTION__), 0 : 0));
 return NULLnullptr;
}
  }

/* Cannot do anything for target exit block.  */
else if (target == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return NULLnullptr;

/* Or replace possibly complicated jump insn by simple jump insn.  */
else
  {
    rtx_code_label *target_label = block_label (target);
    rtx_insn *barrier;
    rtx_insn *label;
    rtx_jump_table_data *table;

    emit_jump_insn_after_noloc (targetm.gen_jump (target_label), insn);
    JUMP_LABEL (BB_END (src))((((src)->il.x.rtl->end_)->u.fld[7]).rt_rtx) = target_label;
    LABEL_NUSES (target_label)(((target_label)->u.fld[4]).rt_int)++;
    if (dump_file)
fprintf (dump_file, "Replacing insn %i by jump %i\n",
 INSN_UID (insn), INSN_UID (BB_END (src)(src)->il.x.rtl->end_));


    delete_insn_chain (insn, insn, false);

    /* Recognize a tablejump that we are converting to a
simple jump and remove its associated CODE_LABEL
and ADDR_VEC or ADDR_DIFF_VEC.  */
    if (tablejump_p (insn, &label, &table))
delete_insn_chain (label, table, false);

    barrier = next_nonnote_nondebug_insn (BB_END (src)(src)->il.x.rtl->end_);
    if (!barrier || !BARRIER_P (barrier)(((enum rtx_code) (barrier)->code) == BARRIER))
emit_barrier_after (BB_END (src)(src)->il.x.rtl->end_);
    else
{
 if (barrier != NEXT_INSN (BB_END (src)(src)->il.x.rtl->end_))
   {
     /* Move the jump before barrier so that the notes
 which originally were or were created before jump table are
 inside the basic block.  */
     rtx_insn *new_insn = BB_END (src)(src)->il.x.rtl->end_;

     update_bb_for_insn_chain (NEXT_INSN (BB_END (src)(src)->il.x.rtl->end_),
		        PREV_INSN (barrier), src);

     SET_NEXT_INSN (PREV_INSN (new_insn)) = NEXT_INSN (new_insn);
     SET_PREV_INSN (NEXT_INSN (new_insn)) = PREV_INSN (new_insn);

     SET_NEXT_INSN (new_insn) = barrier;
     SET_NEXT_INSN (PREV_INSN (barrier)) = new_insn;

     SET_PREV_INSN (new_insn) = PREV_INSN (barrier);
     SET_PREV_INSN (barrier) = new_insn;
   }
}
  }

/* Keep only one edge out and set proper flags.  */
if (!single_succ_p (src))
  remove_edge (e);
gcc_assert (single_succ_p (src))((void)(!(single_succ_p (src)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1185, __FUNCTION__), 0 : 0));

e = single_succ_edge (src);
if (fallthru)
  e->flags = EDGE_FALLTHRU;
else
  e->flags = 0;

e->probability = profile_probability::always ();

if (e->dest != target)
  redirect_edge_succ (e, target);
return e;
1198}

1200/* Subroutine of redirect_branch_edge that tries to patch the jump
 instruction INSN so that it reaches block NEW.  Do this
 only when it originally reached block OLD.  Return true if this
 worked or the original target wasn't OLD, return false if redirection
 doesn't work.  */

1206static bool
1207patch_jump_insn (rtx_insn *insn, rtx_insn *old_label, basic_block new_bb)
1208{
rtx_jump_table_data *table;
rtx tmp;
/* Recognize a tablejump and adjust all matching cases.  */
if (tablejump_p (insn, NULLnullptr, &table))
  {
    rtvec vec;
    int j;
    rtx_code_label *new_label = block_label (new_bb);

    if (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
return false;
    vec = table->get_labels ();

    for (j = GET_NUM_ELEM (vec)((vec)->num_elem) - 1; j >= 0; --j)
if (XEXP (RTVEC_ELT (vec, j), 0)(((((vec)->elem[j]))->u.fld[0]).rt_rtx) == old_label)
 {
   RTVEC_ELT (vec, j)((vec)->elem[j]) = gen_rtx_LABEL_REF (Pmode, new_label)gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((new_label)) );
   --LABEL_NUSES (old_label)(((old_label)->u.fld[4]).rt_int);
   ++LABEL_NUSES (new_label)(((new_label)->u.fld[4]).rt_int);
 }

    /* Handle casesi dispatch insns.  */
    if ((tmp = tablejump_casesi_pattern (insn)) != NULL_RTX(rtx) 0
 && label_ref_label (XEXP (SET_SRC (tmp), 2)((((((tmp)->u.fld[1]).rt_rtx))->u.fld[2]).rt_rtx)) == old_label)
{
 XEXP (SET_SRC (tmp), 2)((((((tmp)->u.fld[1]).rt_rtx))->u.fld[2]).rt_rtx) = gen_rtx_LABEL_REF (Pmode,gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((new_label)) )
				       new_label)gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((new_label)) );
 --LABEL_NUSES (old_label)(((old_label)->u.fld[4]).rt_int);
 ++LABEL_NUSES (new_label)(((new_label)->u.fld[4]).rt_int);
}
  }
else if ((tmp = extract_asm_operands (PATTERN (insn))) != NULLnullptr)
  {
    int i, n = ASM_OPERANDS_LABEL_LENGTH (tmp)(((((tmp)->u.fld[5]).rt_rtvec))->num_elem);
    rtx note;

    if (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
return false;
    rtx_code_label *new_label = block_label (new_bb);

    for (i = 0; i < n; ++i)
{
 rtx old_ref = ASM_OPERANDS_LABEL (tmp, i)(((((tmp)->u.fld[5]).rt_rtvec))->elem[i]);
 gcc_assert (GET_CODE (old_ref) == LABEL_REF)((void)(!(((enum rtx_code) (old_ref)->code) == LABEL_REF) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1252, __FUNCTION__), 0 : 0));
 if (XEXP (old_ref, 0)(((old_ref)->u.fld[0]).rt_rtx) == old_label)
   {
     ASM_OPERANDS_LABEL (tmp, i)(((((tmp)->u.fld[5]).rt_rtvec))->elem[i])
= gen_rtx_LABEL_REF (Pmode, new_label)gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((new_label)) );
     --LABEL_NUSES (old_label)(((old_label)->u.fld[4]).rt_int);
     ++LABEL_NUSES (new_label)(((new_label)->u.fld[4]).rt_int);
   }
}

    if (JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) == old_label)
{
 JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) = new_label;
 note = find_reg_note (insn, REG_LABEL_TARGET, new_label);
 if (note)
   remove_note (insn, note);
}
    else
{
 note = find_reg_note (insn, REG_LABEL_TARGET, old_label);
 if (note)
   remove_note (insn, note);
 if (JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) != new_label
     && !find_reg_note (insn, REG_LABEL_TARGET, new_label))
   add_reg_note (insn, REG_LABEL_TARGET, new_label);
}
    while ((note = find_reg_note (insn, REG_LABEL_OPERAND, old_label))
    != NULL_RTX(rtx) 0)
XEXP (note, 0)(((note)->u.fld[0]).rt_rtx) = new_label;
  }
else
  {
    /* ?? We may play the games with moving the named labels from
one basic block to the other in case only one computed_jump is
available.  */
    if (computed_jump_p (insn)
 /* A return instruction can't be redirected.  */
 || returnjump_p (insn))
return false;

    if (!currently_expanding_to_rtl || JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) == old_label)
{
 /* If the insn doesn't go where we think, we're confused.  */
 gcc_assert (JUMP_LABEL (insn) == old_label)((void)(!((((insn)->u.fld[7]).rt_rtx) == old_label) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1295, __FUNCTION__), 0 : 0));

 /* If the substitution doesn't succeed, die.  This can happen
    if the back end emitted unrecognizable instructions or if
    target is exit block on some arches.  Or for crossing
    jumps.  */
 if (!redirect_jump (as_a <rtx_jump_insn *> (insn),
	      block_label (new_bb), 0))
   {
     gcc_assert (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)((void)(!(new_bb == (((cfun + 0))->cfg->x_exit_block_ptr
) || (__extension__ ({ __typeof ((insn)) const _rtx = ((insn)
); if (((enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag
 ("CROSSING_JUMP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1305, __FUNCTION__); _rtx; })->jump)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1305, __FUNCTION__), 0 : 0))
	  || CROSSING_JUMP_P (insn))((void)(!(new_bb == (((cfun + 0))->cfg->x_exit_block_ptr
) || (__extension__ ({ __typeof ((insn)) const _rtx = ((insn)
); if (((enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag
 ("CROSSING_JUMP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1305, __FUNCTION__); _rtx; })->jump)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1305, __FUNCTION__), 0 : 0));
     return false;
   }
}
  }
return true;
1311}


1314/* Redirect edge representing branch of (un)conditional jump or tablejump,
 NULL on failure  */
1316static edge
1317redirect_branch_edge (edge e, basic_block target)
1318{
rtx_insn *old_label = BB_HEAD (e->dest)(e->dest)->il.x.head_;
basic_block src = e->src;
rtx_insn *insn = BB_END (src)(src)->il.x.rtl->end_;

/* We can only redirect non-fallthru edges of jump insn.  */
if (e->flags & EDGE_FALLTHRU)
  return NULLnullptr;
else if (!JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN) && !currently_expanding_to_rtl)
  return NULLnullptr;

if (!currently_expanding_to_rtl)
  {
    if (!patch_jump_insn (as_a <rtx_jump_insn *> (insn), old_label, target))
return NULLnullptr;
  }
else
  /* When expanding this BB might actually contain multiple
     jumps (i.e. not yet split by find_many_sub_basic_blocks).
     Redirect all of those that match our label.  */
  FOR_BB_INSNS (src, insn)for ((insn) = (src)->il.x.head_; (insn) && (insn) !=
 NEXT_INSN ((src)->il.x.rtl->end_); (insn) = NEXT_INSN (
insn))
    if (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN) && !patch_jump_insn (as_a <rtx_jump_insn *> (insn),
			     old_label, target))
return NULLnullptr;

if (dump_file)
  fprintf (dump_file, "Edge %i->%i redirected to %i\n",
    e->src->index, e->dest->index, target->index);

if (e->dest != target)
  e = redirect_edge_succ_nodup (e, target);

return e;
1351}

1353/* Called when edge E has been redirected to a new destination,
 in order to update the region crossing flag on the edge and
 jump.  */

1357static void
1358fixup_partition_crossing (edge e)
1359{
if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr) || e->dest
    == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return;
/* If we redirected an existing edge, it may already be marked
   crossing, even though the new src is missing a reg crossing note.
   But make sure reg crossing note doesn't already exist before
   inserting.  */
if (BB_PARTITION (e->src)((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)) != BB_PARTITION (e->dest)((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)))
  {
    e->flags |= EDGE_CROSSING;
    if (JUMP_P (BB_END (e->src))(((enum rtx_code) ((e->src)->il.x.rtl->end_)->code
) == JUMP_INSN))
CROSSING_JUMP_P (BB_END (e->src))(__extension__ ({ __typeof (((e->src)->il.x.rtl->end_
)) const _rtx = (((e->src)->il.x.rtl->end_)); if (((
enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag
 ("CROSSING_JUMP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1371, __FUNCTION__); _rtx; })->jump) = 1;
  }
else if (BB_PARTITION (e->src)((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)) == BB_PARTITION (e->dest)((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)))
  {
    e->flags &= ~EDGE_CROSSING;
    /* Remove the section crossing note from jump at end of
       src if it exists, and if no other successors are
       still crossing.  */
    if (JUMP_P (BB_END (e->src))(((enum rtx_code) ((e->src)->il.x.rtl->end_)->code
) == JUMP_INSN) && CROSSING_JUMP_P (BB_END (e->src))(__extension__ ({ __typeof (((e->src)->il.x.rtl->end_
)) const _rtx = (((e->src)->il.x.rtl->end_)); if (((
enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag
 ("CROSSING_JUMP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1379, __FUNCTION__); _rtx; })->jump))
      {
        bool has_crossing_succ = false;
        edge e2;
        edge_iterator ei;
        FOR_EACH_EDGE (e2, ei, e->src->succs)for ((ei) = ei_start_1 (&((e->src->succs))); ei_cond
 ((ei), &(e2)); ei_next (&(ei)))
          {
            has_crossing_succ |= (e2->flags & EDGE_CROSSING);
            if (has_crossing_succ)
              break;
          }
        if (!has_crossing_succ)
   CROSSING_JUMP_P (BB_END (e->src))(__extension__ ({ __typeof (((e->src)->il.x.rtl->end_
)) const _rtx = (((e->src)->il.x.rtl->end_)); if (((
enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag
 ("CROSSING_JUMP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1391, __FUNCTION__); _rtx; })->jump) = 0;
      }
  }
1394}

1396/* Called when block BB has been reassigned to the cold partition,
 because it is now dominated by another cold block,
 to ensure that the region crossing attributes are updated.  */

1400static void
1401fixup_new_cold_bb (basic_block bb)
1402{
edge e;
edge_iterator ei;

/* This is called when a hot bb is found to now be dominated
   by a cold bb and therefore needs to become cold. Therefore,
   its preds will no longer be region crossing. Any non-dominating
   preds that were previously hot would also have become cold
   in the caller for the same region. Any preds that were previously
   region-crossing will be adjusted in fixup_partition_crossing.  */
FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
  {
    fixup_partition_crossing (e);
  }

/* Possibly need to make bb's successor edges region crossing,
   or remove stale region crossing.  */
FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
  {
    /* We can't have fall-through edges across partition boundaries.
       Note that force_nonfallthru will do any necessary partition
       boundary fixup by calling fixup_partition_crossing itself.  */
    if ((e->flags & EDGE_FALLTHRU)
        && BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_PARTITION (e->dest)((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
))
 && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
      force_nonfallthru (e);
    else
      fixup_partition_crossing (e);
  }
1431}

1433/* Attempt to change code to redirect edge E to TARGET.  Don't do that on
 expense of adding new instructions or reordering basic blocks.

 Function can be also called with edge destination equivalent to the TARGET.
 Then it should try the simplifications and do nothing if none is possible.

 Return edge representing the branch if transformation succeeded.  Return NULL
 on failure.
 We still return NULL in case E already destinated TARGET and we didn't
 managed to simplify instruction stream.  */

1444static edge
1445rtl_redirect_edge_and_branch (edge e, basic_block target)
1446{
edge ret;
basic_block src = e->src;
basic_block dest = e->dest;

if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
  return NULLnullptr;

if (dest == target)
  return e;

if ((ret = try_redirect_by_replacing_jump (e, target, false)) != NULLnullptr)
  {
    df_set_bb_dirty (src);
    fixup_partition_crossing (ret);
    return ret;
  }

ret = redirect_branch_edge (e, target);
if (!ret)
  return NULLnullptr;

df_set_bb_dirty (src);
fixup_partition_crossing (ret);
return ret;
1471}

1473/* Emit a barrier after BB, into the footer if we are in CFGLAYOUT mode.  */

1475void
1476emit_barrier_after_bb (basic_block bb)
1477{
rtx_barrier *barrier = emit_barrier_after (BB_END (bb)(bb)->il.x.rtl->end_);
gcc_assert (current_ir_type () == IR_RTL_CFGRTL((void)(!(current_ir_type () == IR_RTL_CFGRTL || current_ir_type
 () == IR_RTL_CFGLAYOUT) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1480, __FUNCTION__), 0 : 0))
            || current_ir_type () == IR_RTL_CFGLAYOUT)((void)(!(current_ir_type () == IR_RTL_CFGRTL || current_ir_type
 () == IR_RTL_CFGLAYOUT) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1480, __FUNCTION__), 0 : 0));
if (current_ir_type () == IR_RTL_CFGLAYOUT)
  {
    rtx_insn *insn = unlink_insn_chain (barrier, barrier);

    if (BB_FOOTER (bb)(bb)->il.x.rtl->footer_)
{
        rtx_insn *footer_tail = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;

        while (NEXT_INSN (footer_tail))
          footer_tail = NEXT_INSN (footer_tail);
        if (!BARRIER_P (footer_tail)(((enum rtx_code) (footer_tail)->code) == BARRIER))
          {
            SET_NEXT_INSN (footer_tail) = insn;
            SET_PREV_INSN (insn) = footer_tail;
          }
}
    else
      BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = insn;
  }
1500}

1502/* Like force_nonfallthru below, but additionally performs redirection
 Used by redirect_edge_and_branch_force.  JUMP_LABEL is used only
 when redirecting to the EXIT_BLOCK, it is either ret_rtx or
 simple_return_rtx, indicating which kind of returnjump to create.
 It should be NULL otherwise.  */

1508basic_block
1509force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
1510{
basic_block jump_block, new_bb = NULLnullptr, src = e->src;
rtx note;
edge new_edge;
int abnormal_edge_flags = 0;
bool asm_goto_edge = false;
int loc;

/* In the case the last instruction is conditional jump to the next
   instruction, first redirect the jump itself and then continue
   by creating a basic block afterwards to redirect fallthru edge.  */
if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
    && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
    && any_condjump_p (BB_END (e->src)(e->src)->il.x.rtl->end_)
    && JUMP_LABEL (BB_END (e->src))((((e->src)->il.x.rtl->end_)->u.fld[7]).rt_rtx) == BB_HEAD (e->dest)(e->dest)->il.x.head_)
  {
    rtx note;
    edge b = unchecked_make_edge (e->src, target, 0);
    bool redirected;

    redirected = redirect_jump (as_a <rtx_jump_insn *> (BB_END (e->src)(e->src)->il.x.rtl->end_),
		  block_label (target), 0);
    gcc_assert (redirected)((void)(!(redirected) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1532, __FUNCTION__), 0 : 0));

    note = find_reg_note (BB_END (e->src)(e->src)->il.x.rtl->end_, REG_BR_PROB, NULL_RTX(rtx) 0);
    if (note)
{
 int prob = XINT (note, 0)(((note)->u.fld[0]).rt_int);

 b->probability = profile_probability::from_reg_br_prob_note (prob);
 e->probability -= e->probability;
}
  }

if (e->flags & EDGE_ABNORMAL)
  {
    /* Irritating special case - fallthru edge to the same block as abnormal
edge.
We can't redirect abnormal edge, but we still can split the fallthru
one and create separate abnormal edge to original destination.
This allows bb-reorder to make such edge non-fallthru.  */
    gcc_assert (e->dest == target)((void)(!(e->dest == target) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1551, __FUNCTION__), 0 : 0));
    abnormal_edge_flags = e->flags & ~EDGE_FALLTHRU;
    e->flags &= EDGE_FALLTHRU;
  }
else
  {
    gcc_assert (e->flags & EDGE_FALLTHRU)((void)(!(e->flags & EDGE_FALLTHRU) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1557, __FUNCTION__), 0 : 0));
    if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
{
 /* We can't redirect the entry block.  Create an empty block
    at the start of the function which we use to add the new
    jump.  */
 edge tmp;
 edge_iterator ei;
 bool found = false;

 basic_block bb = create_basic_block (BB_HEAD (e->dest)(e->dest)->il.x.head_, NULLnullptr,
			       ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));
 bb->count = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count;

 /* Make sure new block ends up in correct hot/cold section.  */
 BB_COPY_PARTITION (bb, e->dest)do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags &
 ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((e->dest)->
flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while (
0);

 /* Change the existing edge's source to be the new block, and add
    a new edge from the entry block to the new block.  */
 e->src = bb;
 for (ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)ei_start_1 (&((((cfun + 0))->cfg->x_entry_block_ptr
)->succs));
      (tmp = ei_safe_edge (ei)); )
   {
     if (tmp == e)
{
  ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->succs->unordered_remove (ei.index);
  found = true;
  break;
}
     else
ei_next (&ei);
   }

 gcc_assert (found)((void)(!(found) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1590, __FUNCTION__), 0 : 0));

 vec_safe_push (bb->succs, e);
 make_single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr), bb,
		 EDGE_FALLTHRU);
}
  }

/* If e->src ends with asm goto, see if any of the ASM_OPERANDS_LABELs
   don't point to the target or fallthru label.  */
if (JUMP_P (BB_END (e->src))(((enum rtx_code) ((e->src)->il.x.rtl->end_)->code
) == JUMP_INSN)
    && target != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
    && (e->flags & EDGE_FALLTHRU)
    && (note = extract_asm_operands (PATTERN (BB_END (e->src)(e->src)->il.x.rtl->end_))))
  {
    int i, n = ASM_OPERANDS_LABEL_LENGTH (note)(((((note)->u.fld[5]).rt_rtvec))->num_elem);
    bool adjust_jump_target = false;

    for (i = 0; i < n; ++i)
{
 if (XEXP (ASM_OPERANDS_LABEL (note, i), 0)((((((((note)->u.fld[5]).rt_rtvec))->elem[i]))->u.fld
[0]).rt_rtx) == BB_HEAD (e->dest)(e->dest)->il.x.head_)
   {
     LABEL_NUSES (XEXP (ASM_OPERANDS_LABEL (note, i), 0))(((((((((((note)->u.fld[5]).rt_rtvec))->elem[i]))->u
.fld[0]).rt_rtx))->u.fld[4]).rt_int)--;
     XEXP (ASM_OPERANDS_LABEL (note, i), 0)((((((((note)->u.fld[5]).rt_rtvec))->elem[i]))->u.fld
[0]).rt_rtx) = block_label (target);
     LABEL_NUSES (XEXP (ASM_OPERANDS_LABEL (note, i), 0))(((((((((((note)->u.fld[5]).rt_rtvec))->elem[i]))->u
.fld[0]).rt_rtx))->u.fld[4]).rt_int)++;
     adjust_jump_target = true;
   }
 if (XEXP (ASM_OPERANDS_LABEL (note, i), 0)((((((((note)->u.fld[5]).rt_rtvec))->elem[i]))->u.fld
[0]).rt_rtx) == BB_HEAD (target)(target)->il.x.head_)
   asm_goto_edge = true;
}
    if (adjust_jump_target)
{
 rtx_insn *insn = BB_END (e->src)(e->src)->il.x.rtl->end_;
 rtx note;
 rtx_insn *old_label = BB_HEAD (e->dest)(e->dest)->il.x.head_;
 rtx_insn *new_label = BB_HEAD (target)(target)->il.x.head_;

 if (JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) == old_label)
   {
     JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) = new_label;
     note = find_reg_note (insn, REG_LABEL_TARGET, new_label);
     if (note)
remove_note (insn, note);
   }
 else
   {
     note = find_reg_note (insn, REG_LABEL_TARGET, old_label);
     if (note)
remove_note (insn, note);
     if (JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) != new_label
  && !find_reg_note (insn, REG_LABEL_TARGET, new_label))
add_reg_note (insn, REG_LABEL_TARGET, new_label);
   }
 while ((note = find_reg_note (insn, REG_LABEL_OPERAND, old_label))
 != NULL_RTX(rtx) 0)
   XEXP (note, 0)(((note)->u.fld[0]).rt_rtx) = new_label;
}
  }

if (EDGE_COUNT (e->src->succs)vec_safe_length (e->src->succs) >= 2 || abnormal_edge_flags || asm_goto_edge)
  {
    rtx_insn *new_head;
    profile_count count = e->count ();
    profile_probability probability = e->probability;
    /* Create the new structures.  */

    /* If the old block ended with a tablejump, skip its table
by searching forward from there.  Otherwise start searching
forward from the last instruction of the old block.  */
    rtx_jump_table_data *table;
    if (tablejump_p (BB_END (e->src)(e->src)->il.x.rtl->end_, NULLnullptr, &table))
new_head = table;
    else
new_head = BB_END (e->src)(e->src)->il.x.rtl->end_;
    new_head = NEXT_INSN (new_head);

    jump_block = create_basic_block (new_head, NULLnullptr, e->src);
    jump_block->count = count;

    /* Make sure new block ends up in correct hot/cold section.  */

    BB_COPY_PARTITION (jump_block, e->src)do { basic_block bb_ = (jump_block); bb_->flags = ((bb_->
flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((e->
src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))));
 } while (0);

    /* Wire edge in.  */
    new_edge = make_edge (e->src, jump_block, EDGE_FALLTHRU);
    new_edge->probability = probability;

    /* Redirect old edge.  */
    redirect_edge_pred (e, jump_block);
    e->probability = profile_probability::always ();

    /* If e->src was previously region crossing, it no longer is
       and the reg crossing note should be removed.  */
    fixup_partition_crossing (new_edge);

    /* If asm goto has any label refs to target's label,
add also edge from asm goto bb to target.  */
    if (asm_goto_edge)
{
 new_edge->probability /= 2;
 jump_block->count /= 2;
 edge new_edge2 = make_edge (new_edge->src, target,
		      e->flags & ~EDGE_FALLTHRU);
 new_edge2->probability = probability - new_edge->probability;
}

    new_bb = jump_block;
  }
else
  jump_block = e->src;

loc = e->goto_locus;
e->flags &= ~EDGE_FALLTHRU;
if (target == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  {
    if (jump_label == ret_rtx)
emit_jump_insn_after_setloc (targetm.gen_return (),
		     BB_END (jump_block)(jump_block)->il.x.rtl->end_, loc);
    else
{
 gcc_assert (jump_label == simple_return_rtx)((void)(!(jump_label == simple_return_rtx) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1710, __FUNCTION__), 0 : 0));
 emit_jump_insn_after_setloc (targetm.gen_simple_return (),
		       BB_END (jump_block)(jump_block)->il.x.rtl->end_, loc);
}
    set_return_jump_label (BB_END (jump_block)(jump_block)->il.x.rtl->end_);
  }
else
  {
    rtx_code_label *label = block_label (target);
    emit_jump_insn_after_setloc (targetm.gen_jump (label),
		   BB_END (jump_block)(jump_block)->il.x.rtl->end_, loc);
    JUMP_LABEL (BB_END (jump_block))((((jump_block)->il.x.rtl->end_)->u.fld[7]).rt_rtx) = label;
    LABEL_NUSES (label)(((label)->u.fld[4]).rt_int)++;
  }

/* We might be in cfg layout mode, and if so, the following routine will
   insert the barrier correctly.  */
emit_barrier_after_bb (jump_block);
redirect_edge_succ_nodup (e, target);

if (abnormal_edge_flags)
  make_edge (src, target, abnormal_edge_flags);

df_mark_solutions_dirty ();
fixup_partition_crossing (e);
return new_bb;
1736}

1738/* Edge E is assumed to be fallthru edge.  Emit needed jump instruction
 (and possibly create new basic block) to make edge non-fallthru.
 Return newly created BB or NULL if none.  */

1742static basic_block
1743rtl_force_nonfallthru (edge e)
1744{
return force_nonfallthru_and_redirect (e, e->dest, NULL_RTX(rtx) 0);
1746}

1748/* Redirect edge even at the expense of creating new jump insn or
 basic block.  Return new basic block if created, NULL otherwise.
 Conversion must be possible.  */

1752static basic_block
1753rtl_redirect_edge_and_branch_force (edge e, basic_block target)
1754{
if (redirect_edge_and_branch (e, target)
    || e->dest == target)
  return NULLnullptr;

/* In case the edge redirection failed, try to force it to be non-fallthru
   and redirect newly created simplejump.  */
df_set_bb_dirty (e->src);
return force_nonfallthru_and_redirect (e, target, NULL_RTX(rtx) 0);
1763}

1765/* The given edge should potentially be a fallthru edge.  If that is in
 fact true, delete the jump and barriers that are in the way.  */

1768static void
1769rtl_tidy_fallthru_edge (edge e)
1770{
rtx_insn *q;
basic_block b = e->src, c = b->next_bb;

/* ??? In a late-running flow pass, other folks may have deleted basic
   blocks by nopping out blocks, leaving multiple BARRIERs between here
   and the target label. They ought to be chastised and fixed.

   We can also wind up with a sequence of undeletable labels between
   one block and the next.

   So search through a sequence of barriers, labels, and notes for
   the head of block C and assert that we really do fall through.  */

for (q = NEXT_INSN (BB_END (b)(b)->il.x.rtl->end_); q != BB_HEAD (c)(c)->il.x.head_; q = NEXT_INSN (q))
  if (NONDEBUG_INSN_P (q)((((enum rtx_code) (q)->code) == INSN) || (((enum rtx_code
) (q)->code) == JUMP_INSN) || (((enum rtx_code) (q)->code
) == CALL_INSN)))
    return;

/* Remove what will soon cease being the jump insn from the source block.
   If block B consisted only of this single jump, turn it into a deleted
   note.  */
q = BB_END (b)(b)->il.x.rtl->end_;
if (JUMP_P (q)(((enum rtx_code) (q)->code) == JUMP_INSN)
    && onlyjump_p (q)
    && (any_uncondjump_p (q)
 || single_succ_p (b)))
  {
    rtx_insn *label;
    rtx_jump_table_data *table;

    if (tablejump_p (q, &label, &table))
{
 /* The label is likely mentioned in some instruction before
    the tablejump and might not be DCEd, so turn it into
    a note instead and move before the tablejump that is going to
    be deleted.  */
 const char *name = LABEL_NAME (label)(((label)->u.fld[6]).rt_str);
 PUT_CODE (label, NOTE)((label)->code = (NOTE));
 NOTE_KIND (label)(((label)->u.fld[4]).rt_int) = NOTE_INSN_DELETED_LABEL;
 NOTE_DELETED_LABEL_NAME (label)(((label)->u.fld[3]).rt_str) = name;
 reorder_insns (label, label, PREV_INSN (q));
 delete_insn (table);
}

    q = PREV_INSN (q);
  }
/* Unconditional jumps with side-effects (i.e. which we can't just delete
   together with the barrier) should never have a fallthru edge.  */
else if (JUMP_P (q)(((enum rtx_code) (q)->code) == JUMP_INSN) && any_uncondjump_p (q))
  return;

/* Selectively unlink the sequence.  */
if (q != PREV_INSN (BB_HEAD (c)(c)->il.x.head_))
  delete_insn_chain (NEXT_INSN (q), PREV_INSN (BB_HEAD (c)(c)->il.x.head_), false);

e->flags |= EDGE_FALLTHRU;
1826}
1827
1828/* Should move basic block BB after basic block AFTER.  NIY.  */

1830static bool
1831rtl_move_block_after (basic_block bb ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
      basic_block after ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1833{
return false;
1835}

1837/* Locate the last bb in the same partition as START_BB.  */

1839static basic_block
1840last_bb_in_partition (basic_block start_bb)
1841{
basic_block bb;
FOR_BB_BETWEEN (bb, start_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)for (bb = start_bb; bb != (((cfun + 0))->cfg->x_exit_block_ptr
); bb = bb->next_bb)
  {
    if (BB_PARTITION (start_bb)((start_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)) != BB_PARTITION (bb->next_bb)((bb->next_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)))
      return bb;
  }
/* Return bb before the exit block.  */
return bb->prev_bb;
1850}

1852/* Split a (typically critical) edge.  Return the new block.
 The edge must not be abnormal.

 ??? The code generally expects to be called on critical edges.
 The case of a block ending in an unconditional jump to a
 block with multiple predecessors is not handled optimally.  */

1859static basic_block
1860rtl_split_edge (edge edge_in)
1861{
basic_block bb, new_bb;
rtx_insn *before;

/* Abnormal edges cannot be split.  */
gcc_assert (!(edge_in->flags & EDGE_ABNORMAL))((void)(!(!(edge_in->flags & EDGE_ABNORMAL)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1866, __FUNCTION__), 0 : 0));

/* We are going to place the new block in front of edge destination.
   Avoid existence of fallthru predecessors.  */
if ((edge_in->flags & EDGE_FALLTHRU) == 0)
  {
    edge e = find_fallthru_edge (edge_in->dest->preds);

    if (e)
force_nonfallthru (e);
  }

/* Create the basic block note.  */
if (edge_in->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  before = BB_HEAD (edge_in->dest)(edge_in->dest)->il.x.head_;
else
  before = NULLnullptr;

/* If this is a fall through edge to the exit block, the blocks might be
   not adjacent, and the right place is after the source.  */
if ((edge_in->flags & EDGE_FALLTHRU)
    && edge_in->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  {
    before = NEXT_INSN (BB_END (edge_in->src)(edge_in->src)->il.x.rtl->end_);
    bb = create_basic_block (before, NULLnullptr, edge_in->src);
    BB_COPY_PARTITION (bb, edge_in->src)do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags &
 ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((edge_in->src)
->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while
 (0);
  }
else
  {
    if (edge_in->src == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
      {
        bb = create_basic_block (before, NULLnullptr, edge_in->dest->prev_bb);
        BB_COPY_PARTITION (bb, edge_in->dest)do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags &
 ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((edge_in->dest
)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while
 (0);
      }
    else
      {
        basic_block after = edge_in->dest->prev_bb;
        /* If this is post-bb reordering, and the edge crosses a partition
           boundary, the new block needs to be inserted in the bb chain
           at the end of the src partition (since we put the new bb into
           that partition, see below). Otherwise we may end up creating
           an extra partition crossing in the chain, which is illegal.
           It can't go after the src, because src may have a fall-through
           to a different block.  */
        if (crtl(&x_rtl)->bb_reorder_complete
            && (edge_in->flags & EDGE_CROSSING))
          {
            after = last_bb_in_partition (edge_in->src);
            before = get_last_bb_insn (after);
            /* The instruction following the last bb in partition should
               be a barrier, since it cannot end in a fall-through.  */
            gcc_checking_assert (BARRIER_P (before))((void)(!((((enum rtx_code) (before)->code) == BARRIER)) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1917, __FUNCTION__), 0 : 0));
            before = NEXT_INSN (before);
          }
        bb = create_basic_block (before, NULLnullptr, after);
        /* Put the split bb into the src partition, to avoid creating
           a situation where a cold bb dominates a hot bb, in the case
           where src is cold and dest is hot. The src will dominate
           the new bb (whereas it might not have dominated dest).  */
        BB_COPY_PARTITION (bb, edge_in->src)do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags &
 ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((edge_in->src)
->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while
 (0);
      }
  }

make_single_succ_edge (bb, edge_in->dest, EDGE_FALLTHRU);

/* Can't allow a region crossing edge to be fallthrough.  */
if (BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_PARTITION (edge_in->dest)((edge_in->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
))
    && edge_in->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  {
    new_bb = force_nonfallthru (single_succ_edge (bb));
    gcc_assert (!new_bb)((void)(!(!new_bb) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1936, __FUNCTION__), 0 : 0));
  }

/* For non-fallthru edges, we must adjust the predecessor's
   jump instruction to target our new block.  */
if ((edge_in->flags & EDGE_FALLTHRU) == 0)
  {
    edge redirected = redirect_edge_and_branch (edge_in, bb);
    gcc_assert (redirected)((void)(!(redirected) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1944, __FUNCTION__), 0 : 0));
  }
else
  {
    if (edge_in->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
{
 /* For asm goto even splitting of fallthru edge might
    need insn patching, as other labels might point to the
    old label.  */
 rtx_insn *last = BB_END (edge_in->src)(edge_in->src)->il.x.rtl->end_;
 if (last
     && JUMP_P (last)(((enum rtx_code) (last)->code) == JUMP_INSN)
     && edge_in->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
     && (extract_asm_operands (PATTERN (last))
  || JUMP_LABEL (last)(((last)->u.fld[7]).rt_rtx) == before)
     && patch_jump_insn (last, before, bb))
   df_set_bb_dirty (edge_in->src);
}
    redirect_edge_succ (edge_in, bb);
  }

return bb;
1966}

1968/* Queue instructions for insertion on an edge between two basic blocks.
 The new instructions and basic blocks (if any) will not appear in the
 CFG until commit_edge_insertions is called.  */

1972void
1973insert_insn_on_edge (rtx pattern, edge e)
1974{
/* We cannot insert instructions on an abnormal critical edge.
   It will be easier to find the culprit if we die now.  */
gcc_assert (!((e->flags & EDGE_ABNORMAL) && EDGE_CRITICAL_P (e)))((void)(!(!((e->flags & EDGE_ABNORMAL) && (vec_safe_length
 ((e)->src->succs) >= 2 && vec_safe_length (
(e)->dest->preds) >= 2))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 1977, __FUNCTION__), 0 : 0));

if (e->insns.r == NULL_RTX(rtx) 0)
  start_sequence ();
else
  push_to_sequence (e->insns.r);

emit_insn (pattern);

e->insns.r = get_insns ();
end_sequence ();
1988}

1990/* Update the CFG for the instructions queued on edge E.  */

1992void
1993commit_one_edge_insertion (edge e)
1994{
rtx_insn *before = NULLnullptr, *after = NULLnullptr, *insns, *tmp, *last;
basic_block bb;

/* Pull the insns off the edge now since the edge might go away.  */
insns = e->insns.r;
e->insns.r = NULLnullptr;

/* Figure out where to put these insns.  If the destination has
   one predecessor, insert there.  Except for the exit block.  */
if (single_pred_p (e->dest) && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  {
    bb = e->dest;

    /* Get the location correct wrt a code label, and "nice" wrt
a basic block note, and before everything else.  */
    tmp = BB_HEAD (bb)(bb)->il.x.head_;
    if (LABEL_P (tmp)(((enum rtx_code) (tmp)->code) == CODE_LABEL))
tmp = NEXT_INSN (tmp);
    if (NOTE_INSN_BASIC_BLOCK_P (tmp)((((enum rtx_code) (tmp)->code) == NOTE) && (((tmp
)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK))
tmp = NEXT_INSN (tmp);
    if (tmp == BB_HEAD (bb)(bb)->il.x.head_)
before = tmp;
    else if (tmp)
after = PREV_INSN (tmp);
    else
after = get_last_insn ();
  }

/* If the source has one successor and the edge is not abnormal,
   insert there.  Except for the entry block.
   Don't do this if the predecessor ends in a jump other than
   unconditional simple jump.  E.g. for asm goto that points all
   its labels at the fallthru basic block, we can't insert instructions
   before the asm goto, as the asm goto can have various of side effects,
   and can't emit instructions after the asm goto, as it must end
   the basic block.  */
else if ((e->flags & EDGE_ABNORMAL) == 0
  && single_succ_p (e->src)
  && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
  && (!JUMP_P (BB_END (e->src))(((enum rtx_code) ((e->src)->il.x.rtl->end_)->code
) == JUMP_INSN)
      || simplejump_p (BB_END (e->src)(e->src)->il.x.rtl->end_)))
  {
    bb = e->src;

    /* It is possible to have a non-simple jump here.  Consider a target
where some forms of unconditional jumps clobber a register.  This
happens on the fr30 for example.

We know this block has a single successor, so we can just emit
the queued insns before the jump.  */
    if (JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
))
before = BB_END (bb)(bb)->il.x.rtl->end_;
    else
{
 /* We'd better be fallthru, or we've lost track of what's what.  */
 gcc_assert (e->flags & EDGE_FALLTHRU)((void)(!(e->flags & EDGE_FALLTHRU) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2050, __FUNCTION__), 0 : 0));

 after = BB_END (bb)(bb)->il.x.rtl->end_;
}
  }

/* Otherwise we must split the edge.  */
else
  {
    bb = split_edge (e);

    /* If E crossed a partition boundary, we needed to make bb end in
       a region-crossing jump, even though it was originally fallthru.  */
    if (JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
))
before = BB_END (bb)(bb)->il.x.rtl->end_;
    else
      after = BB_END (bb)(bb)->il.x.rtl->end_;
  }

/* Now that we've found the spot, do the insertion.  */
if (before)
  {
    emit_insn_before_noloc (insns, before, bb);
    last = prev_nonnote_insn (before);
  }
else
  last = emit_insn_after_noloc (insns, after, bb);

if (returnjump_p (last))
  {
    /* ??? Remove all outgoing edges from BB and add one for EXIT.
This is not currently a problem because this only happens
for the (single) epilogue, which already has a fallthru edge
to EXIT.  */

    e = single_succ_edge (bb);
    gcc_assert (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)((void)(!(e->dest == (((cfun + 0))->cfg->x_exit_block_ptr
) && single_succ_p (bb) && (e->flags &
 EDGE_FALLTHRU)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2087, __FUNCTION__), 0 : 0))
  && single_succ_p (bb) && (e->flags & EDGE_FALLTHRU))((void)(!(e->dest == (((cfun + 0))->cfg->x_exit_block_ptr
) && single_succ_p (bb) && (e->flags &
 EDGE_FALLTHRU)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2087, __FUNCTION__), 0 : 0));

    e->flags &= ~EDGE_FALLTHRU;
    emit_barrier_after (last);

    if (before)
delete_insn (before);
  }
else
  gcc_assert (!JUMP_P (last))((void)(!(!(((enum rtx_code) (last)->code) == JUMP_INSN)) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2096, __FUNCTION__), 0 : 0));
2097}

2099/* Update the CFG for all queued instructions.  */

2101void
2102commit_edge_insertions (void)
2103{
basic_block bb;

/* Optimization passes that invoke this routine can cause hot blocks
   previously reached by both hot and cold blocks to become dominated only
   by cold blocks. This will cause the verification below to fail,
   and lead to now cold code in the hot section. In some cases this
   may only be visible after newly unreachable blocks are deleted,
   which will be done by fixup_partitions.  */
fixup_partitions ();

if (!currently_expanding_to_rtl)
  checking_verify_flow_info ();

FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb !=
 (((cfun + 0))->cfg->x_exit_block_ptr); bb = bb->next_bb
)
  EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb !=
 (((cfun + 0))->cfg->x_exit_block_ptr); bb = bb->next_bb
)
  {
    edge e;
    edge_iterator ei;

    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
if (e->insns.r)
 {
   if (currently_expanding_to_rtl)
     rebuild_jump_labels_chain (e->insns.r);
   commit_one_edge_insertion (e);
 }
  }
2131}
2132

2134/* Print out RTL-specific basic block information (live information
 at start and end with TDF_DETAILS).  FLAGS are the TDF_* masks
 documented in dumpfile.h.  */

2138static void
2139rtl_dump_bb (FILE *outf, basic_block bb, int indent, dump_flags_t flags)
2140{
char *s_indent;

s_indent = (char *) alloca ((size_t) indent + 1)__builtin_alloca((size_t) indent + 1);
memset (s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';

if (df && (flags & TDF_DETAILS))
  {
    df_dump_top (bb, outf);
    putc ('\n', outf);
  }

if (bb->index != ENTRY_BLOCK(0) && bb->index != EXIT_BLOCK(1)
    && rtl_bb_info_initialized_p (bb))
  {
    rtx_insn *last = BB_END (bb)(bb)->il.x.rtl->end_;
    if (last)
last = NEXT_INSN (last);
    for (rtx_insn *insn = BB_HEAD (bb)(bb)->il.x.head_; insn != last; insn = NEXT_INSN (insn))
{
 if (flags & TDF_DETAILS)
   df_dump_insn_top (insn, outf);
 if (! (flags & TDF_SLIM))
   print_rtl_single (outf, insn);
 else
   dump_insn_slim (outf, insn);
 if (flags & TDF_DETAILS)
   df_dump_insn_bottom (insn, outf);
}
  }

if (df && (flags & TDF_DETAILS))
  {
    df_dump_bottom (bb, outf);
    putc ('\n', outf);
  }

2178}
2179
2180/* Like dump_function_to_file, but for RTL.  Print out dataflow information
 for the start of each basic block.  FLAGS are the TDF_* masks documented
 in dumpfile.h.  */

2184void
2185print_rtl_with_bb (FILE *outf, const rtx_insn *rtx_first, dump_flags_t flags)
2186{
const rtx_insn *tmp_rtx;
if (rtx_first == 0)
  fprintf (outf, "(nil)\n");
else
  {
    enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB };
    int max_uid = get_max_uid ();
    basic_block *start = XCNEWVEC (basic_block, max_uid)((basic_block *) xcalloc ((max_uid), sizeof (basic_block)));
    basic_block *end = XCNEWVEC (basic_block, max_uid)((basic_block *) xcalloc ((max_uid), sizeof (basic_block)));
    enum bb_state *in_bb_p = XCNEWVEC (enum bb_state, max_uid)((enum bb_state *) xcalloc ((max_uid), sizeof (enum bb_state)
));
    basic_block bb;

    /* After freeing the CFG, we still have BLOCK_FOR_INSN set on most
insns, but the CFG is not maintained so the basic block info
is not reliable.  Therefore it's omitted from the dumps.  */
    if (! (cfun(cfun + 0)->curr_properties & PROP_cfg(1 << 3)))
      flags &= ~TDF_BLOCKS;

    if (df)
df_dump_start (outf);

    if (cfun(cfun + 0)->curr_properties & PROP_cfg(1 << 3))
{
 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)
   {
     rtx_insn *x;

     start[INSN_UID (BB_HEAD (bb)(bb)->il.x.head_)] = bb;
     end[INSN_UID (BB_END (bb)(bb)->il.x.rtl->end_)] = bb;
     if (flags & TDF_BLOCKS)
{
  for (x = BB_HEAD (bb)(bb)->il.x.head_; x != NULL_RTX(rtx) 0; x = NEXT_INSN (x))
    {
      enum bb_state state = IN_MULTIPLE_BB;

      if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
	state = IN_ONE_BB;
      in_bb_p[INSN_UID (x)] = state;

      if (x == BB_END (bb)(bb)->il.x.rtl->end_)
	break;
    }
}
   }
}

    for (tmp_rtx = rtx_first; tmp_rtx != NULLnullptr; tmp_rtx = NEXT_INSN (tmp_rtx))
{
 if (flags & TDF_BLOCKS)
   {
     bb = start[INSN_UID (tmp_rtx)];
     if (bb != NULLnullptr)
{
  dump_bb_info (outf, bb, 0, dump_flags, true, false);
  if (df && (flags & TDF_DETAILS))
    df_dump_top (bb, outf);
}

     if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
  && !NOTE_P (tmp_rtx)(((enum rtx_code) (tmp_rtx)->code) == NOTE)
  && !BARRIER_P (tmp_rtx)(((enum rtx_code) (tmp_rtx)->code) == BARRIER))
fprintf (outf, ";; Insn is not within a basic block\n");
     else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
fprintf (outf, ";; Insn is in multiple basic blocks\n");
   }

 if (flags & TDF_DETAILS)
   df_dump_insn_top (tmp_rtx, outf);
 if (! (flags & TDF_SLIM))
   print_rtl_single (outf, tmp_rtx);
 else
   dump_insn_slim (outf, tmp_rtx);
 if (flags & TDF_DETAILS)
   df_dump_insn_bottom (tmp_rtx, outf);

 bb = end[INSN_UID (tmp_rtx)];
 if (bb != NULLnullptr)
   {
     if (flags & TDF_BLOCKS)
{
  dump_bb_info (outf, bb, 0, dump_flags, false, true);
  if (df && (flags & TDF_DETAILS))
    df_dump_bottom (bb, outf);
  putc ('\n', outf);
}
     /* Emit a hint if the fallthrough target of current basic block
        isn't the one placed right next.  */
     else if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) > 0)
{
  gcc_assert (BB_END (bb) == tmp_rtx)((void)(!((bb)->il.x.rtl->end_ == tmp_rtx) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2276, __FUNCTION__), 0 : 0));
  const rtx_insn *ninsn = NEXT_INSN (tmp_rtx);
  /* Bypass intervening deleted-insn notes and debug insns.  */
  while (ninsn
	 && !NONDEBUG_INSN_P (ninsn)((((enum rtx_code) (ninsn)->code) == INSN) || (((enum rtx_code
) (ninsn)->code) == JUMP_INSN) || (((enum rtx_code) (ninsn
)->code) == CALL_INSN))
	 && !start[INSN_UID (ninsn)])
    ninsn = NEXT_INSN (ninsn);
  edge e = find_fallthru_edge (bb->succs);
  if (e && ninsn)
    {
      basic_block dest = e->dest;
      if (start[INSN_UID (ninsn)] != dest)
	fprintf (outf, "%s      ; pc falls through to BB %d\n",
		 print_rtx_head, dest->index);
    }
}
   }
}

    free (start);
    free (end);
    free (in_bb_p);
  }
2299}
2300
2301/* Update the branch probability of BB if a REG_BR_PROB is present.  */

2303void
2304update_br_prob_note (basic_block bb)
2305{
rtx note;
note = find_reg_note (BB_END (bb)(bb)->il.x.rtl->end_, REG_BR_PROB, NULL_RTX(rtx) 0);
if (!JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
) || !BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)])->probability.initialized_p ())
  {
    if (note)
{
 rtx *note_link, this_rtx;

 note_link = &REG_NOTES (BB_END (bb))((((bb)->il.x.rtl->end_)->u.fld[6]).rt_rtx);
 for (this_rtx = *note_link; this_rtx; this_rtx = XEXP (this_rtx, 1)(((this_rtx)->u.fld[1]).rt_rtx))
   if (this_rtx == note)
     {
*note_link = XEXP (this_rtx, 1)(((this_rtx)->u.fld[1]).rt_rtx);
break;
     }
}
    return;
  }
if (!note
    || XINT (note, 0)(((note)->u.fld[0]).rt_int) == BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)])->probability.to_reg_br_prob_note ())
  return;
XINT (note, 0)(((note)->u.fld[0]).rt_int) = BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)])->probability.to_reg_br_prob_note ();
2328}

2330/* Get the last insn associated with block BB (that includes barriers and
 tablejumps after BB).  */
2332rtx_insn *
2333get_last_bb_insn (basic_block bb)
2334{
rtx_jump_table_data *table;
rtx_insn *tmp;
rtx_insn *end = BB_END (bb)(bb)->il.x.rtl->end_;

/* Include any jump table following the basic block.  */
if (tablejump_p (end, NULLnullptr, &table))
  end = table;

/* Include any barriers that may follow the basic block.  */
tmp = next_nonnote_nondebug_insn_bb (end);
while (tmp && BARRIER_P (tmp)(((enum rtx_code) (tmp)->code) == BARRIER))
  {
    end = tmp;
    tmp = next_nonnote_nondebug_insn_bb (end);
  }

return end;
2352}

2354/* Add all BBs reachable from entry via hot paths into the SET.  */

2356void
2357find_bbs_reachable_by_hot_paths (hash_set<basic_block> *set)
2358{
auto_vec<basic_block, 64> worklist;

set->add (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));
worklist.safe_push (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));

while (worklist.length () > 0)
  {
    basic_block bb = worklist.pop ();
    edge_iterator ei;
    edge e;

    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
if (BB_PARTITION (e->dest)((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)) != BB_COLD_PARTITION
   && !set->add (e->dest))
 worklist.safe_push (e->dest);
  }
2375}

2377/* Sanity check partition hotness to ensure that basic blocks in
  the cold partition don't dominate basic blocks in the hot partition.
 If FLAG_ONLY is true, report violations as errors. Otherwise
 re-mark the dominated blocks as cold, since this is run after
 cfg optimizations that may make hot blocks previously reached
 by both hot and cold blocks now only reachable along cold paths.  */

2384static auto_vec<basic_block>
2385find_partition_fixes (bool flag_only)
2386{
basic_block bb;
auto_vec<basic_block> bbs_to_fix;
hash_set<basic_block> set;

/* Callers check this.  */
gcc_checking_assert (crtl->has_bb_partition)((void)(!((&x_rtl)->has_bb_partition) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2392, __FUNCTION__), 0 : 0));

find_bbs_reachable_by_hot_paths (&set);

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  if (!set.contains (bb)
&& BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_COLD_PARTITION)
    {
if (flag_only)
 error ("non-cold basic block %d reachable only "
 "by paths crossing the cold partition", bb->index);
else
 BB_SET_PARTITION (bb, BB_COLD_PARTITION)do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags &
 ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (BB_COLD_PARTITION)
); } while (0);
bbs_to_fix.safe_push (bb);
    }

return bbs_to_fix;
2409}

2411/* Perform cleanup on the hot/cold bb partitioning after optimization
 passes that modify the cfg.  */

2414void
2415fixup_partitions (void)
2416{
if (!crtl(&x_rtl)->has_bb_partition)
  return;

/* Delete any blocks that became unreachable and weren't
   already cleaned up, for example during edge forwarding
   and convert_jumps_to_returns. This will expose more
   opportunities for fixing the partition boundaries here.
   Also, the calculation of the dominance graph during verification
   will assert if there are unreachable nodes.  */
delete_unreachable_blocks ();

/* If there are partitions, do a sanity check on them: A basic block in
   a cold partition cannot dominate a basic block in a hot partition.
   Fixup any that now violate this requirement, as a result of edge
   forwarding and unreachable block deletion.  */
auto_vec<basic_block> bbs_to_fix = find_partition_fixes (false);

/* Do the partition fixup after all necessary blocks have been converted to
   cold, so that we only update the region crossings the minimum number of
   places, which can require forcing edges to be non fallthru.  */
if (! bbs_to_fix.is_empty ())
  {
    do
{
 basic_block bb = bbs_to_fix.pop ();
 fixup_new_cold_bb (bb);
}
    while (! bbs_to_fix.is_empty ());

    /* Fix up hot cold block grouping if needed.  */
    if (crtl(&x_rtl)->bb_reorder_complete && current_ir_type () == IR_RTL_CFGRTL)
{
 basic_block bb, first = NULLnullptr, second = NULLnullptr;
 int current_partition = BB_UNPARTITIONED0;

 FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
   {
     if (current_partition != BB_UNPARTITIONED0
  && BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != current_partition)
{
  if (first == NULLnullptr)
    first = bb;
  else if (second == NULLnullptr)
    second = bb;
  else
    {
      /* If we switch partitions for the 3rd, 5th etc. time,
	 move bbs first (inclusive) .. second (exclusive) right
	 before bb.  */
      basic_block prev_first = first->prev_bb;
      basic_block prev_second = second->prev_bb;
      basic_block prev_bb = bb->prev_bb;
      prev_first->next_bb = second;
      second->prev_bb = prev_first;
      prev_second->next_bb = bb;
      bb->prev_bb = prev_second;
      prev_bb->next_bb = first;
      first->prev_bb = prev_bb;
      rtx_insn *prev_first_insn = PREV_INSN (BB_HEAD (first)(first)->il.x.head_);
      rtx_insn *prev_second_insn
	= PREV_INSN (BB_HEAD (second)(second)->il.x.head_);
      rtx_insn *prev_bb_insn = PREV_INSN (BB_HEAD (bb)(bb)->il.x.head_);
      SET_NEXT_INSN (prev_first_insn) = BB_HEAD (second)(second)->il.x.head_;
      SET_PREV_INSN (BB_HEAD (second)(second)->il.x.head_) = prev_first_insn;
      SET_NEXT_INSN (prev_second_insn) = BB_HEAD (bb)(bb)->il.x.head_;
      SET_PREV_INSN (BB_HEAD (bb)(bb)->il.x.head_) = prev_second_insn;
      SET_NEXT_INSN (prev_bb_insn) = BB_HEAD (first)(first)->il.x.head_;
      SET_PREV_INSN (BB_HEAD (first)(first)->il.x.head_) = prev_bb_insn;
      second = NULLnullptr;
    }
}
     current_partition = BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
   }
 gcc_assert (!second)((void)(!(!second) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2490, __FUNCTION__), 0 : 0));
}
  }
2493}

2495/* Verify, in the basic block chain, that there is at most one switch
 between hot/cold partitions. This condition will not be true until
 after reorder_basic_blocks is called.  */

2499static int
2500verify_hot_cold_block_grouping (void)
2501{
basic_block bb;
int err = 0;
bool switched_sections = false;
int current_partition = BB_UNPARTITIONED0;

/* Even after bb reordering is complete, we go into cfglayout mode
   again (in compgoto). Ensure we don't call this before going back
   into linearized RTL when any layout fixes would have been committed.  */
if (!crtl(&x_rtl)->bb_reorder_complete
    || current_ir_type () != IR_RTL_CFGRTL)
  return err;

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    if (current_partition != BB_UNPARTITIONED0
        && BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != current_partition)
{
 if (switched_sections)
   {
     error ("multiple hot/cold transitions found (bb %i)",
     bb->index);
     err = 1;
   }
 else
          switched_sections = true;

        if (!crtl(&x_rtl)->has_bb_partition)
          error ("partition found but function partition flag not set");
}
    current_partition = BB_PARTITION (bb)((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
  }

return err;
2535}
2536

2538/* Perform several checks on the edges out of each block, such as
 the consistency of the branch probabilities, the correctness
 of hot/cold partition crossing edges, and the number of expected
 successor edges.  Also verify that the dominance relationship
 between hot/cold blocks is sane.  */

2544static int
2545rtl_verify_edges (void)
2546{
int err = 0;
basic_block bb;

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)
  {
    int n_fallthru = 0, n_branch = 0, n_abnormal_call = 0, n_sibcall = 0;
    int n_eh = 0, n_abnormal = 0;
    edge e, fallthru = NULLnullptr;
    edge_iterator ei;
    rtx note;
    bool has_crossing_edge = false;

    if (JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
)
 && (note = find_reg_note (BB_END (bb)(bb)->il.x.rtl->end_, REG_BR_PROB, NULL_RTX(rtx) 0))
 && EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) >= 2
 && any_condjump_p (BB_END (bb)(bb)->il.x.rtl->end_))
{
 if (!BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)])->probability.initialized_p ())
   {
     if (profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_ABSENT)
{
  error ("verify_flow_info: "
	 "REG_BR_PROB is set but cfg probability is not");
  err = 1;
}
   }
 else if (XINT (note, 0)(((note)->u.fld[0]).rt_int)
          != BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)])->probability.to_reg_br_prob_note ()
          && profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_ABSENT)
   {
     error ("verify_flow_info: REG_BR_PROB does not match cfg %i %i",
     XINT (note, 0)(((note)->u.fld[0]).rt_int),
     BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)])->probability.to_reg_br_prob_note ());
     err = 1;
   }
}

    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
{
 bool is_crossing;

 if (e->flags & EDGE_FALLTHRU)
   n_fallthru++, fallthru = e;

 is_crossing = (BB_PARTITION (e->src)((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)) != BB_PARTITION (e->dest)((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
))
	 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
	 && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr));
        has_crossing_edge |= is_crossing;
 if (e->flags & EDGE_CROSSING)
   {
     if (!is_crossing)
{
  error ("EDGE_CROSSING incorrectly set across same section");
  err = 1;
}
     if (e->flags & EDGE_FALLTHRU)
{
  error ("fallthru edge crosses section boundary in bb %i",
	 e->src->index);
  err = 1;
}
     if (e->flags & EDGE_EH)
{
  error ("EH edge crosses section boundary in bb %i",
	 e->src->index);
  err = 1;
}
            if (JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
) && !CROSSING_JUMP_P (BB_END (bb))(__extension__ ({ __typeof (((bb)->il.x.rtl->end_)) const
 _rtx = (((bb)->il.x.rtl->end_)); if (((enum rtx_code) (
_rtx)->code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2614, __FUNCTION__); _rtx; })->jump))
{
  error ("No region crossing jump at section boundary in bb %i",
	 bb->index);
  err = 1;
}
   }
 else if (is_crossing)
   {
     error ("EDGE_CROSSING missing across section boundary");
     err = 1;
   }

 if ((e->flags & ~(EDGE_DFS_BACK
	    | EDGE_CAN_FALLTHRU
	    | EDGE_IRREDUCIBLE_LOOP
	    | EDGE_LOOP_EXIT
	    | EDGE_CROSSING
	    | EDGE_PRESERVE)) == 0)
   n_branch++;

 if (e->flags & EDGE_ABNORMAL_CALL)
   n_abnormal_call++;

 if (e->flags & EDGE_SIBCALL)
   n_sibcall++;

 if (e->flags & EDGE_EH)
   n_eh++;

 if (e->flags & EDGE_ABNORMAL)
   n_abnormal++;
}

    if (!has_crossing_edge
 && JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
)
 && CROSSING_JUMP_P (BB_END (bb))(__extension__ ({ __typeof (((bb)->il.x.rtl->end_)) const
 _rtx = (((bb)->il.x.rtl->end_)); if (((enum rtx_code) (
_rtx)->code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2650, __FUNCTION__); _rtx; })->jump))
{
 print_rtl_with_bb (stderrstderr, get_insns (), TDF_BLOCKS | TDF_DETAILS);
 error ("Region crossing jump across same section in bb %i",
 bb->index);
 err = 1;
}

    if (n_eh && !find_reg_note (BB_END (bb)(bb)->il.x.rtl->end_, REG_EH_REGION, NULL_RTX(rtx) 0))
{
 error ("missing REG_EH_REGION note at the end of bb %i", bb->index);
 err = 1;
}
    if (n_eh > 1)
{
 error ("too many exception handling edges in bb %i", bb->index);
 err = 1;
}
    if (n_branch
 && (!JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
)
     || (n_branch > 1 && (any_uncondjump_p (BB_END (bb)(bb)->il.x.rtl->end_)
		   || any_condjump_p (BB_END (bb)(bb)->il.x.rtl->end_)))))
{
 error ("too many outgoing branch edges from bb %i", bb->index);
 err = 1;
}
    if (n_fallthru && any_uncondjump_p (BB_END (bb)(bb)->il.x.rtl->end_))
{
 error ("fallthru edge after unconditional jump in bb %i", bb->index);
 err = 1;
}
    if (n_branch != 1 && any_uncondjump_p (BB_END (bb)(bb)->il.x.rtl->end_))
{
 error ("wrong number of branch edges after unconditional jump"
 " in bb %i", bb->index);
 err = 1;
}
    if (n_branch != 1 && any_condjump_p (BB_END (bb)(bb)->il.x.rtl->end_)
 && JUMP_LABEL (BB_END (bb))((((bb)->il.x.rtl->end_)->u.fld[7]).rt_rtx) != BB_HEAD (fallthru->dest)(fallthru->dest)->il.x.head_)
{
 error ("wrong amount of branch edges after conditional jump"
 " in bb %i", bb->index);
 err = 1;
}
    if (n_abnormal_call && !CALL_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == CALL_INSN
))
{
 error ("abnormal call edges for non-call insn in bb %i", bb->index);
 err = 1;
}
    if (n_sibcall && !CALL_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == CALL_INSN
))
{
 error ("sibcall edges for non-call insn in bb %i", bb->index);
 err = 1;
}
    if (n_abnormal > n_eh
 && !(CALL_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == CALL_INSN
)
      && n_abnormal == n_abnormal_call + n_sibcall)
 && (!JUMP_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN
)
     || any_condjump_p (BB_END (bb)(bb)->il.x.rtl->end_)
     || any_uncondjump_p (BB_END (bb)(bb)->il.x.rtl->end_)))
{
 error ("abnormal edges for no purpose in bb %i", bb->index);
 err = 1;
}

    int has_eh = -1;
    FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
{
 if (has_eh == -1)
   has_eh = (e->flags & EDGE_EH);
 if ((e->flags & EDGE_EH) == has_eh)
   continue;
 error ("EH incoming edge mixed with non-EH incoming edges "
 "in bb %i", bb->index);
 err = 1;
 break;
}
  }

/* If there are partitions, do a sanity check on them: A basic block in
   a cold partition cannot dominate a basic block in a hot partition.  */
if (crtl(&x_rtl)->has_bb_partition && !err
    && current_ir_type () == IR_RTL_CFGLAYOUT)
  {
    auto_vec<basic_block> bbs_to_fix = find_partition_fixes (true);
    err = !bbs_to_fix.is_empty ();
  }

/* Clean up.  */
return err;
2740}

2742/* Checks on the instructions within blocks. Currently checks that each
 block starts with a basic block note, and that basic block notes and
 control flow jumps are not found in the middle of the block.  */

2746static int
2747rtl_verify_bb_insns (void)
2748{
rtx_insn *x;
int err = 0;
basic_block bb;

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)
  {
    /* Now check the header of basic
block.  It ought to contain optional CODE_LABEL followed
by NOTE_BASIC_BLOCK.  */
    x = BB_HEAD (bb)(bb)->il.x.head_;
    if (LABEL_P (x)(((enum rtx_code) (x)->code) == CODE_LABEL))
{
 if (BB_END (bb)(bb)->il.x.rtl->end_ == x)
   {
     error ("NOTE_INSN_BASIC_BLOCK is missing for block %d",
     bb->index);
     err = 1;
   }

 x = NEXT_INSN (x);
}

    if (!NOTE_INSN_BASIC_BLOCK_P (x)((((enum rtx_code) (x)->code) == NOTE) && (((x)->
u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK) || NOTE_BASIC_BLOCK (x)(((x)->u.fld[3]).rt_bb) != bb)
{
 error ("NOTE_INSN_BASIC_BLOCK is missing for block %d",
 bb->index);
 err = 1;
}

    if (BB_END (bb)(bb)->il.x.rtl->end_ == x)
/* Do checks for empty blocks here.  */
;
    else
for (x = NEXT_INSN (x); x; x = NEXT_INSN (x))
 {
   if (NOTE_INSN_BASIC_BLOCK_P (x)((((enum rtx_code) (x)->code) == NOTE) && (((x)->
u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK))
     {
error ("NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d",
       INSN_UID (x), bb->index);
err = 1;
     }

   if (x == BB_END (bb)(bb)->il.x.rtl->end_)
     break;

   if (control_flow_insn_p (x))
     {
error ("in basic block %d:", bb->index);
fatal_insn ("flow control insn inside a basic block", x)_fatal_insn ("flow control insn inside a basic block", x, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 2797, __FUNCTION__);
     }
 }
  }

/* Clean up.  */
return err;
2804}

2806/* Verify that block pointers for instructions in basic blocks, headers and
 footers are set appropriately.  */

2809static int
2810rtl_verify_bb_pointers (void)
2811{
int err = 0;
basic_block bb;

/* Check the general integrity of the basic blocks.  */
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)
  {
    rtx_insn *insn;

    if (!(bb->flags & BB_RTL))
{
 error ("BB_RTL flag not set for block %d", bb->index);
 err = 1;
}

    FOR_BB_INSNS (bb, insn)for ((insn) = (bb)->il.x.head_; (insn) && (insn) !=
 NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (
insn))
if (BLOCK_FOR_INSN (insn) != bb)
 {
   error ("insn %d basic block pointer is %d, should be %d",
   INSN_UID (insn),
   BLOCK_FOR_INSN (insn) ? BLOCK_FOR_INSN (insn)->index : 0,
   bb->index);
   err = 1;
 }

    for (insn = BB_HEADER (bb)(bb)->il.x.rtl->header_; insn; insn = NEXT_INSN (insn))
if (!BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER)
   && BLOCK_FOR_INSN (insn) != NULLnullptr)
 {
   error ("insn %d in header of bb %d has non-NULL basic block",
   INSN_UID (insn), bb->index);
   err = 1;
 }
    for (insn = BB_FOOTER (bb)(bb)->il.x.rtl->footer_; insn; insn = NEXT_INSN (insn))
if (!BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER)
   && BLOCK_FOR_INSN (insn) != NULLnullptr)
 {
   error ("insn %d in footer of bb %d has non-NULL basic block",
   INSN_UID (insn), bb->index);
   err = 1;
 }
  }

/* Clean up.  */
return err;
2856}

2858/* Verify the CFG and RTL consistency common for both underlying RTL and
 cfglayout RTL.

 Currently it does following checks:

 - overlapping of basic blocks
 - insns with wrong BLOCK_FOR_INSN pointers
 - headers of basic blocks (the NOTE_INSN_BASIC_BLOCK note)
 - tails of basic blocks (ensure that boundary is necessary)
 - scans body of the basic block for JUMP_INSN, CODE_LABEL
   and NOTE_INSN_BASIC_BLOCK
 - verify that no fall_thru edge crosses hot/cold partition boundaries
 - verify that there are no pending RTL branch predictions
 - verify that hot blocks are not dominated by cold blocks

 In future it can be extended check a lot of other stuff as well
 (reachability of basic blocks, life information, etc. etc.).  */

2876static int
2877rtl_verify_flow_info_1 (void)
2878{
int err = 0;

err |= rtl_verify_bb_pointers ();

err |= rtl_verify_bb_insns ();

err |= rtl_verify_edges ();

return err;
2888}

2890/* Walk the instruction chain and verify that bb head/end pointers
are correct, and that instructions are in exactly one bb and have
correct block pointers.  */

2894static int
2895rtl_verify_bb_insn_chain (void)
2896{
basic_block bb;
int err = 0;
rtx_insn *x;
rtx_insn *last_head = get_last_insn ();
basic_block *bb_info;
const int max_uid = get_max_uid ();

bb_info = XCNEWVEC (basic_block, max_uid)((basic_block *) xcalloc ((max_uid), sizeof (basic_block)));

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)
  {
    rtx_insn *head = BB_HEAD (bb)(bb)->il.x.head_;
    rtx_insn *end = BB_END (bb)(bb)->il.x.rtl->end_;

    for (x = last_head; x != NULL_RTX(rtx) 0; x = PREV_INSN (x))
{
 /* Verify the end of the basic block is in the INSN chain.  */
 if (x == end)
   break;

          /* And that the code outside of basic blocks has NULL bb field.  */
        if (!BARRIER_P (x)(((enum rtx_code) (x)->code) == BARRIER)
            && BLOCK_FOR_INSN (x) != NULLnullptr)
          {
            error ("insn %d outside of basic blocks has non-NULL bb field",
                   INSN_UID (x));
            err = 1;
          }
}

    if (!x)
{
 error ("end insn %d for block %d not found in the insn stream",
 INSN_UID (end), bb->index);
 err = 1;
}

    /* Work backwards from the end to the head of the basic block
to verify the head is in the RTL chain.  */
    for (; x != NULL_RTX(rtx) 0; x = PREV_INSN (x))
{
 /* While walking over the insn chain, verify insns appear
    in only one basic block.  */
 if (bb_info[INSN_UID (x)] != NULLnullptr)
   {
     error ("insn %d is in multiple basic blocks (%d and %d)",
     INSN_UID (x), bb->index, bb_info[INSN_UID (x)]->index);
     err = 1;
   }

 bb_info[INSN_UID (x)] = bb;

 if (x == head)
   break;
}
    if (!x)
{
 error ("head insn %d for block %d not found in the insn stream",
 INSN_UID (head), bb->index);
 err = 1;
}

    last_head = PREV_INSN (x);
  }

for (x = last_head; x != NULL_RTX(rtx) 0; x = PREV_INSN (x))
  {
    /* Check that the code before the first basic block has NULL
bb field.  */
    if (!BARRIER_P (x)(((enum rtx_code) (x)->code) == BARRIER)
 && BLOCK_FOR_INSN (x) != NULLnullptr)
{
 error ("insn %d outside of basic blocks has non-NULL bb field",
 INSN_UID (x));
 err = 1;
}
  }
free (bb_info);

return err;
2977}

2979/* Verify that fallthru edges point to adjacent blocks in layout order and
 that barriers exist after non-fallthru blocks.  */

2982static int
2983rtl_verify_fallthru (void)
2984{
basic_block bb;
int err = 0;

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)
  {
    edge e;

    e = find_fallthru_edge (bb->succs);
    if (!e)
{
 rtx_insn *insn;

 /* Ensure existence of barrier in BB with no fallthru edges.  */
 for (insn = NEXT_INSN (BB_END (bb)(bb)->il.x.rtl->end_); ; insn = NEXT_INSN (insn))
   {
     if (!insn || NOTE_INSN_BASIC_BLOCK_P (insn)((((enum rtx_code) (insn)->code) == NOTE) && (((insn
)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK))
{
  error ("missing barrier after block %i", bb->index);
  err = 1;
  break;
}
     if (BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
break;
   }
}
    else if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
      && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
{
 rtx_insn *insn;

 if (e->src->next_bb != e->dest)
   {
     error
("verify_flow_info: Incorrect blocks for fallthru %i->%i",
 e->src->index, e->dest->index);
     err = 1;
   }
 else
   for (insn = NEXT_INSN (BB_END (e->src)(e->src)->il.x.rtl->end_); insn != BB_HEAD (e->dest)(e->dest)->il.x.head_;
 insn = NEXT_INSN (insn))
     if (BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER) || NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)))
{
  error ("verify_flow_info: Incorrect fallthru %i->%i",
	 e->src->index, e->dest->index);
  error ("wrong insn in the fallthru edge");
  debug_rtx (insn);
  err = 1;
}
}
  }

 return err;
3037}

3039/* Verify that blocks are laid out in consecutive order. While walking the
 instructions, verify that all expected instructions are inside the basic
 blocks, and that all returns are followed by barriers.  */

3043static int
3044rtl_verify_bb_layout (void)
3045{
basic_block bb;
int err = 0;
rtx_insn *x, *y;
int num_bb_notes;
rtx_insn * const rtx_first = get_insns ();
basic_block last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr), curr_bb = NULLnullptr;

num_bb_notes = 0;

for (x = rtx_first; x; x = NEXT_INSN (x))
  {
    if (NOTE_INSN_BASIC_BLOCK_P (x)((((enum rtx_code) (x)->code) == NOTE) && (((x)->
u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK))
{
 bb = NOTE_BASIC_BLOCK (x)(((x)->u.fld[3]).rt_bb);

 num_bb_notes++;
 if (bb != last_bb_seen->next_bb)
   internal_error ("basic blocks not laid down consecutively");

 curr_bb = last_bb_seen = bb;
}

    if (!curr_bb)
{
 switch (GET_CODE (x)((enum rtx_code) (x)->code))
   {
   case BARRIER:
   case NOTE:
     break;

   case CODE_LABEL:
     /* An ADDR_VEC is placed outside any basic block.  */
     if (NEXT_INSN (x)
  && JUMP_TABLE_DATA_P (NEXT_INSN (x))(((enum rtx_code) (NEXT_INSN (x))->code) == JUMP_TABLE_DATA
))
x = NEXT_INSN (x);

     /* But in any case, non-deletable labels can appear anywhere.  */
     break;

   default:
     fatal_insn ("insn outside basic block", x)_fatal_insn ("insn outside basic block", x, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3086, __FUNCTION__);
   }
}

    if (JUMP_P (x)(((enum rtx_code) (x)->code) == JUMP_INSN)
 && returnjump_p (x) && ! condjump_p (x)
 && ! ((y = next_nonnote_nondebug_insn (x))
&& BARRIER_P (y)(((enum rtx_code) (y)->code) == BARRIER)))
   fatal_insn ("return not followed by barrier", x)_fatal_insn ("return not followed by barrier", x, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3094, __FUNCTION__);

    if (curr_bb && x == BB_END (curr_bb)(curr_bb)->il.x.rtl->end_)
curr_bb = NULLnullptr;
  }

if (num_bb_notes != n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks) - NUM_FIXED_BLOCKS(2))
  internal_error
    ("number of bb notes in insn chain (%d) != n_basic_blocks (%d)",
     num_bb_notes, n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks));

 return err;
3106}

3108/* Verify the CFG and RTL consistency common for both underlying RTL and
 cfglayout RTL, plus consistency checks specific to linearized RTL mode.

 Currently it does following checks:
 - all checks of rtl_verify_flow_info_1
 - test head/end pointers
 - check that blocks are laid out in consecutive order
 - check that all insns are in the basic blocks
   (except the switch handling code, barriers and notes)
 - check that all returns are followed by barriers
 - check that all fallthru edge points to the adjacent blocks
 - verify that there is a single hot/cold partition boundary after bbro  */

3121static int
3122rtl_verify_flow_info (void)
3123{
int err = 0;

err |= rtl_verify_flow_info_1 ();

err |= rtl_verify_bb_insn_chain ();

err |= rtl_verify_fallthru ();

err |= rtl_verify_bb_layout ();

err |= verify_hot_cold_block_grouping ();

return err;
3137}
3138
3139/* Assume that the preceding pass has possibly eliminated jump instructions
 or converted the unconditional jumps.  Eliminate the edges from CFG.
 Return true if any edges are eliminated.  */

3143bool
3144purge_dead_edges (basic_block bb)
3145{
edge e;
rtx_insn *insn = BB_END (bb)(bb)->il.x.rtl->end_;
rtx note;
bool purged = false;
bool found;
edge_iterator ei;

if ((DEBUG_INSN_P (insn)(((enum rtx_code) (insn)->code) == DEBUG_INSN) || NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE)) && insn != BB_HEAD (bb)(bb)->il.x.head_)
  do
    insn = PREV_INSN (insn);
  while ((DEBUG_INSN_P (insn)(((enum rtx_code) (insn)->code) == DEBUG_INSN) || NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE)) && insn != BB_HEAD (bb)(bb)->il.x.head_);

/* If this instruction cannot trap, remove REG_EH_REGION notes.  */
if (NONJUMP_INSN_P (insn)(((enum rtx_code) (insn)->code) == INSN)
    && (note = find_reg_note (insn, REG_EH_REGION, NULLnullptr)))
  {
    rtx eqnote;

    if (! may_trap_p (PATTERN (insn))
 || ((eqnote = find_reg_equal_equiv_note (insn))
     && ! may_trap_p (XEXP (eqnote, 0)(((eqnote)->u.fld[0]).rt_rtx))))
remove_note (insn, note);
  }

/* Cleanup abnormal edges caused by exceptions or non-local gotos.  */
for (ei = ei_start (bb->succs)ei_start_1 (&(bb->succs)); (e = ei_safe_edge (ei)); )
  {
    bool remove = false;

    /* There are three types of edges we need to handle correctly here: EH
edges, abnormal call EH edges, and abnormal call non-EH edges.  The
latter can appear when nonlocal gotos are used.  */
    if (e->flags & EDGE_ABNORMAL_CALL)
{
 if (!CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN))
   remove = true;
 else if (can_nonlocal_goto (insn))
   ;
 else if ((e->flags & EDGE_EH) && can_throw_internal (insn))
   ;
 else if (flag_tmglobal_options.x_flag_tm && find_reg_note (insn, REG_TM, NULLnullptr))
   ;
 else
   remove = true;
}
    else if (e->flags & EDGE_EH)
remove = !can_throw_internal (insn);

    if (remove)
{
 remove_edge (e);
 df_set_bb_dirty (bb);
 purged = true;
}
    else
ei_next (&ei);
  }

if (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN))
  {
    rtx note;
    edge b,f;
    edge_iterator ei;

    /* We do care only about conditional jumps and simplejumps.  */
    if (!any_condjump_p (insn)
 && !returnjump_p (insn)
 && !simplejump_p (insn))
return purged;

    /* Branch probability/prediction notes are defined only for
condjumps.  We've possibly turned condjump into simplejump.  */
    if (simplejump_p (insn))
{
 note = find_reg_note (insn, REG_BR_PROB, NULLnullptr);
 if (note)
   remove_note (insn, note);
 while ((note = find_reg_note (insn, REG_BR_PRED, NULLnullptr)))
   remove_note (insn, note);
}

    for (ei = ei_start (bb->succs)ei_start_1 (&(bb->succs)); (e = ei_safe_edge (ei)); )
{
 /* Avoid abnormal flags to leak from computed jumps turned
    into simplejumps.  */

 e->flags &= ~EDGE_ABNORMAL;

 /* See if this edge is one we should keep.  */
 if ((e->flags & EDGE_FALLTHRU) && any_condjump_p (insn))
   /* A conditional jump can fall through into the next
      block, so we should keep the edge.  */
   {
     ei_next (&ei);
     continue;
   }
 else if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
   && BB_HEAD (e->dest)(e->dest)->il.x.head_ == JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx))
   /* If the destination block is the target of the jump,
      keep the edge.  */
   {
     ei_next (&ei);
     continue;
   }
 else if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
   && returnjump_p (insn))
   /* If the destination block is the exit block, and this
      instruction is a return, then keep the edge.  */
   {
     ei_next (&ei);
     continue;
   }
 else if ((e->flags & EDGE_EH) && can_throw_internal (insn))
   /* Keep the edges that correspond to exceptions thrown by
      this instruction and rematerialize the EDGE_ABNORMAL
      flag we just cleared above.  */
   {
     e->flags |= EDGE_ABNORMAL;
     ei_next (&ei);
     continue;
   }

 /* We do not need this edge.  */
 df_set_bb_dirty (bb);
 purged = true;
 remove_edge (e);
}

    if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) == 0 || !purged)
return purged;

    if (dump_file)
fprintf (dump_file, "Purged edges from bb %i\n", bb->index);

    if (!optimizeglobal_options.x_optimize)
return purged;

    /* Redistribute probabilities.  */
    if (single_succ_p (bb))
{
 single_succ_edge (bb)->probability = profile_probability::always ();
}
    else
{
 note = find_reg_note (insn, REG_BR_PROB, NULLnullptr);
 if (!note)
   return purged;

 b = BRANCH_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(1)] : (*((bb))->succs)[(0)]);
 f = FALLTHRU_EDGE (bb)((*((bb))->succs)[(0)]->flags & EDGE_FALLTHRU ? (*(
(bb))->succs)[(0)] : (*((bb))->succs)[(1)]);
 b->probability = profile_probability::from_reg_br_prob_note
			 (XINT (note, 0)(((note)->u.fld[0]).rt_int));
 f->probability = b->probability.invert ();
}

    return purged;
  }
else if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN) && SIBLING_CALL_P (insn)(__extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if
 (((enum rtx_code) (_rtx)->code) != CALL_INSN) rtl_check_failed_flag
 ("SIBLING_CALL_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3303, __FUNCTION__); _rtx; })->jump))
  {
    /* First, there should not be any EH or ABCALL edges resulting
from non-local gotos and the like.  If there were, we shouldn't
have created the sibcall in the first place.  Second, there
should of course never have been a fallthru edge.  */
    gcc_assert (single_succ_p (bb))((void)(!(single_succ_p (bb)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3309, __FUNCTION__), 0 : 0));
    gcc_assert (single_succ_edge (bb)->flags((void)(!(single_succ_edge (bb)->flags == (EDGE_SIBCALL | EDGE_ABNORMAL
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3311, __FUNCTION__), 0 : 0))
  == (EDGE_SIBCALL | EDGE_ABNORMAL))((void)(!(single_succ_edge (bb)->flags == (EDGE_SIBCALL | EDGE_ABNORMAL
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3311, __FUNCTION__), 0 : 0));

    return 0;
  }

/* If we don't see a jump insn, we don't know exactly why the block would
   have been broken at this point.  Look for a simple, non-fallthru edge,
   as these are only created by conditional branches.  If we find such an
   edge we know that there used to be a jump here and can then safely
   remove all non-fallthru edges.  */
found = false;
FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
  if (! (e->flags & (EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
) | EDGE_FALLTHRU)))
    {
found = true;
break;
    }

if (!found)
  return purged;

/* Remove all but the fake and fallthru edges.  The fake edge may be
   the only successor for this block in the case of noreturn
   calls.  */
for (ei = ei_start (bb->succs)ei_start_1 (&(bb->succs)); (e = ei_safe_edge (ei)); )
  {
    if (!(e->flags & (EDGE_FALLTHRU | EDGE_FAKE)))
{
 df_set_bb_dirty (bb);
 remove_edge (e);
 purged = true;
}
    else
ei_next (&ei);
  }

gcc_assert (single_succ_p (bb))((void)(!(single_succ_p (bb)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3347, __FUNCTION__), 0 : 0));

single_succ_edge (bb)->probability = profile_probability::always ();

if (dump_file)
  fprintf (dump_file, "Purged non-fallthru edges from bb %i\n",
    bb->index);
return purged;
3355}

3357/* Search all basic blocks for potentially dead edges and purge them.  Return
 true if some edge has been eliminated.  */

3360bool
3361purge_all_dead_edges (void)
3362{
int purged = false;
basic_block bb;

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    bool purged_here = purge_dead_edges (bb);

    purged |= purged_here;
  }

return purged;
3374}

3376/* This is used by a few passes that emit some instructions after abnormal
 calls, moving the basic block's end, while they in fact do want to emit
 them on the fallthru edge.  Look for abnormal call edges, find backward
 the call in the block and insert the instructions on the edge instead.

 Similarly, handle instructions throwing exceptions internally.

 Return true when instructions have been found and inserted on edges.  */

3385bool
3386fixup_abnormal_edges (void)
3387{
bool inserted = false;
basic_block bb;

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    edge e;
    edge_iterator ei;

    /* Look for cases we are interested in - calls or instructions causing
       exceptions.  */
    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
if ((e->flags & EDGE_ABNORMAL_CALL)
   || ((e->flags & (EDGE_ABNORMAL | EDGE_EH))
== (EDGE_ABNORMAL | EDGE_EH)))
 break;

    if (e && !CALL_P (BB_END (bb))(((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == CALL_INSN
) && !can_throw_internal (BB_END (bb)(bb)->il.x.rtl->end_))
{
 rtx_insn *insn;

 /* Get past the new insns generated.  Allow notes, as the insns
    may be already deleted.  */
 insn = BB_END (bb)(bb)->il.x.rtl->end_;
 while ((NONJUMP_INSN_P (insn)(((enum rtx_code) (insn)->code) == INSN) || NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE))
 && !can_throw_internal (insn)
 && insn != BB_HEAD (bb)(bb)->il.x.head_)
   insn = PREV_INSN (insn);

 if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN) || can_throw_internal (insn))
   {
     rtx_insn *stop, *next;

     e = find_fallthru_edge (bb->succs);

     stop = NEXT_INSN (BB_END (bb)(bb)->il.x.rtl->end_);
     BB_END (bb)(bb)->il.x.rtl->end_ = insn;

     for (insn = NEXT_INSN (insn); insn != stop; insn = next)
{
  next = NEXT_INSN (insn);
  if (INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN)))
    {
      delete_insn (insn);

      /* Sometimes there's still the return value USE.
	 If it's placed after a trapping call (i.e. that
	 call is the last insn anyway), we have no fallthru
	 edge.  Simply delete this use and don't try to insert
	 on the non-existent edge.
	 Similarly, sometimes a call that can throw is
	 followed in the source with __builtin_unreachable (),
	 meaning that there is UB if the call returns rather
	 than throws.  If there weren't any instructions
	 following such calls before, supposedly even the ones
	 we've deleted aren't significant and can be
	 removed.  */
      if (e)
	{
	  /* We're not deleting it, we're moving it.  */
	  insn->set_undeleted ();
	  SET_PREV_INSN (insn) = NULL_RTX(rtx) 0;
	  SET_NEXT_INSN (insn) = NULL_RTX(rtx) 0;

	  insert_insn_on_edge (insn, e);
	  inserted = true;
	}
    }
  else if (!BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
    set_block_for_insn (insn, NULLnullptr);
}
   }

 /* It may be that we don't find any trapping insn.  In this
    case we discovered quite late that the insn that had been
    marked as can_throw_internal in fact couldn't trap at all.
    So we should in fact delete the EH edges out of the block.  */
 else
   purge_dead_edges (bb);
}
  }

return inserted;
3470}
3471
3472/* Delete the unconditional jump INSN and adjust the CFG correspondingly.
 Note that the INSN should be deleted *after* removing dead edges, so
 that the kept edge is the fallthrough edge for a (set (pc) (pc))
 but not for a (set (pc) (label_ref FOO)).  */

3477void
3478update_cfg_for_uncondjump (rtx_insn *insn)
3479{
basic_block bb = BLOCK_FOR_INSN (insn);
gcc_assert (BB_END (bb) == insn)((void)(!((bb)->il.x.rtl->end_ == insn) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3481, __FUNCTION__), 0 : 0));

purge_dead_edges (bb);

if (current_ir_type () != IR_RTL_CFGLAYOUT)
  {
    if (!find_fallthru_edge (bb->succs))
{
 auto barrier = next_nonnote_nondebug_insn (insn);
 if (!barrier || !BARRIER_P (barrier)(((enum rtx_code) (barrier)->code) == BARRIER))
   emit_barrier_after (insn);
}
    return;
  }

delete_insn (insn);
if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) == 1)
  {
    rtx_insn *insn;

    single_succ_edge (bb)->flags |= EDGE_FALLTHRU;

    /* Remove barriers from the footer if there are any.  */
    for (insn = BB_FOOTER (bb)(bb)->il.x.rtl->footer_; insn; insn = NEXT_INSN (insn))
if (BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
 {
   if (PREV_INSN (insn))
     SET_NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
   else
     BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = NEXT_INSN (insn);
   if (NEXT_INSN (insn))
     SET_PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
 }
else if (LABEL_P (insn)(((enum rtx_code) (insn)->code) == CODE_LABEL))
 break;
  }
3517}
3518
3519/* Cut the insns from FIRST to LAST out of the insns stream.  */

3521rtx_insn *
3522unlink_insn_chain (rtx_insn *first, rtx_insn *last)
3523{
rtx_insn *prevfirst = PREV_INSN (first);
rtx_insn *nextlast = NEXT_INSN (last);

SET_PREV_INSN (first) = NULLnullptr;
SET_NEXT_INSN (last) = NULLnullptr;
if (prevfirst)
  SET_NEXT_INSN (prevfirst) = nextlast;
if (nextlast)
  SET_PREV_INSN (nextlast) = prevfirst;
else
  set_last_insn (prevfirst);
if (!prevfirst)
  set_first_insn (nextlast);
return first;
3538}
3539
3540/* Skip over inter-block insns occurring after BB which are typically
 associated with BB (e.g., barriers). If there are any such insns,
 we return the last one. Otherwise, we return the end of BB.  */

3544static rtx_insn *
3545skip_insns_after_block (basic_block bb)
3546{
rtx_insn *insn, *last_insn, *next_head, *prev;

next_head = NULLnullptr;
if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  next_head = BB_HEAD (bb->next_bb)(bb->next_bb)->il.x.head_;

for (last_insn = insn = BB_END (bb)(bb)->il.x.rtl->end_; (insn = NEXT_INSN (insn)) != 0; )
  {
    if (insn == next_head)
break;

    switch (GET_CODE (insn)((enum rtx_code) (insn)->code))
{
case BARRIER:
 last_insn = insn;
 continue;

case NOTE:
 gcc_assert (NOTE_KIND (insn) != NOTE_INSN_BLOCK_END)((void)(!((((insn)->u.fld[4]).rt_int) != NOTE_INSN_BLOCK_END
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3565, __FUNCTION__), 0 : 0));
 continue;

case CODE_LABEL:
 if (NEXT_INSN (insn)
     && JUMP_TABLE_DATA_P (NEXT_INSN (insn))(((enum rtx_code) (NEXT_INSN (insn))->code) == JUMP_TABLE_DATA
))
   {
     insn = NEXT_INSN (insn);
     last_insn = insn;
     continue;
   }
 break;

default:
 break;
}

    break;
  }

/* It is possible to hit contradictory sequence.  For instance:

   jump_insn
   NOTE_INSN_BLOCK_BEG
   barrier

   Where barrier belongs to jump_insn, but the note does not.  This can be
   created by removing the basic block originally following
   NOTE_INSN_BLOCK_BEG.  In such case reorder the notes.  */

for (insn = last_insn; insn != BB_END (bb)(bb)->il.x.rtl->end_; insn = prev)
  {
    prev = PREV_INSN (insn);
    if (NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE))
switch (NOTE_KIND (insn)(((insn)->u.fld[4]).rt_int))
 {
 case NOTE_INSN_BLOCK_END:
   gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3602, __FUNCTION__));
   break;
 case NOTE_INSN_DELETED:
 case NOTE_INSN_DELETED_LABEL:
 case NOTE_INSN_DELETED_DEBUG_LABEL:
   continue;
 default:
   reorder_insns (insn, insn, last_insn);
 }
  }

return last_insn;
3614}

3616/* Locate or create a label for a given basic block.  */

3618static rtx_insn *
3619label_for_bb (basic_block bb)
3620{
rtx_insn *label = BB_HEAD (bb)(bb)->il.x.head_;

if (!LABEL_P (label)(((enum rtx_code) (label)->code) == CODE_LABEL))
  {
    if (dump_file)
fprintf (dump_file, "Emitting label for block %d\n", bb->index);

    label = block_label (bb);
  }

return label;
3632}

3634/* Locate the effective beginning and end of the insn chain for each
 block, as defined by skip_insns_after_block above.  */

3637static void
3638record_effective_endpoints (void)
3639{
rtx_insn *next_insn;
basic_block bb;
rtx_insn *insn;

for (insn = get_insns ();
     insn
     && NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE)
     && NOTE_KIND (insn)(((insn)->u.fld[4]).rt_int) != NOTE_INSN_BASIC_BLOCK;
     insn = NEXT_INSN (insn))
  continue;
/* No basic blocks at all?  */
gcc_assert (insn)((void)(!(insn) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3651, __FUNCTION__), 0 : 0));

if (PREV_INSN (insn))
  cfg_layout_function_header =
   unlink_insn_chain (get_insns (), PREV_INSN (insn));
else
  cfg_layout_function_header = NULLnullptr;

next_insn = get_insns ();
FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    rtx_insn *end;

    if (PREV_INSN (BB_HEAD (bb)(bb)->il.x.head_) && next_insn != BB_HEAD (bb)(bb)->il.x.head_)
BB_HEADER (bb)(bb)->il.x.rtl->header_ = unlink_insn_chain (next_insn,
				PREV_INSN (BB_HEAD (bb)(bb)->il.x.head_));
    end = skip_insns_after_block (bb);
    if (NEXT_INSN (BB_END (bb)(bb)->il.x.rtl->end_) && BB_END (bb)(bb)->il.x.rtl->end_ != end)
BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = unlink_insn_chain (NEXT_INSN (BB_END (bb)(bb)->il.x.rtl->end_), end);
    next_insn = NEXT_INSN (BB_END (bb)(bb)->il.x.rtl->end_);
  }

cfg_layout_function_footer = next_insn;
if (cfg_layout_function_footer)
  cfg_layout_function_footer = unlink_insn_chain (cfg_layout_function_footer, get_last_insn ());
3676}
3677
3678namespace {

3680const pass_data pass_data_into_cfg_layout_mode =
3681{
RTL_PASS, /* type */
"into_cfglayout", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_CFG, /* tv_id */
0, /* properties_required */
PROP_cfglayout(1 << 9), /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
3691};

3693class pass_into_cfg_layout_mode : public rtl_opt_pass
3694{
3695public:
pass_into_cfg_layout_mode (gcc::context *ctxt)
  : rtl_opt_pass (pass_data_into_cfg_layout_mode, ctxt)
{}

/* opt_pass methods: */
unsigned int execute (function *) final override
  {
    cfg_layout_initialize (0);
    return 0;
  }

3707}; // class pass_into_cfg_layout_mode

3709} // anon namespace

3711rtl_opt_pass *
3712make_pass_into_cfg_layout_mode (gcc::context *ctxt)
3713{
return new pass_into_cfg_layout_mode (ctxt);
3715}

3717namespace {

3719const pass_data pass_data_outof_cfg_layout_mode =
3720{
RTL_PASS, /* type */
"outof_cfglayout", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_CFG, /* tv_id */
0, /* properties_required */
0, /* properties_provided */
PROP_cfglayout(1 << 9), /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
3730};

3732class pass_outof_cfg_layout_mode : public rtl_opt_pass
3733{
3734public:
pass_outof_cfg_layout_mode (gcc::context *ctxt)
  : rtl_opt_pass (pass_data_outof_cfg_layout_mode, ctxt)
{}

/* opt_pass methods: */
unsigned int execute (function *) final override;

3742}; // class pass_outof_cfg_layout_mode

3744unsigned int
3745pass_outof_cfg_layout_mode::execute (function *fun)
3746{
basic_block bb;

FOR_EACH_BB_FN (bb, fun)for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb
 != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
  if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (fun)((fun)->cfg->x_exit_block_ptr))
    bb->aux = bb->next_bb;

cfg_layout_finalize ();

return 0;
3756}

3758} // anon namespace

3760rtl_opt_pass *
3761make_pass_outof_cfg_layout_mode (gcc::context *ctxt)
3762{
return new pass_outof_cfg_layout_mode (ctxt);
3764}
3765

3767/* Link the basic blocks in the correct order, compacting the basic
 block queue while at it.  If STAY_IN_CFGLAYOUT_MODE is false, this
 function also clears the basic block header and footer fields.

 This function is usually called after a pass (e.g. tracer) finishes
 some transformations while in cfglayout mode.  The required sequence
 of the basic blocks is in a linked list along the bb->aux field.
 This functions re-links the basic block prev_bb and next_bb pointers
 accordingly, and it compacts and renumbers the blocks.

 FIXME: This currently works only for RTL, but the only RTL-specific
 bits are the STAY_IN_CFGLAYOUT_MODE bits.  The tracer pass was moved
 to GIMPLE a long time ago, but it doesn't relink the basic block
 chain.  It could do that (to give better initial RTL) if this function
 is made IR-agnostic (and moved to cfganal.cc or cfg.cc while at it).  */

3783void
3784relink_block_chain (bool stay_in_cfglayout_mode)
3785{
basic_block bb, prev_bb;
int index;

/* Maybe dump the re-ordered sequence.  */
if (dump_file)
  {
    fprintf (dump_file, "Reordered sequence:\n");
    for (bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->next_bb, index =
  NUM_FIXED_BLOCKS(2);
  bb;
  bb = (basic_block) bb->aux, index++)
{
 fprintf (dump_file, " %i ", index);
 if (get_bb_original (bb))
   fprintf (dump_file, "duplicate of %i\n",
     get_bb_original (bb)->index);
 else if (forwarder_block_p (bb)
   && !LABEL_P (BB_HEAD (bb))(((enum rtx_code) ((bb)->il.x.head_)->code) == CODE_LABEL
))
   fprintf (dump_file, "compensation\n");
 else
   fprintf (dump_file, "bb %i\n", bb->index);
}
  }

/* Now reorder the blocks.  */
prev_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr);
bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->next_bb;
for (; bb; prev_bb = bb, bb = (basic_block) bb->aux)
  {
    bb->prev_bb = prev_bb;
    prev_bb->next_bb = bb;
  }
prev_bb->next_bb = EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr);
EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb = prev_bb;

/* Then, clean up the aux fields.  */
FOR_ALL_BB_FN (bb, cfun)for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb
 = bb->next_bb)
  {
    bb->aux = NULLnullptr;
    if (!stay_in_cfglayout_mode)
BB_HEADER (bb)(bb)->il.x.rtl->header_ = BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = NULLnullptr;
  }

/* Maybe reset the original copy tables, they are not valid anymore
   when we renumber the basic blocks in compact_blocks.  If we are
   are going out of cfglayout mode, don't re-allocate the tables.  */
if (original_copy_tables_initialized_p ())
  free_original_copy_tables ();
if (stay_in_cfglayout_mode)
  initialize_original_copy_tables ();

/* Finally, put basic_block_info in the new order.  */
compact_blocks ();
3839}
3840

3842/* Given a reorder chain, rearrange the code to match.  */

3844static void
3845fixup_reorder_chain (void)
3846{
basic_block bb;
rtx_insn *insn = NULLnullptr;
1
'insn' initialized to a null pointer value→

if (cfg_layout_function_header)
2
←
Assuming 'cfg_layout_function_header' is null→
3
←
Taking false branch→
  {
    set_first_insn (cfg_layout_function_header);
    insn = cfg_layout_function_header;
    while (NEXT_INSN (insn))
insn = NEXT_INSN (insn);
  }

/* First do the bulk reordering -- rechain the blocks without regard to
   the needed changes to jumps and labels.  */

for (bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->next_bb; bb; bb = (basic_block)
4
←
Loop condition is false. Execution continues on line 3890→
     bb->aux)
  {
    if (BB_HEADER (bb)(bb)->il.x.rtl->header_)
{
 if (insn)
   SET_NEXT_INSN (insn) = BB_HEADER (bb)(bb)->il.x.rtl->header_;
 else
   set_first_insn (BB_HEADER (bb)(bb)->il.x.rtl->header_);
 SET_PREV_INSN (BB_HEADER (bb)(bb)->il.x.rtl->header_) = insn;
 insn = BB_HEADER (bb)(bb)->il.x.rtl->header_;
 while (NEXT_INSN (insn))
   insn = NEXT_INSN (insn);
}
    if (insn)
SET_NEXT_INSN (insn) = BB_HEAD (bb)(bb)->il.x.head_;
    else
set_first_insn (BB_HEAD (bb)(bb)->il.x.head_);
    SET_PREV_INSN (BB_HEAD (bb)(bb)->il.x.head_) = insn;
    insn = BB_END (bb)(bb)->il.x.rtl->end_;
    if (BB_FOOTER (bb)(bb)->il.x.rtl->footer_)
{
 SET_NEXT_INSN (insn) = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;
 SET_PREV_INSN (BB_FOOTER (bb)(bb)->il.x.rtl->footer_) = insn;
 while (NEXT_INSN (insn))
   insn = NEXT_INSN (insn);
}
  }

SET_NEXT_INSN (insn) = cfg_layout_function_footer;
5
←
Passing null pointer value via 1st parameter 'insn'→
6
←
Calling 'SET_NEXT_INSN'→
if (cfg_layout_function_footer)
  SET_PREV_INSN (cfg_layout_function_footer) = insn;

while (NEXT_INSN (insn))
  insn = NEXT_INSN (insn);

set_last_insn (insn);
if (flag_checkingglobal_options.x_flag_checking)
  verify_insn_chain ();

/* Now add jumps and labels as needed to match the blocks new
   outgoing edges.  */

bool remove_unreachable_blocks = false;
for (bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->next_bb; bb ; bb = (basic_block)
     bb->aux)
  {
    edge e_fall, e_taken, e;
    rtx_insn *bb_end_insn;
    rtx ret_label = NULL_RTX(rtx) 0;
    basic_block nb;
    edge_iterator ei;
    bool asm_goto = false;

    if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) == 0)
continue;

    /* Find the old fallthru edge, and another non-EH edge for
a taken jump.  */
    e_taken = e_fall = NULLnullptr;

    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
if (e->flags & EDGE_FALLTHRU)
 e_fall = e;
else if (! (e->flags & EDGE_EH))
 e_taken = e;

    bb_end_insn = BB_END (bb)(bb)->il.x.rtl->end_;
    if (rtx_jump_insn *bb_end_jump = dyn_cast <rtx_jump_insn *> (bb_end_insn))
{
 ret_label = JUMP_LABEL (bb_end_jump)(((bb_end_jump)->u.fld[7]).rt_rtx);
 if (any_condjump_p (bb_end_jump))
   {
     /* This might happen if the conditional jump has side
 effects and could therefore not be optimized away.
 Make the basic block to end with a barrier in order
 to prevent rtl_verify_flow_info from complaining.  */
     if (!e_fall)
{
  gcc_assert (!onlyjump_p (bb_end_jump)((void)(!(!onlyjump_p (bb_end_jump) || returnjump_p (bb_end_jump
) || (e_taken->flags & EDGE_CROSSING)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3942, __FUNCTION__), 0 : 0))
	      || returnjump_p (bb_end_jump)((void)(!(!onlyjump_p (bb_end_jump) || returnjump_p (bb_end_jump
) || (e_taken->flags & EDGE_CROSSING)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3942, __FUNCTION__), 0 : 0))
                            || (e_taken->flags & EDGE_CROSSING))((void)(!(!onlyjump_p (bb_end_jump) || returnjump_p (bb_end_jump
) || (e_taken->flags & EDGE_CROSSING)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3942, __FUNCTION__), 0 : 0));
  emit_barrier_after (bb_end_jump);
  continue;
}

     /* If the old fallthru is still next, nothing to do.  */
     if (bb->aux == e_fall->dest
  || e_fall->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
continue;

     /* The degenerated case of conditional jump jumping to the next
 instruction can happen for jumps with side effects.  We need
 to construct a forwarder block and this will be done just
 fine by force_nonfallthru below.  */
     if (!e_taken)
;

     /* There is another special case: if *neither* block is next,
 such as happens at the very end of a function, then we'll
 need to add a new unconditional jump.  Choose the taken
 edge based on known or assumed probability.  */
     else if (bb->aux != e_taken->dest)
{
  rtx note = find_reg_note (bb_end_jump, REG_BR_PROB, 0);

  if (note
      && profile_probability::from_reg_br_prob_note
		 (XINT (note, 0)(((note)->u.fld[0]).rt_int)) < profile_probability::even ()
      && invert_jump (bb_end_jump,
		      (e_fall->dest
		       == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
		       ? NULL_RTX(rtx) 0
		       : label_for_bb (e_fall->dest)), 0))
    {
      e_fall->flags &= ~EDGE_FALLTHRU;
      gcc_checking_assert (could_fall_through((void)(!(could_fall_through (e_taken->src, e_taken->dest
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3978, __FUNCTION__), 0 : 0))
			   (e_taken->src, e_taken->dest))((void)(!(could_fall_through (e_taken->src, e_taken->dest
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 3978, __FUNCTION__), 0 : 0));
      e_taken->flags |= EDGE_FALLTHRU;
      update_br_prob_note (bb);
      e = e_fall, e_fall = e_taken, e_taken = e;
    }
}

     /* If the "jumping" edge is a crossing edge, and the fall
 through edge is non-crossing, leave things as they are.  */
     else if ((e_taken->flags & EDGE_CROSSING)
       && !(e_fall->flags & EDGE_CROSSING))
continue;

     /* Otherwise we can try to invert the jump.  This will
 basically never fail, however, keep up the pretense.  */
     else if (invert_jump (bb_end_jump,
		    (e_fall->dest
		     == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
		     ? NULL_RTX(rtx) 0
		     : label_for_bb (e_fall->dest)), 0))
{
  e_fall->flags &= ~EDGE_FALLTHRU;
  gcc_checking_assert (could_fall_through((void)(!(could_fall_through (e_taken->src, e_taken->dest
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4001, __FUNCTION__), 0 : 0))
		       (e_taken->src, e_taken->dest))((void)(!(could_fall_through (e_taken->src, e_taken->dest
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4001, __FUNCTION__), 0 : 0));
  e_taken->flags |= EDGE_FALLTHRU;
  update_br_prob_note (bb);
  if (LABEL_NUSES (ret_label)(((ret_label)->u.fld[4]).rt_int) == 0
      && single_pred_p (e_taken->dest))
    delete_insn (as_a<rtx_insn *> (ret_label));
  continue;
}
   }
 else if (extract_asm_operands (PATTERN (bb_end_insn)) != NULLnullptr)
   {
     /* If the old fallthru is still next or if
 asm goto doesn't have a fallthru (e.g. when followed by
 __builtin_unreachable ()), nothing to do.  */
     if (! e_fall
  || bb->aux == e_fall->dest
  || e_fall->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
continue;

     /* Otherwise we'll have to use the fallthru fixup below.
 But avoid redirecting asm goto to EXIT.  */
     asm_goto = true;
   }
 else
   {
     /* Otherwise we have some return, switch or computed
 jump.  In the 99% case, there should not have been a
 fallthru edge.  */
     gcc_assert (returnjump_p (bb_end_insn) || !e_fall)((void)(!(returnjump_p (bb_end_insn) || !e_fall) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4029, __FUNCTION__), 0 : 0));
     continue;
   }
}
    else
{
 /* No fallthru implies a noreturn function with EH edges, or
    something similarly bizarre.  In any case, we don't need to
    do anything.  */
 if (! e_fall)
   continue;

 /* If the fallthru block is still next, nothing to do.  */
 if (bb->aux == e_fall->dest)
   continue;

 /* A fallthru to exit block.  */
 if (e_fall->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
   continue;
}

    /* If E_FALL->dest is just a return block, then we can emit a
return rather than a jump to the return block.  */
    rtx_insn *ret, *use;
    basic_block dest;
    if (!asm_goto
 && bb_is_just_return (e_fall->dest, &ret, &use)
 && ((PATTERN (ret) == simple_return_rtx && targetm.have_simple_return ())
     || (PATTERN (ret) == ret_rtx && targetm.have_return ())))
{
 ret_label = PATTERN (ret);
 dest = EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr);

 e_fall->flags &= ~EDGE_CROSSING;
 /* E_FALL->dest might become unreachable as a result of
    replacing the jump with a return.  So arrange to remove
    unreachable blocks.  */
 remove_unreachable_blocks = true;
}
    else
{
 dest = e_fall->dest;
}

    /* We got here if we need to add a new jump insn. 
Note force_nonfallthru can delete E_FALL and thus we have to
save E_FALL->src prior to the call to force_nonfallthru.  */
    nb = force_nonfallthru_and_redirect (e_fall, dest, ret_label);
    if (nb)
{
 nb->aux = bb->aux;
 bb->aux = nb;
 /* Don't process this new block.  */
 bb = nb;
}
  }

relink_block_chain (/*stay_in_cfglayout_mode=*/false);

/* Annoying special case - jump around dead jumptables left in the code.  */
FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    edge e = find_fallthru_edge (bb->succs);

    if (e && !can_fallthru (e->src, e->dest))
force_nonfallthru (e);
  }

/* Ensure goto_locus from edges has some instructions with that locus in RTL
   when not optimizing.  */
if (!optimizeglobal_options.x_optimize && !DECL_IGNORED_P (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4099, __FUNCTION__))->decl_common.ignored_flag))
  FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
    {
      edge e;
      edge_iterator ei;

      FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
 if (LOCATION_LOCUS (e->goto_locus)((IS_ADHOC_LOC (e->goto_locus)) ? get_location_from_adhoc_loc
 (line_table, e->goto_locus) : (e->goto_locus)) != UNKNOWN_LOCATION((location_t) 0)
     && !(e->flags & EDGE_ABNORMAL))
   {
     edge e2;
     edge_iterator ei2;
     basic_block dest, nb;
     rtx_insn *end;

     insn = BB_END (e->src)(e->src)->il.x.rtl->end_;
     end = PREV_INSN (BB_HEAD (e->src)(e->src)->il.x.head_);
     while (insn != end
     && (!NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || !INSN_HAS_LOCATION (insn)))
insn = PREV_INSN (insn);
     if (insn != end
  && loc_equal (INSN_LOCATION (insn), e->goto_locus))
continue;
     if (simplejump_p (BB_END (e->src)(e->src)->il.x.rtl->end_)
  && !INSN_HAS_LOCATION (BB_END (e->src)(e->src)->il.x.rtl->end_))
{
  INSN_LOCATION (BB_END (e->src)(e->src)->il.x.rtl->end_) = e->goto_locus;
  continue;
}
     dest = e->dest;
     if (dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
{
  /* Non-fallthru edges to the exit block cannot be split.  */
  if (!(e->flags & EDGE_FALLTHRU))
    continue;
}
     else
{
  insn = BB_HEAD (dest)(dest)->il.x.head_;
  end = NEXT_INSN (BB_END (dest)(dest)->il.x.rtl->end_);
  while (insn != end && !NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)))
    insn = NEXT_INSN (insn);
  if (insn != end && INSN_HAS_LOCATION (insn)
      && loc_equal (INSN_LOCATION (insn), e->goto_locus))
    continue;
}
     nb = split_edge (e);
     if (!INSN_P (BB_END (nb))(((((enum rtx_code) ((nb)->il.x.rtl->end_)->code) ==
 INSN) || (((enum rtx_code) ((nb)->il.x.rtl->end_)->
code) == JUMP_INSN) || (((enum rtx_code) ((nb)->il.x.rtl->
end_)->code) == CALL_INSN)) || (((enum rtx_code) ((nb)->
il.x.rtl->end_)->code) == DEBUG_INSN)))
BB_END (nb)(nb)->il.x.rtl->end_ = emit_insn_after_noloc (gen_nop (), BB_END (nb)(nb)->il.x.rtl->end_,
					 nb);
     INSN_LOCATION (BB_END (nb)(nb)->il.x.rtl->end_) = e->goto_locus;

     /* If there are other incoming edges to the destination block
 with the same goto locus, redirect them to the new block as
 well, this can prevent other such blocks from being created
 in subsequent iterations of the loop.  */
     for (ei2 = ei_start (dest->preds)ei_start_1 (&(dest->preds)); (e2 = ei_safe_edge (ei2)); )
if (LOCATION_LOCUS (e2->goto_locus)((IS_ADHOC_LOC (e2->goto_locus)) ? get_location_from_adhoc_loc
 (line_table, e2->goto_locus) : (e2->goto_locus)) != UNKNOWN_LOCATION((location_t) 0)
    && !(e2->flags & (EDGE_ABNORMAL | EDGE_FALLTHRU))
    && e->goto_locus == e2->goto_locus)
  redirect_edge_and_branch (e2, nb);
else
  ei_next (&ei2);
   }
    }

/* Replacing a jump with a return may have exposed an unreachable
   block.  Conditionally remove them if such transformations were
   made.  */
if (remove_unreachable_blocks)
  delete_unreachable_blocks ();
4170}
4171
4172/* Perform sanity checks on the insn chain.
 1. Check that next/prev pointers are consistent in both the forward and
    reverse direction.
 2. Count insns in chain, going both directions, and check if equal.
 3. Check that get_last_insn () returns the actual end of chain.  */

4178DEBUG_FUNCTION__attribute__ ((__used__)) void
4179verify_insn_chain (void)
4180{
rtx_insn *x, *prevx, *nextx;
int insn_cnt1, insn_cnt2;

for (prevx = NULLnullptr, insn_cnt1 = 1, x = get_insns ();
     x != 0;
     prevx = x, insn_cnt1++, x = NEXT_INSN (x))
  gcc_assert (PREV_INSN (x) == prevx)((void)(!(PREV_INSN (x) == prevx) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4187, __FUNCTION__), 0 : 0));

gcc_assert (prevx == get_last_insn ())((void)(!(prevx == get_last_insn ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4189, __FUNCTION__), 0 : 0));

for (nextx = NULLnullptr, insn_cnt2 = 1, x = get_last_insn ();
     x != 0;
     nextx = x, insn_cnt2++, x = PREV_INSN (x))
  gcc_assert (NEXT_INSN (x) == nextx)((void)(!(NEXT_INSN (x) == nextx) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4194, __FUNCTION__), 0 : 0));

gcc_assert (insn_cnt1 == insn_cnt2)((void)(!(insn_cnt1 == insn_cnt2) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4196, __FUNCTION__), 0 : 0));
4197}
4198
4199/* If we have assembler epilogues, the block falling through to exit must
 be the last one in the reordered chain when we reach final.  Ensure
 that this condition is met.  */
4202static void
4203fixup_fallthru_exit_predecessor (void)
4204{
edge e;
basic_block bb = NULLnullptr;

/* This transformation is not valid before reload, because we might
   separate a call from the instruction that copies the return
   value.  */
gcc_assert (reload_completed)((void)(!(reload_completed) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4211, __FUNCTION__), 0 : 0));

e = find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)->preds);
if (e)
  bb = e->src;

if (bb && bb->aux)
  {
    basic_block c = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->next_bb;

    /* If the very first block is the one with the fall-through exit
edge, we have to split that block.  */
    if (c == bb)
{
 bb = split_block_after_labels (bb)->dest;
 bb->aux = c->aux;
 c->aux = bb;
 BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = BB_FOOTER (c)(c)->il.x.rtl->footer_;
 BB_FOOTER (c)(c)->il.x.rtl->footer_ = NULLnullptr;
}

    while (c->aux != bb)
c = (basic_block) c->aux;

    c->aux = bb->aux;
    while (c->aux)
c = (basic_block) c->aux;

    c->aux = bb;
    bb->aux = NULLnullptr;
  }
4242}

4244/* In case there are more than one fallthru predecessors of exit, force that
 there is only one.  */

4247static void
4248force_one_exit_fallthru (void)
4249{
edge e, predecessor = NULLnullptr;
bool more = false;
edge_iterator ei;
basic_block forwarder, bb;

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))
)
  if (e->flags & EDGE_FALLTHRU)
    {
if (predecessor == NULLnullptr)
 predecessor = e;
else
 {
   more = true;
   break;
 }
    }

if (!more)
  return;

/* Exit has several fallthru predecessors.  Create a forwarder block for
   them.  */
forwarder = split_edge (predecessor);
for (ei = ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)ei_start_1 (&((((cfun + 0))->cfg->x_exit_block_ptr)
->preds));
     (e = ei_safe_edge (ei)); )
  {
    if (e->src == forwarder
 || !(e->flags & EDGE_FALLTHRU))
ei_next (&ei);
    else
redirect_edge_and_branch_force (e, forwarder);
  }

/* Fix up the chain of blocks -- make FORWARDER immediately precede the
   exit block.  */
FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    if (bb->aux == NULLnullptr && bb != forwarder)
{
 bb->aux = forwarder;
 break;
}
  }
4293}
4294
4295/* Return true in case it is possible to duplicate the basic block BB.  */

4297static bool
4298cfg_layout_can_duplicate_bb_p (const_basic_block bb)
4299{
/* Do not attempt to duplicate tablejumps, as we need to unshare
   the dispatch table.  This is difficult to do, as the instructions
   computing jump destination may be hoisted outside the basic block.  */
if (tablejump_p (BB_END (bb)(bb)->il.x.rtl->end_, NULLnullptr, NULLnullptr))
  return false;

/* Do not duplicate blocks containing insns that can't be copied.  */
if (targetm.cannot_copy_insn_p)
  {
    rtx_insn *insn = BB_HEAD (bb)(bb)->il.x.head_;
    while (1)
{
 if (INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN)) && targetm.cannot_copy_insn_p (insn))
   return false;
 if (insn == BB_END (bb)(bb)->il.x.rtl->end_)
   break;
 insn = NEXT_INSN (insn);
}
  }

return true;
4321}

4323rtx_insn *
4324duplicate_insn_chain (rtx_insn *from, rtx_insn *to,
      class loop *loop, copy_bb_data *id)
4326{
rtx_insn *insn, *next, *copy;
rtx_note *last;

/* Avoid updating of boundaries of previous basic block.  The
   note will get removed from insn stream in fixup.  */
last = emit_note (NOTE_INSN_DELETED);

/* Create copy at the end of INSN chain.  The chain will
   be reordered later.  */
for (insn = from; insn != NEXT_INSN (to); insn = NEXT_INSN (insn))
  {
    switch (GET_CODE (insn)((enum rtx_code) (insn)->code))
{
case DEBUG_INSN:
 /* Don't duplicate label debug insns.  */
 if (DEBUG_BIND_INSN_P (insn)((((enum rtx_code) (insn)->code) == DEBUG_INSN) &&
 (((enum rtx_code) (PATTERN (insn))->code) == VAR_LOCATION
))
     && TREE_CODE (INSN_VAR_LOCATION_DECL (insn))((enum tree_code) (((((((__extension__ ({ __typeof (PATTERN (
insn)) const _rtx = (PATTERN (insn)); if (((enum rtx_code) (_rtx
)->code) != VAR_LOCATION) rtl_check_failed_flag ("INSN_VAR_LOCATION"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4343, __FUNCTION__); _rtx; }))))->u.fld[0]).rt_tree)))->
base.code) == LABEL_DECL)
   break;
 /* FALLTHRU */
case INSN:
case CALL_INSN:
case JUMP_INSN:
 copy = emit_copy_of_insn_after (insn, get_last_insn ());
 if (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN) && JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx) != NULL_RTX(rtx) 0
     && ANY_RETURN_P (JUMP_LABEL (insn))(((enum rtx_code) ((((insn)->u.fld[7]).rt_rtx))->code) ==
 RETURN || ((enum rtx_code) ((((insn)->u.fld[7]).rt_rtx))->
code) == SIMPLE_RETURN))
   JUMP_LABEL (copy)(((copy)->u.fld[7]).rt_rtx) = JUMP_LABEL (insn)(((insn)->u.fld[7]).rt_rtx);
        maybe_copy_prologue_epilogue_insn (insn, copy);
 /* If requested remap dependence info of cliques brought in
    via inlining.  */
 if (id)
   {
     subrtx_iterator::array_type array;
     FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)for (subrtx_iterator iter (array, PATTERN (insn), rtx_all_subrtx_bounds
); !iter.at_end (); iter.next ())
if (MEM_P (*iter)(((enum rtx_code) (*iter)->code) == MEM) && MEM_EXPR (*iter)(get_mem_attrs (*iter)->expr))
  {
    tree op = MEM_EXPR (*iter)(get_mem_attrs (*iter)->expr);
    if (TREE_CODE (op)((enum tree_code) (op)->base.code) == WITH_SIZE_EXPR)
      op = TREE_OPERAND (op, 0)(*((const_cast<tree*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4364, __FUNCTION__)))));
    while (handled_component_p (op))
      op = TREE_OPERAND (op, 0)(*((const_cast<tree*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4366, __FUNCTION__)))));
    if ((TREE_CODE (op)((enum tree_code) (op)->base.code) == MEM_REF
	 || TREE_CODE (op)((enum tree_code) (op)->base.code) == TARGET_MEM_REF)
	&& MR_DEPENDENCE_CLIQUE (op)((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4369, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) > 1
	&& (!loop
	    || (MR_DEPENDENCE_CLIQUE (op)((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4371, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique)
		!= loop->owned_clique)))
      {
	if (!id->dependence_map)
	  id->dependence_map = new hash_map<dependence_hash,
	      unsigned short>;
	bool existed;
	unsigned short &newc = id->dependence_map->get_or_insert
			 (MR_DEPENDENCE_CLIQUE (op)((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4379, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique), &existed);
	if (!existed)
	  {
	    gcc_assert((void)(!(((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4383, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) <= (cfun + 0)->last_clique) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4383, __FUNCTION__), 0 : 0))
	      (MR_DEPENDENCE_CLIQUE (op) <= cfun->last_clique)((void)(!(((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4383, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) <= (cfun + 0)->last_clique) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4383, __FUNCTION__), 0 : 0));
	    newc = ++cfun(cfun + 0)->last_clique;
	  }
	/* We cannot adjust MR_DEPENDENCE_CLIQUE in-place
	   since MEM_EXPR is shared so make a copy and
	   walk to the subtree again.  */
	tree new_expr = unshare_expr (MEM_EXPR (*iter)(get_mem_attrs (*iter)->expr));
	if (TREE_CODE (new_expr)((enum tree_code) (new_expr)->base.code) == WITH_SIZE_EXPR)
	  new_expr = TREE_OPERAND (new_expr, 0)(*((const_cast<tree*> (tree_operand_check ((new_expr), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4391, __FUNCTION__)))));
	while (handled_component_p (new_expr))
	  new_expr = TREE_OPERAND (new_expr, 0)(*((const_cast<tree*> (tree_operand_check ((new_expr), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4393, __FUNCTION__)))));
	MR_DEPENDENCE_CLIQUE (new_expr)((tree_check2 ((new_expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4394, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) = newc;
	set_mem_expr (const_cast <rtx> (*iter), new_expr);
      }
  }
   }
 break;

case JUMP_TABLE_DATA:
 /* Avoid copying of dispatch tables.  We never duplicate
    tablejumps, so this can hit only in case the table got
    moved far from original jump.
    Avoid copying following barrier as well if any
    (and debug insns in between).  */
 for (next = NEXT_INSN (insn);
      next != NEXT_INSN (to);
      next = NEXT_INSN (next))
   if (!DEBUG_INSN_P (next)(((enum rtx_code) (next)->code) == DEBUG_INSN))
     break;
 if (next != NEXT_INSN (to) && BARRIER_P (next)(((enum rtx_code) (next)->code) == BARRIER))
   insn = next;
 break;

case CODE_LABEL:
 break;

case BARRIER:
 emit_barrier ();
 break;

case NOTE:
 switch (NOTE_KIND (insn)(((insn)->u.fld[4]).rt_int))
   {
     /* In case prologue is empty and function contain label
 in first BB, we may want to copy the block.  */
   case NOTE_INSN_PROLOGUE_END:

   case NOTE_INSN_DELETED:
   case NOTE_INSN_DELETED_LABEL:
   case NOTE_INSN_DELETED_DEBUG_LABEL:
     /* No problem to strip these.  */
   case NOTE_INSN_FUNCTION_BEG:
     /* There is always just single entry to function.  */
   case NOTE_INSN_BASIC_BLOCK:
            /* We should only switch text sections once.  */
   case NOTE_INSN_SWITCH_TEXT_SECTIONS:
     break;

   case NOTE_INSN_EPILOGUE_BEG:
   case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
     emit_note_copy (as_a <rtx_note *> (insn));
     break;

   default:
     /* All other notes should have already been eliminated.  */
     gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4448, __FUNCTION__));
   }
 break;
default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4452, __FUNCTION__));
}
  }
insn = NEXT_INSN (last);
delete_insn (last);
return insn;
4458}

4460/* Create a duplicate of the basic block BB.  */

4462static basic_block
4463cfg_layout_duplicate_bb (basic_block bb, copy_bb_data *id)
4464{
rtx_insn *insn;
basic_block new_bb;

class loop *loop = (id && current_loops((cfun + 0)->x_current_loops)) ? bb->loop_father : NULLnullptr;

insn = duplicate_insn_chain (BB_HEAD (bb)(bb)->il.x.head_, BB_END (bb)(bb)->il.x.rtl->end_, loop, id);
new_bb = create_basic_block (insn,
	       insn ? get_last_insn () : NULLnullptr,
	       EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb);

BB_COPY_PARTITION (new_bb, bb)do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags
 & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((bb)->flags
 & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while (0);
if (BB_HEADER (bb)(bb)->il.x.rtl->header_)
  {
    insn = BB_HEADER (bb)(bb)->il.x.rtl->header_;
    while (NEXT_INSN (insn))
insn = NEXT_INSN (insn);
    insn = duplicate_insn_chain (BB_HEADER (bb)(bb)->il.x.rtl->header_, insn, loop, id);
    if (insn)
BB_HEADER (new_bb)(new_bb)->il.x.rtl->header_ = unlink_insn_chain (insn, get_last_insn ());
  }

if (BB_FOOTER (bb)(bb)->il.x.rtl->footer_)
  {
    insn = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;
    while (NEXT_INSN (insn))
insn = NEXT_INSN (insn);
    insn = duplicate_insn_chain (BB_FOOTER (bb)(bb)->il.x.rtl->footer_, insn, loop, id);
    if (insn)
BB_FOOTER (new_bb)(new_bb)->il.x.rtl->footer_ = unlink_insn_chain (insn, get_last_insn ());
  }

return new_bb;
4497}

4499
4500/* Main entry point to this module - initialize the datastructures for
 CFG layout changes.  It keeps LOOPS up-to-date if not null.

 FLAGS is a set of additional flags to pass to cleanup_cfg().  */

4505void
4506cfg_layout_initialize (int flags)
4507{
rtx_insn_list *x;
basic_block bb;

/* Once bb partitioning is complete, cfg layout mode should not be
   re-entered.  Entering cfg layout mode may require fixups.  As an
   example, if edge forwarding performed when optimizing the cfg
   layout required moving a block from the hot to the cold
   section. This would create an illegal partitioning unless some
   manual fixup was performed.  */
gcc_assert (!crtl->bb_reorder_complete || !crtl->has_bb_partition)((void)(!(!(&x_rtl)->bb_reorder_complete || !(&x_rtl
)->has_bb_partition) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4517, __FUNCTION__), 0 : 0));

initialize_original_copy_tables ();

cfg_layout_rtl_register_cfg_hooks ();

record_effective_endpoints ();

/* Make sure that the targets of non local gotos are marked.  */
for (x = nonlocal_goto_handler_labels((&x_rtl)->x_nonlocal_goto_handler_labels); x; x = x->next ())
  {
    bb = BLOCK_FOR_INSN (x->insn ());
    bb->flags |= BB_NON_LOCAL_GOTO_TARGET;
  }

cleanup_cfg (CLEANUP_CFGLAYOUT32 | flags);
4533}

4535/* Splits superblocks.  */
4536void
4537break_superblocks (void)
4538{
bool need = false;
basic_block bb;

auto_sbitmap superblocks (last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block));
bitmap_clear (superblocks);

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  if (bb->flags & BB_SUPERBLOCK)
    {
bb->flags &= ~BB_SUPERBLOCK;
bitmap_set_bit (superblocks, bb->index);
need = true;
    }

if (need)
  {
    rebuild_jump_labels (get_insns ());
    find_many_sub_basic_blocks (superblocks);
  }
4558}

4560/* Finalize the changes: reorder insn list according to the sequence specified
 by aux pointers, enter compensation code, rebuild scope forest.  */

4563void
4564cfg_layout_finalize (void)
4565{
free_dominance_info (CDI_DOMINATORS);
force_one_exit_fallthru ();
rtl_register_cfg_hooks ();
if (reload_completed && !targetm.have_epilogue ())
  fixup_fallthru_exit_predecessor ();
fixup_reorder_chain ();

rebuild_jump_labels (get_insns ());
delete_dead_jumptables ();

if (flag_checkingglobal_options.x_flag_checking)
  verify_insn_chain ();
checking_verify_flow_info ();
4579}


4582/* Same as split_block but update cfg_layout structures.  */

4584static basic_block
4585cfg_layout_split_block (basic_block bb, void *insnp)
4586{
rtx insn = (rtx) insnp;
basic_block new_bb = rtl_split_block (bb, insn);

BB_FOOTER (new_bb)(new_bb)->il.x.rtl->footer_ = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;
BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = NULLnullptr;

return new_bb;
4594}

4596/* Redirect Edge to DEST.  */
4597static edge
4598cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
4599{
basic_block src = e->src;
edge ret;

if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
  return NULLnullptr;

if (e->dest == dest)
  return e;

if (e->flags & EDGE_CROSSING
    && BB_PARTITION (e->src)((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)) == BB_PARTITION (dest)((dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
    && simplejump_p (BB_END (src)(src)->il.x.rtl->end_))
  {
    if (dump_file)
fprintf (dump_file,
 	 "Removing crossing jump while redirecting edge form %i to %i\n",
 e->src->index, dest->index);
    delete_insn (BB_END (src)(src)->il.x.rtl->end_);
    remove_barriers_from_footer (src);
    e->flags |= EDGE_FALLTHRU;
  }

if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
    && (ret = try_redirect_by_replacing_jump (e, dest, true)))
  {
    df_set_bb_dirty (src);
    return ret;
  }

if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
    && (e->flags & EDGE_FALLTHRU) && !(e->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
)))
  {
    if (dump_file)
fprintf (dump_file, "Redirecting entry edge from bb %i to %i\n",
 e->src->index, dest->index);

    df_set_bb_dirty (e->src);
    redirect_edge_succ (e, dest);
    return e;
  }

/* Redirect_edge_and_branch may decide to turn branch into fallthru edge
   in the case the basic block appears to be in sequence.  Avoid this
   transformation.  */

if (e->flags & EDGE_FALLTHRU)
  {
    /* Redirect any branch edges unified with the fallthru one.  */
    if (JUMP_P (BB_END (src))(((enum rtx_code) ((src)->il.x.rtl->end_)->code) == JUMP_INSN
)
 && label_is_jump_target_p (BB_HEAD (e->dest)(e->dest)->il.x.head_,
		     BB_END (src)(src)->il.x.rtl->end_))
{
 edge redirected;

 if (dump_file)
   fprintf (dump_file, "Fallthru edge unified with branch "
     "%i->%i redirected to %i\n",
     e->src->index, e->dest->index, dest->index);
 e->flags &= ~EDGE_FALLTHRU;
 redirected = redirect_branch_edge (e, dest);
 gcc_assert (redirected)((void)(!(redirected) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4660, __FUNCTION__), 0 : 0));
 redirected->flags |= EDGE_FALLTHRU;
 df_set_bb_dirty (redirected->src);
 return redirected;
}
    /* In case we are redirecting fallthru edge to the branch edge
of conditional jump, remove it.  */
    if (EDGE_COUNT (src->succs)vec_safe_length (src->succs) == 2)
{
 /* Find the edge that is different from E.  */
 edge s = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)(*(src)->succs)[((*(src)->succs)[(0)] == e)];

 if (s->dest == dest
     && any_condjump_p (BB_END (src)(src)->il.x.rtl->end_)
     && onlyjump_p (BB_END (src)(src)->il.x.rtl->end_))
   delete_insn (BB_END (src)(src)->il.x.rtl->end_);
}
    if (dump_file)
fprintf (dump_file, "Redirecting fallthru edge %i->%i to %i\n",
 e->src->index, e->dest->index, dest->index);
    ret = redirect_edge_succ_nodup (e, dest);
  }
else
  ret = redirect_branch_edge (e, dest);

if (!ret)
  return NULLnullptr;

fixup_partition_crossing (ret);
/* We don't want simplejumps in the insn stream during cfglayout.  */
gcc_assert (!simplejump_p (BB_END (src)) || CROSSING_JUMP_P (BB_END (src)))((void)(!(!simplejump_p ((src)->il.x.rtl->end_) || (__extension__
 ({ __typeof (((src)->il.x.rtl->end_)) const _rtx = (((
src)->il.x.rtl->end_)); if (((enum rtx_code) (_rtx)->
code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P",
 _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4690, __FUNCTION__); _rtx; })->jump)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4690, __FUNCTION__), 0 : 0));

df_set_bb_dirty (src);
return ret;
4694}

4696/* Simple wrapper as we always can redirect fallthru edges.  */
4697static basic_block
4698cfg_layout_redirect_edge_and_branch_force (edge e, basic_block dest)
4699{
edge redirected = cfg_layout_redirect_edge_and_branch (e, dest);

gcc_assert (redirected)((void)(!(redirected) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4702, __FUNCTION__), 0 : 0));
return NULLnullptr;
4704}

4706/* Same as delete_basic_block but update cfg_layout structures.  */

4708static void
4709cfg_layout_delete_block (basic_block bb)
4710{
rtx_insn *insn, *next, *prev = PREV_INSN (BB_HEAD (bb)(bb)->il.x.head_), *remaints;
rtx_insn **to;

if (BB_HEADER (bb)(bb)->il.x.rtl->header_)
  {
    next = BB_HEAD (bb)(bb)->il.x.head_;
    if (prev)
SET_NEXT_INSN (prev) = BB_HEADER (bb)(bb)->il.x.rtl->header_;
    else
set_first_insn (BB_HEADER (bb)(bb)->il.x.rtl->header_);
    SET_PREV_INSN (BB_HEADER (bb)(bb)->il.x.rtl->header_) = prev;
    insn = BB_HEADER (bb)(bb)->il.x.rtl->header_;
    while (NEXT_INSN (insn))
insn = NEXT_INSN (insn);
    SET_NEXT_INSN (insn) = next;
    SET_PREV_INSN (next) = insn;
  }
next = NEXT_INSN (BB_END (bb)(bb)->il.x.rtl->end_);
if (BB_FOOTER (bb)(bb)->il.x.rtl->footer_)
  {
    insn = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;
    while (insn)
{
 if (BARRIER_P (insn)(((enum rtx_code) (insn)->code) == BARRIER))
   {
     if (PREV_INSN (insn))
SET_NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
     else
BB_FOOTER (bb)(bb)->il.x.rtl->footer_ = NEXT_INSN (insn);
     if (NEXT_INSN (insn))
SET_PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
   }
 if (LABEL_P (insn)(((enum rtx_code) (insn)->code) == CODE_LABEL))
   break;
 insn = NEXT_INSN (insn);
}
    if (BB_FOOTER (bb)(bb)->il.x.rtl->footer_)
{
 insn = BB_END (bb)(bb)->il.x.rtl->end_;
 SET_NEXT_INSN (insn) = BB_FOOTER (bb)(bb)->il.x.rtl->footer_;
 SET_PREV_INSN (BB_FOOTER (bb)(bb)->il.x.rtl->footer_) = insn;
 while (NEXT_INSN (insn))
   insn = NEXT_INSN (insn);
 SET_NEXT_INSN (insn) = next;
 if (next)
   SET_PREV_INSN (next) = insn;
 else
   set_last_insn (insn);
}
  }
if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  to = &BB_HEADER (bb->next_bb)(bb->next_bb)->il.x.rtl->header_;
else
  to = &cfg_layout_function_footer;

rtl_delete_block (bb);

if (prev)
  prev = NEXT_INSN (prev);
else
  prev = get_insns ();
if (next)
  next = PREV_INSN (next);
else
  next = get_last_insn ();

if (next && NEXT_INSN (next) != prev)
  {
    remaints = unlink_insn_chain (prev, next);
    insn = remaints;
    while (NEXT_INSN (insn))
insn = NEXT_INSN (insn);
    SET_NEXT_INSN (insn) = *to;
    if (*to)
SET_PREV_INSN (*to) = insn;
    *to = remaints;
  }
4788}

4790/* Return true when blocks A and B can be safely merged.  */

4792static bool
4793cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
4794{
/* If we are partitioning hot/cold basic blocks, we don't want to
   mess up unconditional or indirect jumps that cross between hot
   and cold sections.

   Basic block partitioning may result in some jumps that appear to
   be optimizable (or blocks that appear to be mergeable), but which really
   must be left untouched (they are required to make it safely across
   partition boundaries).  See  the comments at the top of
   bb-reorder.cc:partition_hot_cold_basic_blocks for complete details.  */

if (BB_PARTITION (a)((a)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_PARTITION (b)((b)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
  return false;

/* Protect the loop latches.  */
if (current_loops((cfun + 0)->x_current_loops) && b->loop_father->latch == b)
  return false;

/* If we would end up moving B's instructions, make sure it doesn't fall
   through into the exit block, since we cannot recover from a fallthrough
   edge into the exit block occurring in the middle of a function.  */
if (NEXT_INSN (BB_END (a)(a)->il.x.rtl->end_) != BB_HEAD (b)(b)->il.x.head_)
  {
    edge e = find_fallthru_edge (b->succs);
    if (e && e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
return false;
  }

/* There must be exactly one edge in between the blocks.  */
return (single_succ_p (a)
 && single_succ (a) == b
 && single_pred_p (b) == 1
 && a != b
 /* Must be simple edge.  */
 && !(single_succ_edge (a)->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
))
 && a != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
 && b != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
 /* If the jump insn has side effects, we can't kill the edge.
    When not optimizing, try_redirect_by_replacing_jump will
    not allow us to redirect an edge by replacing a table jump.  */
 && (!JUMP_P (BB_END (a))(((enum rtx_code) ((a)->il.x.rtl->end_)->code) == JUMP_INSN
)
     || ((!optimizeglobal_options.x_optimize || reload_completed)
  ? simplejump_p (BB_END (a)(a)->il.x.rtl->end_) : onlyjump_p (BB_END (a)(a)->il.x.rtl->end_))));
4837}

4839/* Merge block A and B.  The blocks must be mergeable.  */

4841static void
4842cfg_layout_merge_blocks (basic_block a, basic_block b)
4843{
/* If B is a forwarder block whose outgoing edge has no location, we'll
   propagate the locus of the edge between A and B onto it.  */
const bool forward_edge_locus
  = (b->flags & BB_FORWARDER_BLOCK) != 0
    && LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus)((IS_ADHOC_LOC ((*(b)->succs)[(0)]->goto_locus)) ? get_location_from_adhoc_loc
 (line_table, (*(b)->succs)[(0)]->goto_locus) : ((*(b)->
succs)[(0)]->goto_locus)) == UNKNOWN_LOCATION((location_t) 0);
rtx_insn *insn;

gcc_checking_assert (cfg_layout_can_merge_blocks_p (a, b))((void)(!(cfg_layout_can_merge_blocks_p (a, b)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4851, __FUNCTION__), 0 : 0));

if (dump_file)
  fprintf (dump_file, "Merging block %d into block %d...\n", b->index,
	 a->index);

/* If there was a CODE_LABEL beginning B, delete it.  */
if (LABEL_P (BB_HEAD (b))(((enum rtx_code) ((b)->il.x.head_)->code) == CODE_LABEL
))
  {
    delete_insn (BB_HEAD (b)(b)->il.x.head_);
  }

/* We should have fallthru edge in a, or we can do dummy redirection to get
   it cleaned up.  */
if (JUMP_P (BB_END (a))(((enum rtx_code) ((a)->il.x.rtl->end_)->code) == JUMP_INSN
))
  try_redirect_by_replacing_jump (EDGE_SUCC (a, 0)(*(a)->succs)[(0)], b, true);
gcc_assert (!JUMP_P (BB_END (a)))((void)(!(!(((enum rtx_code) ((a)->il.x.rtl->end_)->
code) == JUMP_INSN)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4867, __FUNCTION__), 0 : 0));

/* If not optimizing, preserve the locus of the single edge between
   blocks A and B if necessary by emitting a nop.  */
if (!optimizeglobal_options.x_optimize
    && !forward_edge_locus
    && !DECL_IGNORED_P (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4873, __FUNCTION__))->decl_common.ignored_flag))
  emit_nop_for_unique_locus_between (a, b);

/* Move things from b->footer after a->footer.  */
if (BB_FOOTER (b)(b)->il.x.rtl->footer_)
  {
    if (!BB_FOOTER (a)(a)->il.x.rtl->footer_)
BB_FOOTER (a)(a)->il.x.rtl->footer_ = BB_FOOTER (b)(b)->il.x.rtl->footer_;
    else
{
 rtx_insn *last = BB_FOOTER (a)(a)->il.x.rtl->footer_;

 while (NEXT_INSN (last))
   last = NEXT_INSN (last);
 SET_NEXT_INSN (last) = BB_FOOTER (b)(b)->il.x.rtl->footer_;
 SET_PREV_INSN (BB_FOOTER (b)(b)->il.x.rtl->footer_) = last;
}
    BB_FOOTER (b)(b)->il.x.rtl->footer_ = NULLnullptr;
  }

/* Move things from b->header before a->footer.
   Note that this may include dead tablejump data, but we don't clean
   those up until we go out of cfglayout mode.  */
 if (BB_HEADER (b)(b)->il.x.rtl->header_)
   {
    if (! BB_FOOTER (a)(a)->il.x.rtl->footer_)
BB_FOOTER (a)(a)->il.x.rtl->footer_ = BB_HEADER (b)(b)->il.x.rtl->header_;
    else
{
 rtx_insn *last = BB_HEADER (b)(b)->il.x.rtl->header_;

 while (NEXT_INSN (last))
   last = NEXT_INSN (last);
 SET_NEXT_INSN (last) = BB_FOOTER (a)(a)->il.x.rtl->footer_;
 SET_PREV_INSN (BB_FOOTER (a)(a)->il.x.rtl->footer_) = last;
 BB_FOOTER (a)(a)->il.x.rtl->footer_ = BB_HEADER (b)(b)->il.x.rtl->header_;
}
    BB_HEADER (b)(b)->il.x.rtl->header_ = NULLnullptr;
  }

/* In the case basic blocks are not adjacent, move them around.  */
if (NEXT_INSN (BB_END (a)(a)->il.x.rtl->end_) != BB_HEAD (b)(b)->il.x.head_)
  {
    insn = unlink_insn_chain (BB_HEAD (b)(b)->il.x.head_, BB_END (b)(b)->il.x.rtl->end_);

    emit_insn_after_noloc (insn, BB_END (a)(a)->il.x.rtl->end_, a);
  }
/* Otherwise just re-associate the instructions.  */
else
  {
    insn = BB_HEAD (b)(b)->il.x.head_;
    BB_END (a)(a)->il.x.rtl->end_ = BB_END (b)(b)->il.x.rtl->end_;
  }

/* emit_insn_after_noloc doesn't call df_insn_change_bb.
   We need to explicitly call. */
update_bb_for_insn_chain (insn, BB_END (b)(b)->il.x.rtl->end_, a);

/* Skip possible DELETED_LABEL insn.  */
if (!NOTE_INSN_BASIC_BLOCK_P (insn)((((enum rtx_code) (insn)->code) == NOTE) && (((insn
)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK))
  insn = NEXT_INSN (insn);
gcc_assert (NOTE_INSN_BASIC_BLOCK_P (insn))((void)(!(((((enum rtx_code) (insn)->code) == NOTE) &&
 (((insn)->u.fld[4]).rt_int) == NOTE_INSN_BASIC_BLOCK)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 4934, __FUNCTION__), 0 : 0));
BB_HEAD (b)(b)->il.x.head_ = BB_END (b)(b)->il.x.rtl->end_ = NULLnullptr;
delete_insn (insn);

df_bb_delete (b->index);

if (forward_edge_locus)
  EDGE_SUCC (b, 0)(*(b)->succs)[(0)]->goto_locus = EDGE_SUCC (a, 0)(*(a)->succs)[(0)]->goto_locus;

if (dump_file)
  fprintf (dump_file, "Merged blocks %d and %d.\n", a->index, b->index);
4945}

4947/* Split edge E.  */

4949static basic_block
4950cfg_layout_split_edge (edge e)
4951{
basic_block new_bb =
  create_basic_block (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
	? NEXT_INSN (BB_END (e->src)(e->src)->il.x.rtl->end_) : get_insns (),
	NULL_RTX(rtx) 0, e->src);

if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  BB_COPY_PARTITION (new_bb, e->src)do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags
 & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((e->src)
->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while
 (0);
else
  BB_COPY_PARTITION (new_bb, e->dest)do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags
 & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((e->dest
)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while
 (0);
make_edge (new_bb, e->dest, EDGE_FALLTHRU);
redirect_edge_and_branch_force (e, new_bb);

return new_bb;
4965}

4967/* Do postprocessing after making a forwarder block joined by edge FALLTHRU.  */

4969static void
4970rtl_make_forwarder_block (edge fallthru ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
4971{
4972}

4974/* Return true if BB contains only labels or non-executable
 instructions.  */

4977static bool
4978rtl_block_empty_p (basic_block bb)
4979{
rtx_insn *insn;

if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
    || bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return true;

FOR_BB_INSNS (bb, insn)for ((insn) = (bb)->il.x.head_; (insn) && (insn) !=
 NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (
insn))
  if (NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN))
&& (!any_uncondjump_p (insn) || !onlyjump_p (insn)))
    return false;

return true;
4992}

4994/* Split a basic block if it ends with a conditional branch and if
 the other part of the block is not empty.  */

4997static basic_block
4998rtl_split_block_before_cond_jump (basic_block bb)
4999{
rtx_insn *insn;
rtx_insn *split_point = NULLnullptr;
rtx_insn *last = NULLnullptr;
bool found_code = false;

FOR_BB_INSNS (bb, insn)for ((insn) = (bb)->il.x.head_; (insn) && (insn) !=
 NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (
insn))
  {
    if (any_condjump_p (insn))
split_point = last;
    else if (NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)))
found_code = true;
    last = insn;
  }

/* Did not find everything.  */ 
if (found_code && split_point)
  return split_block (bb, split_point)->dest;
else 
  return NULLnullptr;
5019}

5021/* Return 1 if BB ends with a call, possibly followed by some
 instructions that must stay with the call, 0 otherwise.  */

5024static bool
5025rtl_block_ends_with_call_p (basic_block bb)
5026{
rtx_insn *insn = BB_END (bb)(bb)->il.x.rtl->end_;

while (!CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN)
&& insn != BB_HEAD (bb)(bb)->il.x.head_
&& (keep_with_call_p (insn)
    || NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE)
    || DEBUG_INSN_P (insn)(((enum rtx_code) (insn)->code) == DEBUG_INSN)))
  insn = PREV_INSN (insn);
return (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN));
5036}

5038/* Return 1 if BB ends with a conditional branch, 0 otherwise.  */

5040static bool
5041rtl_block_ends_with_condjump_p (const_basic_block bb)
5042{
return any_condjump_p (BB_END (bb)(bb)->il.x.rtl->end_);
5044}

5046/* Return true if we need to add fake edge to exit.
 Helper function for rtl_flow_call_edges_add.  */

5049static bool
5050need_fake_edge_p (const rtx_insn *insn)
5051{
if (!INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN)))
  return false;

if ((CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN)
     && !SIBLING_CALL_P (insn)(__extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if
 (((enum rtx_code) (_rtx)->code) != CALL_INSN) rtl_check_failed_flag
 ("SIBLING_CALL_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5056, __FUNCTION__); _rtx; })->jump)
     && !find_reg_note (insn, REG_NORETURN, NULLnullptr)
     && !(RTL_CONST_OR_PURE_CALL_P (insn)((__extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if
 (((enum rtx_code) (_rtx)->code) != CALL_INSN) rtl_check_failed_flag
 ("RTL_CONST_CALL_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5058, __FUNCTION__); _rtx; })->unchanging) || (__extension__
 ({ __typeof ((insn)) const _rtx = ((insn)); if (((enum rtx_code
) (_rtx)->code) != CALL_INSN) rtl_check_failed_flag ("RTL_PURE_CALL_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5058, __FUNCTION__); _rtx; })->return_val)))))
  return true;

return ((GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == ASM_OPERANDS
  && MEM_VOLATILE_P (PATTERN (insn))(__extension__ ({ __typeof ((PATTERN (insn))) const _rtx = ((
PATTERN (insn))); if (((enum rtx_code) (_rtx)->code) != MEM
 && ((enum rtx_code) (_rtx)->code) != ASM_OPERANDS
 && ((enum rtx_code) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag
 ("MEM_VOLATILE_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5062, __FUNCTION__); _rtx; })->volatil))
 || (GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == PARALLEL
     && asm_noperands (insn) != -1
     && MEM_VOLATILE_P (XVECEXP (PATTERN (insn), 0, 0))(__extension__ ({ __typeof (((((((PATTERN (insn))->u.fld[0
]).rt_rtvec))->elem[0]))) const _rtx = (((((((PATTERN (insn
))->u.fld[0]).rt_rtvec))->elem[0]))); if (((enum rtx_code
) (_rtx)->code) != MEM && ((enum rtx_code) (_rtx)->
code) != ASM_OPERANDS && ((enum rtx_code) (_rtx)->
code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P", _rtx
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5065, __FUNCTION__); _rtx; })->volatil))
 || GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == ASM_INPUT);
5067}

5069/* Add fake edges to the function exit for any non constant and non noreturn
 calls, volatile inline assembly in the bitmap of blocks specified by
 BLOCKS or to the whole CFG if BLOCKS is zero.  Return the number of blocks
 that were split.

 The goal is to expose cases in which entering a basic block does not imply
 that all subsequent instructions must be executed.  */

5077static int
5078rtl_flow_call_edges_add (sbitmap blocks)
5079{
int i;
int blocks_split = 0;
int last_bb = last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block);
bool check_last_block = false;

if (n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks) == NUM_FIXED_BLOCKS(2))
  return 0;

if (! blocks)
  check_last_block = true;
else
  check_last_block = bitmap_bit_p (blocks,
		     EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb->index);

/* In the last basic block, before epilogue generation, there will be
   a fallthru edge to EXIT.  Special care is required if the last insn
   of the last basic block is a call because make_edge folds duplicate
   edges, which would result in the fallthru edge also being marked
   fake, which would result in the fallthru edge being removed by
   remove_fake_edges, which would result in an invalid CFG.

   Moreover, we can't elide the outgoing fake edge, since the block
   profiler needs to take this into account in order to solve the minimal
   spanning tree in the case that the call doesn't return.

   Handle this by adding a dummy instruction in a new last basic block.  */
if (check_last_block)
  {
    basic_block bb = EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb;
    rtx_insn *insn = BB_END (bb)(bb)->il.x.rtl->end_;

    /* Back up past insns that must be kept in the same block as a call.  */
    while (insn != BB_HEAD (bb)(bb)->il.x.head_
    && keep_with_call_p (insn))
insn = PREV_INSN (insn);

    if (need_fake_edge_p (insn))
{
 edge e;

 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr));
 if (e)
   {
     insert_insn_on_edge (gen_use (const0_rtx(const_int_rtx[64])), e);
     commit_edge_insertions ();
   }
}
  }

/* Now add fake edges to the function exit for any non constant
   calls since there is no way that we can determine if they will
   return or not...  */

for (i = NUM_FIXED_BLOCKS(2); i < last_bb; i++)
  {
    basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i)((*(((cfun + 0))->cfg->x_basic_block_info))[(i)]);
    rtx_insn *insn;
    rtx_insn *prev_insn;

    if (!bb)
continue;

    if (blocks && !bitmap_bit_p (blocks, i))
continue;

    for (insn = BB_END (bb)(bb)->il.x.rtl->end_; ; insn = prev_insn)
{
 prev_insn = PREV_INSN (insn);
 if (need_fake_edge_p (insn))
   {
     edge e;
     rtx_insn *split_at_insn = insn;

     /* Don't split the block between a call and an insn that should
 remain in the same block as the call.  */
     if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN))
while (split_at_insn != BB_END (bb)(bb)->il.x.rtl->end_
       && keep_with_call_p (NEXT_INSN (split_at_insn)))
  split_at_insn = NEXT_INSN (split_at_insn);

     /* The handling above of the final block before the epilogue
 should be enough to verify that there is no edge to the exit
 block in CFG already.  Calling make_edge in such case would
 cause us to mark that edge as fake and remove it later.  */

     if (flag_checkingglobal_options.x_flag_checking && split_at_insn == BB_END (bb)(bb)->il.x.rtl->end_)
{
  e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr));
  gcc_assert (e == NULL)((void)(!(e == nullptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5168, __FUNCTION__), 0 : 0));
}

     /* Note that the following may create a new basic block
 and renumber the existing basic blocks.  */
     if (split_at_insn != BB_END (bb)(bb)->il.x.rtl->end_)
{
  e = split_block (bb, split_at_insn);
  if (e)
    blocks_split++;
}

     edge ne = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr), EDGE_FAKE);
     ne->probability = profile_probability::guessed_never ();
   }

 if (insn == BB_HEAD (bb)(bb)->il.x.head_)
   break;
}
  }

if (blocks_split)
  verify_flow_info ();

return blocks_split;
5193}

5195/* Add COMP_RTX as a condition at end of COND_BB.  FIRST_HEAD is
 the conditional branch target, SECOND_HEAD should be the fall-thru
 there is no need to handle this here the loop versioning code handles
 this.  the reason for SECON_HEAD is that it is needed for condition
 in trees, and this should be of the same type since it is a hook.  */
5200static void
5201rtl_lv_add_condition_to_bb (basic_block first_head ,
	    basic_block second_head ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	    basic_block cond_bb, void *comp_rtx)
5204{
rtx_code_label *label;
rtx_insn *seq, *jump;
rtx op0 = XEXP ((rtx)comp_rtx, 0)((((rtx)comp_rtx)->u.fld[0]).rt_rtx);
rtx op1 = XEXP ((rtx)comp_rtx, 1)((((rtx)comp_rtx)->u.fld[1]).rt_rtx);
enum rtx_code comp = GET_CODE ((rtx)comp_rtx)((enum rtx_code) ((rtx)comp_rtx)->code);
machine_mode mode;


label = block_label (first_head);
mode = GET_MODE (op0)((machine_mode) (op0)->mode);
if (mode == VOIDmode((void) 0, E_VOIDmode))
  mode = GET_MODE (op1)((machine_mode) (op1)->mode);

start_sequence ();
op0 = force_operand (op0, NULL_RTX(rtx) 0);
op1 = force_operand (op1, NULL_RTX(rtx) 0);
do_compare_rtx_and_jump (op0, op1, comp, 0, mode, NULL_RTX(rtx) 0, NULLnullptr, label,
	   profile_probability::uninitialized ());
jump = get_last_insn ();
JUMP_LABEL (jump)(((jump)->u.fld[7]).rt_rtx) = label;
LABEL_NUSES (label)(((label)->u.fld[4]).rt_int)++;
seq = get_insns ();
end_sequence ();

/* Add the new cond, in the new head.  */
emit_insn_after (seq, BB_END (cond_bb)(cond_bb)->il.x.rtl->end_);
5231}


5234/* Given a block B with unconditional branch at its end, get the
 store the return the branch edge and the fall-thru edge in
 BRANCH_EDGE and FALLTHRU_EDGE respectively.  */
5237static void
5238rtl_extract_cond_bb_edges (basic_block b, edge *branch_edge,
	   edge *fallthru_edge)
5240{
edge e = EDGE_SUCC (b, 0)(*(b)->succs)[(0)];

if (e->flags & EDGE_FALLTHRU)
  {
    *fallthru_edge = e;
    *branch_edge = EDGE_SUCC (b, 1)(*(b)->succs)[(1)];
  }
else
  {
    *branch_edge = e;
    *fallthru_edge = EDGE_SUCC (b, 1)(*(b)->succs)[(1)];
  }
5253}

5255void
5256init_rtl_bb_info (basic_block bb)
5257{
gcc_assert (!bb->il.x.rtl)((void)(!(!bb->il.x.rtl) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cfgrtl.cc"
, 5258, __FUNCTION__), 0 : 0));
bb->il.x.head_ = NULLnullptr;
bb->il.x.rtl = ggc_cleared_alloc<rtl_bb_info> ();
5261}

5263static bool
5264rtl_bb_info_initialized_p (basic_block bb)
5265{
return bb->il.x.rtl;
5267}

5269/* Returns true if it is possible to remove edge E by redirecting
 it to the destination of the other edge from E->src.  */

5272static bool
5273rtl_can_remove_branch_p (const_edge e)
5274{
const_basic_block src = e->src;
const_basic_block target = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)(*(src)->succs)[((*(src)->succs)[(0)] == e)]->dest;
const rtx_insn *insn = BB_END (src)(src)->il.x.rtl->end_;
rtx set;

/* The conditions are taken from try_redirect_by_replacing_jump.  */
if (target == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return false;

if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
  return false;

if (BB_PARTITION (src)((src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_PARTITION (target)((target)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION
)))
  return false;

if (!onlyjump_p (insn)
    || tablejump_p (insn, NULLnullptr, NULLnullptr))
  return false;

set = single_set (insn);
if (!set || side_effects_p (set))
  return false;

return true;
5299}

5301static basic_block
5302rtl_duplicate_bb (basic_block bb, copy_bb_data *id)
5303{
bb = cfg_layout_duplicate_bb (bb, id);
bb->aux = NULLnullptr;
return bb;
5307}

5309/* Do book-keeping of basic block BB for the profile consistency checker.
 Store the counting in RECORD.  */
5311static void
5312rtl_account_profile_record (basic_block bb, struct profile_record *record)
5313{
rtx_insn *insn;
FOR_BB_INSNS (bb, insn)for ((insn) = (bb)->il.x.head_; (insn) && (insn) !=
 NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (
insn))
  if (INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
 DEBUG_INSN)))
    {
record->size += insn_cost (insn, false);
if (profile_info)
 {
   if (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.ipa ().initialized_p ()
&& ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.ipa ().nonzero_p ()
&& bb->count.ipa ().initialized_p ())
     record->time
+= insn_cost (insn, true) * bb->count.ipa ().to_gcov_type ();
 }
else if (bb->count.initialized_p ()
 && ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.initialized_p ())
 record->time
   += insn_cost (insn, true)
      * bb->count.to_sreal_scale
      (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count).to_double ();
else
 record->time += insn_cost (insn, true);
    }
5336}

5338/* Implementation of CFG manipulation for linearized RTL.  */
5339struct cfg_hooks rtl_cfg_hooks = {
"rtl",
rtl_verify_flow_info,
rtl_dump_bb,
rtl_dump_bb_for_graph,
rtl_create_basic_block,
rtl_redirect_edge_and_branch,
rtl_redirect_edge_and_branch_force,
rtl_can_remove_branch_p,
rtl_delete_block,
rtl_split_block,
rtl_move_block_after,
rtl_can_merge_blocks,  /* can_merge_blocks_p */
rtl_merge_blocks,
rtl_predict_edge,
rtl_predicted_by_p,
cfg_layout_can_duplicate_bb_p,
rtl_duplicate_bb,
rtl_split_edge,
rtl_make_forwarder_block,
rtl_tidy_fallthru_edge,
rtl_force_nonfallthru,
rtl_block_ends_with_call_p,
rtl_block_ends_with_condjump_p,
rtl_flow_call_edges_add,
NULLnullptr, /* execute_on_growing_pred */
NULLnullptr, /* execute_on_shrinking_pred */
NULLnullptr, /* duplicate loop for trees */
NULLnullptr, /* lv_add_condition_to_bb */
NULLnullptr, /* lv_adjust_loop_header_phi*/
NULLnullptr, /* extract_cond_bb_edges */
NULLnullptr, /* flush_pending_stmts */
rtl_block_empty_p, /* block_empty_p */
rtl_split_block_before_cond_jump, /* split_block_before_cond_jump */
rtl_account_profile_record,
5374};

5376/* Implementation of CFG manipulation for cfg layout RTL, where
 basic block connected via fallthru edges does not have to be adjacent.
 This representation will hopefully become the default one in future
 version of the compiler.  */

5381struct cfg_hooks cfg_layout_rtl_cfg_hooks = {
"cfglayout mode",
rtl_verify_flow_info_1,
rtl_dump_bb,
rtl_dump_bb_for_graph,
cfg_layout_create_basic_block,
cfg_layout_redirect_edge_and_branch,
cfg_layout_redirect_edge_and_branch_force,
rtl_can_remove_branch_p,
cfg_layout_delete_block,
cfg_layout_split_block,
rtl_move_block_after,
cfg_layout_can_merge_blocks_p,
cfg_layout_merge_blocks,
rtl_predict_edge,
rtl_predicted_by_p,
cfg_layout_can_duplicate_bb_p,
cfg_layout_duplicate_bb,
cfg_layout_split_edge,
rtl_make_forwarder_block,
NULLnullptr, /* tidy_fallthru_edge */
rtl_force_nonfallthru,
rtl_block_ends_with_call_p,
rtl_block_ends_with_condjump_p,
rtl_flow_call_edges_add,
NULLnullptr, /* execute_on_growing_pred */
NULLnullptr, /* execute_on_shrinking_pred */
duplicate_loop_body_to_header_edge, /* duplicate loop for trees */
rtl_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
NULLnullptr, /* lv_adjust_loop_header_phi*/
rtl_extract_cond_bb_edges, /* extract_cond_bb_edges */
NULLnullptr, /* flush_pending_stmts */  
rtl_block_empty_p, /* block_empty_p */
rtl_split_block_before_cond_jump, /* split_block_before_cond_jump */
rtl_account_profile_record,
5416};

5418#include "gt-cfgrtl.h"

5420#if __GNUC__4 >= 10
5421#  pragma GCC diagnostic pop
5422#endif
←
/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/rtl.h

1	/* Register Transfer Language (RTL) definitions for GCC
2	Copyright (C) 1987-2023 Free Software Foundation, Inc.
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
8	Software Foundation; either version 3, or (at your option) any later
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
17	along with GCC; see the file COPYING3. If not see
18	<http://www.gnu.org/licenses/>. */
19
20	#ifndef GCC_RTL_H
21	#define GCC_RTL_H
22
23	/* This file is occasionally included by generator files which expect
24	machmode.h and other files to exist and would not normally have been
25	included by coretypes.h. */
26	#ifdef GENERATOR_FILE
27	#include "real.h"
28	#include "fixed-value.h"
29	#include "statistics.h"
30	#include "vec.h"
31	#include "hash-table.h"
32	#include "hash-set.h"
33	#include "input.h"
34	#include "is-a.h"
35	#endif /* GENERATOR_FILE */
36
37	#include "hard-reg-set.h"
38
39	class predefined_function_abi;
40
41	/* Value used by some passes to "recognize" noop moves as valid
42	instructions. */
43	#define NOOP_MOVE_INSN_CODE2147483647 INT_MAX2147483647
44
45	/* Register Transfer Language EXPRESSIONS CODES */
46
47	#define RTX_CODEenum rtx_code enum rtx_code
48	enum rtx_code {
49
50	#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
51	#include "rtl.def" /* rtl expressions are documented here */
52	#undef DEF_RTL_EXPR
53
54	LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for
55	NUM_RTX_CODE.
56	Assumes default enum value assignment. */
57
58	/* The cast here, saves many elsewhere. */
59	#define NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE) ((int) LAST_AND_UNUSED_RTX_CODE)
60
61	/* Similar, but since generator files get more entries... */
62	#ifdef GENERATOR_FILE
63	# define NON_GENERATOR_NUM_RTX_CODE ((int) MATCH_OPERAND)
64	#endif
65
66	/* Register Transfer Language EXPRESSIONS CODE CLASSES */
67
68	enum rtx_class {
69	/* We check bit 0-1 of some rtx class codes in the predicates below. */
70
71	/* Bit 0 = comparison if 0, arithmetic is 1
72	Bit 1 = 1 if commutative. */
73	RTX_COMPARE, /* 0 */
74	RTX_COMM_COMPARE,
75	RTX_BIN_ARITH,
76	RTX_COMM_ARITH,
77
78	/* Must follow the four preceding values. */
79	RTX_UNARY, /* 4 */
80
81	RTX_EXTRA,
82	RTX_MATCH,
83	RTX_INSN,
84
85	/* Bit 0 = 1 if constant. */
86	RTX_OBJ, /* 8 */
87	RTX_CONST_OBJ,
88
89	RTX_TERNARY,
90	RTX_BITFIELD_OPS,
91	RTX_AUTOINC
92	};
93
94	#define RTX_OBJ_MASK(~1) (~1)
95	#define RTX_OBJ_RESULT(RTX_OBJ & (~1)) (RTX_OBJ & RTX_OBJ_MASK(~1))
96	#define RTX_COMPARE_MASK(~1) (~1)
97	#define RTX_COMPARE_RESULT(RTX_COMPARE & (~1)) (RTX_COMPARE & RTX_COMPARE_MASK(~1))
98	#define RTX_ARITHMETIC_MASK(~1) (~1)
99	#define RTX_ARITHMETIC_RESULT(RTX_COMM_ARITH & (~1)) (RTX_COMM_ARITH & RTX_ARITHMETIC_MASK(~1))
100	#define RTX_BINARY_MASK(~3) (~3)
101	#define RTX_BINARY_RESULT(RTX_COMPARE & (~3)) (RTX_COMPARE & RTX_BINARY_MASK(~3))
102	#define RTX_COMMUTATIVE_MASK(~2) (~2)
103	#define RTX_COMMUTATIVE_RESULT(RTX_COMM_COMPARE & (~2)) (RTX_COMM_COMPARE & RTX_COMMUTATIVE_MASK(~2))
104	#define RTX_NON_COMMUTATIVE_RESULT(RTX_COMPARE & (~2)) (RTX_COMPARE & RTX_COMMUTATIVE_MASK(~2))
105
106	extern const unsigned char rtx_length[NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE)];
107	#define GET_RTX_LENGTH(CODE)(rtx_length[(int) (CODE)]) (rtx_length[(int) (CODE)])
108
109	extern const char * const rtx_name[NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE)];
110	#define GET_RTX_NAME(CODE)(rtx_name[(int) (CODE)]) (rtx_name[(int) (CODE)])
111
112	extern const char * const rtx_format[NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE)];
113	#define GET_RTX_FORMAT(CODE)(rtx_format[(int) (CODE)]) (rtx_format[(int) (CODE)])
114
115	extern const enum rtx_class rtx_class[NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE)];
116	#define GET_RTX_CLASS(CODE)(rtx_class[(int) (CODE)]) (rtx_class[(int) (CODE)])
117
118	/* True if CODE is part of the insn chain (i.e. has INSN_UID, PREV_INSN
119	and NEXT_INSN fields). */
120	#define INSN_CHAIN_CODE_P(CODE)((unsigned long) (CODE) - (unsigned long) (DEBUG_INSN) <= ( unsigned long) (NOTE) - (unsigned long) (DEBUG_INSN)) IN_RANGE (CODE, DEBUG_INSN, NOTE)((unsigned long) (CODE) - (unsigned long) (DEBUG_INSN) <= ( unsigned long) (NOTE) - (unsigned long) (DEBUG_INSN))
121
122	extern const unsigned char rtx_code_size[NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE)];
123	extern const unsigned char rtx_next[NUM_RTX_CODE((int) LAST_AND_UNUSED_RTX_CODE)];
124
125	/* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label
126	relative to which the offsets are calculated, as explained in rtl.def. */
127	struct addr_diff_vec_flags
128	{
129	/* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */
130	unsigned min_align: 8;
131	/* Flags: */
132	unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC. */
133	unsigned min_after_vec: 1; /* minimum address target label is
134	after the ADDR_DIFF_VEC. */
135	unsigned max_after_vec: 1; /* maximum address target label is
136	after the ADDR_DIFF_VEC. */
137	unsigned min_after_base: 1; /* minimum address target label is
138	after BASE. */
139	unsigned max_after_base: 1; /* maximum address target label is
140	after BASE. */
141	/* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */
142	unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */
143	unsigned : 2;
144	unsigned scale : 8;
145	};
146
147	/* Structure used to describe the attributes of a MEM. These are hashed
148	so MEMs that the same attributes share a data structure. This means
149	they cannot be modified in place. */
150	class GTY(()) mem_attrs
151	{
152	public:
153	mem_attrs ();
154
155	/* The expression that the MEM accesses, or null if not known.
156	This expression might be larger than the memory reference itself.
157	(In other words, the MEM might access only part of the object.) */
158	tree expr;
159
160	/* The offset of the memory reference from the start of EXPR.
161	Only valid if OFFSET_KNOWN_P. */
162	poly_int64 offset;
163
164	/* The size of the memory reference in bytes. Only valid if
165	SIZE_KNOWN_P. */
166	poly_int64 size;
167
168	/* The alias set of the memory reference. */
169	alias_set_type alias;
170
171	/* The alignment of the reference in bits. Always a multiple of
172	BITS_PER_UNIT. Note that EXPR may have a stricter alignment
173	than the memory reference itself. */
174	unsigned int align;
175
176	/* The address space that the memory reference uses. */
177	unsigned char addrspace;
178
179	/* True if OFFSET is known. */
180	bool offset_known_p;
181
182	/* True if SIZE is known. */
183	bool size_known_p;
184	};
185
186	/* Structure used to describe the attributes of a REG in similar way as
187	mem_attrs does for MEM above. Note that the OFFSET field is calculated
188	in the same way as for mem_attrs, rather than in the same way as a
189	SUBREG_BYTE. For example, if a big-endian target stores a byte
190	object in the low part of a 4-byte register, the OFFSET field
191	will be -3 rather than 0. */
192
193	class GTY((for_user)) reg_attrs {
194	public:
195	tree decl; /* decl corresponding to REG. */
196	poly_int64 offset; /* Offset from start of DECL. */
197	};
198
199	/* Common union for an element of an rtx. */
200
201	union rtunion
202	{
203	int rt_int;
204	unsigned int rt_uint;
205	poly_uint16_pod rt_subreg;
206	const char *rt_str;
207	rtx rt_rtx;
208	rtvec rt_rtvec;
209	machine_mode rt_type;
210	addr_diff_vec_flags rt_addr_diff_vec_flags;
211	struct cselib_val *rt_cselib;
212	tree rt_tree;
213	basic_block rt_bb;
214	mem_attrs *rt_mem;
215	class constant_descriptor_rtx *rt_constant;
216	struct dw_cfi_node *rt_cfi;
217	};
218
219	/* Describes the properties of a REG. */
220	struct GTY(()) reg_info {
221	/* The value of REGNO. */
222	unsigned int regno;
223
224	/* The value of REG_NREGS. */
225	unsigned int nregs : 8;
226	unsigned int unused : 24;
227
228	/* The value of REG_ATTRS. */
229	reg_attrs *attrs;
230	};
231
232	/* This structure remembers the position of a SYMBOL_REF within an
233	object_block structure. A SYMBOL_REF only provides this information
234	if SYMBOL_REF_HAS_BLOCK_INFO_P is true. */
235	struct GTY(()) block_symbol {
236	/* The usual SYMBOL_REF fields. */
237	rtunion GTY ((skip)) fld[2];
238
239	/* The block that contains this object. */
240	struct object_block *block;
241
242	/* The offset of this object from the start of its block. It is negative
243	if the symbol has not yet been assigned an offset. */
244	HOST_WIDE_INTlong offset;
245	};
246
247	/* Describes a group of objects that are to be placed together in such
248	a way that their relative positions are known. */
249	struct GTY((for_user)) object_block {
250	/* The section in which these objects should be placed. */
251	section *sect;
252
253	/* The alignment of the first object, measured in bits. */
254	unsigned int alignment;
255
256	/* The total size of the objects, measured in bytes. */
257	HOST_WIDE_INTlong size;
258
259	/* The SYMBOL_REFs for each object. The vector is sorted in
260	order of increasing offset and the following conditions will
261	hold for each element X:
262
263	SYMBOL_REF_HAS_BLOCK_INFO_P (X)
264	!SYMBOL_REF_ANCHOR_P (X)
265	SYMBOL_REF_BLOCK (X) == [address of this structure]
266	SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */
267	vec<rtx, va_gc> *objects;
268
269	/* All the anchor SYMBOL_REFs used to address these objects, sorted
270	in order of increasing offset, and then increasing TLS model.
271	The following conditions will hold for each element X in this vector:
272
273	SYMBOL_REF_HAS_BLOCK_INFO_P (X)
274	SYMBOL_REF_ANCHOR_P (X)
275	SYMBOL_REF_BLOCK (X) == [address of this structure]
276	SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */
277	vec<rtx, va_gc> *anchors;
278	};
279
280	struct GTY((variable_size)) hwivec_def {
281	HOST_WIDE_INTlong elem[1];
282	};
283
284	/* Number of elements of the HWIVEC if RTX is a CONST_WIDE_INT. */
285	#define CWI_GET_NUM_ELEM(RTX)((int)__extension__ ({ __typeof ((RTX)) const _rtx = ((RTX)); if (((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag ("CWI_GET_NUM_ELEM", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/rtl.h" , 285, __FUNCTION__); _rtx; })->u2.num_elem) \
286	((int)RTL_FLAG_CHECK1("CWI_GET_NUM_ELEM", (RTX), CONST_WIDE_INT)__extension__ ({ __typeof ((RTX)) const _rtx = ((RTX)); if (( (enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag ("CWI_GET_NUM_ELEM", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/rtl.h" , 286, __FUNCTION__); _rtx; })->u2.num_elem)
287	#define CWI_PUT_NUM_ELEM(RTX, NUM)(__extension__ ({ __typeof ((RTX)) const _rtx = ((RTX)); if ( ((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag ("CWI_PUT_NUM_ELEM", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/rtl.h" , 287, __FUNCTION__); _rtx; })->u2.num_elem = (NUM)) \
288	(RTL_FLAG_CHECK1("CWI_PUT_NUM_ELEM", (RTX), CONST_WIDE_INT)__extension__ ({ __typeof ((RTX)) const _rtx = ((RTX)); if (( (enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag ("CWI_PUT_NUM_ELEM", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/rtl.h" , 288, __FUNCTION__); _rtx; })->u2.num_elem = (NUM))
289
290	struct GTY((variable_size)) const_poly_int_def {
291	trailing_wide_ints<NUM_POLY_INT_COEFFS1> coeffs;
292	};
293
294	/* RTL expression ("rtx"). */
295
296	/* The GTY "desc" and "tag" options below are a kludge: we need a desc
297	field for gengtype to recognize that inheritance is occurring,
298	so that all subclasses are redirected to the traversal hook for the
299	base class.
300	However, all of the fields are in the base class, and special-casing
301	is at work. Hence we use desc and tag of 0, generating a switch
302	statement of the form:
303	switch (0)
304	{
305	case 0: // all the work happens here
306	}
307	in order to work with the existing special-casing in gengtype. */
308
309	struct GTY((desc("0"), tag("0"),
310	chain_next ("RTX_NEXT (&%h)"),
311	chain_prev ("RTX_PREV (&%h)"))) rtx_def {
312	/* The kind of expression this is. */
313	ENUM_BITFIELD(rtx_code)enum rtx_code code: 16;
314
315	/* The kind of value the expression has. */
316	ENUM_BITFIELD(machine_mode)enum machine_mode mode : 8;
317
318	/* 1 in a MEM if we should keep the alias set for this mem unchanged
319	when we access a component.
320	1 in a JUMP_INSN if it is a crossing jump.
321	1 in a CALL_INSN if it is a sibling call.
322	1 in a SET that is for a return.
323	In a CODE_LABEL, part of the two-bit alternate entry field.
324	1 in a CONCAT is VAL_EXPR_IS_COPIED in var-tracking.cc.
325	1 in a VALUE is SP_BASED_VALUE_P in cselib.cc.
326	1 in a SUBREG generated by LRA for reload insns.
327	1 in a REG if this is a static chain register.
328	Dumped as "/j" in RTL dumps. */
329	unsigned int jump : 1;
330	/* In a CODE_LABEL, part of the two-bit alternate entry field.
331	1 in a MEM if it cannot trap.
332	1 in a CALL_INSN logically equivalent to
333	ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P.
334	1 in a VALUE is SP_DERIVED_VALUE_P in cselib.cc.
335	Dumped as "/c" in RTL dumps. */
336	unsigned int call : 1;
337	/* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere.
338	1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P.
339	1 in a SYMBOL_REF if it addresses something in the per-function
340	constants pool.
341	1 in a CALL_INSN logically equivalent to ECF_CONST and TREE_READONLY.
342	1 in a NOTE, or EXPR_LIST for a const call.
343	1 in a JUMP_INSN of an annulling branch.
344	1 in a CONCAT is VAL_EXPR_IS_CLOBBERED in var-tracking.cc.
345	1 in a preserved VALUE is PRESERVED_VALUE_P in cselib.cc.
346	1 in a clobber temporarily created for LRA.
347	Dumped as "/u" in RTL dumps. */
348	unsigned int unchanging : 1;
349	/* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile.
350	1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE
351	if it has been deleted.
352	1 in a REG expression if corresponds to a variable declared by the user,
353	0 for an internally generated temporary.
354	1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P.
355	1 in a LABEL_REF, REG_LABEL_TARGET or REG_LABEL_OPERAND note for a
356	non-local label.
357	In a SYMBOL_REF, this flag is used for machine-specific purposes.
358	In a PREFETCH, this flag indicates that it should be considered a
359	scheduling barrier.
360	1 in a CONCAT is VAL_NEEDS_RESOLUTION in var-tracking.cc.
361	Dumped as "/v" in RTL dumps. */
362	unsigned int volatil : 1;
363	/* 1 in a REG if the register is used only in exit code a loop.
364	1 in a SUBREG expression if was generated from a variable with a
365	promoted mode.
366	1 in a CODE_LABEL if the label is used for nonlocal gotos
367	and must not be deleted even if its count is zero.
368	1 in an INSN, JUMP_INSN or CALL_INSN if this insn must be scheduled
369	together with the preceding insn. Valid only within sched.
370	1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and
371	from the target of a branch. Valid from reorg until end of compilation;
372	cleared before used.
373
374	The name of the field is historical. It used to be used in MEMs
375	to record whether the MEM accessed part of a structure.
376	Dumped as "/s" in RTL dumps. */
377	unsigned int in_struct : 1;
378	/* At the end of RTL generation, 1 if this rtx is used. This is used for
379	copying shared structure. See `unshare_all_rtl'.
380	In a REG, this is not needed for that purpose, and used instead
381	in `leaf_renumber_regs_insn'.
382	1 in a SYMBOL_REF, means that emit_library_call
383	has used it as the function.
384	1 in a CONCAT is VAL_HOLDS_TRACK_EXPR in var-tracking.cc.
385	1 in a VALUE or DEBUG_EXPR is VALUE_RECURSED_INTO in var-tracking.cc. */
386	unsigned int used : 1;
387	/* 1 in an INSN or a SET if this rtx is related to the call frame,
388	either changing how we compute the frame address or saving and
389	restoring registers in the prologue and epilogue.
390	1 in a REG or MEM if it is a pointer.
391	1 in a SYMBOL_REF if it addresses something in the per-function
392	constant string pool.
393	1 in a VALUE is VALUE_CHANGED in var-tracking.cc.
394	Dumped as "/f" in RTL dumps. */
395	unsigned frame_related : 1;
396	/* 1 in a REG or PARALLEL that is the current function's return value.
397	1 in a SYMBOL_REF for a weak symbol.
398	1 in a CALL_INSN logically equivalent to ECF_PURE and DECL_PURE_P.
399	1 in a CONCAT is VAL_EXPR_HAS_REVERSE in var-tracking.cc.
400	1 in a VALUE or DEBUG_EXPR is NO_LOC_P in var-tracking.cc.
401	Dumped as "/i" in RTL dumps. */
402	unsigned return_val : 1;
403
404	union {
405	/* The final union field is aligned to 64 bits on LP64 hosts,
406	giving a 32-bit gap after the fields above. We optimize the
407	layout for that case and use the gap for extra code-specific
408	information. */
409
410	/* The ORIGINAL_REGNO of a REG. */
411	unsigned int original_regno;
412
413	/* The INSN_UID of an RTX_INSN-class code. */
414	int insn_uid;
415
416	/* The SYMBOL_REF_FLAGS of a SYMBOL_REF. */
417	unsigned int symbol_ref_flags;
418
419	/* The PAT_VAR_LOCATION_STATUS of a VAR_LOCATION. */
420	enum var_init_status var_location_status;
421
422	/* In a CONST_WIDE_INT (aka hwivec_def), this is the number of
423	HOST_WIDE_INTs in the hwivec_def. */
424	unsigned int num_elem;
425
426	/* Information about a CONST_VECTOR. */
427	struct
428	{
429	/* The value of CONST_VECTOR_NPATTERNS. */
430	unsigned int npatterns : 16;
431
432	/* The value of CONST_VECTOR_NELTS_PER_PATTERN. */
433	unsigned int nelts_per_pattern : 8;
434
435	/* For future expansion. */
436	unsigned int unused : 8;
437	} const_vector;
438	} GTY ((skip)) u2;
439
440	/* The first element of the operands of this rtx.
441	The number of operands and their types are controlled
442	by the `code' field, according to rtl.def. */
443	union u {
444	rtunion fld[1];
445	HOST_WIDE_INTlong hwint[1];
446	struct reg_info reg;
447	struct block_symbol block_sym;
448	struct real_value rv;
449	struct fixed_value fv;
450	struct hwivec_def hwiv;
451	struct const_poly_int_def cpi;
452	} GTY ((special ("rtx_def"), desc ("GET_CODE (&%0)"))) u;
453	};
454
455	/* A node for constructing singly-linked lists of rtx. */
456
457	struct GTY(()) rtx_expr_list : public rtx_def
458	{
459	private:
460	/* No extra fields, but adds invariant: (GET_CODE (X) == EXPR_LIST). */
461
462	public:
463	/* Get next in list. */
464	rtx_expr_list *next () const;
465
466	/* Get at the underlying rtx. */
467	rtx element () const;
468	};
469
470	template <>
471	template <>
472	inline bool
473	is_a_helper <rtx_expr_list *>::test (rtx rt)
474	{
475	return rt->code == EXPR_LIST;
476	}
477
478	struct GTY(()) rtx_insn_list : public rtx_def
479	{
480	private:
481	/* No extra fields, but adds invariant: (GET_CODE (X) == INSN_LIST).
482
483	This is an instance of:
484
485	DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA)
486
487	i.e. a node for constructing singly-linked lists of rtx_insn *, where
488	the list is "external" to the insn (as opposed to the doubly-linked
489	list embedded within rtx_insn itself). */
490
491	public:
492	/* Get next in list. */
493	rtx_insn_list *next () const;
494
495	/* Get at the underlying instruction. */
496	rtx_insn *insn () const;
497
498	};
499