|
120
|
1 //===- CodeViewRecordIO.cpp -------------------------------------*- C++ -*-===//
|
|
|
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/CodeView/CodeViewRecordIO.h"
|
|
|
11 #include "llvm/DebugInfo/CodeView/CodeView.h"
|
|
|
12 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
|
|
121
|
13 #include "llvm/Support/BinaryStreamReader.h"
|
|
|
14 #include "llvm/Support/BinaryStreamWriter.h"
|
|
120
|
15
|
|
|
16 using namespace llvm;
|
|
|
17 using namespace llvm::codeview;
|
|
|
18
|
|
|
19 Error CodeViewRecordIO::beginRecord(Optional<uint32_t> MaxLength) {
|
|
|
20 RecordLimit Limit;
|
|
|
21 Limit.MaxLength = MaxLength;
|
|
|
22 Limit.BeginOffset = getCurrentOffset();
|
|
|
23 Limits.push_back(Limit);
|
|
|
24 return Error::success();
|
|
|
25 }
|
|
|
26
|
|
|
27 Error CodeViewRecordIO::endRecord() {
|
|
|
28 assert(!Limits.empty() && "Not in a record!");
|
|
|
29 Limits.pop_back();
|
|
121
|
30 // We would like to assert that we actually read / wrote all the bytes that we
|
|
|
31 // expected to for this record, but unfortunately we can't do this. Some
|
|
|
32 // producers such as MASM over-allocate for certain types of records and
|
|
|
33 // commit the extraneous data, so when reading we can't be sure every byte
|
|
|
34 // will have been read. And when writing we over-allocate temporarily since
|
|
|
35 // we don't know how big the record is until we're finished writing it, so
|
|
|
36 // even though we don't commit the extraneous data, we still can't guarantee
|
|
|
37 // we're at the end of the allocated data.
|
|
120
|
38 return Error::success();
|
|
|
39 }
|
|
|
40
|
|
|
41 uint32_t CodeViewRecordIO::maxFieldLength() const {
|
|
|
42 assert(!Limits.empty() && "Not in a record!");
|
|
|
43
|
|
|
44 // The max length of the next field is the minimum of all lengths that would
|
|
|
45 // be allowed by any of the sub-records we're in. In practice, we can only
|
|
|
46 // ever be at most 1 sub-record deep (in a FieldList), but this works for
|
|
|
47 // the general case.
|
|
|
48 uint32_t Offset = getCurrentOffset();
|
|
|
49 Optional<uint32_t> Min = Limits.front().bytesRemaining(Offset);
|
|
|
50 for (auto X : makeArrayRef(Limits).drop_front()) {
|
|
|
51 Optional<uint32_t> ThisMin = X.bytesRemaining(Offset);
|
|
|
52 if (ThisMin.hasValue())
|
|
|
53 Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin;
|
|
|
54 }
|
|
|
55 assert(Min.hasValue() && "Every field must have a maximum length!");
|
|
|
56
|
|
|
57 return *Min;
|
|
|
58 }
|
|
|
59
|
|
121
|
60 Error CodeViewRecordIO::padToAlignment(uint32_t Align) {
|
|
|
61 if (isReading())
|
|
|
62 return Reader->padToAlignment(Align);
|
|
|
63 return Writer->padToAlignment(Align);
|
|
|
64 }
|
|
|
65
|
|
120
|
66 Error CodeViewRecordIO::skipPadding() {
|
|
|
67 assert(!isWriting() && "Cannot skip padding while writing!");
|
|
|
68
|
|
|
69 if (Reader->bytesRemaining() == 0)
|
|
|
70 return Error::success();
|
|
|
71
|
|
|
72 uint8_t Leaf = Reader->peek();
|
|
|
73 if (Leaf < LF_PAD0)
|
|
|
74 return Error::success();
|
|
|
75 // Leaf is greater than 0xf0. We should advance by the number of bytes in
|
|
|
76 // the low 4 bits.
|
|
|
77 unsigned BytesToAdvance = Leaf & 0x0F;
|
|
|
78 return Reader->skip(BytesToAdvance);
|
|
|
79 }
|
|
|
80
|
|
|
81 Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes) {
|
|
|
82 if (isWriting()) {
|
|
|
83 if (auto EC = Writer->writeBytes(Bytes))
|
|
|
84 return EC;
|
|
|
85 } else {
|
|
|
86 if (auto EC = Reader->readBytes(Bytes, Reader->bytesRemaining()))
|
|
|
87 return EC;
|
|
|
88 }
|
|
|
89 return Error::success();
|
|
|
90 }
|
|
|
91
|
|
121
|
92 Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes) {
|
|
|
93 ArrayRef<uint8_t> BytesRef(Bytes);
|
|
|
94 if (auto EC = mapByteVectorTail(BytesRef))
|
|
|
95 return EC;
|
|
|
96 if (!isWriting())
|
|
|
97 Bytes.assign(BytesRef.begin(), BytesRef.end());
|
|
|
98
|
|
|
99 return Error::success();
|
|
|
100 }
|
|
|
101
|
|
120
|
102 Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) {
|
|
|
103 if (isWriting()) {
|
|
|
104 if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
|
|
|
105 return EC;
|
|
|
106 return Error::success();
|
|
|
107 }
|
|
|
108
|
|
|
109 uint32_t I;
|
|
|
110 if (auto EC = Reader->readInteger(I))
|
|
|
111 return EC;
|
|
|
112 TypeInd.setIndex(I);
|
|
|
113 return Error::success();
|
|
|
114 }
|
|
|
115
|
|
|
116 Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value) {
|
|
|
117 if (isWriting()) {
|
|
|
118 if (Value >= 0) {
|
|
|
119 if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
|
|
|
120 return EC;
|
|
|
121 } else {
|
|
|
122 if (auto EC = writeEncodedSignedInteger(Value))
|
|
|
123 return EC;
|
|
|
124 }
|
|
|
125 } else {
|
|
|
126 APSInt N;
|
|
|
127 if (auto EC = consume(*Reader, N))
|
|
|
128 return EC;
|
|
|
129 Value = N.getExtValue();
|
|
|
130 }
|
|
|
131
|
|
|
132 return Error::success();
|
|
|
133 }
|
|
|
134
|
|
|
135 Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value) {
|
|
|
136 if (isWriting()) {
|
|
|
137 if (auto EC = writeEncodedUnsignedInteger(Value))
|
|
|
138 return EC;
|
|
|
139 } else {
|
|
|
140 APSInt N;
|
|
|
141 if (auto EC = consume(*Reader, N))
|
|
|
142 return EC;
|
|
|
143 Value = N.getZExtValue();
|
|
|
144 }
|
|
|
145 return Error::success();
|
|
|
146 }
|
|
|
147
|
|
|
148 Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value) {
|
|
|
149 if (isWriting()) {
|
|
|
150 if (Value.isSigned())
|
|
|
151 return writeEncodedSignedInteger(Value.getSExtValue());
|
|
|
152 return writeEncodedUnsignedInteger(Value.getZExtValue());
|
|
|
153 }
|
|
|
154
|
|
|
155 return consume(*Reader, Value);
|
|
|
156 }
|
|
|
157
|
|
|
158 Error CodeViewRecordIO::mapStringZ(StringRef &Value) {
|
|
|
159 if (isWriting()) {
|
|
|
160 // Truncate if we attempt to write too much.
|
|
|
161 StringRef S = Value.take_front(maxFieldLength() - 1);
|
|
121
|
162 if (auto EC = Writer->writeCString(S))
|
|
120
|
163 return EC;
|
|
|
164 } else {
|
|
121
|
165 if (auto EC = Reader->readCString(Value))
|
|
120
|
166 return EC;
|
|
|
167 }
|
|
|
168 return Error::success();
|
|
|
169 }
|
|
|
170
|
|
121
|
171 Error CodeViewRecordIO::mapGuid(GUID &Guid) {
|
|
120
|
172 constexpr uint32_t GuidSize = 16;
|
|
|
173 if (maxFieldLength() < GuidSize)
|
|
|
174 return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
|
|
|
175
|
|
|
176 if (isWriting()) {
|
|
121
|
177 if (auto EC = Writer->writeBytes(Guid.Guid))
|
|
120
|
178 return EC;
|
|
|
179 } else {
|
|
121
|
180 ArrayRef<uint8_t> GuidBytes;
|
|
|
181 if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
|
|
120
|
182 return EC;
|
|
121
|
183 memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
|
|
|
184 }
|
|
|
185 return Error::success();
|
|
|
186 }
|
|
|
187
|
|
|
188 Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) {
|
|
|
189 if (isWriting()) {
|
|
|
190 for (auto V : Value) {
|
|
|
191 if (auto EC = mapStringZ(V))
|
|
|
192 return EC;
|
|
|
193 }
|
|
|
194 if (auto EC = Writer->writeInteger<uint8_t>(0))
|
|
|
195 return EC;
|
|
|
196 } else {
|
|
|
197 StringRef S;
|
|
|
198 if (auto EC = mapStringZ(S))
|
|
|
199 return EC;
|
|
|
200 while (!S.empty()) {
|
|
|
201 Value.push_back(S);
|
|
|
202 if (auto EC = mapStringZ(S))
|
|
|
203 return EC;
|
|
|
204 };
|
|
120
|
205 }
|
|
|
206 return Error::success();
|
|
|
207 }
|
|
|
208
|
|
|
209 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
|
|
|
210 assert(Value < 0 && "Encoded integer is not signed!");
|
|
|
211 if (Value >= std::numeric_limits<int8_t>::min()) {
|
|
121
|
212 if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
|
|
120
|
213 return EC;
|
|
121
|
214 if (auto EC = Writer->writeInteger<int8_t>(Value))
|
|
120
|
215 return EC;
|
|
|
216 } else if (Value >= std::numeric_limits<int16_t>::min()) {
|
|
121
|
217 if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT))
|
|
120
|
218 return EC;
|
|
121
|
219 if (auto EC = Writer->writeInteger<int16_t>(Value))
|
|
120
|
220 return EC;
|
|
|
221 } else if (Value >= std::numeric_limits<int32_t>::min()) {
|
|
121
|
222 if (auto EC = Writer->writeInteger<uint16_t>(LF_LONG))
|
|
120
|
223 return EC;
|
|
121
|
224 if (auto EC = Writer->writeInteger<int32_t>(Value))
|
|
120
|
225 return EC;
|
|
|
226 } else {
|
|
121
|
227 if (auto EC = Writer->writeInteger<uint16_t>(LF_QUADWORD))
|
|
120
|
228 return EC;
|
|
|
229 if (auto EC = Writer->writeInteger(Value))
|
|
|
230 return EC;
|
|
|
231 }
|
|
|
232 return Error::success();
|
|
|
233 }
|
|
|
234
|
|
|
235 Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) {
|
|
|
236 if (Value < LF_NUMERIC) {
|
|
121
|
237 if (auto EC = Writer->writeInteger<uint16_t>(Value))
|
|
120
|
238 return EC;
|
|
|
239 } else if (Value <= std::numeric_limits<uint16_t>::max()) {
|
|
121
|
240 if (auto EC = Writer->writeInteger<uint16_t>(LF_USHORT))
|
|
120
|
241 return EC;
|
|
121
|
242 if (auto EC = Writer->writeInteger<uint16_t>(Value))
|
|
120
|
243 return EC;
|
|
|
244 } else if (Value <= std::numeric_limits<uint32_t>::max()) {
|
|
121
|
245 if (auto EC = Writer->writeInteger<uint16_t>(LF_ULONG))
|
|
120
|
246 return EC;
|
|
121
|
247 if (auto EC = Writer->writeInteger<uint32_t>(Value))
|
|
120
|
248 return EC;
|
|
|
249 } else {
|
|
121
|
250 if (auto EC = Writer->writeInteger<uint16_t>(LF_UQUADWORD))
|
|
120
|
251 return EC;
|
|
|
252 if (auto EC = Writer->writeInteger(Value))
|
|
|
253 return EC;
|
|
|
254 }
|
|
|
255
|
|
|
256 return Error::success();
|
|
|
257 }
|
