diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h --- a/llvm/include/llvm/IR/Attributes.h +++ b/llvm/include/llvm/IR/Attributes.h @@ -420,6 +420,11 @@ LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute A) const; + /// Add attributes to the attribute set at the given index. + /// Returns a new list because attribute lists are immutable. + LLVM_NODISCARD AttributeList addAttributes(LLVMContext &C, unsigned Index, + const AttributeSet &S) const; + /// Add attributes to the attribute set at the given index. /// Returns a new list because attribute lists are immutable. LLVM_NODISCARD AttributeList addAttributes(LLVMContext &C, unsigned Index, @@ -658,6 +663,32 @@ /// Return the attributes at the index as a string. std::string getAsString(unsigned Index, bool InAttrGrp = false) const; + /// Return a new AttributeList with sets from the current one, but rearranged. + /// The template parameters to this function represent indices to select from + /// this one. Indices start at -1 (corresponds to the function attributes). An + /// example: List.shuffle<-1, 1, 1>(...) copies `List`'s AttributeList at + /// index 1 into index 0, and keeps index -1 the same. All attributes past + /// index 1 are discarded. + template + AttributeList shuffle(LLVMContext &Ctx, AttributeList *Acc = nullptr, + int CurrIdx = -1) { + AttributeList Ret; + if (Acc == nullptr) + Acc = &Ret; + + AttributeSet IdxSet = getAttributes(Sel); + if (IdxSet.getNumAttributes()) + Ret = Acc->addAttributes(Ctx, CurrIdx, IdxSet); + return Ret; + } + + template + AttributeList shuffle(LLVMContext &Ctx, AttributeList *Acc = nullptr, + int CurrIdx = -1) { + AttributeList CurrList = shuffle(Ctx, Acc, CurrIdx); + return shuffle(Ctx, &CurrList, CurrIdx + 1); + } + //===--------------------------------------------------------------------===// // AttributeList Introspection //===--------------------------------------------------------------------===// diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -1253,18 +1253,18 @@ } AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index, - const AttrBuilder &B) const { - if (!B.hasAttributes()) + const AttributeSet &S) const { + if (!S.hasAttributes()) return *this; if (!pImpl) - return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}}); + return AttributeList::get(C, {{Index, S}}); #ifndef NDEBUG // FIXME it is not obvious how this should work for alignment. For now, say // we can't change a known alignment. const MaybeAlign OldAlign = getAttributes(Index).getAlignment(); - const MaybeAlign NewAlign = B.getAlignment(); + const MaybeAlign NewAlign = S.getAlignment(); assert((!OldAlign || !NewAlign || OldAlign == NewAlign) && "Attempt to change alignment!"); #endif @@ -1275,12 +1275,17 @@ AttrSets.resize(Index + 1); AttrBuilder Merged(AttrSets[Index]); - Merged.merge(B); + Merged.merge(S); AttrSets[Index] = AttributeSet::get(C, Merged); return getImpl(C, AttrSets); } +AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index, + const AttrBuilder &B) const { + return addAttributes(C, Index, AttributeSet::get(C, B)); +} + AttributeList AttributeList::addParamAttribute(LLVMContext &C, ArrayRef ArgNos, Attribute A) const { diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -1449,6 +1449,7 @@ Value *LibCallSimplifier::replacePowWithExp(CallInst *Pow, IRBuilderBase &B) { Value *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1); AttributeList Attrs = Pow->getCalledFunction()->getAttributes(); + AttributeList ExpAttrs = Attrs.shuffle<-1, 0, 2>(B.getContext()); Module *Mod = Pow->getModule(); Type *Ty = Pow->getType(); bool Ignored; @@ -1552,7 +1553,7 @@ FMul, "exp2"); else return emitUnaryFloatFnCall(FMul, TLI, LibFunc_exp2, LibFunc_exp2f, - LibFunc_exp2l, B, Attrs); + LibFunc_exp2l, B, ExpAttrs); } } @@ -1561,7 +1562,7 @@ if (match(Base, m_SpecificFP(10.0)) && hasFloatFn(TLI, Ty, LibFunc_exp10, LibFunc_exp10f, LibFunc_exp10l)) return emitUnaryFloatFnCall(Expo, TLI, LibFunc_exp10, LibFunc_exp10f, - LibFunc_exp10l, B, Attrs); + LibFunc_exp10l, B, ExpAttrs); // pow(x, y) -> exp2(log2(x) * y) if (Pow->hasApproxFunc() && Pow->hasNoNaNs() && BaseF->isFiniteNonZero() && @@ -1584,7 +1585,7 @@ FMul, "exp2"); else if (hasFloatFn(TLI, Ty, LibFunc_exp2, LibFunc_exp2f, LibFunc_exp2l)) return emitUnaryFloatFnCall(FMul, TLI, LibFunc_exp2, LibFunc_exp2f, - LibFunc_exp2l, B, Attrs); + LibFunc_exp2l, B, ExpAttrs); } } @@ -1616,6 +1617,7 @@ Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilderBase &B) { Value *Sqrt, *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1); AttributeList Attrs = Pow->getCalledFunction()->getAttributes(); + AttributeList SqrtAttrs = Attrs.shuffle<-1, 0, 1>(B.getContext()); Module *Mod = Pow->getModule(); Type *Ty = Pow->getType(); @@ -1629,7 +1631,7 @@ if (ExpoF->isNegative() && (!Pow->hasApproxFunc() && !Pow->hasAllowReassoc())) return nullptr; - Sqrt = getSqrtCall(Base, Attrs, Pow->doesNotAccessMemory(), Mod, B, TLI); + Sqrt = getSqrtCall(Base, SqrtAttrs, Pow->doesNotAccessMemory(), Mod, B, TLI); if (!Sqrt) return nullptr; @@ -1798,10 +1800,13 @@ // Turn exp2(uitofp(x)) -> ldexp(1.0, zext(x)) if sizeof(x) < 32 if ((isa(Op) || isa(Op)) && hasFloatFn(TLI, Ty, LibFunc_ldexp, LibFunc_ldexpf, LibFunc_ldexpl)) { - if (Value *Exp = getIntToFPVal(Op, B)) + if (Value *Exp = getIntToFPVal(Op, B)) { + AttributeList Attrs = CI->getCalledFunction()->getAttributes(); + AttributeList LdexpAttrs = Attrs.shuffle<-1, 0, 1, 1>(B.getContext()); return emitBinaryFloatFnCall(ConstantFP::get(Ty, 1.0), Exp, TLI, - LibFunc_ldexp, LibFunc_ldexpf, LibFunc_ldexpl, - B, CI->getCalledFunction()->getAttributes()); + LibFunc_ldexp, LibFunc_ldexpf, + LibFunc_ldexpl, B, LdexpAttrs); + } } return Ret; diff --git a/llvm/test/Transforms/InstCombine/simplify-libcalls.ll b/llvm/test/Transforms/InstCombine/simplify-libcalls.ll --- a/llvm/test/Transforms/InstCombine/simplify-libcalls.ll +++ b/llvm/test/Transforms/InstCombine/simplify-libcalls.ll @@ -175,6 +175,28 @@ ret i32 %y } +declare inreg double @pow(double inreg, double inreg) +declare inreg double @exp2(double inreg) + +; check to make sure parameter attributes are correctly applied +define double @fake_exp2(double %x) { +; CHECK-LABEL: @fake_exp2( +; CHECK-NEXT: [[Y:%.*]] = call inreg double @exp2(double inreg %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) { +; CHECK-LABEL: @fake_ldexp( +; CHECK-NEXT: [[Z:%.*]] = call inreg double @ldexp(double inreg 1.0{{.*}}, i32 inreg %x) +; CHECK-NEXT: ret double [[Z]] + + %y = sitofp i32 %x to double + %z = call inreg double @exp2(double %y) + ret double %z +} + attributes #0 = { nobuiltin } attributes #1 = { builtin }