RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-03-06 17:47:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[WebAssembly] Call memcpy for large byval copies.

Browse Source 
This fixes very slow compilation on
test/CodeGen/Generic/2010-11-04-BigByval.ll . Note that MaxStoresPerMemcpy
and friends are not yet carefully tuned so the cutoff point is currently
somewhat arbitrary. However, it's important that there be a cutoff point
so that we don't emit unbounded quantities of loads and stores.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@261050 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2016-02-17 01:43:37 +00:00
parent 39e0580624
commit 1a8392e483
2 changed files with 15 additions and 18 deletions
lib/Target/WebAssembly
WebAssemblyISelLowering.cpp
test/CodeGen/WebAssembly
byval.ll

2
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

@ -321,7 +321,7 @@ SDValue WebAssemblyTargetLowering::LowerCall(
SDValue FINode = DAG.getFrameIndex(FI, getPointerTy(Layout));
Chain = DAG.getMemcpy(
Chain, DL, FINode, OutVal, SizeNode, Out.Flags.getByValAlign(),
/*isVolatile*/ false, /*AlwaysInline=*/true,
/*isVolatile*/ false, /*AlwaysInline=*/false,
/*isTailCall*/ false, MachinePointerInfo(), MachinePointerInfo());
OutVal = FINode;
}

31
test/CodeGen/WebAssembly/byval.ll

@ -81,23 +81,6 @@ define void @byval_arg_double(%AlignedStruct* %ptr) {
ret void
}
; CHECK-LABEL: byval_arg_big
define void @byval_arg_big(%BigArray* %ptr) {
; CHECK: .param i32
; Subtract 48 from SP (SP is 16-byte aligned)
; CHECK: i32.const [[L2:.+]]=, 48
; CHECK-NEXT: i32.sub [[SP:.+]]=, {{.+}}, [[L2]]
; Copy the AlignedStruct argument to the stack (SP+12, original SP-36)
; CHECK: i64.load $push[[L4:.+]]=, 0($0):p2align=0
; CHECK: i64.store {{.*}}=, 12([[SP]]):p2align=2, $pop[[L4]]
; Pass a pointer to the stack slot to the function
; CHECK-NEXT: i32.const [[L5:.+]]=, 12
; CHECK-NEXT: i32.add [[ARG:.+]]=, [[SP]], [[L5]]
; CHECK-NEXT: call ext_byval_func_bigarray@FUNCTION, [[ARG]]
call void @ext_byval_func_bigarray(%BigArray* byval %ptr)
ret void
}
; CHECK-LABEL: byval_param
define void @byval_param(%SmallStruct* byval align 32 %ptr) {
; CHECK: .param i32
@ -122,3 +105,17 @@ define void @byval_empty_callee(%EmptyStruct* byval %ptr) {
call void @ext_func_empty(%EmptyStruct* %ptr)
ret void
}
; Call memcpy for "big" byvals.
; TODO: When the prolog/epilog sequences are optimized, refine these checks to
; be more specific.
; CHECK-LABEL: big_byval:
; CHECK: i32.call ${{[^,]+}}=, memcpy@FUNCTION,
; CHECK-NEXT: call big_byval_callee@FUNCTION,
%big = type [131072 x i8]
declare void @big_byval_callee(%big* byval align 1)
define void @big_byval(%big* byval align 1 %x) {
call void @big_byval_callee(%big* byval align 1 %x)
ret void
}