blob: c7ba32b82bc6be11e9a6e62d17bcb428dfcb2add (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
//===- NamedStreamMap.cpp - PDB Named Stream Map ----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/Native/NamedStreamMap.h"
#include "llvm/ADT/SparseBitVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/DebugInfo/PDB/Native/HashTable.h"
#include "llvm/DebugInfo/PDB/Native/RawError.h"
#include "llvm/Support/BinaryStreamReader.h"
#include "llvm/Support/Error.h"
#include <algorithm>
#include <cstdint>
using namespace llvm;
using namespace llvm::pdb;
NamedStreamMap::NamedStreamMap() = default;
Error NamedStreamMap::load(BinaryStreamReader &Stream) {
Mapping.clear();
FinalizedHashTable.clear();
FinalizedInfo.reset();
uint32_t StringBufferSize;
if (auto EC = Stream.readInteger(StringBufferSize))
return joinErrors(std::move(EC),
make_error<RawError>(raw_error_code::corrupt_file,
"Expected string buffer size"));
BinaryStreamRef StringsBuffer;
if (auto EC = Stream.readStreamRef(StringsBuffer, StringBufferSize))
return EC;
HashTable OffsetIndexMap;
if (auto EC = OffsetIndexMap.load(Stream))
return EC;
uint32_t NameOffset;
uint32_t NameIndex;
for (const auto &Entry : OffsetIndexMap) {
std::tie(NameOffset, NameIndex) = Entry;
// Compute the offset of the start of the string relative to the stream.
BinaryStreamReader NameReader(StringsBuffer);
NameReader.setOffset(NameOffset);
// Pump out our c-string from the stream.
StringRef Str;
if (auto EC = NameReader.readCString(Str))
return joinErrors(std::move(EC),
make_error<RawError>(raw_error_code::corrupt_file,
"Expected name map name"));
// Add this to a string-map from name to stream number.
Mapping.insert({Str, NameIndex});
}
return Error::success();
}
Error NamedStreamMap::commit(BinaryStreamWriter &Writer) const {
assert(FinalizedInfo.hasValue());
// The first field is the number of bytes of string data.
if (auto EC = Writer.writeInteger(FinalizedInfo->StringDataBytes))
return EC;
// Now all of the string data itself.
for (const auto &Item : Mapping) {
if (auto EC = Writer.writeCString(Item.getKey()))
return EC;
}
// And finally the Offset Index map.
if (auto EC = FinalizedHashTable.commit(Writer))
return EC;
return Error::success();
}
uint32_t NamedStreamMap::finalize() {
if (FinalizedInfo.hasValue())
return FinalizedInfo->SerializedLength;
// Build the finalized hash table.
FinalizedHashTable.clear();
FinalizedInfo.emplace();
for (const auto &Item : Mapping) {
FinalizedHashTable.set(FinalizedInfo->StringDataBytes, Item.getValue());
FinalizedInfo->StringDataBytes += Item.getKeyLength() + 1;
}
// Number of bytes of string data.
FinalizedInfo->SerializedLength += sizeof(support::ulittle32_t);
// Followed by that many actual bytes of string data.
FinalizedInfo->SerializedLength += FinalizedInfo->StringDataBytes;
// Followed by the mapping from Offset to Index.
FinalizedInfo->SerializedLength +=
FinalizedHashTable.calculateSerializedLength();
return FinalizedInfo->SerializedLength;
}
iterator_range<StringMapConstIterator<uint32_t>>
NamedStreamMap::entries() const {
return make_range<StringMapConstIterator<uint32_t>>(Mapping.begin(),
Mapping.end());
}
uint32_t NamedStreamMap::size() const { return Mapping.size(); }
bool NamedStreamMap::get(StringRef Stream, uint32_t &StreamNo) const {
auto Iter = Mapping.find(Stream);
if (Iter == Mapping.end())
return false;
StreamNo = Iter->second;
return true;
}
void NamedStreamMap::set(StringRef Stream, uint32_t StreamNo) {
FinalizedInfo.reset();
Mapping[Stream] = StreamNo;
}
void NamedStreamMap::remove(StringRef Stream) {
FinalizedInfo.reset();
Mapping.erase(Stream);
}
|
