// Attribute Function Definitions
//===----------------------------------------------------------------------===//
-std::string Attribute::getAsString(Attributes Attrs) {
+std::string Attributes::getAsString() const {
std::string Result;
- if (Attrs & Attribute::ZExt)
+ if (hasZExtAttr())
Result += "zeroext ";
- if (Attrs & Attribute::SExt)
+ if (hasSExtAttr())
Result += "signext ";
- if (Attrs & Attribute::NoReturn)
+ if (hasNoReturnAttr())
Result += "noreturn ";
- if (Attrs & Attribute::NoUnwind)
+ if (hasNoUnwindAttr())
Result += "nounwind ";
- if (Attrs & Attribute::UWTable)
+ if (hasUWTableAttr())
Result += "uwtable ";
- if (Attrs & Attribute::ReturnsTwice)
+ if (hasReturnsTwiceAttr())
Result += "returns_twice ";
- if (Attrs & Attribute::InReg)
+ if (hasInRegAttr())
Result += "inreg ";
- if (Attrs & Attribute::NoAlias)
+ if (hasNoAliasAttr())
Result += "noalias ";
- if (Attrs & Attribute::NoCapture)
+ if (hasNoCaptureAttr())
Result += "nocapture ";
- if (Attrs & Attribute::StructRet)
+ if (hasStructRetAttr())
Result += "sret ";
- if (Attrs & Attribute::ByVal)
+ if (hasByValAttr())
Result += "byval ";
- if (Attrs & Attribute::Nest)
+ if (hasNestAttr())
Result += "nest ";
- if (Attrs & Attribute::ReadNone)
+ if (hasReadNoneAttr())
Result += "readnone ";
- if (Attrs & Attribute::ReadOnly)
+ if (hasReadOnlyAttr())
Result += "readonly ";
- if (Attrs & Attribute::OptimizeForSize)
+ if (hasOptimizeForSizeAttr())
Result += "optsize ";
- if (Attrs & Attribute::NoInline)
+ if (hasNoInlineAttr())
Result += "noinline ";
- if (Attrs & Attribute::InlineHint)
+ if (hasInlineHintAttr())
Result += "inlinehint ";
- if (Attrs & Attribute::AlwaysInline)
+ if (hasAlwaysInlineAttr())
Result += "alwaysinline ";
- if (Attrs & Attribute::StackProtect)
+ if (hasStackProtectAttr())
Result += "ssp ";
- if (Attrs & Attribute::StackProtectReq)
+ if (hasStackProtectReqAttr())
Result += "sspreq ";
- if (Attrs & Attribute::NoRedZone)
+ if (hasNoRedZoneAttr())
Result += "noredzone ";
- if (Attrs & Attribute::NoImplicitFloat)
+ if (hasNoImplicitFloatAttr())
Result += "noimplicitfloat ";
- if (Attrs & Attribute::Naked)
+ if (hasNakedAttr())
Result += "naked ";
- if (Attrs & Attribute::NonLazyBind)
+ if (hasNonLazyBindAttr())
Result += "nonlazybind ";
- if (Attrs & Attribute::AddressSafety)
+ if (hasAddressSafetyAttr())
Result += "address_safety ";
- if (Attrs & Attribute::StackAlignment) {
+ if (hasStackAlignmentAttr()) {
Result += "alignstack(";
- Result += utostr(Attribute::getStackAlignmentFromAttrs(Attrs));
+ Result += utostr(getStackAlignment());
Result += ") ";
}
- if (Attrs & Attribute::Alignment) {
+ if (hasAlignmentAttr()) {
Result += "align ";
- Result += utostr(Attribute::getAlignmentFromAttrs(Attrs));
+ Result += utostr(getAlignment());
Result += " ";
}
// Trim the trailing space.
#ifndef NDEBUG
for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
- assert(Attrs[i].Attrs != Attribute::None &&
+ assert(Attrs[i].Attrs.hasAttributes() &&
"Pointless attribute!");
assert((!i || Attrs[i-1].Index < Attrs[i].Index) &&
"Misordered AttributesList!");
/// returned. Attributes for the result are denoted with Idx = 0.
/// Function notes are denoted with idx = ~0.
Attributes AttrListPtr::getAttributes(unsigned Idx) const {
- if (AttrList == 0) return Attribute::None;
+ if (AttrList == 0) return Attributes();
const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
for (unsigned i = 0, e = Attrs.size(); i != e && Attrs[i].Index <= Idx; ++i)
if (Attrs[i].Index == Idx)
return Attrs[i].Attrs;
- return Attribute::None;
+
+ return Attributes();
}
/// hasAttrSomewhere - Return true if the specified attribute is set for at
const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
for (unsigned i = 0, e = Attrs.size(); i != e; ++i)
- if (Attrs[i].Attrs & Attr)
+ if (Attrs[i].Attrs.hasAttributes(Attr))
return true;
return false;
}
#ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't change a known alignment.
- Attributes OldAlign = OldAttrs & Attribute::Alignment;
- Attributes NewAlign = Attrs & Attribute::Alignment;
+ unsigned OldAlign = OldAttrs.getAlignment();
+ unsigned NewAlign = Attrs.getAlignment();
assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
"Attempt to change alignment!");
#endif
#ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't pass in alignment, which no current use does.
- assert(!(Attrs & Attribute::Alignment) && "Attempt to exclude alignment!");
+ assert(!Attrs.hasAlignmentAttr() && "Attempt to exclude alignment!");
#endif
if (AttrList == 0) return AttrListPtr();