• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
beginRecord(Optional<uint32_t> MaxLength)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 
endRecord()27 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   return Error::success();
39 }
40 
maxFieldLength() const41 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 
padToAlignment(uint32_t Align)60 Error CodeViewRecordIO::padToAlignment(uint32_t Align) {
61   if (isReading())
62     return Reader->padToAlignment(Align);
63   return Writer->padToAlignment(Align);
64 }
65 
skipPadding()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 
mapByteVectorTail(ArrayRef<uint8_t> & Bytes)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 
mapByteVectorTail(std::vector<uint8_t> & Bytes)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 
mapInteger(TypeIndex & TypeInd)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 
mapEncodedInteger(int64_t & Value)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 
mapEncodedInteger(uint64_t & Value)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 
mapEncodedInteger(APSInt & Value)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 
mapStringZ(StringRef & Value)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);
162     if (auto EC = Writer->writeCString(S))
163       return EC;
164   } else {
165     if (auto EC = Reader->readCString(Value))
166       return EC;
167   }
168   return Error::success();
169 }
170 
mapGuid(GUID & Guid)171 Error CodeViewRecordIO::mapGuid(GUID &Guid) {
172   constexpr uint32_t GuidSize = 16;
173   if (maxFieldLength() < GuidSize)
174     return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
175 
176   if (isWriting()) {
177     if (auto EC = Writer->writeBytes(Guid.Guid))
178       return EC;
179   } else {
180     ArrayRef<uint8_t> GuidBytes;
181     if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
182       return EC;
183     memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
184   }
185   return Error::success();
186 }
187 
mapStringZVectorZ(std::vector<StringRef> & Value)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     };
205   }
206   return Error::success();
207 }
208 
writeEncodedSignedInteger(const int64_t & Value)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()) {
212     if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
213       return EC;
214     if (auto EC = Writer->writeInteger<int8_t>(Value))
215       return EC;
216   } else if (Value >= std::numeric_limits<int16_t>::min()) {
217     if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT))
218       return EC;
219     if (auto EC = Writer->writeInteger<int16_t>(Value))
220       return EC;
221   } else if (Value >= std::numeric_limits<int32_t>::min()) {
222     if (auto EC = Writer->writeInteger<uint16_t>(LF_LONG))
223       return EC;
224     if (auto EC = Writer->writeInteger<int32_t>(Value))
225       return EC;
226   } else {
227     if (auto EC = Writer->writeInteger<uint16_t>(LF_QUADWORD))
228       return EC;
229     if (auto EC = Writer->writeInteger(Value))
230       return EC;
231   }
232   return Error::success();
233 }
234 
writeEncodedUnsignedInteger(const uint64_t & Value)235 Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) {
236   if (Value < LF_NUMERIC) {
237     if (auto EC = Writer->writeInteger<uint16_t>(Value))
238       return EC;
239   } else if (Value <= std::numeric_limits<uint16_t>::max()) {
240     if (auto EC = Writer->writeInteger<uint16_t>(LF_USHORT))
241       return EC;
242     if (auto EC = Writer->writeInteger<uint16_t>(Value))
243       return EC;
244   } else if (Value <= std::numeric_limits<uint32_t>::max()) {
245     if (auto EC = Writer->writeInteger<uint16_t>(LF_ULONG))
246       return EC;
247     if (auto EC = Writer->writeInteger<uint32_t>(Value))
248       return EC;
249   } else {
250     if (auto EC = Writer->writeInteger<uint16_t>(LF_UQUADWORD))
251       return EC;
252     if (auto EC = Writer->writeInteger(Value))
253       return EC;
254   }
255 
256   return Error::success();
257 }
258