/// an exception might pass by.
/// uwtable + nounwind = Needs an entry because the ABI says so.
- enum AttrVal {
+ enum AttrKind {
// IR-Level Attributes
None, ///< No attributes have been set
AddressSafety, ///< Address safety checking is on.
/// \brief Return a uniquified Attribute object. This takes the uniquified
/// value from the Builder and wraps it in the Attribute class.
- static Attribute get(LLVMContext &Context, ArrayRef<AttrVal> Vals);
+ static Attribute get(LLVMContext &Context, ArrayRef<AttrKind> Vals);
static Attribute get(LLVMContext &Context, AttrBuilder &B);
/// \brief Return true if the attribute is present.
- bool hasAttribute(AttrVal Val) const;
+ bool hasAttribute(AttrKind Val) const;
/// \brief Return true if attributes exist
bool hasAttributes() const;
void clear() { Bits = 0; }
/// addAttribute - Add an attribute to the builder.
- AttrBuilder &addAttribute(Attribute::AttrVal Val);
+ AttrBuilder &addAttribute(Attribute::AttrKind Val);
/// removeAttribute - Remove an attribute from the builder.
- AttrBuilder &removeAttribute(Attribute::AttrVal Val);
+ AttrBuilder &removeAttribute(Attribute::AttrKind Val);
/// addAttribute - Add the attributes from A to the builder.
AttrBuilder &addAttributes(const Attribute &A);
AttrBuilder &removeAttributes(const Attribute &A);
/// contains - Return true if the builder has the specified attribute.
- bool hasAttribute(Attribute::AttrVal A) const;
+ bool hasAttribute(Attribute::AttrKind A) const;
/// hasAttributes - Return true if the builder has IR-level attributes.
bool hasAttributes() const;
///< Index ~0U is used for function attributes.
static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
- ArrayRef<Attribute::AttrVal> Attrs) {
+ ArrayRef<Attribute::AttrKind> Attrs) {
return get(Idx, Attribute::get(C, Attrs));
}
static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
/// \brief Return true if the specified attribute is set for at least one
/// parameter or for the return value.
- bool hasAttrSomewhere(Attribute::AttrVal Attr) const;
+ bool hasAttrSomewhere(Attribute::AttrKind Attr) const;
unsigned getNumAttrs() const;
Attribute &getAttributesAtIndex(unsigned i) const;
/// addFnAttr - Add function attributes to this function.
///
- void addFnAttr(Attribute::AttrVal N) {
+ void addFnAttr(Attribute::AttrKind N) {
// Function Attribute are stored at ~0 index
addAttribute(AttributeSet::FunctionIndex, Attribute::get(getContext(), N));
}
void removeAttribute(unsigned i, Attribute attr);
/// \brief Determine whether this call has the given attribute.
- bool hasFnAttr(Attribute::AttrVal A) const;
+ bool hasFnAttr(Attribute::AttrKind A) const;
/// \brief Determine whether the call or the callee has the given attributes.
- bool paramHasAttr(unsigned i, Attribute::AttrVal A) const;
+ bool paramHasAttr(unsigned i, Attribute::AttrKind A) const;
/// \brief Extract the alignment for a call or parameter (0=unknown).
unsigned getParamAlignment(unsigned i) const {
void removeAttribute(unsigned i, Attribute attr);
/// \brief Determine whether this call has the NoAlias attribute.
- bool hasFnAttr(Attribute::AttrVal A) const;
+ bool hasFnAttr(Attribute::AttrKind A) const;
/// \brief Determine whether the call or the callee has the given attributes.
- bool paramHasAttr(unsigned i, Attribute::AttrVal A) const;
+ bool paramHasAttr(unsigned i, Attribute::AttrKind A) const;
/// \brief Extract the alignment for a call or parameter (0=unknown).
unsigned getParamAlignment(unsigned i) const {
}
/// \brief Return true if this function has the given attribute.
- bool hasFnAttr(Attribute::AttrVal A) const {
+ bool hasFnAttr(Attribute::AttrKind A) const {
CALLSITE_DELEGATE_GETTER(hasFnAttr(A));
}
/// \brief Return true if the call or the callee has the given attribute.
- bool paramHasAttr(unsigned i, Attribute::AttrVal A) const {
+ bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
}
Module *M = B.GetInsertBlock()->getParent()->getParent();
AttributeWithIndex AWI[2];
AWI[0] = AttributeWithIndex::get(M->getContext(), 1, Attribute::NoCapture);
- Attribute::AttrVal AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
+ Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AWI[1] = AttributeWithIndex::get(M->getContext(), AttributeSet::FunctionIndex,
- ArrayRef<Attribute::AttrVal>(AVs, 2));
+ ArrayRef<Attribute::AttrKind>(AVs, 2));
LLVMContext &Context = B.GetInsertBlock()->getContext();
Constant *StrLen = M->getOrInsertFunction("strlen",
Module *M = B.GetInsertBlock()->getParent()->getParent();
AttributeWithIndex AWI[2];
AWI[0] = AttributeWithIndex::get(M->getContext(), 1, Attribute::NoCapture);
- Attribute::AttrVal AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
+ Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AWI[1] = AttributeWithIndex::get(M->getContext(), AttributeSet::FunctionIndex,
- ArrayRef<Attribute::AttrVal>(AVs, 2));
+ ArrayRef<Attribute::AttrKind>(AVs, 2));
LLVMContext &Context = B.GetInsertBlock()->getContext();
Constant *StrNLen = M->getOrInsertFunction("strnlen",
return 0;
Module *M = B.GetInsertBlock()->getParent()->getParent();
- Attribute::AttrVal AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
+ Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AttributeWithIndex AWI =
AttributeWithIndex::get(M->getContext(), AttributeSet::FunctionIndex,
- ArrayRef<Attribute::AttrVal>(AVs, 2));
+ ArrayRef<Attribute::AttrKind>(AVs, 2));
Type *I8Ptr = B.getInt8PtrTy();
Type *I32Ty = B.getInt32Ty();
AttributeWithIndex AWI[3];
AWI[0] = AttributeWithIndex::get(M->getContext(), 1, Attribute::NoCapture);
AWI[1] = AttributeWithIndex::get(M->getContext(), 2, Attribute::NoCapture);
- Attribute::AttrVal AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
+ Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AWI[2] = AttributeWithIndex::get(M->getContext(), AttributeSet::FunctionIndex,
- ArrayRef<Attribute::AttrVal>(AVs, 2));
+ ArrayRef<Attribute::AttrKind>(AVs, 2));
LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *StrNCmp = M->getOrInsertFunction("strncmp",
Module *M = B.GetInsertBlock()->getParent()->getParent();
AttributeWithIndex AWI;
- Attribute::AttrVal AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
+ Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AWI = AttributeWithIndex::get(M->getContext(), AttributeSet::FunctionIndex,
- ArrayRef<Attribute::AttrVal>(AVs, 2));
+ ArrayRef<Attribute::AttrKind>(AVs, 2));
LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemChr = M->getOrInsertFunction("memchr",
AttributeSet::get(M->getContext(), AWI),
AttributeWithIndex AWI[3];
AWI[0] = AttributeWithIndex::get(M->getContext(), 1, Attribute::NoCapture);
AWI[1] = AttributeWithIndex::get(M->getContext(), 2, Attribute::NoCapture);
- Attribute::AttrVal AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
+ Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AWI[2] = AttributeWithIndex::get(M->getContext(), AttributeSet::FunctionIndex,
- ArrayRef<Attribute::AttrVal>(AVs, 2));
+ ArrayRef<Attribute::AttrKind>(AVs, 2));
LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemCmp = M->getOrInsertFunction("memcmp",
// Check the function attribues to find out if this function should be
// optimized for size.
Function *F = L->getHeader()->getParent();
- Attribute::AttrVal SzAttr= Attribute::OptimizeForSize;
+ Attribute::AttrKind SzAttr= Attribute::OptimizeForSize;
bool OptForSize = F->getFnAttributes().hasAttribute(SzAttr);
unsigned VF = CM.selectVectorizationFactor(OptForSize, VectorizationFactor);
// Attribute Implementation
//===----------------------------------------------------------------------===//
-Attribute Attribute::get(LLVMContext &Context, ArrayRef<AttrVal> Vals) {
+Attribute Attribute::get(LLVMContext &Context, ArrayRef<AttrKind> Vals) {
AttrBuilder B;
- for (ArrayRef<AttrVal>::iterator I = Vals.begin(), E = Vals.end();
+ for (ArrayRef<AttrKind>::iterator I = Vals.begin(), E = Vals.end();
I != E; ++I)
B.addAttribute(*I);
return Attribute::get(Context, B);
return Attribute(PA);
}
-bool Attribute::hasAttribute(AttrVal Val) const {
+bool Attribute::hasAttribute(AttrKind Val) const {
return pImpl && pImpl->hasAttribute(Val);
}
// AttrBuilder Implementation
//===----------------------------------------------------------------------===//
-AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrVal Val){
+AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val){
Bits |= AttributeImpl::getAttrMask(Val);
return *this;
}
return *this;
}
-AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrVal Val) {
+AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
Bits &= ~AttributeImpl::getAttrMask(Val);
return *this;
}
return *this;
}
-bool AttrBuilder::hasAttribute(Attribute::AttrVal A) const {
+bool AttrBuilder::hasAttribute(Attribute::AttrKind A) const {
return Bits & AttributeImpl::getAttrMask(A);
}
/// hasAttrSomewhere - Return true if the specified attribute is set for at
/// least one parameter or for the return value.
-bool AttributeSet::hasAttrSomewhere(Attribute::AttrVal Attr) const {
+bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const {
if (AttrList == 0) return false;
const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
setAttributes(PAL);
}
-bool CallInst::hasFnAttr(Attribute::AttrVal A) const {
+bool CallInst::hasFnAttr(Attribute::AttrKind A) const {
if (AttributeList.getParamAttributes(AttributeSet::FunctionIndex)
.hasAttribute(A))
return true;
return false;
}
-bool CallInst::paramHasAttr(unsigned i, Attribute::AttrVal A) const {
+bool CallInst::paramHasAttr(unsigned i, Attribute::AttrKind A) const {
if (AttributeList.getParamAttributes(i).hasAttribute(A))
return true;
if (const Function *F = getCalledFunction())
return setSuccessor(idx, B);
}
-bool InvokeInst::hasFnAttr(Attribute::AttrVal A) const {
+bool InvokeInst::hasFnAttr(Attribute::AttrKind A) const {
if (AttributeList.getParamAttributes(AttributeSet::FunctionIndex).
hasAttribute(A))
return true;
return false;
}
-bool InvokeInst::paramHasAttr(unsigned i, Attribute::AttrVal A) const {
+bool InvokeInst::paramHasAttr(unsigned i, Attribute::AttrKind A) const {
if (AttributeList.getParamAttributes(i).hasAttribute(A))
return true;
if (const Function *F = getCalledFunction())
OS << " AttributeWithIndex AWI[" << maxArgAttrs+1 << "];\n";
OS << " unsigned NumAttrs = 0;\n";
OS << " if (id != 0) {\n";
- OS << " SmallVector<Attribute::AttrVal, 8> AttrVec;\n";
+ OS << " SmallVector<Attribute::AttrKind, 8> AttrVec;\n";
OS << " switch(IntrinsicsToAttributesMap[id - ";
if (TargetOnly)
OS << "Intrinsic::num_intrinsics";