This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: RFA: Store the REG_BR_PROB probability directly as an int


On Sun, Sep 22, 2013 at 12:54 PM, Richard Sandiford
<rdsandiford@googlemail.com> wrote:
> REG_BR_PROB notes are stored as:
>
>   (expr_list:REG_BR_PROB (const_int <prob>) <chain>)
>
> but a full const_int rtx seems a bit heavweight when all we want is
> a plain "int".  This patch uses:
>
>   (int_list:REG_BR_PROB <prob> <chain>)
>
> instead.
>
> I didn't bother adding INT_LIST to lists.c because in practice we never
> free one explicitly.
>
> Probability checks aren't likely to be on any hot paths, so this isn't
> much of an efficency improvement.  Its main selling point for me is that
> it gets rid of some unnecessary GEN_INTs.
>
> Bootstrapped & regression-tested on x86_64-linux-gnu and
> powerpc64-linux-gnu.  Also tested by compiling one target for each
> of the config/ changes and checking the code by hand.
>
> OK to install?

Ok.

Thanks,
Richard.

> Thanks,
> Richard
>
>
> gcc/
>         * doc/rtl.texi (REG_NOTES): Say that int_list can also be used.
>         (REG_BR_PROB): Say that the probability is stored in an int_list.
>         * reg-notes.def: Update commentary to mention INT_LIST.
>         * rtl.def (EXPR_LIST, INSN_LIST): Capitalize comments.
>         (INT_LIST): New rtx.
>         * rtl.h (add_int_reg_note, add_shallow_copy_of_reg_note): Declare.
>         * rtlanal.c (int_reg_note_p): New function.
>         (alloc_reg_note): Assert that the note does not have an int argument.
>         (add_int_reg_note, add_shallow_copy_of_reg_note): New functions.
>         * combine.c (distribute_notes): Use add_shallow_copy_of_rtx.
>         * cse.c (cse_process_notes_1): Expect REG_EQUAL to be an EXPR_LIST
>         rather than an INSN_LIST.  Handle INT_LIST.
>         * ifcvt.c (cond_exec_process_insns): Take the probability as an int
>         rather than an rtx.  Use gen_rtx_INT_LIST to create a REG_BR_PROB note.
>         (cond_exec_process_if_block): Use XINT to extract REG_BR_PROB values.
>         Manipulate them as ints rather than rtxes.
>         * reg-stack.c (subst_asm_stack_regs): Only handle EXPR_LIST notes.
>         * regmove.c (copy_src_to_dest): Likewise.
>         * sched-vis.c (print_insn_with_notes): Handle INT_LIST.
>
>         * config/i386/winnt.c (i386_pe_seh_unwind_emit): Sink pat assignment
>         into the cases that need it.
>         * config/arm/arm.c (arm_unwind_emit): Likewise.
>
>         * asan.c (asan_clear_shadow): Use add_int_reg_note for REG_BR_PROB.
>         * emit-rtl.c (try_split, emit_copy_of_insn_after): Likewise.
>         * loop-doloop.c (add_test, doloop_modify): Likewise.
>         * loop-unswitch.c (compare_and_jump_seq): Likewise.
>         * optabs.c (emit_cmp_and_jump_insn_1): Likewise.
>         * predict.c (combine_predictions_for_insn): Likewise.
>         * print-rtl.c (print_rtx): Handle INT_LIST.
>         * config/aarch64/aarch64.c (aarch64_emit_unlikely_jump): Likewise.
>         * config/alpha/alpha.c (emit_unlikely_jump): Likewise.
>         * config/arm/arm.c (emit_unlikely_jump): Likewise.
>         * config/i386/i386.c (ix86_expand_split_stack_prologue): Likewise.
>         (ix86_split_fp_branch, predict_jump): Likewise.
>         * config/rs6000/rs6000.c (emit_unlikely_jump): Likewise.
>         * config/sh/sh.c (expand_cbranchsi4): Likewise.
>         * config/spu/spu.c (ea_load_store_inline): Likewise.
>
>         * cfgbuild.c (compute_outgoing_frequencies): Use XINT to access the
>         value of a REG_BR_PROB note.
>         * cfgrtl.c (force_nonfallthru_and_redirect): Likewise.
>         (update_br_prob_note, rtl_verify_edges, purge_dead_edges): Likewise.
>         * emit-rtl.c (try_split): Likewise.
>         * predict.c (br_prob_note_reliable_p): Likewise.
>         (invert_br_probabilities, combine_predictions_for_insn): Likewise.
>         * reorg.c (mostly_true_jump): Likewise.
>         * config/bfin/bfin.c (cbranch_predicted_taken_p): Likewise.
>         * config/frv/frv.c (frv_print_operand_jump_hint): Likewise.
>         * config/i386/i386.c (ix86_print_operand): Likewise.
>         * config/ia64/ia64.c (ia64_print_operand): Likewise.
>         * config/mmix/mmix.c (mmix_print_operand): Likewise.
>         * config/rs6000/rs6000.c (output_cbranch): Likewise.
>         * config/s390/s390.c (s390_expand_tbegin): Likewise.
>         * config/sh/sh.c (sh_print_operand, sh_adjust_cost): Likewise.
>         * config/sparc/sparc.c (output_cbranch): Likewise.
>         * config/spu/spu.c (get_branch_target): Likewise.
>         * config/tilegx/tilegx.c (cbranch_predicted_p): Likewise.
>         * config/tilepro/tilepro.c (cbranch_predicted_p): Likewise.
>
> Index: gcc/doc/rtl.texi
> ===================================================================
> --- gcc/doc/rtl.texi    2013-09-22 10:40:05.360270484 +0100
> +++ gcc/doc/rtl.texi    2013-09-22 10:40:06.975271398 +0100
> @@ -3732,8 +3732,8 @@ Def-use and use-def chains are now prefe
>
>  @findex REG_NOTES
>  @item REG_NOTES (@var{i})
> -A list (chain of @code{expr_list} and @code{insn_list} expressions)
> -giving miscellaneous information about the insn.  It is often
> +A list (chain of @code{expr_list}, @code{insn_list} and @code{int_list}
> +expressions) giving miscellaneous information about the insn.  It is often
>  information pertaining to the registers used in this insn.
>  @end table
>
> @@ -3752,10 +3752,10 @@ analysis pass adds a link to insns which
>  that are used for the first time in this insn.
>
>  The @code{REG_NOTES} field of an insn is a chain similar to the
> -@code{LOG_LINKS} field but it includes @code{expr_list} expressions in
> -addition to @code{insn_list} expressions.  There are several kinds of
> -register notes, which are distinguished by the machine mode, which in a
> -register note is really understood as being an @code{enum reg_note}.
> +@code{LOG_LINKS} field but it includes @code{expr_list} and @code{int_list}
> +expressions in addition to @code{insn_list} expressions.  There are several
> +kinds of register notes, which are distinguished by the machine mode, which
> +in a register note is really understood as being an @code{enum reg_note}.
>  The first operand @var{op} of the note is data whose meaning depends on
>  the kind of note.
>
> @@ -3956,16 +3956,16 @@ This indicates an anti dependence (a wri
>  @end table
>
>  These notes describe information gathered from gcov profile data.  They
> -are stored in the @code{REG_NOTES} field of an insn as an
> -@code{expr_list}.
> +are stored in the @code{REG_NOTES} field of an insn.
>
>  @table @code
>  @findex REG_BR_PROB
>  @item REG_BR_PROB
>  This is used to specify the ratio of branches to non-branches of a
> -branch insn according to the profile data.  The value is stored as a
> -value between 0 and REG_BR_PROB_BASE; larger values indicate a higher
> -probability that the branch will be taken.
> +branch insn according to the profile data.  The note is represented
> +as an @code{int_list} expression whose integer value is between 0 and
> +REG_BR_PROB_BASE.  Larger values indicate a higher probability that
> +the branch will be taken.
>
>  @findex REG_BR_PRED
>  @item REG_BR_PRED
> Index: gcc/reg-notes.def
> ===================================================================
> --- gcc/reg-notes.def   2013-09-22 10:40:05.596270617 +0100
> +++ gcc/reg-notes.def   2013-09-22 10:40:06.979271400 +0100
> @@ -18,9 +18,9 @@ along with GCC; see the file COPYING3.
>  <http://www.gnu.org/licenses/>.  */
>
>  /* This file defines all the codes that may appear on individual
> -   EXPR_LIST rtxes in the REG_NOTES chain of an insn.  The codes are
> -   stored in the mode field of the EXPR_LIST.  Source files define
> -   DEF_REG_NOTE appropriately before including this file.  */
> +   EXPR_LIST, INSN_LIST and INT_LIST rtxes in the REG_NOTES chain of an insn.
> +   The codes are stored in the mode field of the rtx.  Source files
> +   define DEF_REG_NOTE appropriately before including this file.  */
>
>  /* Shorthand.  */
>  #define REG_NOTE(NAME) DEF_REG_NOTE (REG_##NAME)
> @@ -94,9 +94,9 @@ REG_NOTE (DEP_ANTI)
>  REG_NOTE (DEP_CONTROL)
>
>  /* REG_BR_PROB is attached to JUMP_INSNs and CALL_INSNs.  It has an
> -   integer value.  For jumps, it is the probability that this is a
> -   taken branch.  For calls, it is the probability that this call
> -   won't return.  */
> +   integer value (in an INT_LIST).  For jumps, it is the probability
> +   that this is a taken branch.  For calls, it is the probability that
> +   this call won't return.  */
>  REG_NOTE (BR_PROB)
>
>  /* Attached to a call insn; indicates that the call is malloc-like and
> Index: gcc/rtl.def
> ===================================================================
> --- gcc/rtl.def 2013-09-22 10:40:05.599270619 +0100
> +++ gcc/rtl.def 2013-09-22 10:40:06.981271401 +0100
> @@ -95,13 +95,16 @@ DEF_RTL_EXPR(DEBUG_EXPR, "debug_expr", "
>     Expressions used in constructing lists.
>     --------------------------------------------------------------------- */
>
> -/* a linked list of expressions */
> +/* A linked list of expressions.  */
>  DEF_RTL_EXPR(EXPR_LIST, "expr_list", "ee", RTX_EXTRA)
>
> -/* a linked list of instructions.
> +/* A linked list of instructions.
>     The insns are represented in print by their uids.  */
>  DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA)
>
> +/* A linked list of integers.  */
> +DEF_RTL_EXPR(INT_LIST, "int_list", "ie", RTX_EXTRA)
> +
>  /* SEQUENCE is used in late passes of the compiler to group insns for
>     one reason or another.
>
> Index: gcc/rtl.h
> ===================================================================
> --- gcc/rtl.h   2013-09-22 10:40:05.600270619 +0100
> +++ gcc/rtl.h   2013-09-22 10:40:06.981271401 +0100
> @@ -2055,6 +2055,8 @@ extern int find_reg_fusage (const_rtx, e
>  extern int find_regno_fusage (const_rtx, enum rtx_code, unsigned int);
>  extern rtx alloc_reg_note (enum reg_note, rtx, rtx);
>  extern void add_reg_note (rtx, enum reg_note, rtx);
> +extern void add_int_reg_note (rtx, enum reg_note, int);
> +extern void add_shallow_copy_of_reg_note (rtx, rtx);
>  extern void remove_note (rtx, const_rtx);
>  extern void remove_reg_equal_equiv_notes (rtx);
>  extern void remove_reg_equal_equiv_notes_for_regno (unsigned int);
> Index: gcc/rtlanal.c
> ===================================================================
> --- gcc/rtlanal.c       2013-09-22 10:40:05.601270620 +0100
> +++ gcc/rtlanal.c       2013-09-22 10:40:06.982271402 +0100
> @@ -1923,6 +1923,14 @@ find_regno_fusage (const_rtx insn, enum
>  }
>
>
> +/* Return true if KIND is an integer REG_NOTE.  */
> +
> +static bool
> +int_reg_note_p (enum reg_note kind)
> +{
> +  return kind == REG_BR_PROB;
> +}
> +
>  /* Allocate a register note with kind KIND and datum DATUM.  LIST is
>     stored as the pointer to the next register note.  */
>
> @@ -1931,6 +1939,7 @@ alloc_reg_note (enum reg_note kind, rtx
>  {
>    rtx note;
>
> +  gcc_checking_assert (!int_reg_note_p (kind));
>    switch (kind)
>      {
>      case REG_CC_SETTER:
> @@ -1961,6 +1970,27 @@ add_reg_note (rtx insn, enum reg_note ki
>    REG_NOTES (insn) = alloc_reg_note (kind, datum, REG_NOTES (insn));
>  }
>
> +/* Add an integer register note with kind KIND and datum DATUM to INSN.  */
> +
> +void
> +add_int_reg_note (rtx insn, enum reg_note kind, int datum)
> +{
> +  gcc_checking_assert (int_reg_note_p (kind));
> +  REG_NOTES (insn) = gen_rtx_INT_LIST ((enum machine_mode) kind,
> +                                      datum, REG_NOTES (insn));
> +}
> +
> +/* Add a register note like NOTE to INSN.  */
> +
> +void
> +add_shallow_copy_of_reg_note (rtx insn, rtx note)
> +{
> +  if (GET_CODE (note) == INT_LIST)
> +    add_int_reg_note (insn, REG_NOTE_KIND (note), XINT (note, 0));
> +  else
> +    add_reg_note (insn, REG_NOTE_KIND (note), XEXP (note, 0));
> +}
> +
>  /* Remove register note NOTE from the REG_NOTES of INSN.  */
>
>  void
> Index: gcc/combine.c
> ===================================================================
> --- gcc/combine.c       2013-09-22 10:40:05.277270436 +0100
> +++ gcc/combine.c       2013-09-22 10:40:06.949271383 +0100
> @@ -13677,7 +13677,7 @@ distribute_notes (rtx notes, rtx from_in
>         }
>
>        if (place2)
> -       add_reg_note (place2, REG_NOTE_KIND (note), XEXP (note, 0));
> +       add_shallow_copy_of_reg_note (place2, note);
>      }
>  }
>
> Index: gcc/cse.c
> ===================================================================
> --- gcc/cse.c   2013-09-22 10:40:05.359270483 +0100
> +++ gcc/cse.c   2013-09-22 10:40:06.975271398 +0100
> @@ -6068,9 +6068,12 @@ cse_process_notes_1 (rtx x, rtx object,
>        return x;
>
>      case EXPR_LIST:
> -    case INSN_LIST:
>        if (REG_NOTE_KIND (x) == REG_EQUAL)
>         XEXP (x, 0) = cse_process_notes (XEXP (x, 0), NULL_RTX, changed);
> +      /* Fall through.  */
> +
> +    case INSN_LIST:
> +    case INT_LIST:
>        if (XEXP (x, 1))
>         XEXP (x, 1) = cse_process_notes (XEXP (x, 1), NULL_RTX, changed);
>        return x;
> Index: gcc/ifcvt.c
> ===================================================================
> --- gcc/ifcvt.c 2013-09-22 10:40:05.362270484 +0100
> +++ gcc/ifcvt.c 2013-09-22 10:40:06.977271399 +0100
> @@ -91,7 +91,7 @@ static rtx last_active_insn (basic_block
>  static rtx find_active_insn_before (basic_block, rtx);
>  static rtx find_active_insn_after (basic_block, rtx);
>  static basic_block block_fallthru (basic_block);
> -static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, rtx, int);
> +static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, int, int);
>  static rtx cond_exec_get_condition (rtx);
>  static rtx noce_get_condition (rtx, rtx *, bool);
>  static int noce_operand_ok (const_rtx);
> @@ -316,7 +316,7 @@ cond_exec_process_insns (ce_if_block_t *
>                          /* if block information */rtx start,
>                          /* first insn to look at */rtx end,
>                          /* last insn to look at */rtx test,
> -                        /* conditional execution test */rtx prob_val,
> +                        /* conditional execution test */int prob_val,
>                          /* probability of branch taken. */int mod_ok)
>  {
>    int must_be_last = FALSE;
> @@ -387,10 +387,10 @@ cond_exec_process_insns (ce_if_block_t *
>
>        validate_change (insn, &PATTERN (insn), pattern, 1);
>
> -      if (CALL_P (insn) && prob_val)
> +      if (CALL_P (insn) && prob_val >= 0)
>         validate_change (insn, &REG_NOTES (insn),
> -                        alloc_EXPR_LIST (REG_BR_PROB, prob_val,
> -                                         REG_NOTES (insn)), 1);
> +                        gen_rtx_INT_LIST ((enum machine_mode) REG_BR_PROB,
> +                                          prob_val, REG_NOTES (insn)), 1);
>
>      insn_done:
>        if (insn == end)
> @@ -449,14 +449,15 @@ cond_exec_process_if_block (ce_if_block_
>    int then_mod_ok;             /* whether conditional mods are ok in THEN */
>    rtx true_expr;               /* test for else block insns */
>    rtx false_expr;              /* test for then block insns */
> -  rtx true_prob_val;           /* probability of else block */
> -  rtx false_prob_val;          /* probability of then block */
> +  int true_prob_val;           /* probability of else block */
> +  int false_prob_val;          /* probability of then block */
>    rtx then_last_head = NULL_RTX;       /* Last match at the head of THEN */
>    rtx else_last_head = NULL_RTX;       /* Last match at the head of ELSE */
>    rtx then_first_tail = NULL_RTX;      /* First match at the tail of THEN */
>    rtx else_first_tail = NULL_RTX;      /* First match at the tail of ELSE */
>    int then_n_insns, else_n_insns, n_insns;
>    enum rtx_code false_code;
> +  rtx note;
>
>    /* If test is comprised of && or || elements, and we've failed at handling
>       all of them together, just use the last test if it is the special case of
> @@ -588,14 +589,17 @@ cond_exec_process_if_block (ce_if_block_
>      goto fail;
>  #endif
>
> -  true_prob_val = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
> -  if (true_prob_val)
> +  note = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
> +  if (note)
>      {
> -      true_prob_val = XEXP (true_prob_val, 0);
> -      false_prob_val = GEN_INT (REG_BR_PROB_BASE - INTVAL (true_prob_val));
> +      true_prob_val = XINT (note, 0);
> +      false_prob_val = REG_BR_PROB_BASE - true_prob_val;
>      }
>    else
> -    false_prob_val = NULL_RTX;
> +    {
> +      true_prob_val = -1;
> +      false_prob_val = -1;
> +    }
>
>    /* If we have && or || tests, do them here.  These tests are in the adjacent
>       blocks after the first block containing the test.  */
> @@ -4113,15 +4117,14 @@ dead_or_predicable (basic_block test_bb,
>          All that's left is making sure the insns involved can actually
>          be predicated.  */
>
> -      rtx cond, prob_val;
> +      rtx cond;
>
>        cond = cond_exec_get_condition (jump);
>        if (! cond)
>         return FALSE;
>
> -      prob_val = find_reg_note (jump, REG_BR_PROB, NULL_RTX);
> -      if (prob_val)
> -       prob_val = XEXP (prob_val, 0);
> +      rtx note = find_reg_note (jump, REG_BR_PROB, NULL_RTX);
> +      int prob_val = (note ? XINT (note, 0) : -1);
>
>        if (reversep)
>         {
> @@ -4130,8 +4133,8 @@ dead_or_predicable (basic_block test_bb,
>             return FALSE;
>           cond = gen_rtx_fmt_ee (rev, GET_MODE (cond), XEXP (cond, 0),
>                                  XEXP (cond, 1));
> -         if (prob_val)
> -           prob_val = GEN_INT (REG_BR_PROB_BASE - INTVAL (prob_val));
> +         if (prob_val >= 0)
> +           prob_val = REG_BR_PROB_BASE - prob_val;
>         }
>
>        if (cond_exec_process_insns (NULL, head, end, cond, prob_val, 0)
> Index: gcc/reg-stack.c
> ===================================================================
> --- gcc/reg-stack.c     2013-09-22 10:40:05.597270617 +0100
> +++ gcc/reg-stack.c     2013-09-22 10:40:06.980271400 +0100
> @@ -2058,6 +2058,8 @@ subst_asm_stack_regs (rtx insn, stack_pt
>    n_notes = 0;
>    for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
>      {
> +      if (GET_CODE (note) != EXPR_LIST)
> +       continue;
>        rtx reg = XEXP (note, 0);
>        rtx *loc = & XEXP (note, 0);
>
> Index: gcc/regmove.c
> ===================================================================
> --- gcc/regmove.c       2013-09-22 10:40:05.597270617 +0100
> +++ gcc/regmove.c       2013-09-22 10:40:06.980271400 +0100
> @@ -652,7 +652,7 @@ copy_src_to_dest (rtx insn, rtx src, rtx
>        for (link = REG_NOTES (insn); link != NULL_RTX; link = next)
>         {
>           next = XEXP (link, 1);
> -         if (XEXP (link, 0) == src)
> +         if (GET_CODE (link) == EXPR_LIST && XEXP (link, 0) == src)
>             {
>               *p_move_notes = link;
>               p_move_notes = &XEXP (link, 1);
> Index: gcc/sched-vis.c
> ===================================================================
> --- gcc/sched-vis.c     2013-09-22 10:40:05.601270620 +0100
> +++ gcc/sched-vis.c     2013-09-22 10:40:06.982271402 +0100
> @@ -751,7 +751,10 @@ print_insn_with_notes (pretty_printer *p
>        {
>         pp_printf (pp, "%s      %s ", print_rtx_head,
>                    GET_REG_NOTE_NAME (REG_NOTE_KIND (note)));
> -       print_pattern (pp, XEXP (note, 0), 1);
> +       if (GET_CODE (note) == INT_LIST)
> +         pp_printf (pp, "%d", XINT (note, 0));
> +       else
> +         print_pattern (pp, XEXP (note, 0), 1);
>         pp_newline (pp);
>        }
>  }
> Index: gcc/config/i386/winnt.c
> ===================================================================
> --- gcc/config/i386/winnt.c     2013-09-22 10:40:05.340270472 +0100
> +++ gcc/config/i386/winnt.c     2013-09-22 10:40:06.962271391 +0100
> @@ -1178,10 +1178,10 @@ i386_pe_seh_unwind_emit (FILE *asm_out_f
>
>    for (note = REG_NOTES (insn); note ; note = XEXP (note, 1))
>      {
> -      pat = XEXP (note, 0);
>        switch (REG_NOTE_KIND (note))
>         {
>         case REG_FRAME_RELATED_EXPR:
> +         pat = XEXP (note, 0);
>           goto found;
>
>         case REG_CFA_DEF_CFA:
> @@ -1195,6 +1195,7 @@ i386_pe_seh_unwind_emit (FILE *asm_out_f
>           gcc_unreachable ();
>
>         case REG_CFA_ADJUST_CFA:
> +         pat = XEXP (note, 0);
>           if (pat == NULL)
>             {
>               pat = PATTERN (insn);
> @@ -1206,6 +1207,7 @@ i386_pe_seh_unwind_emit (FILE *asm_out_f
>           break;
>
>         case REG_CFA_OFFSET:
> +         pat = XEXP (note, 0);
>           if (pat == NULL)
>             pat = single_set (insn);
>           seh_cfa_offset (asm_out_file, seh, pat);
> Index: gcc/config/arm/arm.c
> ===================================================================
> --- gcc/config/arm/arm.c        2013-09-22 10:40:05.305270452 +0100
> +++ gcc/config/arm/arm.c        2013-09-22 10:40:06.954271386 +0100
> @@ -26103,13 +26103,14 @@ arm_unwind_emit (FILE * asm_out_file, rt
>
>    for (note = REG_NOTES (insn); note ; note = XEXP (note, 1))
>      {
> -      pat = XEXP (note, 0);
>        switch (REG_NOTE_KIND (note))
>         {
>         case REG_FRAME_RELATED_EXPR:
> +         pat = XEXP (note, 0);
>           goto found;
>
>         case REG_CFA_REGISTER:
> +         pat = XEXP (note, 0);
>           if (pat == NULL)
>             {
>               pat = PATTERN (insn);
> @@ -27028,10 +27029,10 @@ arm_emit_store_exclusive (enum machine_m
>  static void
>  emit_unlikely_jump (rtx insn)
>  {
> -  rtx very_unlikely = GEN_INT (REG_BR_PROB_BASE / 100 - 1);
> +  int very_unlikely = REG_BR_PROB_BASE / 100 - 1;
>
>    insn = emit_jump_insn (insn);
> -  add_reg_note (insn, REG_BR_PROB, very_unlikely);
> +  add_int_reg_note (insn, REG_BR_PROB, very_unlikely);
>  }
>
>  /* Expand a compare and swap pattern.  */
> Index: gcc/asan.c
> ===================================================================
> --- gcc/asan.c  2013-09-22 10:40:05.262270428 +0100
> +++ gcc/asan.c  2013-09-22 10:40:06.946271382 +0100
> @@ -908,7 +908,7 @@ asan_clear_shadow (rtx shadow_mem, HOST_
>    emit_cmp_and_jump_insns (addr, end, LT, NULL_RTX, Pmode, true, top_label);
>    jump = get_last_insn ();
>    gcc_assert (JUMP_P (jump));
> -  add_reg_note (jump, REG_BR_PROB, GEN_INT (REG_BR_PROB_BASE * 80 / 100));
> +  add_int_reg_note (jump, REG_BR_PROB, REG_BR_PROB_BASE * 80 / 100);
>  }
>
>  /* Insert code to protect stack vars.  The prologue sequence should be emitted
> Index: gcc/emit-rtl.c
> ===================================================================
> --- gcc/emit-rtl.c      2013-09-22 10:40:05.361270484 +0100
> +++ gcc/emit-rtl.c      2013-09-22 10:40:06.976271399 +0100
> @@ -3461,7 +3461,7 @@ try_split (rtx pat, rtx trial, int last)
>
>    if (any_condjump_p (trial)
>        && (note = find_reg_note (trial, REG_BR_PROB, 0)))
> -    split_branch_probability = INTVAL (XEXP (note, 0));
> +    split_branch_probability = XINT (note, 0);
>    probability = split_branch_probability;
>
>    seq = split_insns (pat, trial);
> @@ -3512,7 +3512,7 @@ try_split (rtx pat, rtx trial, int last)
>                  is responsible for this step using
>                  split_branch_probability variable.  */
>               gcc_assert (njumps == 1);
> -             add_reg_note (insn, REG_BR_PROB, GEN_INT (probability));
> +             add_int_reg_note (insn, REG_BR_PROB, probability);
>             }
>         }
>      }
> @@ -5968,7 +5968,7 @@ emit_copy_of_insn_after (rtx insn, rtx a
>           add_reg_note (new_rtx, REG_NOTE_KIND (link),
>                         copy_insn_1 (XEXP (link, 0)));
>         else
> -         add_reg_note (new_rtx, REG_NOTE_KIND (link), XEXP (link, 0));
> +         add_shallow_copy_of_reg_note (new_rtx, link);
>        }
>
>    INSN_CODE (new_rtx) = INSN_CODE (insn);
> Index: gcc/loop-doloop.c
> ===================================================================
> --- gcc/loop-doloop.c   2013-09-22 10:40:05.362270484 +0100
> +++ gcc/loop-doloop.c   2013-09-22 10:40:06.977271399 +0100
> @@ -381,7 +381,7 @@ add_test (rtx cond, edge *e, basic_block
>    JUMP_LABEL (jump) = label;
>
>    /* The jump is supposed to handle an unlikely special case.  */
> -  add_reg_note (jump, REG_BR_PROB, const0_rtx);
> +  add_int_reg_note (jump, REG_BR_PROB, 0);
>
>    LABEL_NUSES (label)++;
>
> @@ -594,8 +594,7 @@ doloop_modify (struct loop *loop, struct
>    if (true_prob_val)
>      {
>        /* Seems safer to use the branch probability.  */
> -      add_reg_note (jump_insn, REG_BR_PROB,
> -                   GEN_INT (desc->in_edge->probability));
> +      add_int_reg_note (jump_insn, REG_BR_PROB, desc->in_edge->probability);
>      }
>  }
>
> Index: gcc/loop-unswitch.c
> ===================================================================
> --- gcc/loop-unswitch.c 2013-09-22 10:40:05.363270485 +0100
> +++ gcc/loop-unswitch.c 2013-09-22 10:40:06.977271399 +0100
> @@ -126,7 +126,7 @@ compare_and_jump_seq (rtx op0, rtx op1,
>        JUMP_LABEL (jump) = label;
>        LABEL_NUSES (label)++;
>      }
> -  add_reg_note (jump, REG_BR_PROB, GEN_INT (prob));
> +  add_int_reg_note (jump, REG_BR_PROB, prob);
>
>    seq = get_insns ();
>    end_sequence ();
> Index: gcc/optabs.c
> ===================================================================
> --- gcc/optabs.c        2013-09-22 10:40:05.364270486 +0100
> +++ gcc/optabs.c        2013-09-22 10:40:06.978271399 +0100
> @@ -4288,7 +4288,7 @@ emit_cmp_and_jump_insn_1 (rtx test, enum
>        && JUMP_P (insn)
>        && any_condjump_p (insn)
>        && !find_reg_note (insn, REG_BR_PROB, 0))
> -    add_reg_note (insn, REG_BR_PROB, GEN_INT (prob));
> +    add_int_reg_note (insn, REG_BR_PROB, prob);
>  }
>
>  /* Generate code to compare X with Y so that the condition codes are
> Index: gcc/predict.c
> ===================================================================
> --- gcc/predict.c       2013-09-22 10:40:05.594270616 +0100
> +++ gcc/predict.c       2013-09-22 10:40:06.979271400 +0100
> @@ -528,7 +528,7 @@ edge_probability_reliable_p (const_edge
>  br_prob_note_reliable_p (const_rtx note)
>  {
>    gcc_assert (REG_NOTE_KIND (note) == REG_BR_PROB);
> -  return probability_reliable_p (INTVAL (XEXP (note, 0)));
> +  return probability_reliable_p (XINT (note, 0));
>  }
>
>  static void
> @@ -682,7 +682,7 @@ invert_br_probabilities (rtx insn)
>
>    for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
>      if (REG_NOTE_KIND (note) == REG_BR_PROB)
> -      XEXP (note, 0) = GEN_INT (REG_BR_PROB_BASE - INTVAL (XEXP (note, 0)));
> +      XINT (note, 0) = REG_BR_PROB_BASE - XINT (note, 0);
>      else if (REG_NOTE_KIND (note) == REG_BR_PRED)
>        XEXP (XEXP (note, 0), 1)
>         = GEN_INT (REG_BR_PROB_BASE - INTVAL (XEXP (XEXP (note, 0), 1)));
> @@ -836,7 +836,7 @@ combine_predictions_for_insn (rtx insn,
>
>    if (!prob_note)
>      {
> -      add_reg_note (insn, REG_BR_PROB, GEN_INT (combined_probability));
> +      add_int_reg_note (insn, REG_BR_PROB, combined_probability);
>
>        /* Save the prediction into CFG in case we are seeing non-degenerated
>          conditional jump.  */
> @@ -849,7 +849,7 @@ combine_predictions_for_insn (rtx insn,
>      }
>    else if (!single_succ_p (bb))
>      {
> -      int prob = INTVAL (XEXP (prob_note, 0));
> +      int prob = XINT (prob_note, 0);
>
>        BRANCH_EDGE (bb)->probability = prob;
>        FALLTHRU_EDGE (bb)->probability = REG_BR_PROB_BASE - prob;
> Index: gcc/print-rtl.c
> ===================================================================
> --- gcc/print-rtl.c     2013-09-22 10:40:05.595270616 +0100
> +++ gcc/print-rtl.c     2013-09-22 10:40:06.979271400 +0100
> @@ -150,7 +150,8 @@ print_rtx (const_rtx in_rtx)
>
>        /* Print REG_NOTE names for EXPR_LIST and INSN_LIST.  */
>        if ((GET_CODE (in_rtx) == EXPR_LIST
> -          || GET_CODE (in_rtx) == INSN_LIST)
> +          || GET_CODE (in_rtx) == INSN_LIST
> +          || GET_CODE (in_rtx) == INT_LIST)
>           && (int)GET_MODE (in_rtx) < REG_NOTE_MAX)
>         fprintf (outfile, ":%s",
>                  GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
> Index: gcc/config/aarch64/aarch64.c
> ===================================================================
> --- gcc/config/aarch64/aarch64.c        2013-09-22 10:40:05.298270448 +0100
> +++ gcc/config/aarch64/aarch64.c        2013-09-22 10:40:06.950271383 +0100
> @@ -7162,10 +7162,10 @@ aarch64_emit_store_exclusive (enum machi
>  static void
>  aarch64_emit_unlikely_jump (rtx insn)
>  {
> -  rtx very_unlikely = GEN_INT (REG_BR_PROB_BASE / 100 - 1);
> +  int very_unlikely = REG_BR_PROB_BASE / 100 - 1;
>
>    insn = emit_jump_insn (insn);
> -  add_reg_note (insn, REG_BR_PROB, very_unlikely);
> +  add_int_reg_note (insn, REG_BR_PROB, very_unlikely);
>  }
>
>  /* Expand a compare and swap pattern.  */
> Index: gcc/config/alpha/alpha.c
> ===================================================================
> --- gcc/config/alpha/alpha.c    2013-09-22 10:40:05.300270449 +0100
> +++ gcc/config/alpha/alpha.c    2013-09-22 10:40:06.951271384 +0100
> @@ -4228,12 +4228,12 @@ alpha_expand_builtin_vector_binop (rtx (
>  static void
>  emit_unlikely_jump (rtx cond, rtx label)
>  {
> -  rtx very_unlikely = GEN_INT (REG_BR_PROB_BASE / 100 - 1);
> +  int very_unlikely = REG_BR_PROB_BASE / 100 - 1;
>    rtx x;
>
>    x = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, label, pc_rtx);
>    x = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, x));
> -  add_reg_note (x, REG_BR_PROB, very_unlikely);
> +  add_int_reg_note (x, REG_BR_PROB, very_unlikely);
>  }
>
>  /* A subroutine of the atomic operation splitters.  Emit a load-locked
> Index: gcc/config/i386/i386.c
> ===================================================================
> --- gcc/config/i386/i386.c      2013-09-22 10:40:05.339270472 +0100
> +++ gcc/config/i386/i386.c      2013-09-22 10:40:06.961271391 +0100
> @@ -11511,8 +11511,8 @@ ix86_expand_split_stack_prologue (void)
>    JUMP_LABEL (jump_insn) = label;
>
>    /* Mark the jump as very likely to be taken.  */
> -  add_reg_note (jump_insn, REG_BR_PROB,
> -               GEN_INT (REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100));
> +  add_int_reg_note (jump_insn, REG_BR_PROB,
> +                   REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100);
>
>    if (split_stack_fn == NULL_RTX)
>      split_stack_fn = gen_rtx_SYMBOL_REF (Pmode, "__morestack");
> @@ -14808,7 +14808,7 @@ ix86_print_operand (FILE *file, rtx x, i
>             x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
>             if (x)
>               {
> -               int pred_val = INTVAL (XEXP (x, 0));
> +               int pred_val = XINT (x, 0);
>
>                 if (pred_val < REG_BR_PROB_BASE * 45 / 100
>                     || pred_val > REG_BR_PROB_BASE * 55 / 100)
> @@ -19454,7 +19454,7 @@ ix86_split_fp_branch (enum rtx_code code
>                        gen_rtx_IF_THEN_ELSE (VOIDmode,
>                                              condition, target1, target2)));
>    if (split_branch_probability >= 0)
> -    add_reg_note (i, REG_BR_PROB, GEN_INT (split_branch_probability));
> +    add_int_reg_note (i, REG_BR_PROB, split_branch_probability);
>  }
>
>  void
> @@ -21961,7 +21961,7 @@ predict_jump (int prob)
>  {
>    rtx insn = get_last_insn ();
>    gcc_assert (JUMP_P (insn));
> -  add_reg_note (insn, REG_BR_PROB, GEN_INT (prob));
> +  add_int_reg_note (insn, REG_BR_PROB, prob);
>  }
>
>  /* Helper function for the string operations below.  Dest VARIABLE whether
> Index: gcc/config/rs6000/rs6000.c
> ===================================================================
> --- gcc/config/rs6000/rs6000.c  2013-09-22 10:40:05.348270476 +0100
> +++ gcc/config/rs6000/rs6000.c  2013-09-22 10:40:06.967271393 +0100
> @@ -17541,7 +17541,7 @@ output_cbranch (rtx op, const char *labe
>    if (note != NULL_RTX)
>      {
>        /* PROB is the difference from 50%.  */
> -      int prob = INTVAL (XEXP (note, 0)) - REG_BR_PROB_BASE / 2;
> +      int prob = XINT (note, 0) - REG_BR_PROB_BASE / 2;
>
>        /* Only hint for highly probable/improbable branches on newer
>          cpus as static prediction overrides processor dynamic
> @@ -18147,12 +18147,12 @@ rs6000_emit_minmax (rtx dest, enum rtx_c
>  static void
>  emit_unlikely_jump (rtx cond, rtx label)
>  {
> -  rtx very_unlikely = GEN_INT (REG_BR_PROB_BASE / 100 - 1);
> +  int very_unlikely = REG_BR_PROB_BASE / 100 - 1;
>    rtx x;
>
>    x = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, label, pc_rtx);
>    x = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, x));
> -  add_reg_note (x, REG_BR_PROB, very_unlikely);
> +  add_int_reg_note (x, REG_BR_PROB, very_unlikely);
>  }
>
>  /* A subroutine of the atomic operation splitters.  Emit a load-locked
> Index: gcc/config/sh/sh.c
> ===================================================================
> --- gcc/config/sh/sh.c  2013-09-22 10:40:05.353270480 +0100
> +++ gcc/config/sh/sh.c  2013-09-22 10:40:06.970271395 +0100
> @@ -1146,7 +1146,7 @@ sh_print_operand (FILE *stream, rtx x, i
>        {
>         rtx note = find_reg_note (current_output_insn, REG_BR_PROB, 0);
>
> -       if (note && INTVAL (XEXP (note, 0)) * 2 < REG_BR_PROB_BASE)
> +       if (note && XINT (note, 0) * 2 < REG_BR_PROB_BASE)
>           fputs ("/u", stream);
>         break;
>        }
> @@ -2082,7 +2082,7 @@ expand_cbranchsi4 (rtx *operands, enum r
>                                           operands[1], operands[2])));
>    rtx jump = emit_jump_insn (branch_expander (operands[3]));
>    if (probability >= 0)
> -    add_reg_note (jump, REG_BR_PROB, GEN_INT (probability));
> +    add_int_reg_note (jump, REG_BR_PROB, probability);
>  }
>
>  /* ??? How should we distribute probabilities when more than one branch
> @@ -10741,8 +10741,7 @@ sh_adjust_cost (rtx insn, rtx link ATTRI
>             {
>               int orig_cost = cost;
>               rtx note = find_reg_note (insn, REG_BR_PROB, 0);
> -             rtx target = ((! note
> -                            || INTVAL (XEXP (note, 0)) * 2 < REG_BR_PROB_BASE)
> +             rtx target = ((!note || XINT (note, 0) * 2 < REG_BR_PROB_BASE)
>                             ? insn : JUMP_LABEL (insn));
>               /* On the likely path, the branch costs 1, on the unlikely path,
>                  it costs 3.  */
> Index: gcc/config/spu/spu.c
> ===================================================================
> --- gcc/config/spu/spu.c        2013-09-22 10:40:05.356270481 +0100
> +++ gcc/config/spu/spu.c        2013-09-22 10:40:06.972271396 +0100
> @@ -2197,7 +2197,7 @@ get_branch_target (rtx branch)
>             {
>               /* If the more probable case is not a fall through, then
>                  try a branch hint.  */
> -             HOST_WIDE_INT prob = INTVAL (XEXP (note, 0));
> +             int prob = XINT (note, 0);
>               if (prob > (REG_BR_PROB_BASE * 6 / 10)
>                   && GET_CODE (XEXP (src, 1)) != PC)
>                 lab = XEXP (src, 1);
> @@ -4342,7 +4342,7 @@ ea_load_store_inline (rtx mem, bool is_s
>                                                             hit_ref, pc_rtx)));
>    /* Say that this branch is very likely to happen.  */
>    v = REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100 - 1;
> -  add_reg_note (insn, REG_BR_PROB, GEN_INT (v));
> +  add_int_reg_note (insn, REG_BR_PROB, v);
>
>    ea_load_store (mem, is_store, ea_addr, data_addr);
>    cont_label = gen_label_rtx ();
> Index: gcc/cfgbuild.c
> ===================================================================
> --- gcc/cfgbuild.c      2013-09-22 10:40:05.272270433 +0100
> +++ gcc/cfgbuild.c      2013-09-22 10:40:06.946271382 +0100
> @@ -542,7 +542,7 @@ compute_outgoing_frequencies (basic_bloc
>
>        if (note)
>         {
> -         probability = INTVAL (XEXP (note, 0));
> +         probability = XINT (note, 0);
>           e = BRANCH_EDGE (b);
>           e->probability = probability;
>           e->count = apply_probability (b->count, probability);
> Index: gcc/cfgrtl.c
> ===================================================================
> --- gcc/cfgrtl.c        2013-09-22 10:40:05.274270435 +0100
> +++ gcc/cfgrtl.c        2013-09-22 10:40:06.947271382 +0100
> @@ -1480,7 +1480,7 @@ force_nonfallthru_and_redirect (edge e,
>        note = find_reg_note (BB_END (e->src), REG_BR_PROB, NULL_RTX);
>        if (note)
>         {
> -         int prob = INTVAL (XEXP (note, 0));
> +         int prob = XINT (note, 0);
>
>           b->probability = prob;
>            /* Update this to use GCOV_COMPUTE_SCALE.  */
> @@ -2207,9 +2207,9 @@ update_br_prob_note (basic_block bb)
>    if (!JUMP_P (BB_END (bb)))
>      return;
>    note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX);
> -  if (!note || INTVAL (XEXP (note, 0)) == BRANCH_EDGE (bb)->probability)
> +  if (!note || XINT (note, 0) == BRANCH_EDGE (bb)->probability)
>      return;
> -  XEXP (note, 0) = GEN_INT (BRANCH_EDGE (bb)->probability);
> +  XINT (note, 0) = BRANCH_EDGE (bb)->probability;
>  }
>
>  /* Get the last insn associated with block BB (that includes barriers and
> @@ -2399,11 +2399,11 @@ rtl_verify_edges (void)
>           && EDGE_COUNT (bb->succs) >= 2
>           && any_condjump_p (BB_END (bb)))
>         {
> -         if (INTVAL (XEXP (note, 0)) != BRANCH_EDGE (bb)->probability
> +         if (XINT (note, 0) != BRANCH_EDGE (bb)->probability
>               && profile_status != PROFILE_ABSENT)
>             {
> -             error ("verify_flow_info: REG_BR_PROB does not match cfg %wi %i",
> -                    INTVAL (XEXP (note, 0)), BRANCH_EDGE (bb)->probability);
> +             error ("verify_flow_info: REG_BR_PROB does not match cfg %i %i",
> +                    XINT (note, 0), BRANCH_EDGE (bb)->probability);
>               err = 1;
>             }
>         }
> @@ -3104,7 +3104,7 @@ purge_dead_edges (basic_block bb)
>
>           b = BRANCH_EDGE (bb);
>           f = FALLTHRU_EDGE (bb);
> -         b->probability = INTVAL (XEXP (note, 0));
> +         b->probability = XINT (note, 0);
>           f->probability = REG_BR_PROB_BASE - b->probability;
>            /* Update these to use GCOV_COMPUTE_SCALE.  */
>           b->count = bb->count * b->probability / REG_BR_PROB_BASE;
> @@ -3735,7 +3735,7 @@ fixup_reorder_chain (void)
>                   rtx note = find_reg_note (bb_end_insn, REG_BR_PROB, 0);
>
>                   if (note
> -                     && INTVAL (XEXP (note, 0)) < REG_BR_PROB_BASE / 2
> +                     && XINT (note, 0) < REG_BR_PROB_BASE / 2
>                       && invert_jump (bb_end_insn,
>                                       (e_fall->dest == EXIT_BLOCK_PTR
>                                        ? NULL_RTX
> Index: gcc/reorg.c
> ===================================================================
> --- gcc/reorg.c 2013-09-22 10:40:05.598270618 +0100
> +++ gcc/reorg.c 2013-09-22 10:40:06.980271400 +0100
> @@ -876,7 +876,7 @@ mostly_true_jump (rtx jump_insn)
>    rtx note = find_reg_note (jump_insn, REG_BR_PROB, 0);
>    if (note)
>      {
> -      int prob = INTVAL (XEXP (note, 0));
> +      int prob = XINT (note, 0);
>
>        if (prob >= REG_BR_PROB_BASE * 9 / 10)
>         return 2;
> Index: gcc/config/bfin/bfin.c
> ===================================================================
> --- gcc/config/bfin/bfin.c      2013-09-22 10:40:05.330270466 +0100
> +++ gcc/config/bfin/bfin.c      2013-09-22 10:40:06.955271386 +0100
> @@ -2438,7 +2438,7 @@ cbranch_predicted_taken_p (rtx insn)
>
>    if (x)
>      {
> -      int pred_val = INTVAL (XEXP (x, 0));
> +      int pred_val = XINT (x, 0);
>
>        return pred_val >= REG_BR_PROB_BASE / 2;
>      }
> Index: gcc/config/frv/frv.c
> ===================================================================
> --- gcc/config/frv/frv.c        2013-09-22 10:40:05.332270468 +0100
> +++ gcc/config/frv/frv.c        2013-09-22 10:40:06.956271387 +0100
> @@ -2643,7 +2643,7 @@ frv_print_operand_jump_hint (rtx insn)
>    rtx note;
>    rtx labelref;
>    int ret;
> -  HOST_WIDE_INT prob = -1;
> +  int prob = -1;
>    enum { UNKNOWN, BACKWARD, FORWARD } jump_type = UNKNOWN;
>
>    gcc_assert (JUMP_P (insn));
> @@ -2669,7 +2669,7 @@ frv_print_operand_jump_hint (rtx insn)
>
>        else
>         {
> -         prob = INTVAL (XEXP (note, 0));
> +         prob = XINT (note, 0);
>           ret = ((prob >= (REG_BR_PROB_BASE / 2))
>                  ? FRV_JUMP_LIKELY
>                  : FRV_JUMP_NOT_LIKELY);
> @@ -2690,10 +2690,10 @@ frv_print_operand_jump_hint (rtx insn)
>         }
>
>        fprintf (stderr,
> -              "%s: uid %ld, %s, probability = %ld, max prob. = %ld, hint = %d\n",
> +              "%s: uid %ld, %s, probability = %d, max prob. = %d, hint = %d\n",
>                IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
> -              (long)INSN_UID (insn), direction, (long)prob,
> -              (long)REG_BR_PROB_BASE, ret);
> +              (long)INSN_UID (insn), direction, prob,
> +              REG_BR_PROB_BASE, ret);
>      }
>  #endif
>
> Index: gcc/config/ia64/ia64.c
> ===================================================================
> --- gcc/config/ia64/ia64.c      2013-09-22 10:40:05.342270473 +0100
> +++ gcc/config/ia64/ia64.c      2013-09-22 10:40:06.963271391 +0100
> @@ -5454,7 +5454,7 @@ ia64_print_operand (FILE * file, rtx x,
>         x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
>         if (x)
>           {
> -           int pred_val = INTVAL (XEXP (x, 0));
> +           int pred_val = XINT (x, 0);
>
>             /* Guess top and bottom 10% statically predicted.  */
>             if (pred_val < REG_BR_PROB_BASE / 50
> Index: gcc/config/mmix/mmix.c
> ===================================================================
> --- gcc/config/mmix/mmix.c      2013-09-22 10:40:05.343270473 +0100
> +++ gcc/config/mmix/mmix.c      2013-09-22 10:40:06.964271391 +0100
> @@ -1531,7 +1531,7 @@ mmix_print_operand (FILE *stream, rtx x,
>        if (TARGET_BRANCH_PREDICT)
>         {
>           x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
> -         if (x && INTVAL (XEXP (x, 0)) > REG_BR_PROB_BASE / 2)
> +         if (x && XINT (x, 0) > REG_BR_PROB_BASE / 2)
>             putc ('P', stream);
>         }
>        return;
> Index: gcc/config/s390/s390.c
> ===================================================================
> --- gcc/config/s390/s390.c      2013-09-22 10:40:05.350270477 +0100
> +++ gcc/config/s390/s390.c      2013-09-22 10:40:06.969271395 +0100
> @@ -9589,7 +9589,7 @@ s390_expand_tbegin (rtx dest, rtx tdb, r
>    rtx retry_reg = gen_reg_rtx (SImode);
>    rtx retry_label = NULL_RTX;
>    rtx jump;
> -  rtx very_unlikely = GEN_INT (REG_BR_PROB_BASE / 100 - 1);
> +  int very_unlikely = REG_BR_PROB_BASE / 100 - 1;
>
>    if (retry != NULL_RTX)
>      {
> @@ -9612,7 +9612,7 @@ s390_expand_tbegin (rtx dest, rtx tdb, r
>
>    JUMP_LABEL (jump) = abort_label;
>    LABEL_NUSES (abort_label) = 1;
> -  add_reg_note (jump, REG_BR_PROB, very_unlikely);
> +  add_int_reg_note (jump, REG_BR_PROB, very_unlikely);
>
>    /* Initialize CC return value.  */
>    emit_move_insn (dest, const0_rtx);
> @@ -9632,7 +9632,7 @@ s390_expand_tbegin (rtx dest, rtx tdb, r
>                                gen_rtx_REG (CCRAWmode, CC_REGNUM),
>                                gen_rtx_CONST_INT (VOIDmode, CC1 | CC3)));
>        LABEL_NUSES (leave_label) = 2;
> -      add_reg_note (jump, REG_BR_PROB, very_unlikely);
> +      add_int_reg_note (jump, REG_BR_PROB, very_unlikely);
>
>        /* CC2 - transient failure. Perform retry with ppa.  */
>        emit_move_insn (count, retry);
> Index: gcc/config/sparc/sparc.c
> ===================================================================
> --- gcc/config/sparc/sparc.c    2013-09-22 10:40:05.355270480 +0100
> +++ gcc/config/sparc/sparc.c    2013-09-22 10:40:06.972271396 +0100
> @@ -7724,7 +7724,7 @@ output_cbranch (rtx op, rtx dest, int la
>        if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
>         {
>           strcpy (p,
> -                 ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
> +                 ((XINT (note, 0) >= REG_BR_PROB_BASE / 2) ^ far)
>                   ? ",pt" : ",pn");
>           p += 3;
>           spaces -= 3;
> @@ -8195,7 +8195,7 @@ output_v9branch (rtx op, rtx dest, int r
>    if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
>      {
>        strcpy (p,
> -             ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
> +             ((XINT (note, 0) >= REG_BR_PROB_BASE / 2) ^ far)
>               ? ",pt" : ",pn");
>        p += 3;
>      }
> Index: gcc/config/tilegx/tilegx.c
> ===================================================================
> --- gcc/config/tilegx/tilegx.c  2013-09-22 10:40:05.357270481 +0100
> +++ gcc/config/tilegx/tilegx.c  2013-09-22 10:40:06.973271397 +0100
> @@ -2529,7 +2529,7 @@ cbranch_predicted_p (rtx insn)
>
>    if (x)
>      {
> -      int pred_val = INTVAL (XEXP (x, 0));
> +      int pred_val = XINT (x, 0);
>
>        return pred_val >= REG_BR_PROB_BASE / 2;
>      }
> Index: gcc/config/tilepro/tilepro.c
> ===================================================================
> --- gcc/config/tilepro/tilepro.c        2013-09-22 10:40:05.358270482 +0100
> +++ gcc/config/tilepro/tilepro.c        2013-09-22 10:40:06.974271397 +0100
> @@ -2411,7 +2411,7 @@ cbranch_predicted_p (rtx insn)
>
>    if (x)
>      {
> -      int pred_val = INTVAL (XEXP (x, 0));
> +      int pred_val = XINT (x, 0);
>
>        return pred_val >= REG_BR_PROB_BASE / 2;
>      }


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]