[BuildLibCalls] Properly set ABI attributes on arguments

[aeubanks]

Summary

Some floating point lib calls have ABI attributes that need to be set on
the caller. Found via D103412.

[aeubanks]

this is kinda ugly, but I'm not sure of a nicer way to do it. Maybe a new method on AttributeList that merges attributes?
ldexp() and friends are the only functions that have ABI attributes set (setSignExtendedArg())

[rnk]

I'd suggest something like:

CI->setAttributes(CI->getCalledFunction()->getAttributes().removeAttributes(Ctx, llvm::AttributeList::FunctionIndex)));

That should take the callee's attribute list, throw away all function index attributes (things like SSE level, noreturn, noinline, alwaysinline, optnone), and apply the return and parameter attributes. It should also create fewer immortal, immutable, but temporary attribute lists.

[aeubanks]

In D103415#2794636, @rnk wrote:

I'd suggest something like:

CI->setAttributes(CI->getCalledFunction()->getAttributes().removeAttributes(Ctx, llvm::AttributeList::FunctionIndex)));

That should take the callee's attribute list, throw away all function index attributes (things like SSE level, noreturn, noinline, alwaysinline, optnone), and apply the return and parameter attributes. It should also create fewer immortal, immutable, but temporary attribute lists.

The problem is that right above, we already call

CI->setAttributes()

and a second one would overwrite that.

I was thinking of adding something new to merge two AttributeLists, but idk

[rnk]

You're right, I don't see a way to directly merge two AttributeList objects. I looked at AttrBuilder::merge, but AttrBuilder makes AttributeSet objects. I guess it makes sense to have an AttributeList method to do this.

[aeubanks]

add merge function

[rnk]

lgtm

There's some horrifying index manipulation involving unsigned overflow that I had to avoid by checking if either AttributeList is empty.

By horrifying, surely you mean far too clever for anyone's best interests. =D

It'd be nice to not have AttributeList::AttrIndex::FunctionIndex = ~0U.

I had a patch to do that back in 2017, but the reviewers at the time felt it was too risky:
https://reviews.llvm.org/D32819#749163
https://reviews.llvm.org/D32819?id=98222#inline-286125

We could try again, but it has the potential to break frontends in ways that are hard to debug.

[aeubanks]

use existing AttributeList merge method
I completely missed that this one already existed

[rnk]

lgtm

llvm/include/llvm/IR/Attributes.h

public:
 
   /// Add the vscale_range attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList addVScaleRangeAttr(LLVMContext &C,
                                                   unsigned Index,
                                                   unsigned MinValue,
                                                   unsigned MaxValue);
 
+  /// Merge two AttributeLists. If either is empty, the other one is returned.
+  LLVM_NODISCARD AttributeList merge(LLVMContext &C,
+                                     const AttributeList &Other);
+
   //===--------------------------------------------------------------------===//
   // AttributeList Accessors
   //===--------------------------------------------------------------------===//
 
   /// The attributes for the specified index are returned.
   AttributeSet getAttributes(unsigned Index) const;
 
   /// The attributes for the argument or parameter at the given index are

llvm/lib/IR/Attributes.cpp

 AttributeList AttributeList::addVScaleRangeAttr(LLVMContext &C, unsigned Index,
                                                 unsigned MinValue,
                                                 unsigned MaxValue) {
   AttrBuilder B;
   B.addVScaleRangeAttr(MinValue, MaxValue);
   return addAttributes(C, Index, B);
 }
 
+AttributeList AttributeList::merge(LLVMContext &C, const AttributeList &Other) {
+  if (isEmpty())
+    return Other;
+  if (Other.isEmpty())
+    return *this;
+
+  auto IndexEnd = std::max(this->index_end(), Other.index_end());
+  if (index_begin() == IndexEnd)
+    return {};
+
+  SmallVector<AttributeSet, 4> AttrSets;
+  for (unsigned I = index_begin(); I != IndexEnd; ++I) {
+    AttrBuilder B1(*this, I);
+    AttrBuilder B2(Other, I);
+    AttrSets.push_back(AttributeSet::get(C, B1.merge(B2)));
+  }
+  return getImpl(C, AttrSets);
+}
+
 //===----------------------------------------------------------------------===//
 // AttributeList Accessor Methods
 //===----------------------------------------------------------------------===//
 
 AttributeSet AttributeList::getParamAttributes(unsigned ArgNo) const {
   return getAttributes(ArgNo + FirstArgIndex);
 }
 

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
                                                  Op1->getType(), Op2->getType());
   if (TLI != nullptr)
     inferLibFuncAttributes(M, Name, *TLI);
   CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
 
   // The incoming attribute set may have come from a speculatable intrinsic, but
   // is being replaced with a library call which is not allowed to be
   // speculatable.
