From 92938b714565db1aea797d7c7a04987cfc6384c2 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 12 Jan 2008 18:54:29 +0000 Subject: [PATCH] we don't have to make an explicit copy of a byval argument when inlining a function if we know that the function does not write to *any* memory. This implements test/Transforms/Inline/byval2.ll git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45912 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Utils/InlineFunction.cpp | 10 +++++---- test/Transforms/Inline/byval2.ll | 28 +++++++++++++++++++++++++ 2 files changed, 34 insertions(+), 4 deletions(-) create mode 100644 test/Transforms/Inline/byval2.ll diff --git a/lib/Transforms/Utils/InlineFunction.cpp b/lib/Transforms/Utils/InlineFunction.cpp index a4978f00783..f730d534a55 100644 --- a/lib/Transforms/Utils/InlineFunction.cpp +++ b/lib/Transforms/Utils/InlineFunction.cpp @@ -241,10 +241,12 @@ bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) { Value *ActualArg = *AI; // When byval arguments actually inlined, we need to make the copy implied - // by them actually explicit. - // TODO: If we know that the callee never modifies the struct, we can - // remove this copy. - if (CalledFunc->paramHasAttr(ArgNo+1, ParamAttr::ByVal)) { + // by them explicit. However, we don't do this if the callee is readonly + // or readnone, because the copy would be unneeded: the callee doesn't + // modify the struct. + if (CalledFunc->paramHasAttr(ArgNo+1, ParamAttr::ByVal) && + !CalledFunc->paramHasAttr(0, ParamAttr::ReadOnly) && + !CalledFunc->paramHasAttr(0, ParamAttr::ReadNone)) { const Type *AggTy = cast(I->getType())->getElementType(); const Type *VoidPtrTy = PointerType::getUnqual(Type::Int8Ty); diff --git a/test/Transforms/Inline/byval2.ll b/test/Transforms/Inline/byval2.ll new file mode 100644 index 00000000000..e949d01856d --- /dev/null +++ b/test/Transforms/Inline/byval2.ll @@ -0,0 +1,28 @@ +; RUN: llvm-as < %s | opt -inline | llvm-dis | not grep {llvm.memcpy} + +; Inlining a byval struct should NOT cause an explicit copy +; into an alloca if the function is readonly + + %struct.ss = type { i32, i64 } +@.str = internal constant [10 x i8] c"%d, %lld\0A\00" ; <[10 x i8]*> [#uses=1] + +define internal i32 @f(%struct.ss* byval %b) nounwind readonly { +entry: + %tmp = getelementptr %struct.ss* %b, i32 0, i32 0 ; [#uses=2] + %tmp1 = load i32* %tmp, align 4 ; [#uses=1] + %tmp2 = add i32 %tmp1, 1 ; [#uses=1] + ret i32 %tmp2 +} + +declare i32 @printf(i8*, ...) nounwind + +define i32 @main() nounwind { +entry: + %S = alloca %struct.ss ; <%struct.ss*> [#uses=4] + %tmp1 = getelementptr %struct.ss* %S, i32 0, i32 0 ; [#uses=1] + store i32 1, i32* %tmp1, align 8 + %tmp4 = getelementptr %struct.ss* %S, i32 0, i32 1 ; [#uses=1] + store i64 2, i64* %tmp4, align 4 + %X = call i32 @f( %struct.ss* byval %S ) nounwind + ret i32 %X +} -- 2.34.1