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