if (!PA) {
// If we didn't find any existing attributes of the same shape then create a
// new one and insert it.
- PA = !Val ?
- new AttributeImpl(Context, Kind) :
- new AttributeImpl(Context, Kind, Val);
+ if (!Val)
+ PA = new EnumAttributeImpl(Kind);
+ else
+ PA = new AlignAttributeImpl(Kind, Val);
pImpl->AttrsSet.InsertNode(PA, InsertPoint);
}
if (!PA) {
// If we didn't find any existing attributes of the same shape then create a
// new one and insert it.
- PA = new AttributeImpl(Context, Kind, Val);
+ PA = new StringAttributeImpl(Kind, Val);
pImpl->AttrsSet.InsertNode(PA, InsertPoint);
}
}
Attribute::AttrKind Attribute::getKindAsEnum() const {
+ if (!pImpl) return None;
assert((isEnumAttribute() || isAlignAttribute()) &&
"Invalid attribute type to get the kind as an enum!");
return pImpl ? pImpl->getKindAsEnum() : None;
}
uint64_t Attribute::getValueAsInt() const {
+ if (!pImpl) return 0;
assert(isAlignAttribute() &&
"Expected the attribute to be an alignment attribute!");
return pImpl ? pImpl->getValueAsInt() : 0;
}
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();
}
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 "sanitize_address";
if (hasAttribute(Attribute::AlwaysInline))
return "alwaysinline";
+ if (hasAttribute(Attribute::Builtin))
+ return "builtin";
if (hasAttribute(Attribute::ByVal))
return "byval";
if (hasAttribute(Attribute::InlineHint))
return "uwtable";
if (hasAttribute(Attribute::ZExt))
return "zeroext";
+ if (hasAttribute(Attribute::Cold))
+ return "cold";
// FIXME: These should be output like this:
//
// AttributeImpl Definition
//===----------------------------------------------------------------------===//
-AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind)
- : Context(C), Entry(new EnumAttributeEntry(Kind)) {}
-
-AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind,
- unsigned Align)
- : Context(C) {
- assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) &&
- "Wrong kind for alignment attribute!");
- Entry = new AlignAttributeEntry(Kind, Align);
-}
-
-AttributeImpl::AttributeImpl(LLVMContext &C, StringRef Kind, StringRef Val)
- : Context(C), Entry(new StringAttributeEntry(Kind, Val)) {}
-
-AttributeImpl::~AttributeImpl() {
- delete Entry;
-}
-
-bool AttributeImpl::isEnumAttribute() const {
- return isa<EnumAttributeEntry>(Entry);
-}
-
-bool AttributeImpl::isAlignAttribute() const {
- return isa<AlignAttributeEntry>(Entry);
-}
-
-bool AttributeImpl::isStringAttribute() const {
- return isa<StringAttributeEntry>(Entry);
-}
+AttributeImpl::~AttributeImpl() {}
bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
if (isStringAttribute()) return false;
}
Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
- if (EnumAttributeEntry *E = dyn_cast<EnumAttributeEntry>(Entry))
- return E->getEnumKind();
- return cast<AlignAttributeEntry>(Entry)->getEnumKind();
+ assert(isEnumAttribute() || isAlignAttribute());
+ return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
}
uint64_t AttributeImpl::getValueAsInt() const {
- return cast<AlignAttributeEntry>(Entry)->getAlignment();
+ assert(isAlignAttribute());
+ return static_cast<const AlignAttributeImpl *>(this)->getAlignment();
}
StringRef AttributeImpl::getKindAsString() const {
- return cast<StringAttributeEntry>(Entry)->getStringKind();
+ assert(isStringAttribute());
+ return static_cast<const StringAttributeImpl *>(this)->getStringKind();
}
StringRef AttributeImpl::getValueAsString() const {
- return cast<StringAttributeEntry>(Entry)->getStringValue();
+ assert(isStringAttribute());
+ return static_cast<const StringAttributeImpl *>(this)->getStringValue();
}
bool AttributeImpl::operator<(const AttributeImpl &AI) const {
case Attribute::SanitizeMemory: return 1ULL << 37;
case Attribute::NoBuiltin: return 1ULL << 38;
case Attribute::Returned: return 1ULL << 39;
+ case Attribute::Cold: return 1ULL << 40;
+ case Attribute::Builtin: return 1ULL << 41;
}
llvm_unreachable("Unsupported attribute type");
}
// If we didn't find any existing attributes of the same shape then create a
// new one and insert it.
if (!PA) {
- PA = new AttributeSetNode(SortedAttrs);
+ // Coallocate entries after the AttributeSetNode itself.
+ void *Mem = ::operator new(sizeof(AttributeSetNode) +
+ sizeof(Attribute) * SortedAttrs.size());
+ PA = new (Mem) AttributeSetNode(SortedAttrs);
pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
}
}
bool AttributeSetNode::hasAttribute(Attribute::AttrKind Kind) const {
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I)
+ for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Kind))
return true;
return false;
}
bool AttributeSetNode::hasAttribute(StringRef Kind) const {
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I)
+ for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Kind))
return true;
return false;
}
Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I)
+ for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Kind))
return *I;
return Attribute();
}
Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I)
+ for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Kind))
return *I;
return Attribute();
}
unsigned AttributeSetNode::getAlignment() const {
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I)
+ for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Attribute::Alignment))
return I->getAlignment();
return 0;
}
unsigned AttributeSetNode::getStackAlignment() const {
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I)
+ for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Attribute::StackAlignment))
return I->getStackAlignment();
return 0;
std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
std::string Str;
- for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
- E = AttrList.end(); I != E; ++I) {
- if (I != AttrList.begin())
+ for (iterator I = begin(), E = end(); I != E; ++I) {
+ if (I != begin())
Str += ' ';
Str += I->getAsString(InAttrGrp);
}
// AttributeSetImpl Definition
//===----------------------------------------------------------------------===//
-uint64_t AttributeSetImpl::Raw(uint64_t Index) const {
+uint64_t AttributeSetImpl::Raw(unsigned Index) const {
for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) {
if (getSlotIndex(I) != Index) continue;
- const AttributeSetNode *ASN = AttrNodes[I].second;
+ const AttributeSetNode *ASN = getSlotNode(I);
uint64_t Mask = 0;
- for (AttributeSetNode::const_iterator II = ASN->begin(),
+ for (AttributeSetNode::iterator II = ASN->begin(),
IE = ASN->end(); II != IE; ++II) {
Attribute Attr = *II;
// If we didn't find any existing attributes of the same shape then
// create a new one and insert it.
if (!PA) {
- PA = new AttributeSetImpl(C, Attrs);
+ // Coallocate entries after the AttributeSetImpl itself.
+ void *Mem = ::operator new(sizeof(AttributeSetImpl) +
+ sizeof(std::pair<unsigned, AttributeSetNode *>) *
+ Attrs.size());
+ PA = new (Mem) AttributeSetImpl(C, Attrs);
pImpl->AttrsLists.InsertNode(PA, InsertPoint);
}
AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) {
if (Attrs.empty()) return AttributeSet();
+ if (Attrs.size() == 1) return Attrs[0];
SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec;
- for (unsigned I = 0, E = Attrs.size(); I != E; ++I) {
- AttributeSet AS = Attrs[I];
- if (!AS.pImpl) continue;
- AttrNodeVec.append(AS.pImpl->AttrNodes.begin(), AS.pImpl->AttrNodes.end());
+ AttributeSetImpl *A0 = Attrs[0].pImpl;
+ if (A0)
+ AttrNodeVec.append(A0->getNode(0), A0->getNode(A0->getNumAttributes()));
+ // Copy all attributes from Attrs into AttrNodeVec while keeping AttrNodeVec
+ // ordered by index. Because we know that each list in Attrs is ordered by
+ // index we only need to merge each successive list in rather than doing a
+ // full sort.
+ for (unsigned I = 1, E = Attrs.size(); I != E; ++I) {
+ AttributeSetImpl *AS = Attrs[I].pImpl;
+ if (!AS) continue;
+ SmallVector<std::pair<unsigned, AttributeSetNode *>, 8>::iterator
+ ANVI = AttrNodeVec.begin(), ANVE;
+ for (const AttributeSetImpl::IndexAttrPair
+ *AI = AS->getNode(0),
+ *AE = AS->getNode(AS->getNumAttributes());
+ AI != AE; ++AI) {
+ ANVE = AttrNodeVec.end();
+ while (ANVI != ANVE && ANVI->first <= AI->first)
+ ++ANVI;
+ ANVI = AttrNodeVec.insert(ANVI, *AI) + 1;
+ }
}
return getImpl(C, AttrNodeVec);
return addAttributes(C, Index, AttributeSet::get(C, Index, B));
}
+AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
+ StringRef Kind, StringRef Value) const {
+ llvm::AttrBuilder B;
+ B.addAttribute(Kind, Value);
+ return addAttributes(C, Index, AttributeSet::get(C, Index, B));
+}
+
AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index,
AttributeSet Attrs) const {
if (!pImpl) return Attrs;
for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
if (Attrs.getSlotIndex(I) == Index) {
- for (AttributeSetImpl::const_iterator II = Attrs.pImpl->begin(I),
+ for (AttributeSetImpl::iterator II = Attrs.pImpl->begin(I),
IE = Attrs.pImpl->end(I); II != IE; ++II)
B.addAttribute(*II);
break;
if (pImpl == 0) return false;
for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
- for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
+ for (AttributeSetImpl::iterator II = pImpl->begin(I),
IE = pImpl->end(I); II != IE; ++II)
if (II->hasAttribute(Attr))
return true;
return pImpl ? pImpl->getNumAttributes() : 0;
}
-uint64_t AttributeSet::getSlotIndex(unsigned Slot) const {
+unsigned AttributeSet::getSlotIndex(unsigned Slot) const {
assert(pImpl && Slot < pImpl->getNumAttributes() &&
"Slot # out of range!");
return pImpl->getSlotIndex(Slot);
for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) {
if (pImpl->getSlotIndex(I) != Index) continue;
- for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
+ for (AttributeSetImpl::iterator II = pImpl->begin(I),
IE = pImpl->end(I); II != IE; ++II)
addAttribute(*II);
.addAttribute(Attribute::Nest)
.addAttribute(Attribute::NoAlias)
.addAttribute(Attribute::NoCapture)
+ .addAttribute(Attribute::ReadNone)
+ .addAttribute(Attribute::ReadOnly)
.addAttribute(Attribute::StructRet);
return AttributeSet::get(Ty->getContext(), Index, Incompatible);
projects / oota-llvm.git / blobdiff