}
};
- typedef SmallVector<MutableArrayRef<uint8_t>, 2> MutableRecordList;
- typedef SmallVector<ArrayRef<uint8_t>, 2> RecordList;
+ typedef SmallVector<MutableArrayRef<uint8_t>, 2> RecordList;
static constexpr uint8_t ContinuationLength = 8;
BumpPtrAllocator &RecordStorage;
RecordSegment CurrentSegment;
- MutableRecordList FieldListSegments;
+ RecordList FieldListSegments;
TypeIndex LastTypeIndex;
Optional<TypeLeafKind> TypeKind;
TypeRecordMapping Mapping;
RecordList SeenRecords;
- StringMap<TypeIndex, BumpPtrAllocator&> HashedRecords;
+ StringMap<TypeIndex> HashedRecords;
bool isInFieldList() const;
TypeIndex calcNextTypeIndex() const;
MutableArrayRef<uint8_t> getCurrentSubRecordData();
MutableArrayRef<uint8_t> getCurrentRecordData();
Error writeRecordPrefix(TypeLeafKind Kind);
- TypeIndex insertRecordBytesPrivate(ArrayRef<uint8_t> &Record);
+ TypeIndex insertRecordBytesPrivate(MutableArrayRef<uint8_t> Record);
+ TypeIndex insertRecordBytesWithCopy(CVType &Record,
+ MutableArrayRef<uint8_t> Data);
Expected<MutableArrayRef<uint8_t>>
addPadding(MutableArrayRef<uint8_t> Record);
public:
explicit TypeSerializer(BumpPtrAllocator &Storage);
- ArrayRef<ArrayRef<uint8_t>> records() const;
+ ArrayRef<MutableArrayRef<uint8_t>> records() const;
TypeIndex getLastTypeIndex() const;
- TypeIndex insertRecordBytes(ArrayRef<uint8_t> Record);
+ TypeIndex insertRecordBytes(MutableArrayRef<uint8_t> Record);
Expected<TypeIndex> visitTypeEndGetIndex(CVType &Record);
Error visitTypeBegin(CVType &Record) override;
}
TypeIndex
-TypeSerializer::insertRecordBytesPrivate(ArrayRef<uint8_t> &Record) {
+TypeSerializer::insertRecordBytesPrivate(MutableArrayRef<uint8_t> Record) {
assert(Record.size() % 4 == 0 && "Record is not aligned to 4 bytes!");
StringRef S(reinterpret_cast<const char *>(Record.data()), Record.size());
TypeIndex NextTypeIndex = calcNextTypeIndex();
auto Result = HashedRecords.try_emplace(S, NextTypeIndex);
-
- StringRef NewData = Result.first->getKey();
- Record = ArrayRef<uint8_t>(NewData.bytes_begin(), NewData.bytes_end());
-
if (Result.second) {
- // If this triggered an insert into the map, store the bytes.
LastTypeIndex = NextTypeIndex;
SeenRecords.push_back(Record);
}
-
return Result.first->getValue();
}
+TypeIndex
+TypeSerializer::insertRecordBytesWithCopy(CVType &Record,
+ MutableArrayRef<uint8_t> Data) {
+ assert(Data.size() % 4 == 0 && "Record is not aligned to 4 bytes!");
+
+ StringRef S(reinterpret_cast<const char *>(Data.data()), Data.size());
+
+ // Do a two state lookup / insert so that we don't have to allocate unless
+ // we're going
+ // to do an insert. This is a big memory savings.
+ auto Iter = HashedRecords.find(S);
+ if (Iter != HashedRecords.end())
+ return Iter->second;
+
+ LastTypeIndex = calcNextTypeIndex();
+ uint8_t *Copy = RecordStorage.Allocate<uint8_t>(Data.size());
+ ::memcpy(Copy, Data.data(), Data.size());
+ Data = MutableArrayRef<uint8_t>(Copy, Data.size());
+ S = StringRef(reinterpret_cast<const char *>(Data.data()), Data.size());
+ HashedRecords.insert(std::make_pair(S, LastTypeIndex));
+ SeenRecords.push_back(Data);
+ Record.RecordData = Data;
+ return LastTypeIndex;
+}
+
Expected<MutableArrayRef<uint8_t>>
TypeSerializer::addPadding(MutableArrayRef<uint8_t> Record) {
uint32_t Align = Record.size() % 4;
: RecordStorage(Storage), LastTypeIndex(),
RecordBuffer(MaxRecordLength * 2),
Stream(RecordBuffer, llvm::support::little), Writer(Stream),
- Mapping(Writer), HashedRecords(Storage) {
+ Mapping(Writer) {
// RecordBuffer needs to be able to hold enough data so that if we are 1
// byte short of MaxRecordLen, and then we try to write MaxRecordLen bytes,
// we won't overflow.
}
-ArrayRef<ArrayRef<uint8_t>> TypeSerializer::records() const {
+ArrayRef<MutableArrayRef<uint8_t>> TypeSerializer::records() const {
return SeenRecords;
}
TypeIndex TypeSerializer::getLastTypeIndex() const { return LastTypeIndex; }
-TypeIndex TypeSerializer::insertRecordBytes(ArrayRef<uint8_t> Record) {
+TypeIndex TypeSerializer::insertRecordBytes(MutableArrayRef<uint8_t> Record) {
assert(!TypeKind.hasValue() && "Already in a type mapping!");
assert(Writer.getOffset() == 0 && "Stream has data already!");
Prefix->RecordLen = ThisRecordData.size() - sizeof(uint16_t);
Record.Type = *TypeKind;
- Record.RecordData = ThisRecordData;
- TypeIndex InsertedTypeIndex = insertRecordBytesPrivate(Record.RecordData);
+ TypeIndex InsertedTypeIndex =
+ insertRecordBytesWithCopy(Record, ThisRecordData);
// Write out each additional segment in reverse order, and update each
// record's continuation index to point to the previous one.