From patchwork Fri Nov 4 00:53:31 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Lee X-Patchwork-Id: 15264 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp88391wru; Thu, 3 Nov 2022 17:58:01 -0700 (PDT) X-Google-Smtp-Source: AMsMyM5SYGn12L5bbQxBRRi4Ktjl3LH/cpMcDBh6Cbyys+4itBVrdmWqLUWHCxxdBLtZ45i9+yXJ X-Received: by 2002:a17:907:a059:b0:78d:1a16:fc5c with SMTP id gz25-20020a170907a05900b0078d1a16fc5cmr32302543ejc.31.1667523481277; Thu, 03 Nov 2022 17:58:01 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1667523481; cv=none; d=google.com; s=arc-20160816; b=GEgmrWbWUtp4JnDd33EGcuXCf1TvYbD9HFFfAPuvZmhnEW9hiEvBW7non1ekdpzOfB F7pyV1Slu+Wymd5bt0XnluXsEFqpHU/EuGYS7unXGWJiXuCvcrVZ1+TlOQ5vuMSJqBem SeDxg9J+JXpVji4rTr9tcyi+sr2NTGiWGV72LlXGtFaQ03WwAILd8TJr2zw22/cYgyUM hwfvoPtkfGRIPgnvNDoAy1utgDvd5O8Pixw3OQGiKl8/LehSL91Tof+M+jihP3mfOHx0 bpYVPVoUfv5UWJ14C0QxkTnuCBYWVYnVJIa/KrTWOKCP4CdOHpy5F9KkTD9zYgTgUrSy ZJNA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:cc:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:message-id:date:subject:to:from:dkim-signature :dmarc-filter:delivered-to; bh=qE80xX6QwDiVA4AtdE4hqX2BFlXocptGy62swA48CoQ=; b=q3YUkbU70POUBUkpFhuBV9H+WeulnqfG4humuZingzZX4e9QvYM/l6Q48nPFBUsWzt 1EinYVar8TkblG+uiLtn/aoj+10A5kVdwB4wcMf1IElF7IWjXXo46p+ULwgqg0phrw8y 2isWOFSrvjHiltbnW1UB5NAtk28PzUnf/jWhTrMdFMwKwUDhYhOH8uz6taantClylhMT HyBAvUC1AYXVKWuhjfVSMFDRZewD/VCWi9PwGEEjAcisAyofkpbDdNzVVlfuXaZElVly 9+gYXVvvDMeU338V3Jp3h5J3LyvEpAS5iER7u7A4bUJbMbHB4r/CzQIiOpfc5A1fAVIg BEzQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=fail header.i=@rivosinc-com.20210112.gappssmtp.com header.s=20210112 header.b=Vlm8alLd; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org" Received: from sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id o7-20020a056402038700b004593fb0c125si2493477edv.103.2022.11.03.17.58.00 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 03 Nov 2022 17:58:01 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=fail header.i=@rivosinc-com.20210112.gappssmtp.com header.s=20210112 header.b=Vlm8alLd; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org" Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C2487385842F for ; Fri, 4 Nov 2022 00:57:55 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-pj1-x1035.google.com (mail-pj1-x1035.google.com [IPv6:2607:f8b0:4864:20::1035]) by sourceware.org (Postfix) with ESMTPS id 6940F3858D3C for ; Fri, 4 Nov 2022 00:57:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 6940F3858D3C Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=rivosinc.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=rivosinc.com Received: by mail-pj1-x1035.google.com with SMTP id c15-20020a17090a1d0f00b0021365864446so3337833pjd.4 for ; Thu, 03 Nov 2022 17:57:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=qE80xX6QwDiVA4AtdE4hqX2BFlXocptGy62swA48CoQ=; b=Vlm8alLdyPsNq/q05JxxxcAgbF4khTq/Qlu31w/e7doh4K+SqdQ+xsZpPeF1ZtAt4O hcfl7wjK2OpfyM60iLsD+YCU4tszosr3cyQ8LW8w87Qvb0/IYvmKzz+bMokNh8EQl4nE SeFYy51qppGAglffsnZFwTIYKHmN6fKse3c4WJdeYtiPrf+9yJaUlebtDkleayh7qe4n 4CA12u8oK4GphZJPGDveIoXoTZdY8zy2uYU8NeMUAXsiyN/I8dKV75JuK0oAkQb+JaTU u8MV++i2ny9zhqyy8pOMme/dZGnNwb09DMgu9sBkTh4aswLjYyQUiWd+wsbhu3nhEZoa TX5g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=qE80xX6QwDiVA4AtdE4hqX2BFlXocptGy62swA48CoQ=; b=JZsFwINcNzlAnFqLOytfLUPf+Ftfp0knxJUdFzkNqDdwTxijforh+7ofikrPxYv67T ogfSoh9R5BZoIM9cRtKXFK3wP3HZPx6AHGLBLgpisvRKTK5U6zqvfCPzKlMWVCLgAQAU A+AucQS6I3XgzgWf2ZKPL5CJ8G7sp6Xsq1s1Kp9RUMKofG6b89GuT5QrhQsRgCCTpYzV 5Zl0/17sHh2wTtEz5PQXq3W4fbyrfk7nRJHjPdROIyvNU/8xe5E6JIuHFOtubLiEKQKv LtFisn0GEYALm3kx7YlWRX8LYjqH+qMNO57F7Jb00z8YQ5XrqBrxvu7TlM6RIVMj7hfE 8L1Q== X-Gm-Message-State: ACrzQf0l6zZhpwSWQnFxwrAtRrL9h01hilrCNdePYPg82HANfhElYwW7 gPANsb04TpjjpLVLvA/xpizXZwmXKz0Vuw== X-Received: by 2002:a17:902:70c4:b0:17c:f9fe:3200 with SMTP id l4-20020a17090270c400b0017cf9fe3200mr33207441plt.1.1667523446867; Thu, 03 Nov 2022 17:57:26 -0700 (PDT) Received: from kevinl.ba.rivosinc.com ([66.220.2.162]) by smtp.gmail.com with ESMTPSA id z15-20020a170903018f00b00186616b8fbasm1344840plg.10.2022.11.03.17.57.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 03 Nov 2022 17:57:26 -0700 (PDT) From: Kevin Lee To: gcc-patches@gcc.gnu.org Subject: [PATCH v3] RISC-V modified add3 for large stack frame optimization [PR105733] Date: Thu, 3 Nov 2022 17:53:31 -0700 Message-Id: <20221104005331.775049-1-kevinl@rivosinc.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Lee , gnu-toolchain@rivosinc.com Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1748525101782401468?= X-GMAIL-MSGID: =?utf-8?q?1748525101782401468?= This is the identical patch with https://gcc.gnu.org/pipermail/gcc-patches/2022-November/604814.html, but with the correct plaintext format. >The loop still seems a bit odd which may point to further improvements >that could be made to this patch. Consider this fragment of the loop: Thank you for the review Jeff! I am currently looking into this issue in a different patch. I'll come back with some improvement. gcc/ChangeLog: Jim Wilson Michael Collison Kevin Lee * config/riscv/predicates.md (const_lui_operand): New Predicate. (add_operand): Ditto. (reg_or_const_int_operand): Ditto. * config/riscv/riscv-protos.h (riscv_eliminable_reg): New function. * config/riscv/riscv-selftests.cc (calculate_x_in_sequence): Consider Parallel insns. * config/riscv/riscv.cc (riscv_eliminable_reg): New function. (riscv_adjust_libcall_cfi_prologue): Use gen_rtx_SET and gen_rtx_fmt_ee instead of gen_add3_insn. (riscv_adjust_libcall_cfi_epilogue): Ditto. * config/riscv/riscv.md (addsi3): Remove. (add3): New instruction for large stack frame optimization. (add3_internal): Ditto. (adddi3): Remove. (add3_internal2): New instruction for insns generated in the prologue and epilogue pass. --- gcc/config/riscv/predicates.md | 13 +++++ gcc/config/riscv/riscv-protos.h | 1 + gcc/config/riscv/riscv-selftests.cc | 3 ++ gcc/config/riscv/riscv.cc | 20 +++++-- gcc/config/riscv/riscv.md | 84 ++++++++++++++++++++++++----- 5 files changed, 104 insertions(+), 17 deletions(-) diff --git a/gcc/config/riscv/predicates.md b/gcc/config/riscv/predicates.md index c2ff41bb0fd..3149f7227ac 100644 --- a/gcc/config/riscv/predicates.md +++ b/gcc/config/riscv/predicates.md @@ -35,6 +35,14 @@ (ior (match_operand 0 "arith_operand") (match_operand 0 "lui_operand"))) +(define_predicate "const_lui_operand" + (and (match_code "const_int") + (match_test "(INTVAL (op) & 0xFFF) == 0 && INTVAL (op) != 0"))) + +(define_predicate "add_operand" + (ior (match_operand 0 "arith_operand") + (match_operand 0 "const_lui_operand"))) + (define_predicate "const_csr_operand" (and (match_code "const_int") (match_test "IN_RANGE (INTVAL (op), 0, 31)"))) @@ -59,6 +67,11 @@ (ior (match_operand 0 "const_0_operand") (match_operand 0 "register_operand"))) +;; For use in adds, when adding to an eliminable register. +(define_predicate "reg_or_const_int_operand" + (ior (match_code "const_int") + (match_operand 0 "register_operand"))) + ;; Only use branch-on-bit sequences when the mask is not an ANDI immediate. (define_predicate "branch_on_bit_operand" (and (match_code "const_int") diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 5a718bb62b4..9348ac71956 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -63,6 +63,7 @@ extern void riscv_expand_conditional_move (rtx, rtx, rtx, rtx_code, rtx, rtx); extern rtx riscv_legitimize_call_address (rtx); extern void riscv_set_return_address (rtx, rtx); extern bool riscv_expand_block_move (rtx, rtx, rtx); +extern bool riscv_eliminable_reg (rtx); extern rtx riscv_return_addr (int, rtx); extern poly_int64 riscv_initial_elimination_offset (int, int); extern void riscv_expand_prologue (void); diff --git a/gcc/config/riscv/riscv-selftests.cc b/gcc/config/riscv/riscv-selftests.cc index 636874ebc0f..50457db708e 100644 --- a/gcc/config/riscv/riscv-selftests.cc +++ b/gcc/config/riscv/riscv-selftests.cc @@ -116,6 +116,9 @@ calculate_x_in_sequence (rtx reg) rtx pat = PATTERN (insn); rtx dest = SET_DEST (pat); + if (GET_CODE (pat) == PARALLEL) + dest = SET_DEST (XVECEXP (pat, 0, 0)); + if (GET_CODE (pat) == CLOBBER) continue; diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 32f9ef9ade9..de9344b37a3 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -4686,6 +4686,16 @@ riscv_initial_elimination_offset (int from, int to) return src - dest; } +/* Return true if X is a register that will be eliminated later on. */ +bool +riscv_eliminable_reg (rtx x) +{ + return REG_P (x) && (REGNO (x) == FRAME_POINTER_REGNUM + || REGNO (x) == ARG_POINTER_REGNUM + || (REGNO (x) >= FIRST_VIRTUAL_REGISTER + && REGNO (x) <= LAST_VIRTUAL_REGISTER)); +} + /* Implement RETURN_ADDR_RTX. We do not support moving back to a previous frame. */ @@ -4887,8 +4897,9 @@ riscv_adjust_libcall_cfi_prologue () } /* Debug info for adjust sp. */ - adjust_sp_rtx = gen_add3_insn (stack_pointer_rtx, - stack_pointer_rtx, GEN_INT (-saved_size)); + adjust_sp_rtx = gen_rtx_SET (stack_pointer_rtx, + gen_rtx_fmt_ee (PLUS, GET_MODE (stack_pointer_rtx), + stack_pointer_rtx, GEN_INT (saved_size))); dwarf = alloc_reg_note (REG_CFA_ADJUST_CFA, adjust_sp_rtx, dwarf); return dwarf; @@ -4990,8 +5001,9 @@ riscv_adjust_libcall_cfi_epilogue () int saved_size = cfun->machine->frame.save_libcall_adjustment; /* Debug info for adjust sp. */ - adjust_sp_rtx = gen_add3_insn (stack_pointer_rtx, - stack_pointer_rtx, GEN_INT (saved_size)); + adjust_sp_rtx = gen_rtx_SET (stack_pointer_rtx, + gen_rtx_fmt_ee (PLUS, GET_MODE (stack_pointer_rtx), + stack_pointer_rtx, GEN_INT (saved_size))); dwarf = alloc_reg_note (REG_CFA_ADJUST_CFA, adjust_sp_rtx, dwarf); diff --git a/gcc/config/riscv/riscv.md b/gcc/config/riscv/riscv.md index 798f7370a08..985dbdd50c4 100644 --- a/gcc/config/riscv/riscv.md +++ b/gcc/config/riscv/riscv.md @@ -446,23 +446,80 @@ [(set_attr "type" "fadd") (set_attr "mode" "")]) -(define_insn "addsi3" - [(set (match_operand:SI 0 "register_operand" "=r,r") - (plus:SI (match_operand:SI 1 "register_operand" " r,r") - (match_operand:SI 2 "arith_operand" " r,I")))] +(define_expand "add3" + [(parallel + [(set (match_operand:GPR 0 "register_operand" "") + (plus:GPR (match_operand:GPR 1 "register_operand" "") + (match_operand:GPR 2 "add_operand" ""))) + (clobber (match_scratch:GPR 3 ""))])] "" - "add%i2%~\t%0,%1,%2" +{ + if (riscv_eliminable_reg (operands[1])) + { + if (splittable_const_int_operand (operands[2], mode)) + { + /* The idea here is that we emit + add op0, op1, %hi(op2) + addi op0, op0, %lo(op2) + Then when op1, the eliminable reg, gets replaced with sp+offset, + we can simplify the constants. */ + HOST_WIDE_INT high_part = CONST_HIGH_PART (INTVAL (operands[2])); + emit_insn (gen_add3_internal (operands[0], operands[1], + GEN_INT (high_part))); + operands[1] = operands[0]; + operands[2] = GEN_INT (INTVAL (operands[2]) - high_part); + } + else if (! const_arith_operand (operands[2], mode)) + operands[2] = force_reg (mode, operands[2]); + } +}) + +(define_insn_and_split "add3_internal" + [(set (match_operand:GPR 0 "register_operand" "=r,r,&r,!&r") + (plus:GPR (match_operand:GPR 1 "register_operand" " %r,r,r,0") + (match_operand:GPR 2 "add_operand" " r,I,L,L"))) + (clobber (match_scratch:GPR 3 "=X,X,X,&r"))] + "" +{ + if ((which_alternative == 2) || (which_alternative == 3)) + return "#"; + + if (TARGET_64BIT && mode == SImode) + return "add%i2w\t%0,%1,%2"; + else + return "add%i2\t%0,%1,%2"; +} + "&& reload_completed && const_lui_operand (operands[2], mode)" + [(const_int 0)] +{ + if (REGNO (operands[0]) != REGNO (operands[1])) + { + emit_insn (gen_mov (operands[0], operands[2])); + emit_insn (gen_add3_internal (operands[0], operands[0], operands[1])); + } + else + { + emit_insn (gen_mov (operands[3], operands[2])); + emit_insn (gen_add3_internal (operands[0], operands[0], operands[3])); + } + DONE; +} [(set_attr "type" "arith") - (set_attr "mode" "SI")]) + (set_attr "mode" "")]) -(define_insn "adddi3" - [(set (match_operand:DI 0 "register_operand" "=r,r") - (plus:DI (match_operand:DI 1 "register_operand" " r,r") - (match_operand:DI 2 "arith_operand" " r,I")))] - "TARGET_64BIT" - "add%i2\t%0,%1,%2" +(define_insn "add3_internal2" + [(set (match_operand:GPR 0 "register_operand" "=r,r") + (plus:GPR (match_operand:GPR 1 "register_operand" " %r,r") + (match_operand:GPR 2 "arith_operand" " r,I")))] + "" + { + if (TARGET_64BIT && mode == SImode) + return "add%i2w\t%0,%1,%2"; + else + return "add%i2\t%0,%1,%2"; + } [(set_attr "type" "arith") - (set_attr "mode" "DI")]) + (set_attr "mode" "")]) (define_expand "addv4" [(set (match_operand:GPR 0 "register_operand" "=r,r") @@ -508,6 +565,7 @@ DONE; }) + (define_expand "uaddv4" [(set (match_operand:GPR 0 "register_operand" "=r,r") (plus:GPR (match_operand:GPR 1 "register_operand" " r,r")