6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 04:30:23 +00:00
Code Issues Projects Releases Wiki Activity

Rename AttributeSets to AttributeGroups so that it's more meaningful.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@174911 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2013-02-11 22:33:26 +00:00
parent 04ef4be048
commit e9229a6a96
3 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -161,44 +161,20 @@ static void WriteStringRecord(unsigned Code, StringRef Str,
Stream.EmitRecord(Code, Vals, AbbrevToUse);
}
/// \brief This returns an integer containing an encoding of all the LLVM
/// attributes found in the given attribute bitset. Any change to this encoding
/// is a breaking change to bitcode compatibility.
/// N.B. This should be used only by the bitcode writer!
static uint64_t encodeLLVMAttributesForBitcode(AttributeSet Attrs,
unsigned Index) {
// FIXME: Remove in 4.0!
// FIXME: It doesn't make sense to store the alignment information as an
// expanded out value, we should store it as a log2 value. However, we can't
// just change that here without breaking bitcode compatibility. If this ever
// becomes a problem in practice, we should introduce new tag numbers in the
// bitcode file and have those tags use a more efficiently encoded alignment
// field.
// Store the alignment in the bitcode as a 16-bit raw value instead of a 5-bit
// log2 encoded value. Shift the bits above the alignment up by 11 bits.
uint64_t EncodedAttrs = Attrs.Raw(Index) & 0xffff;
if (Attrs.hasAttribute(Index, Attribute::Alignment))
EncodedAttrs |= Attrs.getParamAlignment(Index) << 16;
EncodedAttrs |= (Attrs.Raw(Index) & (0xfffffULL << 21)) << 11;
return EncodedAttrs;
}
static void WriteAttributeGroupTable(const ValueEnumerator &VE,
BitstreamWriter &Stream) {
const std::vector<AttributeSet> &Attrs = VE.getAttributeSets();
if (Attrs.empty()) return;
const std::vector<AttributeSet> &AttrGrps = VE.getAttributeGroups();
if (AttrGrps.empty()) return;
Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);
SmallVector<uint64_t, 64> Record;
for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
AttributeSet AS = Attrs[i];
for (unsigned i = 0, e = AttrGrps.size(); i != e; ++i) {
AttributeSet AS = AttrGrps[i];
for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) {
AttributeSet A = AS.getSlotAttributes(i);
Record.push_back(VE.getAttributeSetID(A));
Record.push_back(VE.getAttributeGroupID(A));
Record.push_back(AS.getSlotIndex(i));
for (AttributeSet::iterator I = AS.begin(0), E = AS.end(0);
@ -233,6 +209,30 @@ static void WriteAttributeGroupTable(const ValueEnumerator &VE,
Stream.ExitBlock();
}
/// \brief This returns an integer containing an encoding of all the LLVM
/// attributes found in the given attribute bitset. Any change to this encoding
/// is a breaking change to bitcode compatibility.
/// N.B. This should be used only by the bitcode writer!
static uint64_t encodeLLVMAttributesForBitcode(AttributeSet Attrs,
unsigned Index) {
// FIXME: Remove in 4.0!
// FIXME: It doesn't make sense to store the alignment information as an
// expanded out value, we should store it as a log2 value. However, we can't
// just change that here without breaking bitcode compatibility. If this ever
// becomes a problem in practice, we should introduce new tag numbers in the
// bitcode file and have those tags use a more efficiently encoded alignment
// field.
// Store the alignment in the bitcode as a 16-bit raw value instead of a 5-bit
// log2 encoded value. Shift the bits above the alignment up by 11 bits.
uint64_t EncodedAttrs = Attrs.Raw(Index) & 0xffff;
if (Attrs.hasAttribute(Index, Attribute::Alignment))
EncodedAttrs |= Attrs.getParamAlignment(Index) << 16;
EncodedAttrs |= (Attrs.Raw(Index) & (0xfffffULL << 21)) << 11;
return EncodedAttrs;
}
static void WriteAttributeTable(const ValueEnumerator &VE,
BitstreamWriter &Stream) {
const std::vector<AttributeSet> &Attrs = VE.getAttributes();

6
lib/Bitcode/Writer/ValueEnumerator.cpp
View File

@ -431,10 +431,10 @@ void ValueEnumerator::EnumerateAttributes(const AttributeSet &PAL) {
// Do lookups for all attribute groups.
for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) {
AttributeSet AS = PAL.getSlotAttributes(i);
unsigned &Entry = AttributeSetMap[AS];
unsigned &Entry = AttributeGroupMap[AS];
if (Entry == 0) {
AttributeSets.push_back(AS);
Entry = AttributeSets.size();
AttributeGroups.push_back(AS);
Entry = AttributeGroups.size();
}
}
}

18
lib/Bitcode/Writer/ValueEnumerator.h
View File

@ -52,9 +52,9 @@ private:
SmallVector<const MDNode *, 8> FunctionLocalMDs;
ValueMapType MDValueMap;
typedef DenseMap<AttributeSet, unsigned> AttributeSetMapType;
AttributeSetMapType AttributeSetMap;
std::vector<AttributeSet> AttributeSets;
typedef DenseMap<AttributeSet, unsigned> AttributeGroupMapType;
AttributeGroupMapType AttributeGroupMap;
std::vector<AttributeSet> AttributeGroups;
typedef DenseMap<void*, unsigned> AttributeMapType;
AttributeMapType AttributeMap;
@ -102,17 +102,17 @@ public:
unsigned getInstructionID(const Instruction *I) const;
void setInstructionID(const Instruction *I);
unsigned getAttributeID(const AttributeSet &PAL) const {
unsigned getAttributeID(AttributeSet PAL) const {
if (PAL.isEmpty()) return 0; // Null maps to zero.
AttributeMapType::const_iterator I = AttributeMap.find(PAL.getRawPointer());
assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!");
return I->second;
}
unsigned getAttributeSetID(const AttributeSet &PAL) const {
unsigned getAttributeGroupID(AttributeSet PAL) const {
if (PAL.isEmpty()) return 0; // Null maps to zero.
AttributeSetMapType::const_iterator I = AttributeSetMap.find(PAL);
assert(I != AttributeSetMap.end() && "Attribute not in ValueEnumerator!");
AttributeGroupMapType::const_iterator I = AttributeGroupMap.find(PAL);
assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!");
return I->second;
}
@ -135,8 +135,8 @@ public:
const std::vector<AttributeSet> &getAttributes() const {
return Attribute;
}
const std::vector<AttributeSet> &getAttributeSets() const {
return AttributeSets;
const std::vector<AttributeSet> &getAttributeGroups() const {
return AttributeGroups;
}
/// getGlobalBasicBlockID - This returns the function-specific ID for the