From d178ada55ea4cc5d71443ec27495092fbb72b230 Mon Sep 17 00:00:00 2001 From: Saleem Abdulrasool Date: Tue, 28 Oct 2014 18:27:37 +0000 Subject: Transforms: reapply SVN r219899 This restores the commit from SVN r219899 with an additional change to ensure that the CodeGen is correct for the case that was identified as being incorrect (originally PR7272). In the case that during inlining we need to synthesize a value on the stack (i.e. for passing a value byval), then any function involving that alloca must be stripped of its tailness as the restriction that it does not access the parent's stack no longer holds. Unfortunately, a single alloca can cause a rippling effect through out the inlining as the value may be aliased or may be mutated through an escaped external call. As such, we simply track if an alloca has been introduced in the frame during inlining, and strip any tail calls. llvm-svn: 220811 --- llvm/lib/Transforms/Utils/InlineFunction.cpp | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) (limited to 'llvm/lib/Transforms/Utils/InlineFunction.cpp') diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp index 1b2e208..c158940 100644 --- a/llvm/lib/Transforms/Utils/InlineFunction.cpp +++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp @@ -743,7 +743,8 @@ static void HandleByValArgumentInit(Value *Dst, Value *Src, Module *M, static Value *HandleByValArgument(Value *Arg, Instruction *TheCall, const Function *CalledFunc, InlineFunctionInfo &IFI, - unsigned ByValAlignment) { + unsigned ByValAlignment, + bool &AddedNewAllocas) { PointerType *ArgTy = cast(Arg->getType()); Type *AggTy = ArgTy->getElementType(); @@ -785,6 +786,7 @@ static Value *HandleByValArgument(Value *Arg, Instruction *TheCall, // Uses of the argument in the function should use our new alloca // instead. + AddedNewAllocas = true; return NewAlloca; } @@ -958,6 +960,7 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI, SmallVector Returns; ClonedCodeInfo InlinedFunctionInfo; Function::iterator FirstNewBlock; + bool AddedNewAllocas = false; { // Scope to destroy VMap after cloning. ValueToValueMapTy VMap; @@ -981,7 +984,8 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI, // modify the struct. if (CS.isByValArgument(ArgNo)) { ActualArg = HandleByValArgument(ActualArg, TheCall, CalledFunc, IFI, - CalledFunc->getParamAlignment(ArgNo+1)); + CalledFunc->getParamAlignment(ArgNo+1), + AddedNewAllocas); if (ActualArg != *AI) ByValInit.push_back(std::make_pair(ActualArg, (Value*) *AI)); } @@ -1096,9 +1100,18 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI, // f -> musttail g -> tail f ==> f -> tail f // f -> g -> musttail f ==> f -> f // f -> g -> tail f ==> f -> f + // + // If an alloca was introduced in the frame due to a byval parameter + // being passed to a subsequent call, tail calls must have the tail + // stripped as they may not access variables in the caller's stack. + // A single alloca ripples through out as the alloca may be aliased by + // bitcasts or may escape and be mutated outside of the function. CallInst::TailCallKind ChildTCK = CI->getTailCallKind(); ChildTCK = std::min(CallSiteTailKind, ChildTCK); - CI->setTailCallKind(ChildTCK); + if (AddedNewAllocas) + CI->setTailCallKind(CallInst::TCK_None); + else + CI->setTailCallKind(ChildTCK); InlinedMustTailCalls |= CI->isMustTailCall(); // Calls inlined through a 'nounwind' call site should be marked -- cgit v1.1