-  CI->setAttributes(Attrs.removeAttribute(B.getContext(),
-                                          AttributeList::FunctionIndex,
-                                          Attribute::Speculatable));
+  CI->setAttributes(
+      Attrs
+          .removeAttribute(B.getContext(), AttributeList::FunctionIndex,
+                           Attribute::Speculatable)
+          .merge(B.getContext(), CI->getCalledFunction()->getAttributes()));
   if (const Function *F =
           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
     CI->setCallingConv(F->getCallingConv());
 
   return CI;
 }
 
 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,

llvm/test/Transforms/InstCombine/exp2-1.ll

 
 declare double @exp2(double)
 declare float @exp2f(float)
 
 ; Check exp2(sitofp(x)) -> ldexp(1.0, sext(x)).
 
 define double @test_simplify1(i32 %x) {
 ; LDEXP32-LABEL: @test_simplify1(
-; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[X:%.*]])
+; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[X:%.*]])
 ; LDEXP32-NEXT:    ret double [[LDEXP]]
 ;
 ; LDEXP16-LABEL: @test_simplify1(
 ; LDEXP16-NEXT:    [[CONV:%.*]] = sitofp i32 [[X:%.*]] to double
 ; LDEXP16-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; LDEXP16-NEXT:    ret double [[RET]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify1(
-; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[X:%.*]])
+; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[X:%.*]])
 ; NOLDEXPF-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXP-LABEL: @test_simplify1(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = sitofp i32 [[X:%.*]] to double
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; NOLDEXP-NEXT:    ret double [[RET]]
 ;
   %conv = sitofp i32 %x to double
   %ret = call double @exp2(double %conv)
   ret double %ret
 }
 
 define double @test_simplify2(i16 signext %x) {
 ; LDEXP32-LABEL: @test_simplify2(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = sext i16 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret double [[LDEXP]]
 ;
 ; LDEXP16-LABEL: @test_simplify2(
-; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 [[X:%.*]])
+; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 signext [[X:%.*]])
 ; LDEXP16-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify2(
 ; NOLDEXPF-NEXT:    [[TMP1:%.*]] = sext i16 [[X:%.*]] to i32
-; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; NOLDEXPF-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXP-LABEL: @test_simplify2(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = sitofp i16 [[X:%.*]] to double
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; NOLDEXP-NEXT:    ret double [[RET]]
 ;
   %conv = sitofp i16 %x to double
   %ret = call double @exp2(double %conv)
   ret double %ret
 }
 
 define double @test_simplify3(i8 signext %x) {
 ; LDEXP32-LABEL: @test_simplify3(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = sext i8 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret double [[LDEXP]]
 ;
 ; LDEXP16-LABEL: @test_simplify3(
 ; LDEXP16-NEXT:    [[TMP1:%.*]] = sext i8 [[X:%.*]] to i16
-; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 [[TMP1]])
+; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 signext [[TMP1]])
 ; LDEXP16-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify3(
 ; NOLDEXPF-NEXT:    [[TMP1:%.*]] = sext i8 [[X:%.*]] to i32
-; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; NOLDEXPF-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXP-LABEL: @test_simplify3(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = sitofp i8 [[X:%.*]] to double
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; NOLDEXP-NEXT:    ret double [[RET]]
 ;
   %conv = sitofp i8 %x to double
   %ret = call double @exp2(double %conv)
   ret double %ret
 }
 
 define float @test_simplify4(i32 %x) {
 ; LDEXP32-LABEL: @test_simplify4(
-; LDEXP32-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 [[X:%.*]])
+; LDEXP32-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 signext [[X:%.*]])
 ; LDEXP32-NEXT:    ret float [[LDEXPF]]
 ;
 ; LDEXP16-LABEL: @test_simplify4(
 ; LDEXP16-NEXT:    [[CONV:%.*]] = sitofp i32 [[X:%.*]] to float
 ; LDEXP16-NEXT:    [[RET:%.*]] = call float @exp2f(float [[CONV]])
 ; LDEXP16-NEXT:    ret float [[RET]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify4(
;
   %conv = uitofp i32 %x to double
   %ret = call double @exp2(double %conv)
   ret double %ret
 }
 
 define double @test_simplify6(i16 zeroext %x) {
 ; LDEXP32-LABEL: @test_simplify6(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = zext i16 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret double [[LDEXP]]
 ;
 ; LDEXP16-LABEL: @test_simplify6(
 ; LDEXP16-NEXT:    [[CONV:%.*]] = uitofp i16 [[X:%.*]] to double
 ; LDEXP16-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; LDEXP16-NEXT:    ret double [[RET]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify6(
 ; NOLDEXPF-NEXT:    [[TMP1:%.*]] = zext i16 [[X:%.*]] to i32
-; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; NOLDEXPF-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXP-LABEL: @test_simplify6(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = uitofp i16 [[X:%.*]] to double
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; NOLDEXP-NEXT:    ret double [[RET]]
 ;
   %conv = uitofp i16 %x to double
   %ret = call double @exp2(double %conv)
   ret double %ret
 }
 
 define double @test_simplify7(i8 zeroext %x) {
 ; LDEXP32-LABEL: @test_simplify7(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret double [[LDEXP]]
 ;
 ; LDEXP16-LABEL: @test_simplify7(
 ; LDEXP16-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i16
-; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 [[TMP1]])
+; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 signext [[TMP1]])
 ; LDEXP16-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify7(
 ; NOLDEXPF-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
-; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; NOLDEXPF-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXP-LABEL: @test_simplify7(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = uitofp i8 [[X:%.*]] to double
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call double @exp2(double [[CONV]])
 ; NOLDEXP-NEXT:    ret double [[RET]]
 ;
   %conv = uitofp i8 %x to double
   %ret = call double @exp2(double %conv)
   ret double %ret
 }
 
 define float @test_simplify8(i8 zeroext %x) {
 ; LDEXP32-LABEL: @test_simplify8(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret float [[LDEXPF]]
 ;
 ; LDEXP16-LABEL: @test_simplify8(
 ; LDEXP16-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i16
-; LDEXP16-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i16 [[TMP1]])
+; LDEXP16-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i16 signext [[TMP1]])
 ; LDEXP16-NEXT:    ret float [[LDEXPF]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify8(
 ; NOLDEXPF-NEXT:    [[CONV:%.*]] = uitofp i8 [[X:%.*]] to float
 ; NOLDEXPF-NEXT:    [[RET:%.*]] = call float @exp2f(float [[CONV]])
 ; NOLDEXPF-NEXT:    ret float [[RET]]
 ;
 ; NOLDEXP-LABEL: @test_simplify8(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = uitofp i8 [[X:%.*]] to float
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call float @exp2f(float [[CONV]])
 ; NOLDEXP-NEXT:    ret float [[RET]]
 ;
   %conv = uitofp i8 %x to float
   %ret = call float @exp2f(float %conv)
   ret float %ret
 }
 
 declare double @llvm.exp2.f64(double)
 declare float @llvm.exp2.f32(float)
 
 define double @test_simplify9(i8 zeroext %x) {
 ; LDEXP32-LABEL: @test_simplify9(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret double [[LDEXP]]
 ;
 ; LDEXP16-LABEL: @test_simplify9(
 ; LDEXP16-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i16
-; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 [[TMP1]])
+; LDEXP16-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i16 signext [[TMP1]])
 ; LDEXP16-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify9(
 ; NOLDEXPF-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
-; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 [[TMP1]])
+; NOLDEXPF-NEXT:    [[LDEXP:%.*]] = call double @ldexp(double 1.000000e+00, i32 signext [[TMP1]])
 ; NOLDEXPF-NEXT:    ret double [[LDEXP]]
 ;
 ; NOLDEXP-LABEL: @test_simplify9(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = uitofp i8 [[X:%.*]] to double
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call double @llvm.exp2.f64(double [[CONV]])
 ; NOLDEXP-NEXT:    ret double [[RET]]
 ;
   %conv = uitofp i8 %x to double
   %ret = call double @llvm.exp2.f64(double %conv)
   ret double %ret
 }
 
 define float @test_simplify10(i8 zeroext %x) {
 ; LDEXP32-LABEL: @test_simplify10(
 ; LDEXP32-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i32
-; LDEXP32-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 [[TMP1]])
+; LDEXP32-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 signext [[TMP1]])
 ; LDEXP32-NEXT:    ret float [[LDEXPF]]
 ;
 ; LDEXP16-LABEL: @test_simplify10(
 ; LDEXP16-NEXT:    [[TMP1:%.*]] = zext i8 [[X:%.*]] to i16
-; LDEXP16-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i16 [[TMP1]])
+; LDEXP16-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i16 signext [[TMP1]])
 ; LDEXP16-NEXT:    ret float [[LDEXPF]]
 ;
 ; NOLDEXPF-LABEL: @test_simplify10(
 ; NOLDEXPF-NEXT:    [[CONV:%.*]] = uitofp i8 [[X:%.*]] to float
 ; NOLDEXPF-NEXT:    [[RET:%.*]] = call float @llvm.exp2.f32(float [[CONV]])
 ; NOLDEXPF-NEXT:    ret float [[RET]]
 ;
 ; NOLDEXP-LABEL: @test_simplify10(
 ; NOLDEXP-NEXT:    [[CONV:%.*]] = uitofp i8 [[X:%.*]] to float
 ; NOLDEXP-NEXT:    [[RET:%.*]] = call float @llvm.exp2.f32(float [[CONV]])
 ; NOLDEXP-NEXT:    ret float [[RET]]
 ;
   %conv = uitofp i8 %x to float
   %ret = call float @llvm.exp2.f32(float %conv)
   ret float %ret
 }

llvm/test/Transforms/InstCombine/pow_fp_int.ll

 ;
   %subfp = uitofp i31 %x to double
   %pow = tail call afn double @llvm.pow.f64(double 7.000000e+00, double %subfp)
   ret double %pow
 }
 
 define double @pow_sitofp_double_const_base_2_fast(i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_double_const_base_2_fast(
-; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i32 [[X:%.*]])
+; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i32 signext [[X:%.*]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[LDEXPF]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
   %pow = tail call afn float @llvm.pow.f32(float 2.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
;
   %pow = tail call afn float @llvm.pow.f32(float 16.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_uitofp_const_base_2_fast(i31 %x) {
 ; CHECK-LABEL: @pow_uitofp_const_base_2_fast(
 ; CHECK-NEXT:    [[TMP1:%.*]] = zext i31 [[X:%.*]] to i32
-; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i32 [[TMP1]])
+; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i32 signext [[TMP1]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[LDEXPF]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = uitofp i31 %x to float
   %pow = tail call afn float @llvm.pow.f32(float 2.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
;
   %subfp = uitofp i32 %x to float
   %pow = tail call float @llvm.pow.f32(float 7.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_const_base_2_no_fast(i32 %x) {
 ; CHECK-LABEL: @pow_sitofp_const_base_2_no_fast(
-; CHECK-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 [[X:%.*]])
+; CHECK-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i32 signext [[X:%.*]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[LDEXPF]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i32 %x to float
   %pow = tail call float @llvm.pow.f32(float 2.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }

llvm/test/Transforms/InstCombine/pow_fp_int16.ll

 ;
   %subfp = uitofp i15 %x to double
   %pow = tail call afn double @llvm.pow.f64(double 7.000000e+00, double %subfp)
   ret double %pow
 }
 
 define double @pow_sitofp_double_const_base_2_fast(i16 %x) {
 ; CHECK-LABEL: @pow_sitofp_double_const_base_2_fast(
-; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i16 [[X:%.*]])
+; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i16 signext [[X:%.*]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[LDEXPF]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i16 %x to float
   %pow = tail call afn float @llvm.pow.f32(float 2.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
;
   %pow = tail call afn float @llvm.pow.f32(float 16.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_uitofp_const_base_2_fast(i15 %x) {
 ; CHECK-LABEL: @pow_uitofp_const_base_2_fast(
 ; CHECK-NEXT:    [[TMP1:%.*]] = zext i15 [[X:%.*]] to i16
-; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i16 [[TMP1]])
+; CHECK-NEXT:    [[LDEXPF:%.*]] = call afn float @ldexpf(float 1.000000e+00, i16 signext [[TMP1]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[LDEXPF]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = uitofp i15 %x to float
   %pow = tail call afn float @llvm.pow.f32(float 2.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
;
   %subfp = uitofp i16 %x to float
   %pow = tail call float @llvm.pow.f32(float 7.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }
 
 define double @pow_sitofp_const_base_2_no_fast(i16 %x) {
 ; CHECK-LABEL: @pow_sitofp_const_base_2_no_fast(
-; CHECK-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i16 [[X:%.*]])
+; CHECK-NEXT:    [[LDEXPF:%.*]] = call float @ldexpf(float 1.000000e+00, i16 signext [[X:%.*]])
 ; CHECK-NEXT:    [[RES:%.*]] = fpext float [[LDEXPF]] to double
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %subfp = sitofp i16 %x to float
   %pow = tail call float @llvm.pow.f32(float 2.000000e+00, float %subfp)
   %res = fpext float %pow to double
   ret double %res
 }

llvm/test/Transforms/InstCombine/simplify-libcalls.ll

 ; CHECK-NEXT:    [[Y:%.*]] = call double @exp2(double %x)
 ; CHECK-NEXT:    ret double [[Y]]
 
   %y = call inreg double @pow(double inreg 2.0, double inreg %x)
   ret double %y
 }
 define double @fake_ldexp(i32 %x) {
 ; CHECK32-LABEL: @fake_ldexp(
-; CHECK32-NEXT:    [[Z:%.*]] = call double @ldexp(double 1.0{{.*}}, i32 %x)
+; CHECK32-NEXT:    [[Z:%.*]] = call double @ldexp(double 1.0{{.*}}, i32 signext %x)
 ; CHECK32-NEXT:    ret double [[Z]]
 
 ; CHECK16-LABEL: @fake_ldexp(
 ; CHECK16-NEXT:    [[Y:%.*]] = sitofp i32 %x to double
 ; CHECK16-NEXT:    [[Z:%.*]] = call inreg double @exp2(double [[Y]])
 ; CHECK16-NEXT:    ret double [[Z]]
 
   %y = sitofp i32 %x to double
   %z = call inreg double @exp2(double %y)
   ret double %z
 }
 define double @fake_ldexp_16(i16 %x) {
 ; CHECK32-LABEL: @fake_ldexp_16(
 ; CHECK32-NEXT:    [[Y:%.*]] = sext i16 %x to i32
-; CHECK32-NEXT:    [[Z:%.*]] = call double @ldexp(double 1.0{{.*}}, i32 [[Y]])
+; CHECK32-NEXT:    [[Z:%.*]] = call double @ldexp(double 1.0{{.*}}, i32 signext [[Y]])
 ; CHECK32-NEXT:    ret double [[Z]]
 
 ; CHECK16-LABEL: @fake_ldexp_16(
-; CHECK16-NEXT:    [[Z:%.*]] = call double @ldexp(double 1.0{{.*}}, i16 %x)
+; CHECK16-NEXT:    [[Z:%.*]] = call double @ldexp(double 1.0{{.*}}, i16 signext %x)
 ; CHECK16-NEXT:    ret double [[Z]]
 
   %y = sitofp i16 %x to double
   %z = call inreg double @exp2(double %y)
   ret double %z
 }
 
+; CHECK: declare double @ldexp(double, i{{16|32}} signext)
+
 
 attributes #0 = { nobuiltin }
 attributes #1 = { builtin }

llvm/unittests/IR/AttributesTest.cpp

TEST(Attributes, AddAttributes) {
   EXPECT_TRUE(AL.hasFnAttribute(Attribute::NoReturn));
   B.clear();
   B.addAttribute(Attribute::SExt);
   AL = AL.addAttributes(C, AttributeList::ReturnIndex, B);
   EXPECT_TRUE(AL.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt));
   EXPECT_TRUE(AL.hasFnAttribute(Attribute::NoReturn));
 }
 
+TEST(Attributes, MergeAttributes) {
+  LLVMContext C;
+  AttributeList AL1;
+  AttributeList AL2;
+  EXPECT_TRUE(AL1.merge(C, AL2).isEmpty());
+
+  AttrBuilder B;
+  B.addAttribute(Attribute::NoReturn);
+  AL1 = AL1.addAttributes(C, AttributeList::FunctionIndex, AttributeSet::get(C, B));
+  AttributeList Merged = AL1.merge(C, AL2);
+  EXPECT_EQ(Merged, AL1);
+
+  B.clear();
+  B.addAttribute(Attribute::Hot);
+  AL2 = AL2.addParamAttributes(C, 1, B);
+  B.addAttribute(Attribute::Convergent);
+  AL1 = AL1.addParamAttributes(C, 1, B);
+  Merged = AL1.merge(C, AL2);
+
+  EXPECT_TRUE(Merged.hasFnAttribute(Attribute::NoReturn));
+  EXPECT_FALSE(Merged.hasParamAttribute(0, Attribute::NoReturn));
+  EXPECT_TRUE(Merged.hasParamAttribute(1, Attribute::Hot));
+  EXPECT_TRUE(Merged.hasParamAttribute(1, Attribute::Convergent));
+  EXPECT_FALSE(Merged.hasAttrSomewhere(Attribute::Cold));
+  EXPECT_EQ(Merged, AL2.merge(C, AL1));
+}
+
 TEST(Attributes, RemoveAlign) {
   LLVMContext C;
 
   Attribute AlignAttr = Attribute::getWithAlignment(C, Align(8));
   Attribute StackAlignAttr = Attribute::getWithStackAlignment(C, Align(32));
   AttrBuilder B_align_readonly;
   B_align_readonly.addAttribute(AlignAttr);
   B_align_readonly.addAttribute(Attribute::ReadOnly);