Are you sure you have all my changes applied? I applied the 4 patches
attached to PR55121 into my trunk checkout that has my fixes, and to a
pristine trunk checkout. I configured and built both for
--target=arm-none-linux-gnueabi, and built using your options, .i file
and gcda file. I can reproduce the failure using the pristine trunk
with your patches but not with my fixed trunk + your patches. (I just
updated to head to pickup recent changes and get the same result. The
vec changes required some manual changes to the patch, which I will
resend shortly.)

Without my fixes:

$ ~/extra/gcc_trunk_3_arm-eabi/gcc/cc1 -fpreproce
ssed eval.i -quiet -dumpbase eval.c -march=armv7-a -mtune=cortex-a9
-mthumb -mfpu=neon -mvectorize-with-neon-quad -mfloat-abi=softfp
-mtls-dialect=gnu -auxbase-strip eval.o -g -O3 -version -fprofile-use
-fno-common -o eval.s -freorder-blocks-and-partition
GNU C (GCC) version 4.8.0 20121126 (experimental) (arm-none-linux-gnueabi)
compiled by GNU C version 4.4.3, GMP version 4.3.2, MPFR version
2.4.2-p1, MPC version 0.8.1
GGC heuristics: --param ggc-min-expand=30 --param ggc-min-heapsize=4096
GNU C (GCC) version 4.8.0 20121126 (experimental) (arm-none-linux-gnueabi)
compiled by GNU C version 4.4.3, GMP version 4.3.2, MPFR version
2.4.2-p1, MPC version 0.8.1
GGC heuristics: --param ggc-min-expand=30 --param ggc-min-heapsize=4096
Compiler executable checksum: d19cc60a2f07de08237a8488bb35cd1a
eval.c: In function ‘Ge’:
eval.c:792:1: internal compiler error: in df_compact_blocks, at df-core.c:1560
 }
 ^
0x622f71 df_compact_blocks()
../../gcc_trunk_3/gcc/df-core.c:1560
0x5cfcb5 compact_blocks()
../../gcc_trunk_3/gcc/cfg.c:162
0xc9dce0 reorder_basic_blocks
../../gcc_trunk_3/gcc/bb-reorder.c:2154
0xc9dce0 rest_of_handle_reorder_blocks
../../gcc_trunk_3/gcc/bb-reorder.c:2219
Please submit a full bug report,
with preprocessed source if appropriate.
Please include the complete backtrace with any bug report.
See <http://gcc.gnu.org/bugs.html> for instructions.


With my fixes:

$ ~/extra/gcc_trunk_4_arm-eabi/gcc/cc1 -fpreproce
ssed eval.i -quiet -dumpbase eval.c -march=armv7-a -mtune=cortex-a9
-mthumb -mfpu=neon -mvectorize-with-neon-quad -mfloat-abi=softfp
-mtls-dialect=gnu -auxbase-strip eval.o -g -O3 -version -fprofile-use
-fno-common -o eval.s -freorder-blocks-and-partition
GNU C (GCC) version 4.8.0 20121126 (experimental) (arm-none-linux-gnueabi)
compiled by GNU C version 4.4.3, GMP version 4.3.2, MPFR version
2.4.2-p1, MPC version 0.8.1
GGC heuristics: --param ggc-min-expand=30 --param ggc-min-heapsize=4096
GNU C (GCC) version 4.8.0 20121126 (experimental) (arm-none-linux-gnueabi)
compiled by GNU C version 4.4.3, GMP version 4.3.2, MPFR version
2.4.2-p1, MPC version 0.8.1
GGC heuristics: --param ggc-min-expand=30 --param ggc-min-heapsize=4096
Compiler executable checksum: 45b468efa7c981f9afb44c4dac2424f3


Thanks,
Teresa

