From d108e67950032622d9debad3fd95bc5fc8838bca Mon Sep 17 00:00:00 2001 From: Anatoly Sokolov Date: Sat, 9 Apr 2011 23:10:45 +0400 Subject: [PATCH] expr.c (expand_expr_real_1): Use add_to_hard_reg_set function instead of loop. * 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. From-SVN: r172231 --- gcc/ChangeLog | 10 ++++++ gcc/expr.c | 17 +++------- gcc/function.c | 8 ++--- gcc/ira.c | 14 +++----- gcc/reload1.c | 84 +++++++++++++++++++++--------------------------- gcc/sched-deps.c | 11 +++---- gcc/sel-sched.c | 15 +++------ 7 files changed, 67 insertions(+), 92 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index ea76776a23e..2ec51f2346c 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2011-04-09 Anatoly Sokolov + + * 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. + 2011-04-09 Xinliang David Li PR tree-optimization/PR48484 diff --git a/gcc/expr.c b/gcc/expr.c index 6dc45666dad..491d2b13e6a 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -8451,18 +8451,11 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, 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 diff --git a/gcc/function.c b/gcc/function.c index 14d21c97a42..c292282070c 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -2912,12 +2912,8 @@ static void 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 diff --git a/gcc/ira.c b/gcc/ira.c index 79deab6344d..719473213c8 100644 --- a/gcc/ira.c +++ b/gcc/ira.c @@ -1724,16 +1724,10 @@ compute_regs_asm_clobbered (void) { 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); } } } diff --git a/gcc/reload1.c b/gcc/reload1.c index 9b11cfb5c51..b4f3aec12dd 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -4958,60 +4958,54 @@ static void 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_FOR_INPUT_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_input_addr[opnum], i); - break; + case RELOAD_OTHER: + add_to_hard_reg_set (&reload_reg_used, mode, regno); + break; - case RELOAD_FOR_INPADDR_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_inpaddr_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_OUTPUT_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_output_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_OUTADDR_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_outaddr_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_OPERAND_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_op_addr, 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_OPADDR_ADDR: - SET_HARD_REG_BIT (reload_reg_used_in_op_addr_reload, i); - break; + case RELOAD_FOR_OPERAND_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_op_addr, mode, regno); + break; - case RELOAD_FOR_OTHER_ADDRESS: - SET_HARD_REG_BIT (reload_reg_used_in_other_addr, 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_INPUT: - SET_HARD_REG_BIT (reload_reg_used_in_input[opnum], i); - break; + case RELOAD_FOR_OTHER_ADDRESS: + add_to_hard_reg_set (&reload_reg_used_in_other_addr, mode, regno); + break; - case RELOAD_FOR_OUTPUT: - SET_HARD_REG_BIT (reload_reg_used_in_output[opnum], i); - break; + case RELOAD_FOR_INPUT: + add_to_hard_reg_set (&reload_reg_used_in_input[opnum], mode, regno); + break; - case RELOAD_FOR_INSN: - SET_HARD_REG_BIT (reload_reg_used_in_insn, i); - break; - } + case RELOAD_FOR_OUTPUT: + add_to_hard_reg_set (&reload_reg_used_in_output[opnum], mode, regno); + 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 @@ choose_reload_regs (struct insn_chain *chain) 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 diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c index 393e651f3df..6abef8b9f4d 100644 --- a/gcc/sched-deps.c +++ b/gcc/sched-deps.c @@ -1,7 +1,8 @@ /* Instruction scheduling pass. This file computes dependencies between instructions. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, + 2011 Free Software Foundation, Inc. Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by, and currently maintained by, Jim Wilson (wilson@cygnus.com) @@ -2259,16 +2260,12 @@ sched_analyze_1 (struct deps_desc *deps, rtx x, rtx insn) /* 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 } diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c index e298208ddb5..8a012acec9d 100644 --- a/gcc/sel-sched.c +++ b/gcc/sel-sched.c @@ -1263,17 +1263,12 @@ mark_unavailable_hard_regs (def_t def, struct reg_rename *reg_rename_p, FIXME: it is enough to do this once per all original defs. */ if (frame_pointer_needed) { - int i; - - for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;) - SET_HARD_REG_BIT (reg_rename_p->unavailable_hard_regs, - FRAME_POINTER_REGNUM + i); + add_to_hard_reg_set (®_rename_p->unavailable_hard_regs, + Pmode, FRAME_POINTER_REGNUM); -#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 -- 2.30.2