//===----------------------------------------------------------------------===//
#include "llvm/IR/Attributes.h"
-#include "llvm/IR/Function.h"
#include "AttributeImpl.h"
#include "LLVMContextImpl.h"
#include "llvm/ADT/STLExtras.h"
if (!pImpl) return None;
assert((isEnumAttribute() || isIntAttribute()) &&
"Invalid attribute type to get the kind as an enum!");
- return pImpl ? pImpl->getKindAsEnum() : None;
+ return pImpl->getKindAsEnum();
}
uint64_t Attribute::getValueAsInt() const {
if (!pImpl) return 0;
assert(isIntAttribute() &&
"Expected the attribute to be an integer attribute!");
- return pImpl ? pImpl->getValueAsInt() : 0;
+ return pImpl->getValueAsInt();
}
StringRef Attribute::getKindAsString() const {
if (!pImpl) return StringRef();
assert(isStringAttribute() &&
"Invalid attribute type to get the kind as a string!");
- return pImpl ? pImpl->getKindAsString() : StringRef();
+ return pImpl->getKindAsString();
}
StringRef Attribute::getValueAsString() const {
if (!pImpl) return StringRef();
assert(isStringAttribute() &&
"Invalid attribute type to get the value as a string!");
- return pImpl ? pImpl->getValueAsString() : StringRef();
+ return pImpl->getValueAsString();
}
bool Attribute::hasAttribute(AttrKind Kind) const {
SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
array_pod_sort(SortedAttrs.begin(), SortedAttrs.end());
- for (SmallVectorImpl<Attribute>::iterator I = SortedAttrs.begin(),
- E = SortedAttrs.end(); I != E; ++I)
- I->Profile(ID);
+ for (Attribute Attr : SortedAttrs)
+ Attr.Profile(ID);
void *InsertPoint;
AttributeSetNode *PA =
if (!B.contains(Kind))
continue;
- if (Kind == Attribute::Alignment)
- Attrs.push_back(std::make_pair(Index, Attribute::
- getWithAlignment(C, B.getAlignment())));
- else if (Kind == Attribute::StackAlignment)
- Attrs.push_back(std::make_pair(Index, Attribute::
- getWithStackAlignment(C, B.getStackAlignment())));
- else if (Kind == Attribute::Dereferenceable)
- Attrs.push_back(std::make_pair(Index,
- Attribute::getWithDereferenceableBytes(C,
- B.getDereferenceableBytes())));
- else if (Kind == Attribute::DereferenceableOrNull)
- Attrs.push_back(
- std::make_pair(Index, Attribute::getWithDereferenceableOrNullBytes(
- C, B.getDereferenceableOrNullBytes())));
- else
- Attrs.push_back(std::make_pair(Index, Attribute::get(C, Kind)));
+ Attribute Attr;
+ switch (Kind) {
+ case Attribute::Alignment:
+ Attr = Attribute::getWithAlignment(C, B.getAlignment());
+ break;
+ case Attribute::StackAlignment:
+ Attr = Attribute::getWithStackAlignment(C, B.getStackAlignment());
+ break;
+ case Attribute::Dereferenceable:
+ Attr = Attribute::getWithDereferenceableBytes(
+ C, B.getDereferenceableBytes());
+ break;
+ case Attribute::DereferenceableOrNull:
+ Attr = Attribute::getWithDereferenceableOrNullBytes(
+ C, B.getDereferenceableOrNullBytes());
+ break;
+ default:
+ Attr = Attribute::get(C, Kind);
+ }
+ Attrs.push_back(std::make_pair(Index, Attr));
}
// Add target-dependent (string) attributes.
AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index,
ArrayRef<Attribute::AttrKind> Kind) {
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
- for (ArrayRef<Attribute::AttrKind>::iterator I = Kind.begin(),
- E = Kind.end(); I != E; ++I)
- Attrs.push_back(std::make_pair(Index, Attribute::get(C, *I)));
+ for (Attribute::AttrKind K : Kind)
+ Attrs.push_back(std::make_pair(Index, Attribute::get(C, K)));
return get(C, Attrs);
}
return addAttributes(C, Index, AttributeSet::get(C, Index, B));
}
+AttributeSet AttributeSet::addAttribute(LLVMContext &C,
+ ArrayRef<unsigned> Indices,
+ Attribute A) const {
+ unsigned I = 0, E = pImpl ? pImpl->getNumAttributes() : 0;
+ auto IdxI = Indices.begin(), IdxE = Indices.end();
+ SmallVector<AttributeSet, 4> AttrSet;
+
+ while (I != E && IdxI != IdxE) {
+ if (getSlotIndex(I) < *IdxI)
+ AttrSet.emplace_back(getSlotAttributes(I++));
+ else if (getSlotIndex(I) > *IdxI)
+ AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A)));
+ else {
+ AttrBuilder B(getSlotAttributes(I), *IdxI);
+ B.addAttribute(A);
+ AttrSet.emplace_back(AttributeSet::get(C, *IdxI, B));
+ ++I;
+ ++IdxI;
+ }
+ }
+
+ while (I != E)
+ AttrSet.emplace_back(getSlotAttributes(I++));
+
+ while (IdxI != IdxE)
+ AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A)));
+
+ return get(C, AttrSet);
+}
+
AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index,
AttributeSet Attrs) const {
if (!pImpl) return Attrs;
bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{
AttributeSetNode *ASN = getAttributes(Index);
- return ASN ? ASN->hasAttribute(Kind) : false;
+ return ASN && ASN->hasAttribute(Kind);
}
bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const {
AttributeSetNode *ASN = getAttributes(Index);
- return ASN ? ASN->hasAttribute(Kind) : false;
+ return ASN && ASN->hasAttribute(Kind);
}
bool AttributeSet::hasAttributes(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index);
- return ASN ? ASN->hasAttributes() : false;
+ return ASN && ASN->hasAttributes();
}
/// \brief Return true if the specified attribute is set for at least one
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
Attribute Attr = *I;
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
- Attribute::AttrKind Kind = I->getKindAsEnum();
- Attrs[Kind] = false;
-
- if (Kind == Attribute::Alignment)
- Alignment = 0;
- else if (Kind == Attribute::StackAlignment)
- StackAlignment = 0;
- else if (Kind == Attribute::Dereferenceable)
- DerefBytes = 0;
- else if (Kind == Attribute::DereferenceableOrNull)
- DerefOrNullBytes = 0;
+ removeAttribute(Attr.getKindAsEnum());
} else {
assert(Attr.isStringAttribute() && "Invalid attribute type!");
- std::map<std::string, std::string>::iterator
- Iter = TargetDepAttrs.find(Attr.getKindAsString());
- if (Iter != TargetDepAttrs.end())
- TargetDepAttrs.erase(Iter);
+ removeAttribute(Attr.getKindAsString());
}
}
assert(Slot != ~0U && "Couldn't find the index!");
- for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot);
- I != E; ++I) {
+ for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
Attribute Attr = *I;
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
if (Attrs[I->getKindAsEnum()])
return Incompatible;
}
-
-template<typename AttrClass>
-static bool isEqual(const Function &Caller, const Function &Callee) {
- return Caller.getFnAttribute(AttrClass::Kind) ==
- Callee.getFnAttribute(AttrClass::Kind);
-}
-
-/// \brief Compute the logical AND of the attributes of the caller and the
-/// callee.
-///
-/// This function sets the caller's attribute to false if the callee's attribute
-/// is false.
-template<typename AttrClass>
-static void setAND(Function &Caller, const Function &Callee) {
- if (AttrClass::isSet(Caller, AttrClass::Kind) &&
- !AttrClass::isSet(Callee, AttrClass::Kind))
- AttrClass::set(Caller, AttrClass::Kind, false);
-}
-
-/// \brief Compute the logical OR of the attributes of the caller and the
-/// callee.
-///
-/// This function sets the caller's attribute to true if the callee's attribute
-/// is true.
-template<typename AttrClass>
-static void setOR(Function &Caller, const Function &Callee) {
- if (!AttrClass::isSet(Caller, AttrClass::Kind) &&
- AttrClass::isSet(Callee, AttrClass::Kind))
- AttrClass::set(Caller, AttrClass::Kind, true);
-}
-
-/// \brief If the inlined function had a higher stack protection level than the
-/// calling function, then bump up the caller's stack protection level.
-static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
- // If upgrading the SSP attribute, clear out the old SSP Attributes first.
- // Having multiple SSP attributes doesn't actually hurt, but it adds useless
- // clutter to the IR.
- AttrBuilder B;
- B.addAttribute(Attribute::StackProtect)
- .addAttribute(Attribute::StackProtectStrong)
- .addAttribute(Attribute::StackProtectReq);
- AttributeSet OldSSPAttr = AttributeSet::get(Caller.getContext(),
- AttributeSet::FunctionIndex,
- B);
-
- if (Callee.hasFnAttribute(Attribute::SafeStack)) {
- Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
- Caller.addFnAttr(Attribute::SafeStack);
- } else if (Callee.hasFnAttribute(Attribute::StackProtectReq) &&
- !Caller.hasFnAttribute(Attribute::SafeStack)) {
- Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
- Caller.addFnAttr(Attribute::StackProtectReq);
- } else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
- !Caller.hasFnAttribute(Attribute::SafeStack) &&
- !Caller.hasFnAttribute(Attribute::StackProtectReq)) {
- Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
- Caller.addFnAttr(Attribute::StackProtectStrong);
- } else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
- !Caller.hasFnAttribute(Attribute::SafeStack) &&
- !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
- !Caller.hasFnAttribute(Attribute::StackProtectStrong))
- Caller.addFnAttr(Attribute::StackProtect);
-}
-
-#define GET_ATTR_COMPAT_FUNC
-#include "AttributesCompatFunc.inc"
-
-bool AttributeFuncs::areInlineCompatible(const Function &Caller,
- const Function &Callee) {
- return hasCompatibleFnAttrs(Caller, Callee);
-}
-
-
-void AttributeFuncs::mergeAttributesForInlining(Function &Caller,
- const Function &Callee) {
- mergeFnAttrs(Caller, Callee);
-}