On Mon, Nov 26, 2012 at 8:25 AM, Christophe Lyon
<christophe.l...@linaro.org> wrote:
> Hi,
>
> I have tested your patch on Spec2000 on ARM, and I can still see
> several failures caused by:
> "error: fallthru edge crosses section boundary", including the case
> described in PR55121.
>
> On 26 November 2012 16:55, Teresa Johnson <tejohn...@google.com> wrote:
>> Ping.
>> Teresa
>>
>> On Thu, Nov 15, 2012 at 12:10 PM, Teresa Johnson <tejohn...@google.com> 
>> wrote:
>>> Revised patch that fixes failures encountered when enabling
>>> -freorder-blocks-and-partition, including the failure reported in PR 53743.
>>>
>>> This includes new verification code to ensure no cold blocks dominate hot
>>> blocks contributed by Steven Bosscher.
>>>
>>> I attempted to make the handling of partition updates through the 
>>> optimization
>>> passes much more consistent, removing a number of partial fixes in the code
>>> stream in the process. The code to fixup partitions (including the 
>>> BB_PARTITION
>>> assignement, region crossing jump notes, and switch text section notes) is
>>> now handled in a few centralized locations. For example, inside
>>> rtl_redirect_edge_and_branch and force_nonfallthru_and_redirect, so that 
>>> callers
>>> don't need to attempt the fixup themselves.
>>>
>>> For optimization passes that make adjustments to the cfg while in cfg layout
>>> mode that are not easy to fix up incrementally, the new routine
>>> fixup_partitions handles the cleanup globally. This does require calculation
>>> of the dominance relation, however, as far as I can tell the routines which
>>> now invoke this global fixup (try_optimize_cfg and commit_edge_insertions)
>>> are invoked typically once (or a small number of times in the case of
>>> try_optimize_cfg) per optimization pass. Additionally, I compared the
>>> -ftime-report output for some large fdo compilations and saw only minimal
>>> increases in the dominance computation times, which were only a tiny percent
>>> of the overall compile time.
>>>
>>> Additionally, I added a flag to the rtl_data structure to indicate whether
>>> any partitioning was actually performed, so that optimizations which were
>>> conservatively disabled whenever the flag_reorder_blocks_and_partition
>>> is enabled (e.g. try_crossjump_to_edge, part of connect_traces) can be less
>>> conservative for functions where no partitions were formed (e.g. they are
>>> completely hot).
>>>
>>> Bootstrapped and tested on x86_64-unknown-linux-gnu. Also tested with 
>>> SPEC2006 int
>>> benchmarks and internal google benchmarks using profile feedback and
>>> -freorder-blocks-and-partition to get more coverage. Ok for trunk?
>>>
>>> Thanks,
>>> Teresa
>>>
>>> 2012-11-14  Teresa Johnson  <tejohn...@google.com>
>>>             Steven Bosscher  <ste...@gcc.gnu.org>
>>>
>>>         * cfghooks.h (cfg_layout_finalize): New parameter.
>>>         * modulo-sched.c (rest_of_handle_sms): New cfg_layout_finalize
>>>         parameter.
>>>         * ifcvt.c (find_if_case_1): Replace BB_COPY_PARTITION with assert
>>>         as this is now done by redirect_edge_and_branch_force.
>>>         * function.c (thread_prologue_and_epilogue_insns): Insert new bb 
>>> after
>>>         barriers, new cfg_layout_finalize parameter, and don't store exit
>>>         predecessor BB until after it is potentially split.
>>>         * function.h (struct rtl_data): New flag has_bb_partition.
>>>         * hw-doloop.c (reorder_loops): New cfg_layout_finalize parameter.
>>>         * cfgcleanup.c (try_crossjump_to_edge): Only skip optimization if
>>>         any blocks in function actually partitioned.
>>>         (try_optimize_cfg): If cfg changed, invoke fixup_partitions to clean
>>>         up partitioning.
>>>         * bb-reorder.c (connect_traces): Only look for partitions and skip
>>>         block copying if any blocks in function actually partitioned.
>>>         (emit_barrier_after_bb): Handle insertion in non-cfglayout mode.
>>>         (find_rarely_executed_basic_blocks_and_crossing_edges): Ensure
>>>         that no cold blocks dominate a hot block.
>>>         (fix_up_fall_thru_edges): Replace BB_COPY_PARTITION with assert
>>>         as this is now done by force_nonfallthru_and_redirect.
>>>         (add_reg_crossing_jump_notes): Handle the fact that some jumps may
>>>         already be marked with region crossing note.
>>>         (reorder_basic_blocks): Only need to verify partitions if any
>>>         blocks in function actually partitioned.
>>>         (insert_section_boundary_note): Only need to insert note if any
>>>         blocks in function actually partitioned.
>>>         (rest_of_handle_reorder_blocks): New cfg_layout_finalize
>>>         parameter, and remove call to insert_section_boundary_note as this
>>>         is now called via cfg_layout_finalize/fixup_reorder_chain.
>>>         (duplicate_computed_gotos): New cfg_layout_finalize
>>>         parameter.
>>>         (partition_hot_cold_basic_blocks): Set flag indicating function
>>>         has bb partitions.
>>>         * bb-reorder.h: Declare insert_section_boundary_note and
>>>         emit_barrier_after_bb, which are no longer static.
>>>         * basic-block.h: Declare new function fixup_partitions.
>>>         * cfgrtl.c (try_redirect_by_replacing_jump): Remove unnecessary
>>>         check for region crossing note.
>>>         (fixup_partition_crossing): New function.
>>>         (fixup_bb_partition): Ditto.
>>>         (rtl_redirect_edge_and_branch): Fixup partition boundaries.
>>>         (force_nonfallthru_and_redirect): Fixup partition boundaries,
>>>         remove old code that tried to do this. Emit barrier correctly
>>>         when we are in cfglayout mode.
>>>         (rtl_split_edge): Correctly fixup partition boundaries.
>>>         (commit_one_edge_insertion): Remove old code that tried to
>>>         fixup region crossing edge since this is now handled in
>>>         split_block, and set up insertion point correctly since
>>>         block may now end in a jump.
>>>         (commit_edge_insertions): Invoke fixup_partitions to sanitize 
>>> partition
>>>         boundaries after optimizations that modify cfg and before trying to
>>>         verify the flow info.
>>>         (fixup_partitions): New function.
>>>         (rtl_verify_flow_info_1): Add verification that no cold bbs dominate
>>>         hot bbs.
>>>         (record_effective_endpoints): Remove region-crossing notes and set 
>>> flag
>>>         indicating that they need to be reinserted on exit from cfglayout 
>>> mode.
>>>         (outof_cfg_layout_mode): New cfg_layout_finalize parameter.
>>>         (fixup_reorder_chain): Call insert_section_boundary_note if 
>>> necessary.
>>>         Remove old code that attempted to fixup region crossing note as
>>>         this is now handled in force_nonfallthru_and_redirect.
>>>         (duplicate_insn_chain): Don't duplicate switch section notes.
>>>         (cfg_layout_finalize): Pass new parameter to fixup_reorder_chain.
>>>         (rtl_can_remove_branch_p): Remove unnecessary check for region 
>>> crossing
>>>         note.
>>>
>>> Index: cfghooks.h
>>> ===================================================================
>>> --- cfghooks.h  (revision 193376)
>>> +++ cfghooks.h  (working copy)
>>> @@ -204,7 +204,7 @@ extern void copy_bbs (basic_block *, unsigned, bas
>>>  void account_profile_record (struct profile_record *, int);
>>>
>>>  extern void cfg_layout_initialize (unsigned int);
>>> -extern void cfg_layout_finalize (void);
>>> +extern void cfg_layout_finalize (bool);
>>>
>>>  /* Hooks containers.  */
>>>  extern struct cfg_hooks gimple_cfg_hooks;
>>> @@ -218,4 +218,3 @@ extern void cfg_layout_rtl_register_cfg_hooks (voi
>>>  extern void gimple_register_cfg_hooks (void);
>>>  extern struct cfg_hooks get_cfg_hooks (void);
>>>  extern void set_cfg_hooks (struct cfg_hooks);
>>> -
>>> Index: modulo-sched.c
>>> ===================================================================
>>> --- modulo-sched.c      (revision 193376)
>>> +++ modulo-sched.c      (working copy)
>>> @@ -3354,7 +3354,7 @@ rest_of_handle_sms (void)
>>>      if (bb->next_bb != EXIT_BLOCK_PTR)
>>>        bb->aux = bb->next_bb;
>>>    free_dominance_info (CDI_DOMINATORS);
>>> -  cfg_layout_finalize ();
>>> +  cfg_layout_finalize (false);
>>>  #endif /* INSN_SCHEDULING */
>>>    return 0;
>>>  }
>>> Index: ifcvt.c
>>> ===================================================================
>>> --- ifcvt.c     (revision 193376)
>>> +++ ifcvt.c     (working copy)
>>> @@ -3900,10 +3900,9 @@ find_if_case_1 (basic_block test_bb, edge then_edg
>>>    if (new_bb)
>>>      {
>>>        df_bb_replace (then_bb_index, new_bb);
>>> -      /* Since the fallthru edge was redirected from test_bb to new_bb,
>>> -         we need to ensure that new_bb is in the same partition as
>>> -         test bb (you can not fall through across section boundaries).  */
>>> -      BB_COPY_PARTITION (new_bb, test_bb);
>>> +      /* This should have been done above via 
>>> force_nonfallthru_and_redirect
>>> +         (possibly called from redirect_edge_and_branch_force).  */
>>> +      gcc_assert (BB_PARTITION (new_bb) == BB_PARTITION (test_bb));
>>>      }
>>>
>>>    num_true_changes++;
>>> Index: function.c
>>> ===================================================================
>>> --- function.c  (revision 193376)
>>> +++ function.c  (working copy)
>>> @@ -6249,8 +6249,10 @@ thread_prologue_and_epilogue_insns (void)
>>>                     break;
>>>                 if (e)
>>>                   {
>>> -                   copy_bb = create_basic_block (NEXT_INSN (BB_END 
>>> (e->src)),
>>> -                                                 NULL_RTX, e->src);
>>> +                    /* Make sure we insert after any barriers.  */
>>> +                    rtx end = get_last_bb_insn (e->src);
>>> +                    copy_bb = create_basic_block (NEXT_INSN (end),
>>> +                                                  NULL_RTX, e->src);
>>>                     BB_COPY_PARTITION (copy_bb, e->src);
>>>                   }
>>>                 else
>>> @@ -6475,7 +6477,7 @@ thread_prologue_and_epilogue_insns (void)
>>>         if (cur_bb->index >= NUM_FIXED_BLOCKS
>>>             && cur_bb->next_bb->index >= NUM_FIXED_BLOCKS)
>>>           cur_bb->aux = cur_bb->next_bb;
>>> -      cfg_layout_finalize ();
>>> +      cfg_layout_finalize (false);
>>>      }
>>>
>>>  epilogue_done:
>>> @@ -6517,7 +6519,7 @@ epilogue_done:
>>>        basic_block simple_return_block_cold = NULL;
>>>        edge pending_edge_hot = NULL;
>>>        edge pending_edge_cold = NULL;
>>> -      basic_block exit_pred = EXIT_BLOCK_PTR->prev_bb;
>>> +      basic_block exit_pred;
>>>        int i;
>>>
>>>        gcc_assert (entry_edge != orig_entry_edge);
>>> @@ -6545,6 +6547,12 @@ epilogue_done:
>>>             else
>>>               pending_edge_cold = e;
>>>           }
>>> +
>>> +      /* Save a pointer to the exit's predecessor BB for use in
>>> +         inserting new BBs at the end of the function. Do this
>>> +         after the call to split_block above which may split
>>> +         the original exit pred.  */
>>> +      exit_pred = EXIT_BLOCK_PTR->prev_bb;
>>>
>>>        FOR_EACH_VEC_ELT (edge, unconverted_simple_returns, i, e)
>>>         {
>>> Index: function.h
>>> ===================================================================
>>> --- function.h  (revision 193376)
>>> +++ function.h  (working copy)
>>> @@ -459,6 +459,11 @@ struct GTY(()) rtl_data {
>>>       sched2) and is useful only if the port defines LEAF_REGISTERS.  */
>>>    bool uses_only_leaf_regs;
>>>
>>> +  /* Nonzero if the function being compiled has undergone hot/cold 
>>> partitioning
>>> +     (under flag_reorder_blocks_and_partition) and has at least one cold
>>> +     block.  */
>>> +  bool has_bb_partition;
>>> +
>>>    /* Like regs_ever_live, but 1 if a reg is set or clobbered from an
>>>       asm.  Unlike regs_ever_live, elements of this array corresponding
>>>       to eliminable regs (like the frame pointer) are set if an asm
>>> Index: hw-doloop.c
>>> ===================================================================
>>> --- hw-doloop.c (revision 193376)
>>> +++ hw-doloop.c (working copy)
>>> @@ -547,7 +547,7 @@ reorder_loops (hwloop_info loops)
>>>        else
>>>         bb->aux = NULL;
>>>      }
>>> -  cfg_layout_finalize ();
>>> +  cfg_layout_finalize (false);
>>>    clear_aux_for_blocks ();
>>>    df_analyze ();
>>>  }
>>> Index: cfgcleanup.c
>>> ===================================================================
>>> --- cfgcleanup.c        (revision 193376)
>>> +++ cfgcleanup.c        (working copy)
>>> @@ -1824,7 +1824,7 @@ try_crossjump_to_edge (int mode, edge e1, edge e2,
>>>       partition boundaries).  See the comments at the top of
>>>       bb-reorder.c:partition_hot_cold_basic_blocks for complete details.  */
>>>
>>> -  if (flag_reorder_blocks_and_partition && reload_completed)
>>> +  if (crtl->has_bb_partition && reload_completed)
>>>      return false;
>>>
>>>    /* Search backward through forwarder blocks.  We don't need to worry
>>> @@ -2767,10 +2767,21 @@ try_optimize_cfg (int mode)
>>>               df_analyze ();
>>>             }
>>>
>>> +         if (changed)
>>> +            {
>>> +              /* Edge forwarding in particular 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. This is not 
>>> easy
>>> +                 to detect and fix during edge forwarding, and in some 
>>> cases
>>> +                 is only visible after newly unreachable blocks are 
>>> deleted,
>>> +                 which will be done in fixup_partitions.  */
>>> +              fixup_partitions ();
>>> +
>>>  #ifdef ENABLE_CHECKING
>>> -         if (changed)
>>> -           verify_flow_info ();
>>> +              verify_flow_info ();
>>>  #endif
>>> +            }
>>>
>>>           changed_overall |= changed;
>>>           first_pass = false;
>>> Index: bb-reorder.c
>>> ===================================================================
>>> --- bb-reorder.c        (revision 193376)
>>> +++ bb-reorder.c        (working copy)
>>> @@ -1054,7 +1054,7 @@ connect_traces (int n_traces, struct trace *traces
>>>    current_partition = BB_PARTITION (traces[0].first);
>>>    two_passes = false;
>>>
>>> -  if (flag_reorder_blocks_and_partition)
>>> +  if (crtl->has_bb_partition)
>>>      for (i = 0; i < n_traces && !two_passes; i++)
>>>        if (BB_PARTITION (traces[0].first)
>>>           != BB_PARTITION (traces[i].first))
>>> @@ -1263,7 +1263,7 @@ connect_traces (int n_traces, struct trace *traces
>>>                       }
>>>                   }
>>>
>>> -             if (flag_reorder_blocks_and_partition)
>>> +             if (crtl->has_bb_partition)
>>>                 try_copy = false;
>>>
>>>               /* Copy tiny blocks always; copy larger blocks only when the
>>> @@ -1381,13 +1381,14 @@ get_uncond_jump_length (void)
>>>    return length;
>>>  }
>>>
>>> -/* Emit a barrier into the footer of BB.  */
>>> +/* Emit a barrier after BB, into the footer if we are in CFGLAYOUT mode.  
>>> */
>>>
>>> -static void
>>> +void
>>>  emit_barrier_after_bb (basic_block bb)
>>>  {
>>>    rtx barrier = emit_barrier_after (BB_END (bb));
>>> -  BB_FOOTER (bb) = unlink_insn_chain (barrier, barrier);
>>> +  if (current_ir_type () == IR_RTL_CFGLAYOUT)
>>> +    BB_FOOTER (bb) = unlink_insn_chain (barrier, barrier);
>>>  }
>>>
>>>  /* The landing pad OLD_LP, in block OLD_BB, has edges from both partitions.
>>> @@ -1463,18 +1464,109 @@ find_rarely_executed_basic_blocks_and_crossing_edg
>>>  {
>>>    VEC(edge, heap) *crossing_edges = NULL;
>>>    basic_block bb;
>>> -  edge e;
>>> -  edge_iterator ei;
>>> +  edge e, e2;
>>> +  edge_iterator ei, ei2;
>>> +  unsigned int cold_bb_count = 0;
>>> +  VEC (basic_block, heap) *bbs_in_hot_partition = NULL;
>>> +  VEC (basic_block, heap) *bbs_newly_hot = NULL;
>>>
>>>    /* Mark which partition (hot/cold) each basic block belongs in.  */
>>>    FOR_EACH_BB (bb)
>>>      {
>>>        if (probably_never_executed_bb_p (cfun, bb))
>>> -       BB_SET_PARTITION (bb, BB_COLD_PARTITION);
>>> +        {
>>> +          BB_SET_PARTITION (bb, BB_COLD_PARTITION);
>>> +          cold_bb_count++;
>>> +        }
>>>        else
>>> -       BB_SET_PARTITION (bb, BB_HOT_PARTITION);
>>> +        {
>>> +          BB_SET_PARTITION (bb, BB_HOT_PARTITION);
>>> +          VEC_safe_push (basic_block, heap, bbs_in_hot_partition, bb);
>>> +        }
>>>      }
>>>
>>> +  /* Ensure that no cold bbs dominate hot bbs. This could happen as a 
>>> result of
>>> +     several different possibilities. One is that there are edge weight 
>>> insanities
>>> +     due to optimization phases that do not properly update basic block 
>>> profile
>>> +     counts. The second is that the entry of the function may not be hot, 
>>> because
>>> +     it is entered fewer times than the number of profile training runs, 
>>> but there
>>> +     is a loop inside the function that causes blocks within the function 
>>> to be
>>> +     above the threshold for hotness.  */
>>> +  if (cold_bb_count)
>>> +    {
>>> +      bool dom_calculated_here = !dom_info_available_p (CDI_DOMINATORS);
>>> +
>>> +      if (dom_calculated_here)
>>> +        calculate_dominance_info (CDI_DOMINATORS);
>>> +
>>> +      /* Keep examining hot bbs until we have either checked them all, or
>>> +         re-marked all cold bbs hot.  */
>>> +      while (! VEC_empty (basic_block, bbs_in_hot_partition)
>>> +             && cold_bb_count)
>>> +        {
>>> +          basic_block dom_bb;
>>> +
>>> +          bb = VEC_pop (basic_block, bbs_in_hot_partition);
>>> +          dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
>>> +
>>> +          /* If bb's immediate dominator is also hot then it is ok.  */
>>> +          if (BB_PARTITION (dom_bb) != BB_COLD_PARTITION)
>>> +            continue;
>>> +
>>> +          /* We have a hot bb with an immediate dominator that is cold.
>>> +             The dominator needs to be re-marked to hot.  */
>>> +          BB_SET_PARTITION (dom_bb, BB_HOT_PARTITION);
>>> +          cold_bb_count--;
>>> +
>>> +          /* Now we need to examine newly-hot dom_bb to see if it is also
>>> +             dominated by a cold bb.  */
>>> +          VEC_safe_push (basic_block, heap, bbs_in_hot_partition, dom_bb);
>>> +
>>> +          /* We should also adjust any cold blocks that the newly-hot bb
>>> +             feeds and see if it makes sense to re-mark those as hot as
>>> +             well.  */
>>> +          VEC_safe_push (basic_block, heap, bbs_newly_hot, dom_bb);
>>> +          while (! VEC_empty (basic_block, bbs_newly_hot))
>>> +            {
>>> +              basic_block new_hot_bb = VEC_pop (basic_block, 
>>> bbs_newly_hot);
>>> +              /* Examine all successors of this newly-hot bb to see if they
>>> +                 are cold and should be re-marked as hot.  */
>>> +              FOR_EACH_EDGE (e, ei, new_hot_bb->succs)
>>> +                {
>>> +                  bool any_cold_preds = false;
>>> +                  basic_block succ = e->dest;
>>> +                  if (BB_PARTITION (succ) != BB_COLD_PARTITION)
>>> +                    continue;
>>> +                  /* Does this block have any cold predecessors now?  */
>>> +                  FOR_EACH_EDGE (e2, ei2, succ->preds)
>>> +                  {
>>> +                    if (BB_PARTITION (e2->src) == BB_COLD_PARTITION)
>>> +                      {
>>> +                        any_cold_preds = true;
>>> +                        break;
>>> +                      }
>>> +                  }
>>> +                  if (any_cold_preds)
>>> +                    continue;
>>> +
>>> +                  /* Here we have a successor of newly-hot bb that is cold
>>> +                     but no longer has any cold precessessors. Since the 
>>> original
>>> +                     assignment of our newly-hot bb was incorrect, this 
>>> successor's
>>> +                     assignment as cold is also suspect. Go ahead and 
>>> re-mark it
>>> +                     as hot now too. Better heuristics may be in order 
>>> here.  */
>>> +                  BB_SET_PARTITION (succ, BB_HOT_PARTITION);
>>> +                  cold_bb_count--;
>>> +                  VEC_safe_push (basic_block, heap, bbs_in_hot_partition, 
>>> succ);
>>> +                  /* Examine this successor as a newly-hot bb.  */
>>> +                  VEC_safe_push (basic_block, heap, bbs_newly_hot, succ);
>>> +                }
>>> +            }
>>> +        }
>>> +
>>> +      if (dom_calculated_here)
>>> +        free_dominance_info (CDI_DOMINATORS);
>>> +    }
>>> +
>>>    /* The format of .gcc_except_table does not allow landing pads to
>>>       be in a different partition as the throw.  Fix this by either
>>>       moving or duplicating the landing pads.  */
>>> @@ -1766,10 +1858,10 @@ fix_up_fall_thru_edges (void)
>>>                       new_bb->aux = cur_bb->aux;
>>>                       cur_bb->aux = new_bb;
>>>
>>> -                     /* Make sure new fall-through bb is in same
>>> -                        partition as bb it's falling through from.  */
>>> +                      /* This is done by force_nonfallthru_and_redirect.  
>>> */
>>> +                     gcc_assert (BB_PARTITION (new_bb)
>>> +                                  == BB_PARTITION (cur_bb));
>>>
>>> -                     BB_COPY_PARTITION (new_bb, cur_bb);
>>>                       single_succ_edge (new_bb)->flags |= EDGE_CROSSING;
>>>                     }
>>>                   else
>>> @@ -2067,7 +2159,10 @@ add_reg_crossing_jump_notes (void)
>>>    FOR_EACH_BB (bb)
>>>      FOR_EACH_EDGE (e, ei, bb->succs)
>>>        if ((e->flags & EDGE_CROSSING)
>>> -         && JUMP_P (BB_END (e->src)))
>>> +         && JUMP_P (BB_END (e->src))
>>> +          /* Some notes were added during fix_up_fall_thru_edges, via
>>> +             force_nonfallthru_and_redirect.  */
>>> +          && !find_reg_note (BB_END (e->src), REG_CROSSING_JUMP, NULL_RTX))
>>>         add_reg_note (BB_END (e->src), REG_CROSSING_JUMP, NULL_RTX);
>>>  }
>>>
>>> @@ -2160,7 +2255,7 @@ reorder_basic_blocks (void)
>>>        dump_flow_info (dump_file, dump_flags);
>>>      }
>>>
>>> -  if (flag_reorder_blocks_and_partition)
>>> +  if (crtl->has_bb_partition)
>>>      verify_hot_cold_block_grouping ();
>>>  }
>>>
>>> @@ -2172,14 +2267,14 @@ reorder_basic_blocks (void)
>>>     encountering this note will make the compiler switch between the
>>>     hot and cold text sections.  */
>>>
>>> -static void
>>> +void
>>>  insert_section_boundary_note (void)
>>>  {
>>>    basic_block bb;
>>>    rtx new_note;
>>>    int first_partition = 0;
>>>
>>> -  if (!flag_reorder_blocks_and_partition)
>>> +  if (!crtl->has_bb_partition)
>>>      return;
>>>
>>>    FOR_EACH_BB (bb)
>>> @@ -2222,10 +2317,8 @@ rest_of_handle_reorder_blocks (void)
>>>    FOR_EACH_BB (bb)
>>>      if (bb->next_bb != EXIT_BLOCK_PTR)
>>>        bb->aux = bb->next_bb;
>>> -  cfg_layout_finalize ();
>>> +  cfg_layout_finalize (true);
>>>
>>> -  /* Add NOTE_INSN_SWITCH_TEXT_SECTIONS notes.  */
>>> -  insert_section_boundary_note ();
>>>    return 0;
>>>  }
>>>
>>> @@ -2366,7 +2459,7 @@ duplicate_computed_gotos (void)
>>>      }
>>>
>>>  done:
>>> -  cfg_layout_finalize ();
>>> +  cfg_layout_finalize (false);
>>>
>>>    BITMAP_FREE (candidates);
>>>    return 0;
>>> @@ -2511,6 +2604,8 @@ partition_hot_cold_basic_blocks (void)
>>>    if (crossing_edges == NULL)
>>>      return 0;
>>>
>>> +  crtl->has_bb_partition = true;
>>> +
>>>    /* Make sure the source of any crossing edge ends in a jump and the
>>>       destination of any crossing edge has a label.  */
>>>    add_labels_and_missing_jumps (crossing_edges);
>>> Index: bb-reorder.h
>>> ===================================================================
>>> --- bb-reorder.h        (revision 193376)
>>> +++ bb-reorder.h        (working copy)
>>> @@ -36,4 +36,8 @@ extern struct target_bb_reorder *this_target_bb_re
>>>
>>>  extern int get_uncond_jump_length (void);
>>>
>>> +extern void insert_section_boundary_note (void);
>>> +
>>> +extern void emit_barrier_after_bb (basic_block bb);
>>> +
>>>  #endif
>>> Index: basic-block.h
>>> ===================================================================
>>> --- basic-block.h       (revision 193376)
>>> +++ basic-block.h       (working copy)
>>> @@ -806,6 +806,7 @@ extern basic_block force_nonfallthru_and_redirect
>>>  extern bool contains_no_active_insn_p (const_basic_block);
>>>  extern bool forwarder_block_p (const_basic_block);
>>>  extern bool can_fallthru (basic_block, basic_block);
>>> +extern void fixup_partitions (void);
>>>
>>>  /* In cfgbuild.c.  */
>>>  extern void find_many_sub_basic_blocks (sbitmap);
>>> Index: cfgrtl.c
>>> ===================================================================
>>> --- cfgrtl.c    (revision 193376)
>>> +++ cfgrtl.c    (working copy)
>>> @@ -46,6 +46,7 @@ along with GCC; see the file COPYING3.  If not see
>>>  #include "tree.h"
>>>  #include "hard-reg-set.h"
>>>  #include "basic-block.h"
>>> +#include "bb-reorder.h"
>>>  #include "regs.h"
>>>  #include "flags.h"
>>>  #include "function.h"
>>> @@ -67,11 +68,12 @@ along with GCC; see the file COPYING3.  If not see
>>>     Only applicable if the CFG is in cfglayout mode.  */
>>>  static GTY(()) rtx cfg_layout_function_footer;
>>>  static GTY(()) rtx cfg_layout_function_header;
>>> +static bool had_sec_boundary_notes;
>>>
>>>  static rtx skip_insns_after_block (basic_block);
>>>  static void record_effective_endpoints (void);
>>>  static rtx label_for_bb (basic_block);
>>> -static void fixup_reorder_chain (void);
>>> +static void fixup_reorder_chain (bool finalize_reorder_blocks);
>>>
>>>  void verify_insn_chain (void);
>>>  static void fixup_fallthru_exit_predecessor (void);
>>> @@ -976,8 +978,7 @@ try_redirect_by_replacing_jump (edge e, basic_bloc
>>>       partition boundaries).  See  the comments at the top of
>>>       bb-reorder.c:partition_hot_cold_basic_blocks for complete details.  */
>>>
>>> -  if (find_reg_note (insn, REG_CROSSING_JUMP, NULL_RTX)
>>> -      || BB_PARTITION (src) != BB_PARTITION (target))
>>> +  if (BB_PARTITION (src) != BB_PARTITION (target))
>>>      return NULL;
>>>
>>>    /* We can replace or remove a complex jump only when we have exactly
>>> @@ -1286,6 +1287,71 @@ redirect_branch_edge (edge e, basic_block target)
>>>    return e;
>>>  }
>>>
>>> +/* Called when edge E has been redirected to a new destination,
>>> +   in order to update the region crossing flag on the edge and
>>> +   jump.  */
>>> +
>>> +static void
>>> +fixup_partition_crossing (edge e, basic_block target)
>>> +{
>>> +  rtx note;
>>> +
>>> +  gcc_assert (e->dest == target);
>>> +
>>> +  if (e->src == ENTRY_BLOCK_PTR || target == 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) != BB_PARTITION (target))
>>> +    {
>>> +      e->flags |= EDGE_CROSSING;
>>> +      note = find_reg_note (BB_END (e->src), REG_CROSSING_JUMP, NULL_RTX);
>>> +      if (JUMP_P (BB_END (e->src))
>>> +          && !note)
>>> +        add_reg_note (BB_END (e->src), REG_CROSSING_JUMP, NULL_RTX);
>>> +    }
>>> +  else if (BB_PARTITION (e->src) == BB_PARTITION (target))
>>> +    {
>>> +      e->flags &= ~EDGE_CROSSING;
>>> +      /* Remove the region crossing note from jump at end of
>>> +         e->src if it exists.  */
>>> +      note = find_reg_note (BB_END (e->src), REG_CROSSING_JUMP, NULL_RTX);
>>> +      if (note)
>>> +        remove_note (BB_END (e->src), note);
>>> +    }
>>> +}
>>> +
>>> +/* Called when block BB has been reassigned to a different partition,
>>> +   to ensure that the region crossing attributes are updated.  */
>>> +
>>> +static void
>>> +fixup_bb_partition (basic_block bb)
>>> +{
>>> +  edge e;
>>> +  edge_iterator ei;
>>> +
>>> +  /* Now need to make bb's pred edges non-region crossing.  */
>>> +  FOR_EACH_EDGE (e, ei, bb->preds)
>>> +    {
>>> +      fixup_partition_crossing (e, e->dest);
>>> +    }
>>> +
>>> +  /* Possibly need to make bb's successor edges region crossing,
>>> +     or remove stale region crossing.  */
>>> +  FOR_EACH_EDGE (e, ei, bb->succs)
>>> +    {
>>> +      if ((e->flags & EDGE_FALLTHRU)
>>> +          && BB_PARTITION (bb) != BB_PARTITION (e->dest)
>>> +          && e->dest != EXIT_BLOCK_PTR)
>>> +        /* force_nonfallthru_and_redirect calls fixup_partition_crossing.  
>>> */
>>> +        force_nonfallthru (e);
>>> +      else
>>> +        fixup_partition_crossing (e, e->dest);
>>> +    }
>>> +}
>>> +
>>>  /* Attempt to change code to redirect edge E to TARGET.  Don't do that on
>>>     expense of adding new instructions or reordering basic blocks.
>>>
>>> @@ -1302,16 +1368,18 @@ rtl_redirect_edge_and_branch (edge e, basic_block
>>>  {
>>>    edge ret;
>>>    basic_block src = e->src;
>>> +  basic_block dest = e->dest;
>>>
>>>    if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
>>>      return NULL;
>>>
>>> -  if (e->dest == target)
>>> +  if (dest == target)
>>>      return e;
>>>
>>>    if ((ret = try_redirect_by_replacing_jump (e, target, false)) != NULL)
>>>      {
>>>        df_set_bb_dirty (src);
>>> +      fixup_partition_crossing (ret, target);
>>>        return ret;
>>>      }
>>>
>>> @@ -1320,6 +1388,7 @@ rtl_redirect_edge_and_branch (edge e, basic_block
>>>      return NULL;
>>>
>>>    df_set_bb_dirty (src);
>>> +  fixup_partition_crossing (ret, target);
>>>    return ret;
>>>  }
>>>
>>> @@ -1454,18 +1523,16 @@ force_nonfallthru_and_redirect (edge e, basic_bloc
>>>        /* Make sure new block ends up in correct hot/cold section.  */
>>>
>>>        BB_COPY_PARTITION (jump_block, e->src);
>>> -      if (flag_reorder_blocks_and_partition
>>> -         && targetm_common.have_named_sections
>>> -         && JUMP_P (BB_END (jump_block))
>>> -         && !any_condjump_p (BB_END (jump_block))
>>> -         && (EDGE_SUCC (jump_block, 0)->flags & EDGE_CROSSING))
>>> -       add_reg_note (BB_END (jump_block), REG_CROSSING_JUMP, NULL_RTX);
>>>
>>>        /* Wire edge in.  */
>>>        new_edge = make_edge (e->src, jump_block, EDGE_FALLTHRU);
>>>        new_edge->probability = probability;
>>>        new_edge->count = count;
>>>
>>> +      /* If e->src was previously region crossing, it no longer is
>>> +         and the reg crossing note should be removed.  */
>>> +      fixup_partition_crossing (new_edge, jump_block);
>>> +
>>>        /* Redirect old edge.  */
>>>        redirect_edge_pred (e, jump_block);
>>>        e->probability = REG_BR_PROB_BASE;
>>> @@ -1521,13 +1588,16 @@ force_nonfallthru_and_redirect (edge e, basic_bloc
>>>        LABEL_NUSES (label)++;
>>>      }
>>>
>>> -  emit_barrier_after (BB_END (jump_block));
>>> +  /* 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, target);
>>>    return new_bb;
>>>  }
>>>
>>> @@ -1626,7 +1696,7 @@ rtl_move_block_after (basic_block bb ATTRIBUTE_UNU
>>>  static basic_block
>>>  rtl_split_edge (edge edge_in)
>>>  {
>>> -  basic_block bb;
>>> +  basic_block bb, new_bb;
>>>    rtx before;
>>>
>>>    /* Abnormal edges cannot be split.  */
>>> @@ -1659,12 +1729,26 @@ rtl_split_edge (edge edge_in)
>>>    else
>>>      {
>>>        bb = create_basic_block (before, NULL, edge_in->dest->prev_bb);
>>> -      /* ??? Why not edge_in->dest->prev_bb here?  */
>>> -      BB_COPY_PARTITION (bb, edge_in->dest);
>>> +      if (edge_in->src == ENTRY_BLOCK_PTR)
>>> +        BB_COPY_PARTITION (bb, edge_in->dest);
>>> +      else
>>> +        /* 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);
>>>      }
>>>
>>>    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_PARTITION (edge_in->dest)
>>> +      && edge_in->dest != EXIT_BLOCK_PTR)
>>> +    {
>>> +      new_bb = force_nonfallthru (single_succ_edge (bb));
>>> +      gcc_assert (!new_bb);
>>> +    }
>>> +
>>>    /* For non-fallthru edges, we must adjust the predecessor's
>>>       jump instruction to target our new block.  */
>>>    if ((edge_in->flags & EDGE_FALLTHRU) == 0)
>>> @@ -1777,17 +1861,13 @@ commit_one_edge_insertion (edge e)
>>>    else
>>>      {
>>>        bb = split_edge (e);
>>> -      after = BB_END (bb);
>>>
>>> -      if (flag_reorder_blocks_and_partition
>>> -         && targetm_common.have_named_sections
>>> -         && e->src != ENTRY_BLOCK_PTR
>>> -         && BB_PARTITION (e->src) == BB_COLD_PARTITION
>>> -         && !(e->flags & EDGE_CROSSING)
>>> -         && JUMP_P (after)
>>> -         && !any_condjump_p (after)
>>> -         && (single_succ_edge (bb)->flags & EDGE_CROSSING))
>>> -       add_reg_note (after, REG_CROSSING_JUMP, NULL_RTX);
>>> +      /* 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)))
>>> +       before = BB_END (bb);
>>> +      else
>>> +        after = BB_END (bb);
>>>      }
>>>
>>>    /* Now that we've found the spot, do the insertion.  */
>>> @@ -1827,6 +1907,14 @@ commit_edge_insertions (void)
>>>  {
>>>    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 ();
>>> +
>>>  #ifdef ENABLE_CHECKING
>>>    verify_flow_info ();
>>>  #endif
>>> @@ -2028,7 +2116,75 @@ get_last_bb_insn (basic_block bb)
>>>
>>>    return end;
>>>  }
>>> -
>>> +
>>> +/* Perform cleanup on the hot/cold bb partitioning after optimization
>>> +   passes that modify the cfg.  */
>>> +
>>> +void
>>> +fixup_partitions (void)
>>> +{
>>> +  basic_block bb;
>>> +
>>> +  if (!crtl->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.  */
>>> +  VEC (basic_block, heap) *bbs_in_cold_partition = NULL;
>>> +  VEC (basic_block, heap) *bbs_to_fix = NULL;
>>> +  FOR_EACH_BB (bb)
>>> +    if ((BB_PARTITION (bb) == BB_COLD_PARTITION))
>>> +      VEC_safe_push (basic_block, heap, bbs_in_cold_partition, bb);
>>> +  if (! VEC_empty (basic_block, bbs_in_cold_partition))
>>> +    {
>>> +      bool dom_calculated_here = !dom_info_available_p (CDI_DOMINATORS);
>>> +      basic_block son;
>>> +
>>> +      if (dom_calculated_here)
>>> +        calculate_dominance_info (CDI_DOMINATORS);
>>> +
>>> +      while (! VEC_empty (basic_block, bbs_in_cold_partition))
>>> +        {
>>> +          bb = VEC_pop (basic_block, bbs_in_cold_partition);
>>> +          /* If bb is not yet cold (because it was added below as
>>> +             a block dominated by a cold bb) then mark it cold here.  */
>>> +          if ((BB_PARTITION (bb) != BB_COLD_PARTITION))
>>> +            {
>>> +              BB_SET_PARTITION (bb, BB_COLD_PARTITION);
>>> +              VEC_safe_push (basic_block, heap, bbs_to_fix, bb);
>>> +            }
>>> +          /* Any blocks dominated by a block in the cold section
>>> +             must also be cold.  */
>>> +          for (son = first_dom_son (CDI_DOMINATORS, bb);
>>> +               son;
>>> +               son = next_dom_son (CDI_DOMINATORS, son))
>>> +            VEC_safe_push (basic_block, heap, bbs_in_cold_partition, son);
>>> +        }
>>> +
>>> +      if (dom_calculated_here)
>>> +        free_dominance_info (CDI_DOMINATORS);
>>> +    }
>>> +
>>> +  /* 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.  */
>>> +  while (! VEC_empty (basic_block, bbs_to_fix))
>>> +    {
>>> +      bb = VEC_pop (basic_block, bbs_to_fix);
>>> +      fixup_bb_partition (bb);
>>> +    }
>>> +}
>>> +
>>>  /* Verify the CFG and RTL consistency common for both underlying RTL and
>>>     cfglayout RTL.
>>>
>>> @@ -2052,6 +2208,7 @@ rtl_verify_flow_info_1 (void)
>>>    rtx x;
>>>    int err = 0;
>>>    basic_block bb;
>>> +  bool have_partitions = false;
>>>
>>>    /* Check the general integrity of the basic blocks.  */
>>>    FOR_EACH_BB_REVERSE (bb)
>>> @@ -2169,6 +2326,8 @@ rtl_verify_flow_info_1 (void)
>>>
>>>           if (e->flags & EDGE_ABNORMAL)
>>>             n_abnormal++;
>>> +
>>> +          have_partitions |= is_crossing;
>>>         }
>>>
>>>        if (n_eh && !find_reg_note (BB_END (bb), REG_EH_REGION, NULL_RTX))
>>> @@ -2293,6 +2452,40 @@ rtl_verify_flow_info_1 (void)
>>>           }
>>>      }
>>>
>>> +  /* 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.  */
>>> +  VEC (basic_block, heap) *bbs_in_cold_partition = NULL;
>>> +  if (have_partitions && !err)
>>> +    FOR_EACH_BB (bb)
>>> +      if ((BB_PARTITION (bb) == BB_COLD_PARTITION))
>>> +        VEC_safe_push (basic_block, heap, bbs_in_cold_partition, bb);
>>> +  if (! VEC_empty (basic_block, bbs_in_cold_partition))
>>> +    {
>>> +      bool dom_calculated_here = !dom_info_available_p (CDI_DOMINATORS);
>>> +      basic_block son;
>>> +
>>> +      if (dom_calculated_here)
>>> +        calculate_dominance_info (CDI_DOMINATORS);
>>> +
>>> +      while (! VEC_empty (basic_block, bbs_in_cold_partition))
>>> +        {
>>> +          bb = VEC_pop (basic_block, bbs_in_cold_partition);
>>> +          if ((BB_PARTITION (bb) != BB_COLD_PARTITION))
>>> +            {
>>> +              error ("non-cold basic block %d dominated "
>>> +                     "by a block in the cold partition", bb->index);
>>> +              err = 1;
>>> +            }
>>> +          for (son = first_dom_son (CDI_DOMINATORS, bb);
>>> +               son;
>>> +               son = next_dom_son (CDI_DOMINATORS, son))
>>> +            VEC_safe_push (basic_block, heap, bbs_in_cold_partition, son);
>>> +        }
>>> +
>>> +      if (dom_calculated_here)
>>> +        free_dominance_info (CDI_DOMINATORS);
>>> +    }
>>> +
>>>    /* Clean up.  */
>>>    return err;
>>>  }
>>> @@ -2965,14 +3158,41 @@ record_effective_endpoints (void)
>>>    else
>>>      cfg_layout_function_header = NULL_RTX;
>>>
>>> +  had_sec_boundary_notes = false;
>>> +
>>>    next_insn = get_insns ();
>>>    FOR_EACH_BB (bb)
>>>      {
>>>        rtx end;
>>>
>>>        if (PREV_INSN (BB_HEAD (bb)) && next_insn != BB_HEAD (bb))
>>> -       BB_HEADER (bb) = unlink_insn_chain (next_insn,
>>> -                                             PREV_INSN (BB_HEAD (bb)));
>>> +        {
>>> +          /* Rather than try to keep section boundary notes incrementally
>>> +             up-to-date through cfg layout optimizations, simply remove 
>>> them
>>> +             and flag that they should be re-inserted when exiting
>>> +             cfg layout mode.  */
>>> +          rtx check_insn = next_insn;
>>> +          while (check_insn)
>>> +            {
>>> +              if (NOTE_P (check_insn)
>>> +                  && NOTE_KIND (check_insn) == 
>>> NOTE_INSN_SWITCH_TEXT_SECTIONS)
>>> +              {
>>> +                had_sec_boundary_notes |= true;
>>> +                /* Remove note from chain. Grab new next_insn first.  */
>>> +                if (next_insn == check_insn)
>>> +                  next_insn = NEXT_INSN (check_insn);
>>> +                /* Delete note.  */
>>> +                delete_insn (check_insn);
>>> +                /* There will only be one.  */
>>> +                break;
>>> +              }
>>> +              check_insn = NEXT_INSN (check_insn);
>>> +            }
>>> +          /* If we still have header instructions left after above loop.  
>>> */
>>> +          if (next_insn != BB_HEAD (bb))
>>> +            BB_HEADER (bb) = unlink_insn_chain (next_insn,
>>> +                                                PREV_INSN (BB_HEAD (bb)));
>>> +        }
>>>        end = skip_insns_after_block (bb);
>>>        if (NEXT_INSN (BB_END (bb)) && BB_END (bb) != end)
>>>         BB_FOOTER (bb) = unlink_insn_chain (NEXT_INSN (BB_END (bb)), end);
>>> @@ -3000,7 +3220,7 @@ outof_cfg_layout_mode (void)
>>>      if (bb->next_bb != EXIT_BLOCK_PTR)
>>>        bb->aux = bb->next_bb;
>>>
>>> -  cfg_layout_finalize ();
>>> +  cfg_layout_finalize (false);
>>>
>>>    return 0;
>>>  }
>>> @@ -3120,10 +3340,13 @@ relink_block_chain (bool stay_in_cfglayout_mode)
>>>  }
>>>
>>>
>>> -/* Given a reorder chain, rearrange the code to match.  */
>>> +/* Given a reorder chain, rearrange the code to match. If
>>> +   this is called when we will FINALIZE_REORDER_BLOCKS, or when
>>> +   section boundary notes were removed on entry to cfg layout
>>> +   mode, insert section boundary notes here.  */
>>>
>>>  static void
>>> -fixup_reorder_chain (void)
>>> +fixup_reorder_chain (bool finalize_reorder_blocks)
>>>  {
>>>    basic_block bb;
>>>    rtx insn = NULL;
>>> @@ -3150,7 +3373,7 @@ static void
>>>           PREV_INSN (BB_HEADER (bb)) = insn;
>>>           insn = BB_HEADER (bb);
>>>           while (NEXT_INSN (insn))
>>> -           insn = NEXT_INSN (insn);
>>> +            insn = NEXT_INSN (insn);
>>>         }
>>>        if (insn)
>>>         NEXT_INSN (insn) = BB_HEAD (bb);
>>> @@ -3175,6 +3398,11 @@ static void
>>>      insn = NEXT_INSN (insn);
>>>
>>>    set_last_insn (insn);
>>> +
>>> +  /* Add NOTE_INSN_SWITCH_TEXT_SECTIONS notes.  */
>>> +  if (had_sec_boundary_notes || finalize_reorder_blocks)
>>> +    insert_section_boundary_note ();
>>> +
>>>  #ifdef ENABLE_CHECKING
>>>    verify_insn_chain ();
>>>  #endif
>>> @@ -3187,7 +3415,7 @@ static void
>>>        edge e_fall, e_taken, e;
>>>        rtx bb_end_insn;
>>>        rtx ret_label = NULL_RTX;
>>> -      basic_block nb, src_bb;
>>> +      basic_block nb;
>>>        edge_iterator ei;
>>>
>>>        if (EDGE_COUNT (bb->succs) == 0)
>>> @@ -3322,7 +3550,6 @@ static void
>>>        /* 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.  */
>>> -      src_bb = e_fall->src;
>>>        nb = force_nonfallthru_and_redirect (e_fall, e_fall->dest, 
>>> ret_label);
>>>        if (nb)
>>>         {
>>> @@ -3330,17 +3557,6 @@ static void
>>>           bb->aux = nb;
>>>           /* Don't process this new block.  */
>>>           bb = nb;
>>> -
>>> -         /* Make sure new bb is tagged for correct section (same as
>>> -            fall-thru source, since you cannot fall-thru across
>>> -            section boundaries).  */
>>> -         BB_COPY_PARTITION (src_bb, single_pred (bb));
>>> -         if (flag_reorder_blocks_and_partition
>>> -             && targetm_common.have_named_sections
>>> -             && JUMP_P (BB_END (bb))
>>> -             && !any_condjump_p (BB_END (bb))
>>> -             && (EDGE_SUCC (bb, 0)->flags & EDGE_CROSSING))
>>> -           add_reg_note (BB_END (bb), REG_CROSSING_JUMP, NULL_RTX);
>>>         }
>>>      }
>>>
>>> @@ -3644,10 +3860,11 @@ duplicate_insn_chain (rtx from, rtx to)
>>>             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_SWITCH_TEXT_SECTIONS:
>>>               emit_note_copy (insn);
>>>               break;
>>>
>>> @@ -3759,10 +3976,13 @@ break_superblocks (void)
>>>  }
>>>
>>>  /* Finalize the changes: reorder insn list according to the sequence 
>>> specified
>>> -   by aux pointers, enter compensation code, rebuild scope forest.  */
>>> +   by aux pointers, enter compensation code, rebuild scope forest. If
>>> +   this is called when we will FINALIZE_REORDER_BLOCKS, indicate that
>>> +   to fixup_reorder_chain so that it can insert the proper switch text
>>> +   section notes.  */
>>>
>>>  void
>>> -cfg_layout_finalize (void)
>>> +cfg_layout_finalize (bool finalize_reorder_blocks)
>>>  {
>>>  #ifdef ENABLE_CHECKING
>>>    verify_flow_info ();
>>> @@ -3775,7 +3995,7 @@ void
>>>  #endif
>>>        )
>>>      fixup_fallthru_exit_predecessor ();
>>> -  fixup_reorder_chain ();
>>> +  fixup_reorder_chain (finalize_reorder_blocks);
>>>
>>>    rebuild_jump_labels (get_insns ());
>>>    delete_dead_jumptables ();
>>> @@ -4454,8 +4674,7 @@ rtl_can_remove_branch_p (const_edge e)
>>>    if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
>>>      return false;
>>>
>>> -  if (find_reg_note (insn, REG_CROSSING_JUMP, NULL_RTX)
>>> -      || BB_PARTITION (src) != BB_PARTITION (target))
>>> +  if (BB_PARTITION (src) != BB_PARTITION (target))
>>>      return false;
>>>
>>>    if (!onlyjump_p (insn)
>>>
>>> --
>>> This patch is available for review at http://codereview.appspot.com/6823047
>>
>>
>>
>> --
>> Teresa Johnson | Software Engineer | tejohn...@google.com | 408-460-2413



-- 
Teresa Johnson | Software Engineer | tejohn...@google.com | 408-460-2413

Reply via email to