Page MenuHomePhabricator
Differential D132108 Diff 454155 llvm/test/CodeGen/LoongArch/calling-conv-lp64d.ll

Changeset View

Standalone View

View Options

llvm/test/CodeGen/LoongArch/calling-conv-lp64d.ll

Show All 15 Lines
define i64 @caller_i128_in_regs() nounwind { define i64 @caller_i128_in_regs() nounwind {
; CHECK-LABEL: caller_i128_in_regs: ; CHECK-LABEL: caller_i128_in_regs:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -16 ; CHECK-NEXT: addi.d $sp, $sp, -16
; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
; CHECK-NEXT: ori $a0, $zero, 1 ; CHECK-NEXT: ori $a0, $zero, 1
; CHECK-NEXT: ori $a1, $zero, 2 ; CHECK-NEXT: ori $a1, $zero, 2
; CHECK-NEXT: move $a2, $zero ; CHECK-NEXT: move $a2, $zero
; CHECK-NEXT: bl callee_i128_in_regs ; CHECK-NEXT: bl %plt(callee_i128_in_regs)
; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 16 ; CHECK-NEXT: addi.d $sp, $sp, 16
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i64 @callee_i128_in_regs(i64 1, i128 2) %1 = call i64 @callee_i128_in_regs(i64 1, i128 2)
ret i64 %1 ret i64 %1
} }
;; Check that the stack is used once the GPRs are exhausted. ;; Check that the stack is used once the GPRs are exhausted.
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ori $a0, $zero, 1 ; CHECK-NEXT: ori $a0, $zero, 1
; CHECK-NEXT: ori $a1, $zero, 2 ; CHECK-NEXT: ori $a1, $zero, 2
; CHECK-NEXT: ori $a2, $zero, 3 ; CHECK-NEXT: ori $a2, $zero, 3
; CHECK-NEXT: ori $a3, $zero, 4 ; CHECK-NEXT: ori $a3, $zero, 4
; CHECK-NEXT: ori $a4, $zero, 5 ; CHECK-NEXT: ori $a4, $zero, 5
; CHECK-NEXT: ori $a6, $zero, 6 ; CHECK-NEXT: ori $a6, $zero, 6
; CHECK-NEXT: ori $a7, $zero, 7 ; CHECK-NEXT: ori $a7, $zero, 7
; CHECK-NEXT: move $a5, $zero ; CHECK-NEXT: move $a5, $zero
; CHECK-NEXT: bl callee_many_scalars ; CHECK-NEXT: bl %plt(callee_many_scalars)
; CHECK-NEXT: ld.d $ra, $sp, 24 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 24 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 32 ; CHECK-NEXT: addi.d $sp, $sp, 32
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i64 @callee_many_scalars(i8 1, i16 2, i32 3, i64 4, i128 5, i64 6, i128 7, i64 8) %1 = call i64 @callee_many_scalars(i8 1, i16 2, i32 3, i64 4, i128 5, i64 6, i128 7, i64 8)
ret i64 %1 ret i64 %1
} }
;; Check that i256 is passed indirectly. ;; Check that i256 is passed indirectly.
Show All 35 Lines
; CHECK-NEXT: st.d $zero, $sp, 8 ; CHECK-NEXT: st.d $zero, $sp, 8
; CHECK-NEXT: st.d $zero, $sp, 56 ; CHECK-NEXT: st.d $zero, $sp, 56
; CHECK-NEXT: st.d $zero, $sp, 48 ; CHECK-NEXT: st.d $zero, $sp, 48
; CHECK-NEXT: st.d $zero, $sp, 40 ; CHECK-NEXT: st.d $zero, $sp, 40
; CHECK-NEXT: ori $a0, $zero, 1 ; CHECK-NEXT: ori $a0, $zero, 1
; CHECK-NEXT: st.d $a0, $sp, 32 ; CHECK-NEXT: st.d $a0, $sp, 32
; CHECK-NEXT: addi.d $a0, $sp, 32 ; CHECK-NEXT: addi.d $a0, $sp, 32
; CHECK-NEXT: addi.d $a1, $sp, 0 ; CHECK-NEXT: addi.d $a1, $sp, 0
; CHECK-NEXT: bl callee_large_scalars ; CHECK-NEXT: bl %plt(callee_large_scalars)
; CHECK-NEXT: ld.d $ra, $sp, 72 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 72 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 80 ; CHECK-NEXT: addi.d $sp, $sp, 80
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i64 @callee_large_scalars(i256 1, i256 2) %1 = call i64 @callee_large_scalars(i256 1, i256 2)
ret i64 %1 ret i64 %1
} }
;; Check that arguments larger than 2*GRLen are handled correctly when their ;; Check that arguments larger than 2*GRLen are handled correctly when their
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ori $a0, $zero, 1 ; CHECK-NEXT: ori $a0, $zero, 1
; CHECK-NEXT: ori $a1, $zero, 2 ; CHECK-NEXT: ori $a1, $zero, 2
; CHECK-NEXT: ori $a2, $zero, 3 ; CHECK-NEXT: ori $a2, $zero, 3
; CHECK-NEXT: ori $a3, $zero, 4 ; CHECK-NEXT: ori $a3, $zero, 4
; CHECK-NEXT: ori $a4, $zero, 5 ; CHECK-NEXT: ori $a4, $zero, 5
; CHECK-NEXT: ori $a5, $zero, 6 ; CHECK-NEXT: ori $a5, $zero, 6
; CHECK-NEXT: ori $a6, $zero, 7 ; CHECK-NEXT: ori $a6, $zero, 7
; CHECK-NEXT: addi.d $a7, $sp, 48 ; CHECK-NEXT: addi.d $a7, $sp, 48
; CHECK-NEXT: bl callee_large_scalars_exhausted_regs ; CHECK-NEXT: bl %plt(callee_large_scalars_exhausted_regs)
; CHECK-NEXT: ld.d $ra, $sp, 88 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 88 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 96 ; CHECK-NEXT: addi.d $sp, $sp, 96
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i64 @callee_large_scalars_exhausted_regs( %1 = call i64 @callee_large_scalars_exhausted_regs(
i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i256 8, i64 9, i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i256 8, i64 9,
i256 10) i256 10)
ret i64 %1 ret i64 %1
} }
Show All 30 Lines
; CHECK-NEXT: st.d $a0, $sp, 16 ; CHECK-NEXT: st.d $a0, $sp, 16
; CHECK-NEXT: ori $a0, $zero, 3 ; CHECK-NEXT: ori $a0, $zero, 3
; CHECK-NEXT: st.d $a0, $sp, 56 ; CHECK-NEXT: st.d $a0, $sp, 56
; CHECK-NEXT: st.d $a0, $sp, 24 ; CHECK-NEXT: st.d $a0, $sp, 24
; CHECK-NEXT: ori $a0, $zero, 4 ; CHECK-NEXT: ori $a0, $zero, 4
; CHECK-NEXT: st.d $a0, $sp, 64 ; CHECK-NEXT: st.d $a0, $sp, 64
; CHECK-NEXT: st.d $a0, $sp, 32 ; CHECK-NEXT: st.d $a0, $sp, 32
; CHECK-NEXT: addi.d $a0, $sp, 8 ; CHECK-NEXT: addi.d $a0, $sp, 8
; CHECK-NEXT: bl callee_large_struct ; CHECK-NEXT: bl %plt(callee_large_struct)
; CHECK-NEXT: ld.d $ra, $sp, 72 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 72 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 80 ; CHECK-NEXT: addi.d $sp, $sp, 80
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%ls = alloca %struct.large, align 8 %ls = alloca %struct.large, align 8
%a = getelementptr inbounds %struct.large, ptr %ls, i64 0, i32 0 %a = getelementptr inbounds %struct.large, ptr %ls, i64 0, i32 0
store i64 1, ptr %a store i64 1, ptr %a
%b = getelementptr inbounds %struct.large, ptr %ls, i64 0, i32 1 %b = getelementptr inbounds %struct.large, ptr %ls, i64 0, i32 1
store i64 2, ptr %b store i64 2, ptr %b
Show All 16 Lines; CHECK-NEXT: ret
ret i128 -1 ret i128 -1
} }
define i64 @caller_small_scalar_ret() nounwind { define i64 @caller_small_scalar_ret() nounwind {
; CHECK-LABEL: caller_small_scalar_ret: ; CHECK-LABEL: caller_small_scalar_ret:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -16 ; CHECK-NEXT: addi.d $sp, $sp, -16
; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
; CHECK-NEXT: bl callee_small_scalar_ret ; CHECK-NEXT: bl %plt(callee_small_scalar_ret)
; CHECK-NEXT: addi.w $a2, $zero, -2 ; CHECK-NEXT: addi.w $a2, $zero, -2
; CHECK-NEXT: xor $a0, $a0, $a2 ; CHECK-NEXT: xor $a0, $a0, $a2
; CHECK-NEXT: orn $a0, $a0, $a1 ; CHECK-NEXT: orn $a0, $a0, $a1
; CHECK-NEXT: sltui $a0, $a0, 1 ; CHECK-NEXT: sltui $a0, $a0, 1
; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 16 ; CHECK-NEXT: addi.d $sp, $sp, 16
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i128 @callee_small_scalar_ret() %1 = call i128 @callee_small_scalar_ret()
Show All 15 Lines; CHECK-NEXT: ret
ret %struct.small { i64 1, ptr null } ret %struct.small { i64 1, ptr null }
} }
define i64 @caller_small_struct_ret() nounwind { define i64 @caller_small_struct_ret() nounwind {
; CHECK-LABEL: caller_small_struct_ret: ; CHECK-LABEL: caller_small_struct_ret:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -16 ; CHECK-NEXT: addi.d $sp, $sp, -16
; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
; CHECK-NEXT: bl callee_small_struct_ret ; CHECK-NEXT: bl %plt(callee_small_struct_ret)
; CHECK-NEXT: add.d $a0, $a0, $a1 ; CHECK-NEXT: add.d $a0, $a0, $a1
; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 16 ; CHECK-NEXT: addi.d $sp, $sp, 16
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call %struct.small @callee_small_struct_ret() %1 = call %struct.small @callee_small_struct_ret()
%2 = extractvalue %struct.small %1, 0 %2 = extractvalue %struct.small %1, 0
%3 = extractvalue %struct.small %1, 1 %3 = extractvalue %struct.small %1, 1
%4 = ptrtoint ptr %3 to i64 %4 = ptrtoint ptr %3 to i64
Show All 18 Lines
} }
define void @caller_large_scalar_ret() nounwind { define void @caller_large_scalar_ret() nounwind {
; CHECK-LABEL: caller_large_scalar_ret: ; CHECK-LABEL: caller_large_scalar_ret:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -48 ; CHECK-NEXT: addi.d $sp, $sp, -48
; CHECK-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill
; CHECK-NEXT: addi.d $a0, $sp, 0 ; CHECK-NEXT: addi.d $a0, $sp, 0
; CHECK-NEXT: bl callee_large_scalar_ret ; CHECK-NEXT: bl %plt(callee_large_scalar_ret)
; CHECK-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 48 ; CHECK-NEXT: addi.d $sp, $sp, 48
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i256 @callee_large_scalar_ret() %1 = call i256 @callee_large_scalar_ret()
ret void ret void
} }
;; Check return struct which size is more than 2*GRLen. ;; Check return struct which size is more than 2*GRLen.
Show All 26 Lines
} }
define i64 @caller_large_struct_ret() nounwind { define i64 @caller_large_struct_ret() nounwind {
; CHECK-LABEL: caller_large_struct_ret: ; CHECK-LABEL: caller_large_struct_ret:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -48 ; CHECK-NEXT: addi.d $sp, $sp, -48
; CHECK-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill
; CHECK-NEXT: addi.d $a0, $sp, 8 ; CHECK-NEXT: addi.d $a0, $sp, 8
; CHECK-NEXT: bl callee_large_struct_ret ; CHECK-NEXT: bl %plt(callee_large_struct_ret)
; CHECK-NEXT: ld.d $a0, $sp, 32 ; CHECK-NEXT: ld.d $a0, $sp, 32
; CHECK-NEXT: ld.d $a1, $sp, 8 ; CHECK-NEXT: ld.d $a1, $sp, 8
; CHECK-NEXT: add.d $a0, $a1, $a0 ; CHECK-NEXT: add.d $a0, $a1, $a0
; CHECK-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 48 ; CHECK-NEXT: addi.d $sp, $sp, 48
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = alloca %struct.large %1 = alloca %struct.large
call void @callee_large_struct_ret(ptr sret(%struct.large) %1) call void @callee_large_struct_ret(ptr sret(%struct.large) %1)
Show All 27 Lines
define i64 @caller_float_in_fpr() nounwind { define i64 @caller_float_in_fpr() nounwind {
; CHECK-LABEL: caller_float_in_fpr: ; CHECK-LABEL: caller_float_in_fpr:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -16 ; CHECK-NEXT: addi.d $sp, $sp, -16
; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
; CHECK-NEXT: ori $a0, $zero, 1 ; CHECK-NEXT: ori $a0, $zero, 1
; CHECK-NEXT: movgr2fr.w $fa0, $zero ; CHECK-NEXT: movgr2fr.w $fa0, $zero
; CHECK-NEXT: movgr2fr.d $fa1, $zero ; CHECK-NEXT: movgr2fr.d $fa1, $zero
; CHECK-NEXT: bl callee_float_in_fpr ; CHECK-NEXT: bl %plt(callee_float_in_fpr)
; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 16 ; CHECK-NEXT: addi.d $sp, $sp, 16
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i64 @callee_float_in_fpr(i64 1, float 0.0, double 0.0) %1 = call i64 @callee_float_in_fpr(i64 1, float 0.0, double 0.0)
ret i64 %1 ret i64 %1
} }
;; Check that the GPR is used once the FPRs are exhausted. ;; Check that the GPR is used once the FPRs are exhausted.
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; CHECK-NEXT: fld.d $fa5, $a1, 0 ; CHECK-NEXT: fld.d $fa5, $a1, 0
; CHECK-NEXT: fld.d $fa6, $a0, 0 ; CHECK-NEXT: fld.d $fa6, $a0, 0
; CHECK-NEXT: pcalau12i $a0, .LCPI21_6 ; CHECK-NEXT: pcalau12i $a0, .LCPI21_6
; CHECK-NEXT: addi.d $a0, $a0, .LCPI21_6 ; CHECK-NEXT: addi.d $a0, $a0, .LCPI21_6
; CHECK-NEXT: fld.d $fa7, $a0, 0 ; CHECK-NEXT: fld.d $fa7, $a0, 0
; CHECK-NEXT: ori $a0, $zero, 0 ; CHECK-NEXT: ori $a0, $zero, 0
; CHECK-NEXT: lu32i.d $a0, 131072 ; CHECK-NEXT: lu32i.d $a0, 131072
; CHECK-NEXT: lu52i.d $a0, $a0, 1026 ; CHECK-NEXT: lu52i.d $a0, $a0, 1026
; CHECK-NEXT: bl callee_double_in_gpr_exhausted_fprs ; CHECK-NEXT: bl %plt(callee_double_in_gpr_exhausted_fprs)
; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 16 ; CHECK-NEXT: addi.d $sp, $sp, 16
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call i64 @callee_double_in_gpr_exhausted_fprs( %1 = call i64 @callee_double_in_gpr_exhausted_fprs(
double 1.0, double 2.0, double 3.0, double 4.0, double 5.0, double 6.0, double 1.0, double 2.0, double 3.0, double 4.0, double 5.0, double 6.0,
double 7.0, double 8.0, double 9.0) double 7.0, double 8.0, double 9.0)
ret i64 %1 ret i64 %1
} }
Show All 10 Lines; CHECK-NEXT: ret
ret double 1.0 ret double 1.0
} }
define i64 @caller_double_ret() nounwind { define i64 @caller_double_ret() nounwind {
; CHECK-LABEL: caller_double_ret: ; CHECK-LABEL: caller_double_ret:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: addi.d $sp, $sp, -16 ; CHECK-NEXT: addi.d $sp, $sp, -16
; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill ; CHECK-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
; CHECK-NEXT: bl callee_double_ret ; CHECK-NEXT: bl %plt(callee_double_ret)
; CHECK-NEXT: movfr2gr.d $a0, $fa0 ; CHECK-NEXT: movfr2gr.d $a0, $fa0
; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload ; CHECK-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
; CHECK-NEXT: addi.d $sp, $sp, 16 ; CHECK-NEXT: addi.d $sp, $sp, 16
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%1 = call double @callee_double_ret() %1 = call double @callee_double_ret()
%2 = bitcast double %1 to i64 %2 = bitcast double %1 to i64
ret i64 %2 ret i64 %2
} }