[ICP] Remove incompatible attributes at indirect-call promoted callsites.

[trentxintong]

Summary

Removing ncompatible attributes at indirect-call promoted callsites, not removing it results in
at least a IR verification error.

[trentxintong]

Update comment in test case.

[davidxl]

lib/Transforms/Utils/CallPromotionUtils.cpp

415

use 'else' instead of continue?

426

Guard the following change with a flag : attributeChanged?

[trentxintong]

Address comments from @davidxl

[davidxl]

lgtm

lib/Transforms/Utils/CallPromotionUtils.cpp

Instruction *llvm::promoteCall(CallSite CS, Function *Callee,
   // Change the function type of the call site the match that of the callee.
   CS.mutateFunctionType(Callee->getFunctionType());
 
   // Inspect the arguments of the call site. If an argument's type doesn't
   // match the corresponding formal argument's type in the callee, bitcast it
   // to the correct type.
   auto CalleeType = Callee->getFunctionType();
   auto CalleeParamNum = CalleeType->getNumParams();
+
+  LLVMContext &Ctx = Callee->getContext();
+  const AttributeList &CallerPAL = CS.getAttributes();
+  // The new list of argument attributes.
+  SmallVector<AttributeSet, 4> NewArgAttrs;
+
   for (unsigned ArgNo = 0; ArgNo < CalleeParamNum; ++ArgNo) {
     auto *Arg = CS.getArgument(ArgNo);
     Type *FormalTy = CalleeType->getParamType(ArgNo);
     Type *ActualTy = Arg->getType();
     if (FormalTy != ActualTy) {
       auto *Cast = CastInst::CreateBitOrPointerCast(Arg, FormalTy, "",
                                                     CS.getInstruction());
       CS.setArgument(ArgNo, Cast);
+
+      // Remove any incompatible attributes for the argument.
+      AttrBuilder ArgAttrs(CallerPAL.getParamAttributes(ArgNo));
+      ArgAttrs.remove(AttributeFuncs::typeIncompatible(FormalTy));
+      NewArgAttrs.push_back(AttributeSet::get(Ctx, ArgAttrs));
+      continue;
     }
+    NewArgAttrs.push_back(CallerPAL.getParamAttributes(ArgNo));
   }
 
   // If the return type of the call site doesn't match that of the callee, cast
   // the returned value to the appropriate type.
   if (!CallSiteRetTy->isVoidTy() && CallSiteRetTy != CalleeRetTy)
     createRetBitCast(CS, CallSiteRetTy, RetBitCast);
 
+  // Remove any incompatible return value attribute.
+  AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex);
+  RAttrs.remove(AttributeFuncs::typeIncompatible(CalleeRetTy));
+  // Set the new callsite attribute.
+  CS.setAttributes(AttributeList::get(Ctx, CallerPAL.getFnAttributes(),
+                                      AttributeSet::get(Ctx, RAttrs),
+                                      NewArgAttrs));
+
   return CS.getInstruction();
 }
 
 Instruction *llvm::promoteCallWithIfThenElse(CallSite CS, Function *Callee,
                                              MDNode *BranchWeights) {
 
   // Version the indirect call site. If the called value is equal to the given
   // callee, 'NewInst' will be executed, otherwise the original call site will
   // be executed.
   Instruction *NewInst = versionCallSite(CS, Callee, BranchWeights);
 
   // Promote 'NewInst' so that it directly calls the desired function.
   return promoteCall(CallSite(NewInst), Callee);
 }
 
 #undef DEBUG_TYPE

test/Transforms/Util/call-promotion-utils-ptrcast-attribute.ll

+; RUN: opt -S -pgo-icall-prom -icp-total-percent-threshold=0 < %s 2>&1 | FileCheck %s
+
+; Test that CallPromotionUtils will promote calls which require pointer cast
+; safely, i.e. drop appropriate attributes.
+
+@foo = common global i8* (i8*)* null, align 8
+
+; casting to i64 and pointer attribute at callsite dropped.
+define i64 @func2(i64 %a) {
+  ret i64 undef
+}
+
+; no casting needed, attribute at callsite preserved.
+define i8* @func4(i8* %a) {
+  ret i8* undef
+}
+
+define i8* @bar(i8* %arg) {
+  %tmp = load i8* (i8*)*, i8* (i8*)** @foo, align 8
+
+; Make sure callsite attributes are preserved on arguments and retval.
+; CHECK: call noalias i8* @func4(i8* nonnull
+
+; Make sure callsite attributes are dropped on arguments and retval.
+; CHECK: [[ARG:%[0-9]+]] = ptrtoint i8* %arg to i64
+; CHECK-NEXT: call i64 @func2(i64 [[ARG]])
+
+  %call = call noalias i8* %tmp(i8* nonnull %arg), !prof !1
+  ret i8* %call
+}
+
+!1 = !{!"VP", i32 0, i64 1440, i64 7651369219802541373, i64 1030, i64 -4377547752858689819, i64 410}