From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1005) id F3A353857809; Wed, 23 Mar 2022 16:45:22 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org F3A353857809 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Michael Meissner To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/meissner/heads/work082)] Improve vsx_extract_ X-Act-Checkin: gcc X-Git-Author: Michael Meissner X-Git-Refname: refs/users/meissner/heads/work082 X-Git-Oldrev: 4e9c51e9364bfc88b05b9d0808dfc9bfdff3cc55 X-Git-Newrev: df5e4b1f79a2efc54b211e11177f66ef9d360645 Message-Id: <20220323164522.F3A353857809@sourceware.org> Date: Wed, 23 Mar 2022 16:45:22 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 23 Mar 2022 16:45:23 -0000 https://gcc.gnu.org/g:df5e4b1f79a2efc54b211e11177f66ef9d360645 commit df5e4b1f79a2efc54b211e11177f66ef9d360645 Author: Michael Meissner Date: Wed Mar 23 12:45:02 2022 -0400 Improve vsx_extract_ In looking at PR target/99293, I noticed that the code in vsx_extract_ could be improved. When the element being extracted is the element in the upper 64-bits, we should do an insn_split to convert this to a simple move. This would allow the post reload passes to eliminate the move completely. The code was written before we moved to LRA for register allocation and it restricted the target register to just traditional floating point registers. I have changed this to target any VSX register. The insn type attribute was incorrect in that it used "mfvsr" instead of "vecperm" when a xxpermdi would be generated. Also, when a "mvfsrld" would be generated, the type should be "mfvsr". 2022-03-22 Michael Meissner gcc/ PR target/99392 * config/rs6000/rs6000.md (vsx_extract_): Split extracts that are just a move to being a move insn. Use the correct insn type for the alternatives. (insn splitter for vsx_extract_): Add new splitter. Diff: --- gcc/config/rs6000/vsx.md | 49 +++++++++++++++++++++--------------------------- 1 file changed, 21 insertions(+), 28 deletions(-) diff --git a/gcc/config/rs6000/vsx.md b/gcc/config/rs6000/vsx.md index a1c95c61b2e..031d2560265 100644 --- a/gcc/config/rs6000/vsx.md +++ b/gcc/config/rs6000/vsx.md @@ -3397,46 +3397,27 @@ ;; Optimize cases were we can do a simple or direct move. ;; Or see if we can avoid doing the move at all -;; There are some unresolved problems with reload that show up if an Altivec -;; register was picked. Limit the scalar value to FPRs for now. - (define_insn "vsx_extract_" - [(set (match_operand: 0 "gpc_reg_operand" "=d, d, wr, wr") + [(set (match_operand: 0 "gpc_reg_operand" "=wa, wa, r, r") (vec_select: - (match_operand:VSX_D 1 "gpc_reg_operand" "wa, wa, wa, wa") + (match_operand:VSX_D 1 "gpc_reg_operand" "wa, wa, wa, wa") (parallel - [(match_operand:QI 2 "const_0_to_1_operand" "wD, n, wD, n")])))] + [(match_operand:QI 2 "const_0_to_1_operand" "wD, n, wD, n")])))] "VECTOR_MEM_VSX_P (mode)" { int element = INTVAL (operands[2]); - int op0_regno = REGNO (operands[0]); - int op1_regno = REGNO (operands[1]); + int op0_regno = reg_or_subregno (operands[0]); + int op1_regno = reg_or_subregno (operands[1]); int fldDM; gcc_assert (IN_RANGE (element, 0, 1)); gcc_assert (VSX_REGNO_P (op1_regno)); if (element == VECTOR_ELEMENT_SCALAR_64BIT) - { - if (op0_regno == op1_regno) - return ASM_COMMENT_START " vec_extract to same register"; - - else if (INT_REGNO_P (op0_regno) && TARGET_DIRECT_MOVE - && TARGET_POWERPC64) - return "mfvsrd %0,%x1"; - - else if (FP_REGNO_P (op0_regno) && FP_REGNO_P (op1_regno)) - return "fmr %0,%1"; - - else if (VSX_REGNO_P (op0_regno)) - return "xxlor %x0,%x1,%x1"; - - else - gcc_unreachable (); - } + return "#"; - else if (element == VECTOR_ELEMENT_MFVSRLD_64BIT && INT_REGNO_P (op0_regno) - && TARGET_P9_VECTOR && TARGET_POWERPC64 && TARGET_DIRECT_MOVE) + if (INT_REGNO_P (op0_regno) && TARGET_P9_VECTOR && TARGET_POWERPC64 + && TARGET_DIRECT_MOVE) return "mfvsrld %0,%x1"; else if (VSX_REGNO_P (op0_regno)) @@ -3451,9 +3432,21 @@ else gcc_unreachable (); } - [(set_attr "type" "veclogical,mfvsr,mfvsr,vecperm") + [(set_attr "type" "*,vecperm,mfvsr,mfvsr") (set_attr "isa" "*,*,p8v,p9v")]) +;; Convert extracting the element in the upper 64-bit bits to just a move. +(define_split + [(set (match_operand: 0 "gpc_reg_operand") + (vec_select: + (match_operand:VSX_D 1 "gpc_reg_operand") + (parallel [(match_operand:QI 2 "vsx_scalar_64bit")])))] + "VECTOR_MEM_VSX_P (mode) && reload_completed" + [(set (match_dup 0) (match_dup 3))] +{ + operands[3] = gen_rtx_REG (mode, reg_or_subregno (operands[1])); +}) + ;; Optimize extracting a single scalar element from memory. (define_insn_and_split "*vsx_extract___load" [(set (match_operand: 0 "register_operand" "=wa,wr")