Differential D79141 Diff 315201 llvm/test/CodeGen/RISCV/split-sp-adjust.ll

Changeset View

Standalone View

llvm/test/CodeGen/RISCV/split-sp-adjust.ll

	; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py			; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
	; RUN: llc -mtriple=riscv32 -verify-machineinstrs < %s \			; RUN: llc -mtriple=riscv32 -verify-machineinstrs < %s \
	; RUN: \| FileCheck %s -check-prefix=RV32I			; RUN: \| FileCheck %s -check-prefix=RV32I
				; RUN: llc -mtriple=riscv32 -mattr=+c -verify-machineinstrs -riscv-no-aliases < %s \
				; RUN: \| FileCheck %s -check-prefix=RV32IC
				; RUN: llc -mtriple=riscv64 -verify-machineinstrs < %s \
				; RUN: \| FileCheck %s -check-prefix=RV64I
				; RUN: llc -mtriple=riscv64 -mattr=+c -verify-machineinstrs -riscv-no-aliases < %s \
				; RUN: \| FileCheck %s -check-prefix=RV64IC

	; The stack size is 2048 and the SP adjustment will be split.			; These tests check split stack pointer adjustment.
	define i32 @SplitSP() nounwind {			;
	; RV32I-LABEL: SplitSP:			; Instead of adjusting the stack pointer once, if the stack is larger than a
	; RV32I: # %bb.0: # %entry			; threshold, we adjust it twice: once to before saving the CSRs, and once after.
	; RV32I-NEXT: addi sp, sp, -2032			; The intention here is to ensure that the offsets when saving the CSRs fit into
	; RV32I-NEXT: sw ra, 2028(sp) # 4-byte Folded Spill			; the offset field in the CSR load/store instructions, so the threshold depends
	; RV32I-NEXT: addi sp, sp, -16			; on which instructions are available.
	; RV32I-NEXT: addi a0, sp, 16			;
	; RV32I-NEXT: call foo@plt			; We show which instructions are compressed, because the important thing is that
	; RV32I-NEXT: mv a0, zero			; the thresholds allow the stack offsets to fit into c.{l,s}{d,w}sp if
	; RV32I-NEXT: addi sp, sp, 16			; compressed instructions are available, and `{l,s}{d,w}` if not. It is also
	; RV32I-NEXT: lw ra, 2028(sp) # 4-byte Folded Reload			; best if the stack adjustments use compressed instructions when available, or
	; RV32I-NEXT: addi sp, sp, 2032			; at most a single `addi`.
	; RV32I-NEXT: ret			;
				; These tests include unwind information to ensure it remains valid when
				; splitting the SP adjustment. When splitting the SP adjustment, there will be
				; two .cfi_def_cfa_offset directives, one for each split. The CSR info will come
				; between them. This is correct, as the `.cfi_offset <reg>, <offset>` offsets
				; are defined relative to the CFA, not relative to the stack pointer, so we
				; don't need to restate the CFA offsets after the second SP adjustment.

				declare i32 @use_pointer(i8*)

				; stack size is 128 and stack pointer adjustment will not be split.
				define i32 @stack_never_split() {
				entry:
				%xx = alloca [120 x i8], align 1
				%0 = getelementptr inbounds [120 x i8], [120 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				; stack size is 256 (RV32) or 272 (RV64) and stack pointer adjustment will not
				; be split.
				define i32 @stack_never_split_2() {
				entry:
				%xx = alloca [252 x i8], align 1
				%0 = getelementptr inbounds [252 x i8], [252 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				; stack size is 272 (RV32) or 288 (RV64) and stack pointer adjustment will
				; be split on RV32*C if we have sufficient instruction compression gains.

				define i32 @stack_split_rv32_c_optspeed_save4() {
				entry:
				%xx = alloca [256 x i8], align 1
				call void asm sideeffect "", "~{s0},~{s1},~{s2}"()
				%0 = getelementptr inbounds [256 x i8], [256 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				define i32 @stack_split_rv32_c_optspeed_save5() {
				entry:
				%xx = alloca [240 x i8], align 1
				call void asm sideeffect "", "~{s0},~{s1},~{s2},~{s3}"()
				%0 = getelementptr inbounds [240 x i8], [240 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				define i32 @stack_split_rv32_c_optsize_save1() optsize {
				entry:
				%xx = alloca [268 x i8], align 1
				%0 = getelementptr inbounds [268 x i8], [268 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				define i32 @stack_split_rv32_c_optsize_save2() optsize {
				entry:
				%xx = alloca [264 x i8], align 1
				call void asm sideeffect "", "~{s0}"()
				%0 = getelementptr inbounds [264 x i8], [264 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				; stack size is 496 (RV32) or 512 (RV64) and stack pointer adjustment will be
				; split on RV32C and RV64C if we have sufficient instruction compression gains.

				define i32 @stack_split_rv64_c_optspeed_save4() {
				entry:
				%xx = alloca [476 x i8], align 1
				call void asm sideeffect "", "~{s0},~{s1},~{s2}"()
				%0 = getelementptr inbounds [476 x i8], [476 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				define i32 @stack_split_rv64_c_optspeed_save5() {
				entry:
				%xx = alloca [472 x i8], align 1
				call void asm sideeffect "", "~{s0},~{s1},~{s2},~{s3}"()
				%0 = getelementptr inbounds [472 x i8], [472 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				define i32 @stack_split_rv64_c_optsize_save1() optsize {
				entry:
				%xx = alloca [492 x i8], align 1
				%0 = getelementptr inbounds [492 x i8], [492 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				define i32 @stack_split_rv64_c_optsize_save2() optsize {
				entry:
				%xx = alloca [488 x i8], align 1
				call void asm sideeffect "", "~{s0}"()
				%0 = getelementptr inbounds [488 x i8], [488 x i8]* %xx, i32 0, i32 0
				%call = call i32 @use_pointer(i8* nonnull %0)
				ret i32 %call
				}

				; The stack size is 2048 and the SP adjustment will always be split.
				define i32 @stack_split_always() {
	entry:			entry:
	%xx = alloca [2028 x i8], align 1			%xx = alloca [2028 x i8], align 1
	%0 = getelementptr inbounds [2028 x i8], [2028 x i8]* %xx, i32 0, i32 0			%0 = getelementptr inbounds [2028 x i8], [2028 x i8]* %xx, i32 0, i32 0
	%call = call i32 @foo(i8* nonnull %0)			%call = call i32 @use_pointer(i8* nonnull %0)
	ret i32 0			ret i32 0
	}			}

	; The stack size is 2032 and the SP adjustment will not be split.			; The stack size is 2048 and the SP adjustment will always be split. This test
	define i32 @NoSplitSP() nounwind {			; ensures that the CFI info remains correct if the stack pointer adjustment is
	; RV32I-LABEL: NoSplitSP:			; split and a frame pointer is needed.
	; RV32I: # %bb.0: # %entry			define i32 @stack_split_always_with_fp() "frame-pointer"="all" {
	; RV32I-NEXT: addi sp, sp, -2032			entry:
	; RV32I-NEXT: sw ra, 2028(sp) # 4-byte Folded Spill			%xx = alloca [2028 x i8], align 1
	; RV32I-NEXT: addi a0, sp, 4			%0 = getelementptr inbounds [2028 x i8], [2028 x i8]* %xx, i32 0, i32 0
	; RV32I-NEXT: call foo@plt			%call = call i32 @use_pointer(i8* nonnull %0)
	; RV32I-NEXT: mv a0, zero
	; RV32I-NEXT: lw ra, 2028(sp) # 4-byte Folded Reload
	; RV32I-NEXT: addi sp, sp, 2032
	; RV32I-NEXT: ret
	entry:
	%xx = alloca [2024 x i8], align 1
	%0 = getelementptr inbounds [2024 x i8], [2024 x i8]* %xx, i32 0, i32 0
	%call = call i32 @foo(i8* nonnull %0)
	ret i32 0			ret i32 0
	}			}
				shiva0217Unsubmitted Done Reply Inline Actions The stack didn't split for rv32c because the stack size is 256 which is equal to the limit. Should we choose a slightly greater stack size for stack_split_rv32_c test case? shiva0217: The stack didn't split for rv32c because the stack size is 256 which is equal to the limit.
				lenaryUnsubmitted Done Reply Inline Actions Great catch - I forgot to update the tests when I tweaked the limits. lenary: Great catch - I forgot to update the tests when I tweaked the limits.

	declare i32 @foo(i8*)