6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-03-25 00:35:30 +00:00
Code Issues Projects Releases Wiki Activity

Rename AlignAttribute to IntAttribute

Browse Source 
Currently the only kind of integer IR attributes that we have are alignment
attributes, and so the attribute kind that takes an integer parameter is called
AlignAttr, but that will change (we'll soon be adding a dereferenceable
attribute that also takes an integer value). Accordingly, rename AlignAttribute
to IntAttribute (class names, enums, etc.).

No functionality change intended.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213352 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Hal Finkel 2014-07-18 06:51:55 +00:00
parent a32c319741
commit d0261683e8
5 changed files with 29 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/IR/Attributes.h
View File

@ -141,8 +141,8 @@ public:
/// \brief Return true if the attribute is an Attribute::AttrKind type.
bool isEnumAttribute() const;
/// \brief Return true if the attribute is an alignment attribute.
bool isAlignAttribute() const;
/// \brief Return true if the attribute is an integer attribute.
bool isIntAttribute() const;
/// \brief Return true if the attribute is a string (target-dependent)
/// attribute.

2
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -683,7 +683,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() {
return EC;
B.addAttribute(Kind);
} else if (Record[i] == 1) { // Align attribute
} else if (Record[i] == 1) { // Integer attribute
Attribute::AttrKind Kind;
if (std::error_code EC = ParseAttrKind(Record[++i], &Kind))
return EC;

2
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -272,7 +272,7 @@ static void WriteAttributeGroupTable(const ValueEnumerator &VE,
if (Attr.isEnumAttribute()) {
Record.push_back(0);
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
} else if (Attr.isAlignAttribute()) {
} else if (Attr.isIntAttribute()) {
Record.push_back(1);
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
Record.push_back(Attr.getValueAsInt());

18
lib/IR/AttributeImpl.h
View File

@ -39,7 +39,7 @@ class AttributeImpl : public FoldingSetNode {
protected:
enum AttrEntryKind {
EnumAttrEntry,
AlignAttrEntry,
IntAttrEntry,
StringAttrEntry
};
@ -49,7 +49,7 @@ public:
virtual ~AttributeImpl();
bool isEnumAttribute() const { return KindID == EnumAttrEntry; }
bool isAlignAttribute() const { return KindID == AlignAttrEntry; }
bool isIntAttribute() const { return KindID == IntAttrEntry; }
bool isStringAttribute() const { return KindID == StringAttrEntry; }
bool hasAttribute(Attribute::AttrKind A) const;
@ -67,7 +67,7 @@ public:
void Profile(FoldingSetNodeID &ID) const {
if (isEnumAttribute())
Profile(ID, getKindAsEnum(), 0);
else if (isAlignAttribute())
else if (isIntAttribute())
Profile(ID, getKindAsEnum(), getValueAsInt());
else
Profile(ID, getKindAsString(), getValueAsString());
@ -108,19 +108,19 @@ public:
Attribute::AttrKind getEnumKind() const { return Kind; }
};
class AlignAttributeImpl : public EnumAttributeImpl {
class IntAttributeImpl : public EnumAttributeImpl {
void anchor() override;
unsigned Align;
uint64_t Val;
public:
AlignAttributeImpl(Attribute::AttrKind Kind, unsigned Align)
: EnumAttributeImpl(AlignAttrEntry, Kind), Align(Align) {
IntAttributeImpl(Attribute::AttrKind Kind, uint64_t Val)
: EnumAttributeImpl(IntAttrEntry, Kind), Val(Val) {
assert(
(Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) &&
"Wrong kind for alignment attribute!");
"Wrong kind for int attribute!");
}
unsigned getAlignment() const { return Align; }
uint64_t getValue() const { return Val; }
};
class StringAttributeImpl : public AttributeImpl {

32
lib/IR/Attributes.cpp
View File

@ -47,7 +47,7 @@ Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
if (!Val)
PA = new EnumAttributeImpl(Kind);
else
PA = new AlignAttributeImpl(Kind, Val);
PA = new IntAttributeImpl(Kind, Val);
pImpl->AttrsSet.InsertNode(PA, InsertPoint);
}
@ -96,8 +96,8 @@ bool Attribute::isEnumAttribute() const {
return pImpl && pImpl->isEnumAttribute();
}
bool Attribute::isAlignAttribute() const {
return pImpl && pImpl->isAlignAttribute();
bool Attribute::isIntAttribute() const {
return pImpl && pImpl->isIntAttribute();
}
bool Attribute::isStringAttribute() const {
@ -106,15 +106,15 @@ bool Attribute::isStringAttribute() const {
Attribute::AttrKind Attribute::getKindAsEnum() const {
if (!pImpl) return None;
assert((isEnumAttribute() || isAlignAttribute()) &&
assert((isEnumAttribute() || isIntAttribute()) &&
"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!");
assert(isIntAttribute() &&
"Expected the attribute to be an integer attribute!");
return pImpl ? pImpl->getValueAsInt() : 0;
}
@ -296,7 +296,7 @@ bool Attribute::operator<(Attribute A) const {
// Pin the vtables to this file.
AttributeImpl::~AttributeImpl() {}
void EnumAttributeImpl::anchor() {}
void AlignAttributeImpl::anchor() {}
void IntAttributeImpl::anchor() {}
void StringAttributeImpl::anchor() {}
bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
@ -310,13 +310,13 @@ bool AttributeImpl::hasAttribute(StringRef Kind) const {
}
Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
assert(isEnumAttribute() || isAlignAttribute());
assert(isEnumAttribute() || isIntAttribute());
return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
}
uint64_t AttributeImpl::getValueAsInt() const {
assert(isAlignAttribute());
return static_cast<const AlignAttributeImpl *>(this)->getAlignment();
assert(isIntAttribute());
return static_cast<const IntAttributeImpl *>(this)->getValue();
}
StringRef AttributeImpl::getKindAsString() const {
@ -334,18 +334,18 @@ bool AttributeImpl::operator<(const AttributeImpl &AI) const {
// relative to their enum value) and then strings.
if (isEnumAttribute()) {
if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
if (AI.isAlignAttribute()) return true;
if (AI.isIntAttribute()) return true;
if (AI.isStringAttribute()) return true;
}
if (isAlignAttribute()) {
if (isIntAttribute()) {
if (AI.isEnumAttribute()) return false;
if (AI.isAlignAttribute()) return getValueAsInt() < AI.getValueAsInt();
if (AI.isIntAttribute()) return getValueAsInt() < AI.getValueAsInt();
if (AI.isStringAttribute()) return true;
}
if (AI.isEnumAttribute()) return false;
if (AI.isAlignAttribute()) return false;
if (AI.isIntAttribute()) return false;
if (getKindAsString() == AI.getKindAsString())
return getValueAsString() < AI.getValueAsString();
return getKindAsString() < AI.getKindAsString();
@ -1029,7 +1029,7 @@ AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
Attribute Attr = *I;
if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
Attribute::AttrKind Kind = I->getKindAsEnum();
Attrs[Kind] = false;
@ -1117,7 +1117,7 @@ bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const {
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot);
I != E; ++I) {
Attribute Attr = *I;
if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
if (Attrs[I->getKindAsEnum()])
return true;
} else {