From patchwork Thu Dec 1 10:03:30 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fei Gao X-Patchwork-Id: 61308 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 8949338532C5 for ; Thu, 1 Dec 2022 10:04:12 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from zg8tmty1ljiyny4xntqumjca.icoremail.net (zg8tmty1ljiyny4xntqumjca.icoremail.net [165.227.154.27]) by sourceware.org (Postfix) with SMTP id 2CE813858C60 for ; Thu, 1 Dec 2022 10:03:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 2CE813858C60 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=eswincomputing.com Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=eswincomputing.com Received: from localhost.localdomain (unknown [10.12.130.31]) by app2 (Coremail) with SMTP id EggMCgDXtS8BfIhjHYwUAA--.2533S5; Thu, 01 Dec 2022 18:03:46 +0800 (CST) From: Fei Gao To: gcc-patches@gcc.gnu.org Cc: jeffreyalaw@gmail.com, kito.cheng@gmail.com, palmer@dabbelt.com, Fei Gao Subject: [PATCH 1/3] RISC-V: add a new parameter in riscv_first_stack_step. Date: Thu, 1 Dec 2022 10:03:30 +0000 Message-Id: <20221201100332.22226-2-gaofei@eswincomputing.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20221201100332.22226-1-gaofei@eswincomputing.com> References: <20221201100332.22226-1-gaofei@eswincomputing.com> X-CM-TRANSID: EggMCgDXtS8BfIhjHYwUAA--.2533S5 X-Coremail-Antispam: 1UD129KBjvJXoWxtFWDKw4rXr1fWryfCry3Arb_yoW7XrWfpr Z09rsxAr48Jr1fuFyUJFs3AF1fJ34kKr45KryUWr1Fkw1DXw4xKFW7try8ArZI9a97Zw10 kF4DWF1Y9347AaDanT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUPa14x267AKxVW8JVW5JwAFc2x0x2IEx4CE42xK8VAvwI8IcIk0 rVWrJVCq3wAFIxvE14AKwVWUJVWUGwA2048vs2IY020E87I2jVAFwI0_Jr4l82xGYIkIc2 x26xkF7I0E14v26r1Y6r1xM28lY4IEw2IIxxk0rwA2F7IY1VAKz4vEj48ve4kI8wA2z4x0 Y4vE2Ix0cI8IcVAFwI0_tr0E3s1l84ACjcxK6xIIjxv20xvEc7CjxVAFwI0_Gr1j6F4UJw A2z4x0Y4vEx4A2jsIE14v26rxl6s0DM28EF7xvwVC2z280aVCY1x0267AKxVW0oVCq3wAS 0I0E0xvYzxvE52x082IY62kv0487Mc02F40EFcxC0VAKzVAqx4xG6I80ewAv7VC0I7IYx2 IY67AKxVWUJVWUGwAv7VC2z280aVAFwI0_Jr0_Gr1lOx8S6xCaFVCjc4AY6r1j6r4UM4x0 Y48IcxkI7VAKI48JM4x0x7Aq67IIx4CEVc8vx2IErcIFxwCY1x0262kKe7AKxVWUAVWUtw CY02Avz4vE-syl42xK82IYc2Ij64vIr41l4I8I3I0E4IkC6x0Yz7v_Jr0_Gr1lx2IqxVAq x4xG67AKxVWUJVWUGwC20s026x8GjcxK67AKxVWUGVWUWwC2zVAF1VAY17CE14v26r126r 1DMIIYrxkI7VAKI48JMIIF0xvE2Ix0cI8IcVAFwI0_Jr0_JF4lIxAIcVC0I7IYx2IY6xkF 7I0E14v26r1j6r4UMIIF0xvE42xK8VAvwI8IcIk0rVWUJVWUCwCI42IY6I8E87Iv67AKxV WUJVW8JwCI42IY6I8E87Iv6xkF7I0E14v26r4j6r4UJbIYCTnIWIevJa73UjIFyTuYvjfU YvtCUUUUU X-CM-SenderInfo: xjdrwv3l6h245lqf0zpsxwx03jof0z/ X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, RCVD_IN_MSPIKE_H2, SPF_FAIL, SPF_HELO_NONE, 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: , Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" frame->total_size to remaining_size conversion is done as an independent patch without functionality change as per review comment. gcc/ChangeLog: * config/riscv/riscv.cc (riscv_first_stack_step): add a new function parameter remaining_size. (riscv_compute_frame_info): adapt new riscv_first_stack_step interface. (riscv_expand_prologue): likewise. (riscv_expand_epilogue): likewise. --- gcc/config/riscv/riscv.cc | 48 +++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 05bdba5ab4d..f0bbcd6d6be 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -4634,7 +4634,7 @@ riscv_save_libcall_count (unsigned mask) They decrease stack_pointer_rtx but leave frame_pointer_rtx and hard_frame_pointer_rtx unchanged. */ -static HOST_WIDE_INT riscv_first_stack_step (struct riscv_frame_info *frame); +static HOST_WIDE_INT riscv_first_stack_step (struct riscv_frame_info *frame, poly_int64 remaining_size); /* Handle stack align for poly_int. */ static poly_int64 @@ -4663,7 +4663,7 @@ riscv_compute_frame_info (void) save/restore t0. We check for this before clearing the frame struct. */ if (cfun->machine->interrupt_handler_p) { - HOST_WIDE_INT step1 = riscv_first_stack_step (frame); + HOST_WIDE_INT step1 = riscv_first_stack_step (frame, frame->total_size); if (! POLY_SMALL_OPERAND_P ((frame->total_size - step1))) interrupt_save_prologue_temp = true; } @@ -4913,45 +4913,45 @@ riscv_restore_reg (rtx reg, rtx mem) without adding extra instructions. */ static HOST_WIDE_INT -riscv_first_stack_step (struct riscv_frame_info *frame) +riscv_first_stack_step (struct riscv_frame_info *frame, poly_int64 remaining_size) { - HOST_WIDE_INT frame_total_constant_size; - if (!frame->total_size.is_constant ()) - frame_total_constant_size - = riscv_stack_align (frame->total_size.coeffs[0]) - - riscv_stack_align (frame->total_size.coeffs[1]); + HOST_WIDE_INT remaining_const_size; + if (!remaining_size.is_constant ()) + remaining_const_size + = riscv_stack_align (remaining_size.coeffs[0]) + - riscv_stack_align (remaining_size.coeffs[1]); else - frame_total_constant_size = frame->total_size.to_constant (); + remaining_const_size = remaining_size.to_constant (); - if (SMALL_OPERAND (frame_total_constant_size)) - return frame_total_constant_size; + if (SMALL_OPERAND (remaining_const_size)) + return remaining_const_size; HOST_WIDE_INT min_first_step = - RISCV_STACK_ALIGN ((frame->total_size - frame->frame_pointer_offset).to_constant()); + riscv_stack_align ((remaining_size - frame->frame_pointer_offset).to_constant()); HOST_WIDE_INT max_first_step = IMM_REACH / 2 - PREFERRED_STACK_BOUNDARY / 8; - HOST_WIDE_INT min_second_step = frame_total_constant_size - max_first_step; + HOST_WIDE_INT min_second_step = remaining_const_size - max_first_step; gcc_assert (min_first_step <= max_first_step); /* As an optimization, use the least-significant bits of the total frame size, so that the second adjustment step is just LUI + ADD. */ if (!SMALL_OPERAND (min_second_step) - && frame_total_constant_size % IMM_REACH < IMM_REACH / 2 - && frame_total_constant_size % IMM_REACH >= min_first_step) - return frame_total_constant_size % IMM_REACH; + && remaining_const_size % IMM_REACH < IMM_REACH / 2 + && remaining_const_size % IMM_REACH >= min_first_step) + return remaining_const_size % IMM_REACH; if (TARGET_RVC) { /* If we need two subtracts, and one is small enough to allow compressed - loads and stores, then put that one first. */ + loads and stores, then put that one first. */ if (IN_RANGE (min_second_step, 0, - (TARGET_64BIT ? SDSP_REACH : SWSP_REACH))) - return MAX (min_second_step, min_first_step); + (TARGET_64BIT ? SDSP_REACH : SWSP_REACH))) + return MAX (min_second_step, min_first_step); /* If we need LUI + ADDI + ADD for the second adjustment step, then start - with the minimum first step, so that we can get compressed loads and - stores. */ + with the minimum first step, so that we can get compressed loads and + stores. */ else if (!SMALL_OPERAND (min_second_step)) - return min_first_step; + return min_first_step; } return max_first_step; @@ -5037,7 +5037,7 @@ riscv_expand_prologue (void) /* Save the registers. */ if ((frame->mask | frame->fmask) != 0) { - HOST_WIDE_INT step1 = riscv_first_stack_step (frame); + HOST_WIDE_INT step1 = riscv_first_stack_step (frame, frame->total_size); if (size.is_constant ()) step1 = MIN (size.to_constant(), step1); @@ -5216,7 +5216,7 @@ riscv_expand_epilogue (int style) possible in the second step without going out of range. */ if ((frame->mask | frame->fmask) != 0) { - step2 = riscv_first_stack_step (frame); + step2 = riscv_first_stack_step (frame, frame->total_size); step1 -= step2; } From patchwork Thu Dec 1 10:03:31 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fei Gao X-Patchwork-Id: 61307 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 88B313852C49 for ; Thu, 1 Dec 2022 10:04:11 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from zg8tmtyylji0my4xnjeumjiw.icoremail.net (zg8tmtyylji0my4xnjeumjiw.icoremail.net [162.243.161.220]) by sourceware.org (Postfix) with SMTP id 8BF7A385840C for ; Thu, 1 Dec 2022 10:03:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 8BF7A385840C Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=eswincomputing.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=eswincomputing.com Received: from localhost.localdomain (unknown [10.12.130.31]) by app2 (Coremail) with SMTP id EggMCgDXtS8BfIhjHYwUAA--.2533S6; Thu, 01 Dec 2022 18:03:46 +0800 (CST) From: Fei Gao To: gcc-patches@gcc.gnu.org Cc: jeffreyalaw@gmail.com, kito.cheng@gmail.com, palmer@dabbelt.com, Fei Gao Subject: [PATCH 2/3] RISC-V: optimize stack manipulation in save-restore Date: Thu, 1 Dec 2022 10:03:31 +0000 Message-Id: <20221201100332.22226-3-gaofei@eswincomputing.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20221201100332.22226-1-gaofei@eswincomputing.com> References: <20221201100332.22226-1-gaofei@eswincomputing.com> X-CM-TRANSID: EggMCgDXtS8BfIhjHYwUAA--.2533S6 X-Coremail-Antispam: 1UD129KBjvJXoW3Ww1kZrWxAry3XF43JrWxtFb_yoWxuryDpr s5XFsayw1UJryfArnrtF1xJF15J395Gr1YkrZ3CrySywnrArZ7Ka93K3W3ZFWUua1kZrnI kF4Dur1Y9397G3DanT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUmq14x267AKxVW5JVWrJwAFc2x0x2IEx4CE42xK8VAvwI8IcIk0 rVWrJVCq3wAFIxvE14AKwVWUJVWUGwA2048vs2IY020E87I2jVAFwI0_Jryl82xGYIkIc2 x26xkF7I0E14v26r1I6r4UM28lY4IEw2IIxxk0rwA2F7IY1VAKz4vEj48ve4kI8wA2z4x0 Y4vE2Ix0cI8IcVAFwI0_tr0E3s1l84ACjcxK6xIIjxv20xvEc7CjxVAFwI0_Gr1j6F4UJw A2z4x0Y4vEx4A2jsIE14v26rxl6s0DM28EF7xvwVC2z280aVCY1x0267AKxVW0oVCq3wAS 0I0E0xvYzxvE52x082IY62kv0487Mc02F40EFcxC0VAKzVAqx4xG6I80ewAv7VC0I7IYx2 IY67AKxVWUJVWUGwAv7VC2z280aVAFwI0_Jr0_Gr1lOx8S6xCaFVCjc4AY6r1j6r4UM4x0 Y48IcxkI7VAKI48JM4x0x7Aq67IIx4CEVc8vx2IErcIFxwCY1x0262kKe7AKxVWUAVWUtw CY02Avz4vE-syl42xK82IYc2Ij64vIr41l4I8I3I0E4IkC6x0Yz7v_Jr0_Gr1l4IxYO2xF xVAFwI0_Jrv_JF1lx2IqxVAqx4xG67AKxVWUJVWUGwC20s026x8GjcxK67AKxVWUGVWUWw C2zVAF1VAY17CE14v26r126r1DMIIYrxkI7VAKI48JMIIF0xvE2Ix0cI8IcVAFwI0_Jr0_ JF4lIxAIcVC0I7IYx2IY6xkF7I0E14v26r4j6F4UMIIF0xvE42xK8VAvwI8IcIk0rVWUJV WUCwCI42IY6I8E87Iv67AKxVWUJVW8JwCI42IY6I8E87Iv6xkF7I0E14v26r4j6r4UJbIY CTnIWIevJa73UjIFyTuYvjfUnKsjUUUUU X-CM-SenderInfo: xjdrwv3l6h245lqf0zpsxwx03jof0z/ X-Spam-Status: No, score=-11.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_SHORT, 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: , Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" The stack that save-restore reserves is not well accumulated in stack allocation and deallocation. This patch allows less instructions to be used in stack allocation and deallocation if save-restore enabled. before patch: bar: call t0,__riscv_save_4 addi sp,sp,-64 ... li t0,-12288 addi t0,t0,-1968 # optimized out after patch add sp,sp,t0 # prologue ... li t0,12288 # epilogue addi t0,t0,2000 # optimized out after patch add sp,sp,t0 ... addi sp,sp,32 tail __riscv_restore_4 after patch: bar: call t0,__riscv_save_4 addi sp,sp,-2032 ... li t0,-12288 add sp,sp,t0 # prologue ... li t0,12288 # epilogue add sp,sp,t0 ... addi sp,sp,2032 tail __riscv_restore_4 gcc/ChangeLog: * config/riscv/riscv.cc (riscv_expand_prologue): consider save-restore in stack allocation. (riscv_expand_epilogue): consider save-restore in stack deallocation. gcc/testsuite/ChangeLog: * gcc.target/riscv/stack_save_restore.c: New test. --- gcc/config/riscv/riscv.cc | 50 ++++++++++--------- .../gcc.target/riscv/stack_save_restore.c | 40 +++++++++++++++ 2 files changed, 66 insertions(+), 24 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/stack_save_restore.c diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index f0bbcd6d6be..a50f2303032 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -5010,12 +5010,12 @@ void riscv_expand_prologue (void) { struct riscv_frame_info *frame = &cfun->machine->frame; - poly_int64 size = frame->total_size; + poly_int64 remaining_size = frame->total_size; unsigned mask = frame->mask; rtx insn; if (flag_stack_usage_info) - current_function_static_stack_size = constant_lower_bound (size); + current_function_static_stack_size = constant_lower_bound (remaining_size); if (cfun->machine->naked_p) return; @@ -5026,7 +5026,7 @@ riscv_expand_prologue (void) rtx dwarf = NULL_RTX; dwarf = riscv_adjust_libcall_cfi_prologue (); - size -= frame->save_libcall_adjustment; + remaining_size -= frame->save_libcall_adjustment; insn = emit_insn (riscv_gen_gpr_save_insn (frame)); frame->mask = 0; /* Temporarily fib that we need not save GPRs. */ @@ -5037,16 +5037,14 @@ riscv_expand_prologue (void) /* Save the registers. */ if ((frame->mask | frame->fmask) != 0) { - HOST_WIDE_INT step1 = riscv_first_stack_step (frame, frame->total_size); - if (size.is_constant ()) - step1 = MIN (size.to_constant(), step1); + HOST_WIDE_INT step1 = riscv_first_stack_step (frame, remaining_size); insn = gen_add3_insn (stack_pointer_rtx, stack_pointer_rtx, GEN_INT (-step1)); RTX_FRAME_RELATED_P (emit_insn (insn)) = 1; - size -= step1; - riscv_for_each_saved_reg (size, riscv_save_reg, false, false); + remaining_size -= step1; + riscv_for_each_saved_reg (remaining_size, riscv_save_reg, false, false); } frame->mask = mask; /* Undo the above fib. */ @@ -5055,29 +5053,29 @@ riscv_expand_prologue (void) if (frame_pointer_needed) { insn = gen_add3_insn (hard_frame_pointer_rtx, stack_pointer_rtx, - GEN_INT ((frame->hard_frame_pointer_offset - size).to_constant ())); + GEN_INT ((frame->hard_frame_pointer_offset - remaining_size).to_constant ())); RTX_FRAME_RELATED_P (emit_insn (insn)) = 1; riscv_emit_stack_tie (); } /* Allocate the rest of the frame. */ - if (known_gt (size, 0)) + if (known_gt (remaining_size, 0)) { /* Two step adjustment: 1.scalable frame. 2.constant frame. */ poly_int64 scalable_frame (0, 0); - if (!size.is_constant ()) + if (!remaining_size.is_constant ()) { /* First for scalable frame. */ - poly_int64 scalable_frame = size; - scalable_frame.coeffs[0] = size.coeffs[1]; + poly_int64 scalable_frame = remaining_size; + scalable_frame.coeffs[0] = remaining_size.coeffs[1]; riscv_v_adjust_scalable_frame (stack_pointer_rtx, scalable_frame, false); - size -= scalable_frame; + remaining_size -= scalable_frame; } /* Second step for constant frame. */ - HOST_WIDE_INT constant_frame = size.to_constant (); + HOST_WIDE_INT constant_frame = remaining_size.to_constant (); if (constant_frame == 0) return; @@ -5142,6 +5140,8 @@ riscv_expand_epilogue (int style) HOST_WIDE_INT step2 = 0; bool use_restore_libcall = ((style == NORMAL_RETURN) && riscv_use_save_libcall (frame)); + unsigned libcall_size = use_restore_libcall ? + frame->save_libcall_adjustment : 0; rtx ra = gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM); rtx insn; @@ -5212,13 +5212,18 @@ riscv_expand_epilogue (int style) REG_NOTES (insn) = dwarf; } + if (use_restore_libcall) + frame->mask = 0; /* Temporarily fib for GPRs. */ + /* If we need to restore registers, deallocate as much stack as possible in the second step without going out of range. */ if ((frame->mask | frame->fmask) != 0) - { - step2 = riscv_first_stack_step (frame, frame->total_size); - step1 -= step2; - } + step2 = riscv_first_stack_step (frame, frame->total_size - libcall_size); + + if (use_restore_libcall) + frame->mask = mask; /* Undo the above fib. */ + + step1 -= step2 + libcall_size; /* Set TARGET to BASE + STEP1. */ if (known_gt (step1, 0)) @@ -5272,15 +5277,12 @@ riscv_expand_epilogue (int style) frame->mask = 0; /* Temporarily fib that we need not save GPRs. */ /* Restore the registers. */ - riscv_for_each_saved_reg (frame->total_size - step2, riscv_restore_reg, + riscv_for_each_saved_reg (frame->total_size - step2 - libcall_size, + riscv_restore_reg, true, style == EXCEPTION_RETURN); if (use_restore_libcall) - { frame->mask = mask; /* Undo the above fib. */ - gcc_assert (step2 >= frame->save_libcall_adjustment); - step2 -= frame->save_libcall_adjustment; - } if (need_barrier_p) riscv_emit_stack_tie (); diff --git a/gcc/testsuite/gcc.target/riscv/stack_save_restore.c b/gcc/testsuite/gcc.target/riscv/stack_save_restore.c new file mode 100644 index 00000000000..522e706cfbf --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/stack_save_restore.c @@ -0,0 +1,40 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv32imafc -mabi=ilp32f -msave-restore -O2 -fno-schedule-insns -fno-schedule-insns2 -fno-unroll-loops -fno-peel-loops -fno-lto" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +char my_getchar(); +float getf(); + +/* +**bar: +** call t0,__riscv_save_4 +** addi sp,sp,-2032 +** ... +** li t0,-12288 +** add sp,sp,t0 +** ... +** li t0,12288 +** add sp,sp,t0 +** ... +** addi sp,sp,2032 +** tail __riscv_restore_4 +*/ +int bar() +{ + float volatile farray[3568]; + + float sum = 0; + float f1 = getf(); + float f2 = getf(); + float f3 = getf(); + float f4 = getf(); + + for (int i = 0; i < 3568; i++) + { + farray[i] = my_getchar() * 1.2; + sum += farray[i]; + } + + return sum + f1 + f2 + f3 + f4; +} + From patchwork Thu Dec 1 10:03:32 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fei Gao X-Patchwork-Id: 61309 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A508438518A9 for ; Thu, 1 Dec 2022 10:04:19 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from zg8tmtyylji0my4xnjeumjiw.icoremail.net (zg8tmtyylji0my4xnjeumjiw.icoremail.net [162.243.161.220]) by sourceware.org (Postfix) with SMTP id B3195385781F for ; Thu, 1 Dec 2022 10:03:58 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org B3195385781F Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=eswincomputing.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=eswincomputing.com Received: from localhost.localdomain (unknown [10.12.130.31]) by app2 (Coremail) with SMTP id EggMCgDXtS8BfIhjHYwUAA--.2533S7; Thu, 01 Dec 2022 18:03:46 +0800 (CST) From: Fei Gao To: gcc-patches@gcc.gnu.org Cc: jeffreyalaw@gmail.com, kito.cheng@gmail.com, palmer@dabbelt.com, Fei Gao Subject: [PATCH 3/3] RISC-V: make the stack manipulation codes more readable. Date: Thu, 1 Dec 2022 10:03:32 +0000 Message-Id: <20221201100332.22226-4-gaofei@eswincomputing.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20221201100332.22226-1-gaofei@eswincomputing.com> References: <20221201100332.22226-1-gaofei@eswincomputing.com> X-CM-TRANSID: EggMCgDXtS8BfIhjHYwUAA--.2533S7 X-Coremail-Antispam: 1UD129KBjvJXoWxury7Kw18XrWrAw15Gry5XFb_yoW5WFW5pr s8XrnxAF48CF1furZrtrZ3JF13J3s5Ka15WrW8urnYkw1DZ3yxKFZFgFy8ZrZ8Gan7Zr1q yFsruF1Y9a47GaDanT9S1TB71UUUUU7qnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDU0xBIdaVrnRJUUUPa14x267AKxVWrJVCq3wAFc2x0x2IEx4CE42xK8VAvwI8IcIk0 rVWrJVCq3wAFIxvE14AKwVWUJVWUGwA2048vs2IY020E87I2jVAFwI0_JrWl82xGYIkIc2 x26xkF7I0E14v26r4j6ryUM28lY4IEw2IIxxk0rwA2F7IY1VAKz4vEj48ve4kI8wA2z4x0 Y4vE2Ix0cI8IcVAFwI0_tr0E3s1l84ACjcxK6xIIjxv20xvEc7CjxVAFwI0_Gr1j6F4UJw A2z4x0Y4vEx4A2jsIE14v26rxl6s0DM28EF7xvwVC2z280aVCY1x0267AKxVW0oVCq3wAS 0I0E0xvYzxvE52x082IY62kv0487Mc02F40EFcxC0VAKzVAqx4xG6I80ewAv7VC0I7IYx2 IY67AKxVWUJVWUGwAv7VC2z280aVAFwI0_Jr0_Gr1lOx8S6xCaFVCjc4AY6r1j6r4UM4x0 Y48IcxkI7VAKI48JM4x0x7Aq67IIx4CEVc8vx2IErcIFxwCY1x0262kKe7AKxVWUAVWUtw CY02Avz4vE-syl42xK82IYc2Ij64vIr41l4I8I3I0E4IkC6x0Yz7v_Jr0_Gr1lx2IqxVAq x4xG67AKxVWUJVWUGwC20s026x8GjcxK67AKxVWUGVWUWwC2zVAF1VAY17CE14v26r126r 1DMIIYrxkI7VAKI48JMIIF0xvE2Ix0cI8IcVAFwI0_Jr0_JF4lIxAIcVC0I7IYx2IY6xkF 7I0E14v26r4j6F4UMIIF0xvE42xK8VAvwI8IcIk0rVWUJVWUCwCI42IY6I8E87Iv67AKxV WUJVW8JwCI42IY6I8E87Iv6xkF7I0E14v26r4j6r4UJbIYCTnIWIevJa73UjIFyTuYvjfU 1yIUUUUUU X-CM-SenderInfo: xjdrwv3l6h245lqf0zpsxwx03jof0z/ X-Spam-Status: No, score=-11.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, 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: , Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" gcc/ChangeLog: * config/riscv/riscv.cc (riscv_first_stack_step): make codes more readable. (riscv_expand_epilogue): likewise. --- gcc/config/riscv/riscv.cc | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index a50f2303032..95da08ffb3b 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -4926,8 +4926,11 @@ riscv_first_stack_step (struct riscv_frame_info *frame, poly_int64 remaining_siz if (SMALL_OPERAND (remaining_const_size)) return remaining_const_size; + poly_int64 callee_saved_first_step = + remaining_size - frame->frame_pointer_offset; + gcc_assert(callee_saved_first_step.is_constant ()); HOST_WIDE_INT min_first_step = - riscv_stack_align ((remaining_size - frame->frame_pointer_offset).to_constant()); + riscv_stack_align (callee_saved_first_step.to_constant ()); HOST_WIDE_INT max_first_step = IMM_REACH / 2 - PREFERRED_STACK_BOUNDARY / 8; HOST_WIDE_INT min_second_step = remaining_const_size - max_first_step; gcc_assert (min_first_step <= max_first_step); @@ -4935,7 +4938,7 @@ riscv_first_stack_step (struct riscv_frame_info *frame, poly_int64 remaining_siz /* As an optimization, use the least-significant bits of the total frame size, so that the second adjustment step is just LUI + ADD. */ if (!SMALL_OPERAND (min_second_step) - && remaining_const_size % IMM_REACH < IMM_REACH / 2 + && remaining_const_size % IMM_REACH <= max_first_step && remaining_const_size % IMM_REACH >= min_first_step) return remaining_const_size % IMM_REACH; @@ -5129,14 +5132,14 @@ riscv_adjust_libcall_cfi_epilogue () void riscv_expand_epilogue (int style) { - /* Split the frame into two. STEP1 is the amount of stack we should - deallocate before restoring the registers. STEP2 is the amount we - should deallocate afterwards. + /* Split the frame into 3 steps. STEP1 is the amount of stack we should + deallocate before restoring the registers. STEP2 is the amount we + should deallocate afterwards including the callee saved regs. STEP3 + is the amount deallocated by save-restore libcall. Start off by assuming that no registers need to be restored. */ struct riscv_frame_info *frame = &cfun->machine->frame; unsigned mask = frame->mask; - poly_int64 step1 = frame->total_size; HOST_WIDE_INT step2 = 0; bool use_restore_libcall = ((style == NORMAL_RETURN) && riscv_use_save_libcall (frame)); @@ -5223,7 +5226,7 @@ riscv_expand_epilogue (int style) if (use_restore_libcall) frame->mask = mask; /* Undo the above fib. */ - step1 -= step2 + libcall_size; + poly_int64 step1 = frame->total_size - step2 - libcall_size; /* Set TARGET to BASE + STEP1. */ if (known_gt (step1, 0))