Line data Source code
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"
13 : #include "llvm/Support/BinaryStreamReader.h"
14 : #include "llvm/Support/BinaryStreamWriter.h"
15 :
16 : using namespace llvm;
17 : using namespace llvm::codeview;
18 :
19 36133 : Error CodeViewRecordIO::beginRecord(Optional<uint32_t> MaxLength) {
20 : RecordLimit Limit;
21 : Limit.MaxLength = MaxLength;
22 36133 : Limit.BeginOffset = getCurrentOffset();
23 36133 : Limits.push_back(Limit);
24 36133 : return Error::success();
25 : }
26 :
27 36131 : Error CodeViewRecordIO::endRecord() {
28 : assert(!Limits.empty() && "Not in a record!");
29 : Limits.pop_back();
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.
38 36131 : return Error::success();
39 : }
40 :
41 21242 : 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 21242 : Optional<uint32_t> Min = Limits.front().bytesRemaining(Offset);
50 27845 : for (auto X : makeArrayRef(Limits).drop_front()) {
51 : Optional<uint32_t> ThisMin = X.bytesRemaining(Offset);
52 6603 : if (ThisMin.hasValue())
53 6603 : Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin;
54 : }
55 : assert(Min.hasValue() && "Every field must have a maximum length!");
56 :
57 21242 : return *Min;
58 : }
59 :
60 3925 : Error CodeViewRecordIO::padToAlignment(uint32_t Align) {
61 3925 : if (isReading())
62 2701 : return Reader->padToAlignment(Align);
63 1224 : return Writer->padToAlignment(Align);
64 : }
65 :
66 9222 : Error CodeViewRecordIO::skipPadding() {
67 : assert(!isWriting() && "Cannot skip padding while writing!");
68 :
69 18444 : if (Reader->bytesRemaining() == 0)
70 : return Error::success();
71 :
72 8947 : uint8_t Leaf = Reader->peek();
73 8947 : 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 3517 : unsigned BytesToAdvance = Leaf & 0x0F;
78 3517 : return Reader->skip(BytesToAdvance);
79 : }
80 :
81 1040 : Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes) {
82 1040 : if (isWriting()) {
83 4 : if (auto EC = Writer->writeBytes(Bytes))
84 : return EC;
85 : } else {
86 2076 : if (auto EC = Reader->readBytes(Bytes, Reader->bytesRemaining()))
87 : return EC;
88 : }
89 : return Error::success();
90 : }
91 :
92 32 : Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes) {
93 : ArrayRef<uint8_t> BytesRef(Bytes);
94 64 : if (auto EC = mapByteVectorTail(BytesRef))
95 : return EC;
96 32 : if (!isWriting())
97 31 : Bytes.assign(BytesRef.begin(), BytesRef.end());
98 :
99 : return Error::success();
100 : }
101 :
102 35675 : Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) {
103 35675 : if (isWriting()) {
104 20877 : if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
105 : return EC;
106 : return Error::success();
107 : }
108 :
109 : uint32_t I;
110 57432 : if (auto EC = Reader->readInteger(I))
111 : return EC;
112 28716 : TypeInd.setIndex(I);
113 : return Error::success();
114 : }
115 :
116 0 : Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value) {
117 0 : if (isWriting()) {
118 0 : if (Value >= 0) {
119 0 : if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
120 : return EC;
121 : } else {
122 0 : if (auto EC = writeEncodedSignedInteger(Value))
123 : return EC;
124 : }
125 : } else {
126 : APSInt N;
127 0 : if (auto EC = consume(*Reader, N))
128 : return EC;
129 0 : Value = N.getExtValue();
130 : }
131 :
132 : return Error::success();
133 : }
134 :
135 4750 : Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value) {
136 4750 : if (isWriting()) {
137 1540 : if (auto EC = writeEncodedUnsignedInteger(Value))
138 : return EC;
139 : } else {
140 : APSInt N;
141 7960 : if (auto EC = consume(*Reader, N))
142 : return EC;
143 3980 : Value = N.getZExtValue();
144 : }
145 : return Error::success();
146 : }
147 :
148 13034 : Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value) {
149 13034 : if (isWriting()) {
150 6096 : if (Value.isSigned())
151 0 : return writeEncodedSignedInteger(Value.getSExtValue());
152 6096 : return writeEncodedUnsignedInteger(Value.getZExtValue());
153 : }
154 :
155 6938 : return consume(*Reader, Value);
156 : }
157 :
158 29001 : Error CodeViewRecordIO::mapStringZ(StringRef &Value) {
159 29001 : if (isWriting()) {
160 : // Truncate if we attempt to write too much.
161 10088 : StringRef S = Value.take_front(maxFieldLength() - 1);
162 20176 : if (auto EC = Writer->writeCString(S))
163 : return EC;
164 : } else {
165 37826 : if (auto EC = Reader->readCString(Value))
166 : return EC;
167 : }
168 : return Error::success();
169 : }
170 :
171 20 : Error CodeViewRecordIO::mapGuid(GUID &Guid) {
172 : constexpr uint32_t GuidSize = 16;
173 20 : if (maxFieldLength() < GuidSize)
174 : return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
175 :
176 20 : if (isWriting()) {
177 20 : if (auto EC = Writer->writeBytes(Guid.Guid))
178 : return EC;
179 : } else {
180 10 : ArrayRef<uint8_t> GuidBytes;
181 20 : if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
182 : return EC;
183 10 : memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
184 : }
185 : return Error::success();
186 : }
187 :
188 111 : Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) {
189 111 : if (isWriting()) {
190 799 : for (auto V : Value) {
191 1420 : if (auto EC = mapStringZ(V))
192 : return EC;
193 : }
194 178 : if (auto EC = Writer->writeInteger<uint8_t>(0))
195 : return EC;
196 : } else {
197 22 : StringRef S;
198 44 : if (auto EC = mapStringZ(S))
199 : return EC;
200 184 : while (!S.empty()) {
201 162 : Value.push_back(S);
202 324 : if (auto EC = mapStringZ(S))
203 : return EC;
204 : };
205 : }
206 : return Error::success();
207 : }
208 :
209 0 : Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
210 : assert(Value < 0 && "Encoded integer is not signed!");
211 0 : if (Value >= std::numeric_limits<int8_t>::min()) {
212 0 : if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
213 : return EC;
214 0 : if (auto EC = Writer->writeInteger<int8_t>(Value))
215 : return EC;
216 0 : } else if (Value >= std::numeric_limits<int16_t>::min()) {
217 0 : if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT))
218 : return EC;
219 0 : if (auto EC = Writer->writeInteger<int16_t>(Value))
220 : return EC;
221 0 : } else if (Value >= std::numeric_limits<int32_t>::min()) {
222 0 : if (auto EC = Writer->writeInteger<uint16_t>(LF_LONG))
223 : return EC;
224 0 : if (auto EC = Writer->writeInteger<int32_t>(Value))
225 : return EC;
226 : } else {
227 0 : if (auto EC = Writer->writeInteger<uint16_t>(LF_QUADWORD))
228 : return EC;
229 0 : if (auto EC = Writer->writeInteger(Value))
230 : return EC;
231 : }
232 : return Error::success();
233 : }
234 :
235 6866 : Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) {
236 6866 : if (Value < LF_NUMERIC) {
237 13534 : if (auto EC = Writer->writeInteger<uint16_t>(Value))
238 : return EC;
239 99 : } else if (Value <= std::numeric_limits<uint16_t>::max()) {
240 14 : if (auto EC = Writer->writeInteger<uint16_t>(LF_USHORT))
241 : return EC;
242 14 : if (auto EC = Writer->writeInteger<uint16_t>(Value))
243 : return EC;
244 92 : } else if (Value <= std::numeric_limits<uint32_t>::max()) {
245 182 : if (auto EC = Writer->writeInteger<uint16_t>(LF_ULONG))
246 : return EC;
247 182 : if (auto EC = Writer->writeInteger<uint32_t>(Value))
248 : return EC;
249 : } else {
250 2 : if (auto EC = Writer->writeInteger<uint16_t>(LF_UQUADWORD))
251 : return EC;
252 2 : if (auto EC = Writer->writeInteger(Value))
253 : return EC;
254 : }
255 :
256 : return Error::success();
257 : }
|
