From patchwork Sun Sep 22 10:54:43 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 276960 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 60E542C00B7 for ; Sun, 22 Sep 2013 20:55:15 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; q=dns; s= default; b=XoXIoscQ/z+C4fc8IdLZpXqkTzN1OqEjWuTjHv83xdogJCiaWBBRW FQO0qV72tuUZ1o+swIancPdmiziKYki535y6/nMbt+hHS71/3kfRncOLO0jwXLZz Sr7EhtyQL2o0XuBPvRUORQSep58JIn80olMFgGu75KtlnGgBqStBPE= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; s= default; bh=MEdta+pHClIcvKFeODKngz/t9M4=; b=iobR5y3mYJ08PnxaXr3C SPXF+e8Tgl0/F6iThoKhQtcabUD1troB62c6dXbWiV7wIW0SKaaU0xrSfaFzqtDw M9ZMRbI9VJ9aT0n+zKuysoZwdmfb/TG6dC1tincol7CB0jybBKdaTYoYA+WiZQVT L2F8zW3U++7CLvh8FYXpEv4= Received: (qmail 22184 invoked by alias); 22 Sep 2013 10:55:07 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 22172 invoked by uid 89); 22 Sep 2013 10:55:07 -0000 Received: from mail-wg0-f44.google.com (HELO mail-wg0-f44.google.com) (74.125.82.44) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Sun, 22 Sep 2013 10:55:07 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.0 required=5.0 tests=ALL_TRUSTED, AWL, BAYES_50, FREEMAIL_FROM autolearn=ham version=3.3.2 X-HELO: mail-wg0-f44.google.com Received: by mail-wg0-f44.google.com with SMTP id b13so2019347wgh.11 for ; Sun, 22 Sep 2013 03:55:00 -0700 (PDT) X-Received: by 10.180.189.132 with SMTP id gi4mr9374338wic.19.1379847300530; Sun, 22 Sep 2013 03:55:00 -0700 (PDT) Received: from localhost ([2.26.173.24]) by mx.google.com with ESMTPSA id q5sm17843498wiz.3.1969.12.31.16.00.00 (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Sun, 22 Sep 2013 03:54:59 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, rdsandiford@googlemail.com Subject: RFA: Store the REG_BR_PROB probability directly as an int Date: Sun, 22 Sep 2013 11:54:43 +0100 Message-ID: <87k3i9f7nw.fsf@talisman.default> MIME-Version: 1.0 REG_BR_PROB notes are stored as: (expr_list:REG_BR_PROB (const_int ) ) 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 ) 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? 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. . */ /* 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; }