summaryrefslogtreecommitdiffstats
path: root/llvm/lib/Bitcode
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/Bitcode')
-rw-r--r--llvm/lib/Bitcode/Reader/BitcodeReader.cpp34
-rw-r--r--llvm/lib/Bitcode/Reader/BitstreamReader.cpp6
-rw-r--r--llvm/lib/Bitcode/Writer/BitcodeWriter.cpp85
-rw-r--r--llvm/lib/Bitcode/Writer/ValueEnumerator.cpp23
-rw-r--r--llvm/lib/Bitcode/Writer/ValueEnumerator.h15
5 files changed, 129 insertions, 34 deletions
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index bb479dbcedc..b849db4427a 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -2363,7 +2363,7 @@ std::error_code BitcodeReader::parseMetadata(bool ModuleLevel) {
NextMetadataNo++);
break;
}
- case bitc::METADATA_STRING: {
+ case bitc::METADATA_STRING_OLD: {
std::string String(Record.begin(), Record.end());
// Test for upgrading !llvm.loop.
@@ -2373,6 +2373,38 @@ std::error_code BitcodeReader::parseMetadata(bool ModuleLevel) {
MetadataList.assignValue(MD, NextMetadataNo++);
break;
}
+ case bitc::METADATA_BULK_STRING_SIZES: {
+ // This is a pair of records for an MDString block: SIZES, which is a
+ // list of string lengths; and DATA, which is a blob with all the strings
+ // concatenated together.
+ //
+ // Note: since this record type was introduced after the upgrade for
+ // !llvm.loop, we don't need to change HasSeenOldLoopTags.
+ if (Record.empty())
+ return error("Invalid record: missing bulk metadata string sizes");
+
+ StringRef Blob;
+ SmallVector<uint64_t, 1> BlobRecord;
+ Code = Stream.ReadCode();
+ unsigned BlobCode = Stream.readRecord(Code, BlobRecord, &Blob);
+ if (BlobCode != bitc::METADATA_BULK_STRING_DATA)
+ return error("Invalid record: missing bulk metadata string data");
+ if (!BlobRecord.empty())
+ return error("Invalid record: unexpected bulk metadata arguments");
+
+ for (uint64_t Size : Record) {
+ if (Blob.size() < Size)
+ return error("Invalid record: not enough bulk metadata string bytes");
+
+ // Extract the current string.
+ MetadataList.assignValue(MDString::get(Context, Blob.slice(0, Size)),
+ NextMetadataNo++);
+ Blob = Blob.drop_front(Size);
+ }
+ if (!Blob.empty())
+ return error("Invalid record: too many bulk metadata string bytes");
+ break;
+ }
case bitc::METADATA_KIND: {
// Support older bitcode files that had METADATA_KIND records in a
// block with METADATA_BLOCK_ID.
diff --git a/llvm/lib/Bitcode/Reader/BitstreamReader.cpp b/llvm/lib/Bitcode/Reader/BitstreamReader.cpp
index db9e0cd63ac..43dae0c35a7 100644
--- a/llvm/lib/Bitcode/Reader/BitstreamReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitstreamReader.cpp
@@ -261,6 +261,10 @@ unsigned BitstreamCursor::readRecord(unsigned AbbrevID,
}
// Otherwise, inform the streamer that we need these bytes in memory.
+ // Skip over tail padding first. We can't do it later if this is a
+ // streaming memory object, since that could reallocate the storage that
+ // the blob pointer references.
+ JumpToBit(NewEnd);
const char *Ptr = (const char*)
BitStream->getBitcodeBytes().getPointer(CurBitPos/8, NumElts);
@@ -272,8 +276,6 @@ unsigned BitstreamCursor::readRecord(unsigned AbbrevID,
for (; NumElts; --NumElts)
Vals.push_back((unsigned char)*Ptr++);
}
- // Skip over tail padding.
- JumpToBit(NewEnd);
}
return Code;
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 5d051649699..0108667c9e2 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -1347,31 +1347,78 @@ static void writeNamedMetadata(const Module &M, const ValueEnumerator &VE,
}
}
+static unsigned createMDStringDataAbbrev(BitstreamWriter &Stream) {
+ BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_BULK_STRING_DATA));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
+ return Stream.EmitAbbrev(Abbv);
+}
+
+static void emitMDStringBlob(unsigned DataAbbrev,
+ ArrayRef<const Metadata *> Strings,
+ BitstreamWriter &Stream,
+ SmallVectorImpl<uint64_t> &Record,
+ SmallString<4096> &Blob) {
+ for (const Metadata *MD : Strings) {
+ StringRef S = cast<MDString>(MD)->getString();
+ Record.push_back(S.size());
+ Blob.append(S.begin(), S.end());
+ }
+
+ Stream.EmitRecord(bitc::METADATA_BULK_STRING_SIZES, Record);
+ Record.clear();
+
+ Record.push_back(bitc::METADATA_BULK_STRING_DATA);
+ Stream.EmitRecordWithBlob(DataAbbrev, Record, Blob);
+ Record.clear();
+}
+
+/// Write out a section of records for MDString.
+///
+/// All the MDString elements in a metadata block are emitted in bulk. They're
+/// grouped into blocks, and each block is emitted with pair of records:
+///
+/// - SIZES: a list of the sizes of the strings in the block.
+/// - DATA: the blob itself.
+static void writeMetadataStrings(ArrayRef<const Metadata *> Strings,
+ BitstreamWriter &Stream,
+ SmallVectorImpl<uint64_t> &Record) {
+ if (Strings.empty())
+ return;
+
+ // Emit strings in large blocks to reduce record overhead. Somewhat
+ // arbitrarily, limit this to 512 strings per blob:
+ // - big enough to eliminate overhead;
+ // - small enough that the reader's SIZES record will stay within a page.
+ const size_t NumStringsPerBlob = 512;
+ Record.reserve(std::min(NumStringsPerBlob, Strings.size()));
+
+ unsigned DataAbbrev = createMDStringDataAbbrev(Stream);
+ SmallString<4096> Blob;
+ while (Strings.size() > NumStringsPerBlob) {
+ emitMDStringBlob(DataAbbrev, Strings.slice(0, NumStringsPerBlob), Stream,
+ Record, Blob);
+ Strings = Strings.slice(NumStringsPerBlob);
+ }
+ if (!Strings.empty())
+ emitMDStringBlob(DataAbbrev, Strings, Stream, Record, Blob);
+}
+
static void WriteModuleMetadata(const Module &M,
const ValueEnumerator &VE,
BitstreamWriter &Stream) {
- const auto &MDs = VE.getMDs();
- if (MDs.empty() && M.named_metadata_empty())
+ if (VE.getMDs().empty() && M.named_metadata_empty())
return;
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
- unsigned MDSAbbrev = 0;
- if (VE.hasMDString()) {
- // Abbrev for METADATA_STRING.
- BitCodeAbbrev *Abbv = new BitCodeAbbrev();
- Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING));
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
- MDSAbbrev = Stream.EmitAbbrev(Abbv);
- }
-
// Initialize MDNode abbreviations.
#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
#include "llvm/IR/Metadata.def"
SmallVector<uint64_t, 64> Record;
- for (const Metadata *MD : MDs) {
+ writeMetadataStrings(VE.getMDStrings(), Stream, Record);
+ for (const Metadata *MD : VE.getNonMDStrings()) {
if (const MDNode *N = dyn_cast<MDNode>(MD)) {
assert(N->isResolved() && "Expected forward references to be resolved");
@@ -1385,17 +1432,7 @@ static void WriteModuleMetadata(const Module &M,
#include "llvm/IR/Metadata.def"
}
}
- if (const auto *MDC = dyn_cast<ConstantAsMetadata>(MD)) {
- WriteValueAsMetadata(MDC, VE, Stream, Record);
- continue;
- }
- const MDString *MDS = cast<MDString>(MD);
- // Code: [strchar x N]
- Record.append(MDS->bytes_begin(), MDS->bytes_end());
-
- // Emit the finished record.
- Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev);
- Record.clear();
+ WriteValueAsMetadata(cast<ConstantAsMetadata>(MD), VE, Stream, Record);
}
writeNamedMetadata(M, VE, Stream, Record);
diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
index 08b5e45703a..69cafb7eeee 100644
--- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -280,8 +280,7 @@ static bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) {
ValueEnumerator::ValueEnumerator(const Module &M,
bool ShouldPreserveUseListOrder)
- : HasMDString(false),
- ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
+ : ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
if (ShouldPreserveUseListOrder)
UseListOrders = predictUseListOrder(M);
@@ -375,6 +374,9 @@ ValueEnumerator::ValueEnumerator(const Module &M,
// Optimize constant ordering.
OptimizeConstants(FirstConstant, Values.size());
+
+ // Organize metadata ordering.
+ organizeMetadata();
}
unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const {
@@ -530,8 +532,8 @@ void ValueEnumerator::EnumerateMetadata(const Metadata *MD) {
EnumerateMDNodeOperands(N);
else if (auto *C = dyn_cast<ConstantAsMetadata>(MD))
EnumerateValue(C->getValue());
-
- HasMDString |= isa<MDString>(MD);
+ else
+ ++NumMDStrings;
// Replace the dummy ID inserted above with the correct one. MetadataMap may
// have changed by inserting operands, so we need a fresh lookup here.
@@ -557,6 +559,19 @@ void ValueEnumerator::EnumerateFunctionLocalMetadata(
FunctionLocalMDs.push_back(Local);
}
+void ValueEnumerator::organizeMetadata() {
+ if (!NumMDStrings)
+ return;
+
+ // Put the strings first.
+ std::stable_partition(MDs.begin(), MDs.end(),
+ [](const Metadata *MD) { return isa<MDString>(MD); });
+
+ // Renumber.
+ for (unsigned I = 0, E = MDs.size(); I != E; ++I)
+ MetadataMap[MDs[I]] = I + 1;
+}
+
void ValueEnumerator::EnumerateValue(const Value *V) {
assert(!V->getType()->isVoidTy() && "Can't insert void values!");
assert(!isa<MetadataAsValue>(V) && "EnumerateValue doesn't handle Metadata!");
diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.h b/llvm/lib/Bitcode/Writer/ValueEnumerator.h
index 7665210d014..fd09a695a99 100644
--- a/llvm/lib/Bitcode/Writer/ValueEnumerator.h
+++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.h
@@ -66,7 +66,7 @@ private:
SmallVector<const LocalAsMetadata *, 8> FunctionLocalMDs;
typedef DenseMap<const Metadata *, unsigned> MetadataMapType;
MetadataMapType MetadataMap;
- bool HasMDString;
+ unsigned NumMDStrings = 0;
bool ShouldPreserveUseListOrder;
typedef DenseMap<AttributeSet, unsigned> AttributeGroupMapType;
@@ -121,8 +121,6 @@ public:
}
unsigned numMDs() const { return MDs.size(); }
- bool hasMDString() const { return HasMDString; }
-
bool shouldPreserveUseListOrder() const { return ShouldPreserveUseListOrder; }
unsigned getTypeID(Type *T) const {
@@ -157,9 +155,16 @@ public:
const ValueList &getValues() const { return Values; }
const std::vector<const Metadata *> &getMDs() const { return MDs; }
+ ArrayRef<const Metadata *> getMDStrings() const {
+ return makeArrayRef(MDs).slice(0, NumMDStrings);
+ }
+ ArrayRef<const Metadata *> getNonMDStrings() const {
+ return makeArrayRef(MDs).slice(NumMDStrings);
+ }
const SmallVectorImpl<const LocalAsMetadata *> &getFunctionLocalMDs() const {
return FunctionLocalMDs;
}
+
const TypeList &getTypes() const { return Types; }
const std::vector<const BasicBlock*> &getBasicBlocks() const {
return BasicBlocks;
@@ -189,6 +194,10 @@ public:
private:
void OptimizeConstants(unsigned CstStart, unsigned CstEnd);
+ // Reorder the reachable metadata. This is not just an optimization, but is
+ // mandatory for emitting MDString correctly.
+ void organizeMetadata();
+
void EnumerateMDNodeOperands(const MDNode *N);
void EnumerateMetadata(const Metadata *MD);
void EnumerateFunctionLocalMetadata(const LocalAsMetadata *Local);
OpenPOWER on IntegriCloud