On Sun, Sep 22, 2013 at 12:54 PM, Richard Sandiford
<[email protected]> 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, ®_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;
> }
