From patchwork Wed Apr 6 18:21:12 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Anatoly Sokolov X-Patchwork-Id: 90046 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]) by ozlabs.org (Postfix) with SMTP id 56E53B6F06 for ; Thu, 7 Apr 2011 04:20:55 +1000 (EST) Received: (qmail 15367 invoked by alias); 6 Apr 2011 18:20:52 -0000 Received: (qmail 15355 invoked by uid 22791); 6 Apr 2011 18:20:50 -0000 X-SWARE-Spam-Status: No, hits=0.8 required=5.0 tests=AWL, BAYES_00, KAM_THEBAT, RCVD_IN_DNSWL_NONE, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from contrabass.post.ru (HELO contrabass.corbina.net) (85.21.78.5) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 06 Apr 2011 18:20:42 +0000 Received: from corbina.ru (mail.post.ru [195.14.50.16]) by contrabass.corbina.net (Postfix) with ESMTP id 8B494CB075; Wed, 6 Apr 2011 22:20:40 +0400 (MSD) Received: from [95.26.119.68] (account aesok@post.ru HELO Vista.corbina.ru) by corbina.ru (CommuniGate Pro SMTP 5.1.14) with ESMTPA id 315022710; Wed, 06 Apr 2011 22:20:40 +0400 Date: Wed, 6 Apr 2011 22:21:12 +0400 From: Anatoly Sokolov Message-ID: <191990967.20110406222112@post.ru> To: gcc-patches@gcc.gnu.org CC: Jeff Law Subject: [PATCH] Cleanup, use add_to_hard_reg_set instead of SET_HARD_REG_BIT loops. MIME-Version: 1.0 X-IsSubscribed: yes 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 Hi. This patch converts loops of SET_HARD_REG_BIT in to add_to_hard_reg_set functions call. The patch has been bootstrapped on and regression tested on x86_64-unknown-linux-gnu for c. OK to install? * expr.c (expand_expr_real_1): Use add_to_hard_reg_set function instead of loop. * sel-sched.c (mark_unavailable_hard_regs): Likewise. * function.c (record_hard_reg_sets): Likewise. * ira.c (compute_regs_asm_clobbered): Likewise. * sched-deps.c (sched_analyze_1): Likewise. * reload1.c (mark_reload_reg_in_use, choose_reload_regs): Likewise. Anatoly. Index: gcc/sel-sched.c =================================================================== --- gcc/sel-sched.c (revision 172049) +++ gcc/sel-sched.c (working copy) @@ -1263,17 +1263,12 @@ FIXME: it is enough to do this once per all original defs. */ if (frame_pointer_needed) { - int i; + add_to_hard_reg_set (®_rename_p->unavailable_hard_regs, + Pmode, FRAME_POINTER_REGNUM); - for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;) - SET_HARD_REG_BIT (reg_rename_p->unavailable_hard_regs, - FRAME_POINTER_REGNUM + i); - -#if !HARD_FRAME_POINTER_IS_FRAME_POINTER - for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;) - SET_HARD_REG_BIT (reg_rename_p->unavailable_hard_regs, - HARD_FRAME_POINTER_REGNUM + i); -#endif + if (!HARD_FRAME_POINTER_IS_FRAME_POINTER) + add_to_hard_reg_set (®_rename_p->unavailable_hard_regs, + Pmode, HARD_FRAME_POINTER_IS_FRAME_POINTER); } #ifdef STACK_REGS Index: gcc/expr.c =================================================================== --- gcc/expr.c (revision 172049) +++ gcc/expr.c (working copy) @@ -8451,18 +8451,10 @@ gcc_assert (decl_rtl); decl_rtl = copy_rtx (decl_rtl); /* Record writes to register variables. */ - if (modifier == EXPAND_WRITE && REG_P (decl_rtl) - && REGNO (decl_rtl) < FIRST_PSEUDO_REGISTER) - { - int i = REGNO (decl_rtl); - int nregs = hard_regno_nregs[i][GET_MODE (decl_rtl)]; - while (nregs) - { - SET_HARD_REG_BIT (crtl->asm_clobbers, i); - i++; - nregs--; - } - } + if (modifier == EXPAND_WRITE + && REG_P (decl_rtl) && HARD_REGISTER_P (decl_rtl)) + add_to_hard_reg_set (&crtl->asm_clobbers, + GET_MODE (decl_rtl), REGNO (decl_rtl)); /* Ensure variable marked as used even if it doesn't go through a parser. If it hasn't be used yet, write out an external Index: gcc/function.c =================================================================== --- gcc/function.c (revision 172049) +++ gcc/function.c (working copy) @@ -2912,12 +2912,8 @@ record_hard_reg_sets (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data) { HARD_REG_SET *pset = (HARD_REG_SET *)data; - if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER) - { - int nregs = hard_regno_nregs[REGNO (x)][GET_MODE (x)]; - while (nregs-- > 0) - SET_HARD_REG_BIT (*pset, REGNO (x) + nregs); - } + if (REG_P (x) && HARD_REGISTER_P (x)) + add_to_hard_reg_set (pset, GET_MODE (x), REGNO (x)); } /* A subroutine of assign_parms. Allocate a pseudo to hold the current Index: gcc/ira.c =================================================================== --- gcc/ira.c (revision 172049) +++ gcc/ira.c (working copy) @@ -1724,16 +1724,10 @@ { df_ref def = *def_rec; unsigned int dregno = DF_REF_REGNO (def); - if (dregno < FIRST_PSEUDO_REGISTER) - { - unsigned int i; - enum machine_mode mode = GET_MODE (DF_REF_REAL_REG (def)); - unsigned int end = dregno - + hard_regno_nregs[dregno][mode] - 1; - - for (i = dregno; i <= end; ++i) - SET_HARD_REG_BIT(crtl->asm_clobbers, i); - } + if (HARD_REGISTER_NUM_P (dregno)) + add_to_hard_reg_set (&crtl->asm_clobbers, + GET_MODE (DF_REF_REAL_REG (def)), + dregno); } } } Index: gcc/sched-deps.c =================================================================== --- gcc/sched-deps.c (revision 172049) +++ gcc/sched-deps.c (working copy) @@ -2259,16 +2259,12 @@ /* Treat all writes to a stack register as modifying the TOS. */ if (regno >= FIRST_STACK_REG && regno <= LAST_STACK_REG) { - int nregs; - /* Avoid analyzing the same register twice. */ if (regno != FIRST_STACK_REG) sched_analyze_reg (deps, FIRST_STACK_REG, mode, code, insn); - nregs = hard_regno_nregs[FIRST_STACK_REG][mode]; - while (--nregs >= 0) - SET_HARD_REG_BIT (implicit_reg_pending_uses, - FIRST_STACK_REG + nregs); + add_to_hard_reg_set (&implicit_reg_pending_uses, mode, + FIRST_STACK_REG); } #endif } Index: gcc/reload1.c =================================================================== --- gcc/reload1.c (revision 172049) +++ gcc/reload1.c (working copy) @@ -4958,60 +4958,54 @@ mark_reload_reg_in_use (unsigned int regno, int opnum, enum reload_type type, enum machine_mode mode) { - unsigned int nregs = hard_regno_nregs[regno][mode]; - unsigned int i; - - for (i = regno; i < nregs + regno; i++) + switch (type) { - switch (type) - { - case RELOAD_OTHER: - SET_HARD_REG_BIT (reload_reg_used, i); - break; + case RELOAD_OTHER: + add_to_hard_reg_set (&reload_reg_used, mode, regno); + break; - case RELOAD_FOR_INPUT_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_input_addr[opnum], i); - break; + case RELOAD_FOR_INPUT_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_input_addr[opnum], mode, regno); + break; - case RELOAD_FOR_INPADDR_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_inpaddr_addr[opnum], i); - break; + case RELOAD_FOR_INPADDR_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_inpaddr_addr[opnum], mode, regno); + break; - case RELOAD_FOR_OUTPUT_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_output_addr[opnum], i); - break; + case RELOAD_FOR_OUTPUT_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_output_addr[opnum], mode, regno); + break; - case RELOAD_FOR_OUTADDR_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_outaddr_addr[opnum], i); - break; + case RELOAD_FOR_OUTADDR_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_outaddr_addr[opnum], mode, regno); + break; - case RELOAD_FOR_OPERAND_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_op_addr, i); - break; + case RELOAD_FOR_OPERAND_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_op_addr, mode, regno); + break; - case RELOAD_FOR_OPADDR_ADDR: - SET_HARD_REG_BIT (reload_reg_used_in_op_addr_reload, i); - break; + case RELOAD_FOR_OPADDR_ADDR: + add_to_hard_reg_set (&reload_reg_used_in_op_addr_reload, mode, regno); + break; - case RELOAD_FOR_OTHER_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_other_addr, i); - break; + case RELOAD_FOR_OTHER_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_other_addr, mode, regno); + break; - case RELOAD_FOR_INPUT: - SET_HARD_REG_BIT (reload_reg_used_in_input[opnum], i); - break; + case RELOAD_FOR_INPUT: + add_to_hard_reg_set (&reload_reg_used_in_input[opnum], mode, regno); + break; - case RELOAD_FOR_OUTPUT: - SET_HARD_REG_BIT (reload_reg_used_in_output[opnum], i); - break; + case RELOAD_FOR_OUTPUT: + add_to_hard_reg_set (&reload_reg_used_in_output[opnum], mode, regno); + break; - case RELOAD_FOR_INSN: - SET_HARD_REG_BIT (reload_reg_used_in_insn, i); - break; - } - - SET_HARD_REG_BIT (reload_reg_used_at_all, i); + case RELOAD_FOR_INSN: + add_to_hard_reg_set (&reload_reg_used_in_insn, mode, regno); + break; } + + add_to_hard_reg_set (&reload_reg_used_at_all, mode, regno); } /* Similarly, but show REGNO is no longer in use for a reload. */ @@ -6946,11 +6940,7 @@ nregno + nr); if (i >= 0) - { - nr = hard_regno_nregs[i][rld[r].mode]; - while (--nr >= 0) - SET_HARD_REG_BIT (reg_is_output_reload, i + nr); - } + add_to_hard_reg_set (®_is_output_reload, rld[r].mode, i); gcc_assert (rld[r].when_needed == RELOAD_OTHER || rld[r].when_needed == RELOAD_FOR_OUTPUT