[InlineFunction] Preserve attributes when forwarding VarArgs.

[rnk]

Looks good with one test, thanks!

test/Transforms/Inline/inline-varargs.ll

45 ↗

(On Diff #128082)

Can you add a test using an signext i8 return type and attribute?

[fhahn]

Rebased and add signext tests

llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp

// instructions at the end of the current alloca list.
     // Move any dbg.declares describing the allocas into the entry basic block.
     DIBuilder DIB(*Caller->getParent());
     for (auto &AI : IFI.StaticAllocas)
       replaceDbgDeclareForAlloca(AI, AI, DIB, DIExpression::NoDeref, 0,
                                  DIExpression::NoDeref);
   }
 
   SmallVector<Value*,4> VarArgsToForward;
+  SmallVector<AttributeSet, 4> VarArgsAttrs;
   for (unsigned i = CalledFunc->getFunctionType()->getNumParams();
-       i < CS.getNumArgOperands(); i++)
+       i < CS.getNumArgOperands(); i++) {
     VarArgsToForward.push_back(CS.getArgOperand(i));
+    VarArgsAttrs.push_back(CS.getAttributes().getParamAttributes(i));
+  }
 
   bool InlinedMustTailCalls = false, InlinedDeoptimizeCalls = false;
   if (InlinedFunctionInfo.ContainsCalls) {
     CallInst::TailCallKind CallSiteTailKind = CallInst::TCK_None;
     if (CallInst *CI = dyn_cast<CallInst>(TheCall))
       CallSiteTailKind = CI->getTailCallKind();
 
     for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
          ++BB) {
       for (auto II = BB->begin(); II != BB->end();) {
         Instruction &I = *II++;
         CallInst *CI = dyn_cast<CallInst>(&I);
         if (!CI)
           continue;
 
         // Forward varargs from inlined call site to calls to the
         // ForwardVarArgsTo function, if requested, and to musttail calls.
         if (!VarArgsToForward.empty() &&
             ((ForwardVarArgsTo &&
               CI->getCalledFunction() == ForwardVarArgsTo) ||
              CI->isMustTailCall())) {
+          // Collect attributes for non-vararg parameters.
+          AttributeList Attrs = CI->getAttributes();
+          SmallVector<AttributeSet, 8> ArgAttrs;
+          if (!Attrs.isEmpty()) {
+            for (unsigned ArgNo = 0;
+                 ArgNo < CI->getFunctionType()->getNumParams(); ++ArgNo)
+              ArgAttrs.push_back(Attrs.getParamAttributes(ArgNo));
+          }
+
+          // Add VarArg attributes.
+          ArgAttrs.append(VarArgsAttrs.begin(), VarArgsAttrs.end());
+          Attrs = AttributeList::get(CI->getContext(), Attrs.getFnAttributes(),
+                                     Attrs.getRetAttributes(), ArgAttrs);
+          // Add VarArgs to existing parameters.
           SmallVector<Value *, 6> Params(CI->arg_operands());
           Params.append(VarArgsToForward.begin(), VarArgsToForward.end());
-          CallInst *Call =
+          CallInst *NewCI =
               CallInst::Create(CI->getCalledFunction() ? CI->getCalledFunction()
                                                        : CI->getCalledValue(),
                                Params, "", CI);
-          Call->setDebugLoc(CI->getDebugLoc());
-          CI->replaceAllUsesWith(Call);
+          NewCI->setDebugLoc(CI->getDebugLoc());
+          NewCI->setAttributes(Attrs);
+          CI->replaceAllUsesWith(NewCI);
           CI->eraseFromParent();
+          CI = NewCI;
         }
 
         if (Function *F = CI->getCalledFunction())
           InlinedDeoptimizeCalls |=
               F->getIntrinsicID() == Intrinsic::experimental_deoptimize;
 
         // We need to reduce the strength of any inlined tail calls.  For
         // musttail, we have to avoid introducing potential unbounded stack

llvm/trunk/test/Transforms/Inline/inline-varargs.ll

 ; RUN: opt < %s -inline -S | FileCheck %s
 ; RUN: opt < %s -passes='cgscc(inline,function(instcombine))' -S | FileCheck %s
 
 declare void @ext_method(i8*, i32)
-declare void @vararg_fn(i8*, ...)
+declare signext i16 @vararg_fn(...) #0
 
 define linkonce_odr void @thunk(i8* %this, ...) {
   %this_adj = getelementptr i8, i8* %this, i32 4
-  musttail call void (i8*, ...) bitcast (void (i8*, i32)* @ext_method to void (i8*, ...)*)(i8* %this_adj, ...)
+  musttail call void (i8*, ...) bitcast (void (i8*, i32)* @ext_method to void (i8*, ...)*)(i8* nonnull %this_adj, ...)
   ret void
 }
 
 define void @thunk_caller(i8* %p) {
   call void (i8*, ...) @thunk(i8* %p, i32 42)
   ret void
 }
 ; CHECK-LABEL: define void @thunk_caller(i8* %p)
-; CHECK: call void (i8*, ...) bitcast (void (i8*, i32)* @ext_method to void (i8*, ...)*)(i8* %this_adj.i, i32 42)
+; CHECK: call void (i8*, ...) bitcast (void (i8*, i32)* @ext_method to void (i8*, ...)*)(i8* nonnull %this_adj.i, i32 42)
 
-define void @test_callee_2(i8* %this, ...) {
-  %this_adj = getelementptr i8, i8* %this, i32 4
-  musttail call void (i8*, ...) @vararg_fn(i8* %this_adj, ...)
+define signext i16 @test_callee_2(...) {
+  %res = musttail call signext i16 (...) @vararg_fn(...) #0
+  ret i16 %res
+}
+
+define void @test_caller_2(i8* %p, i8* %q, i16 %r) {
+  call signext i16 (...) @test_callee_2(i8* %p, i8* byval %q, i16 signext %r)
   ret void
 }
+; CHECK-LABEL: define void @test_caller_2
+; CHECK: call signext i16 (...) @vararg_fn(i8* %p, i8* byval %q, i16 signext %r) [[FN_ATTRS:#[0-9]+]]
 
-define void @test_caller_2(i8* %p) {
-  call void (i8*, ...) @test_callee_2(i8* %p)
+define void @test_callee_3(i8* %p, ...) {
+  call signext i16 (...) @vararg_fn()
   ret void
 }
-; CHECK-LABEL: define void @test_caller_2(i8* %p)
-; CHECK: call void (i8*, ...) @vararg_fn(i8* %this_adj.i)
 
+define void @test_caller_3(i8* %p, i8* %q) {
+  call void (i8*, ...) @test_callee_3(i8* nonnull %p, i8* %q)
+  ret void
+}
+; CHECK-LABEL: define void @test_caller_3
+; CHECK: call signext i16 (...) @vararg_fn()
 
 define internal i32 @varg_accessed(...) {
 entry:
   %vargs = alloca i8*, align 8
   %vargs.ptr = bitcast i8** %vargs to i8*
   call void @llvm.va_start(i8* %vargs.ptr)
   %va1 = va_arg i8** %vargs, i32
   call void @llvm.va_end(i8* %vargs.ptr)
   ret i32 %va1
 }
 
 define i32 @call_vargs() {
   %res = call i32 (...) @varg_accessed(i32 10)
   ret i32 %res
 }
 ; CHECK-LABEL: @call_vargs
 ; CHECK: %res = call i32 (...) @varg_accessed(i32 10)
 
 declare void @llvm.va_start(i8*)
 declare void @llvm.va_end(i8*)
+
+; CHECK: attributes [[FN_ATTRS]] = { "foo"="bar" }
+attributes #0 = { "foo"="bar" }