LLVM  10.0.0svn
CodeViewRecordIO.cpp
Go to the documentation of this file.
1 //===- CodeViewRecordIO.cpp -------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
14 
15 using namespace llvm;
16 using namespace llvm::codeview;
17 
19  RecordLimit Limit;
20  Limit.MaxLength = MaxLength;
21  Limit.BeginOffset = getCurrentOffset();
22  Limits.push_back(Limit);
23  return Error::success();
24 }
25 
27  assert(!Limits.empty() && "Not in a record!");
28  Limits.pop_back();
29  // We would like to assert that we actually read / wrote all the bytes that we
30  // expected to for this record, but unfortunately we can't do this. Some
31  // producers such as MASM over-allocate for certain types of records and
32  // commit the extraneous data, so when reading we can't be sure every byte
33  // will have been read. And when writing we over-allocate temporarily since
34  // we don't know how big the record is until we're finished writing it, so
35  // even though we don't commit the extraneous data, we still can't guarantee
36  // we're at the end of the allocated data.
37 
38  if (isStreaming()) {
39  // For streaming mode, add padding to align with 4 byte boundaries for each
40  // record
42  if (Align == 0)
43  return Error::success();
44 
45  int PaddingBytes = 4 - Align;
46  while (PaddingBytes > 0) {
47  char Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes);
48  StringRef BytesSR = StringRef(&Pad, sizeof(Pad));
49  Streamer->EmitBytes(BytesSR);
50  --PaddingBytes;
51  }
52  resetStreamedLen();
53  }
54  return Error::success();
55 }
56 
58  if (isStreaming())
59  return 0;
60 
61  assert(!Limits.empty() && "Not in a record!");
62 
63  // The max length of the next field is the minimum of all lengths that would
64  // be allowed by any of the sub-records we're in. In practice, we can only
65  // ever be at most 1 sub-record deep (in a FieldList), but this works for
66  // the general case.
67  uint32_t Offset = getCurrentOffset();
68  Optional<uint32_t> Min = Limits.front().bytesRemaining(Offset);
69  for (auto X : makeArrayRef(Limits).drop_front()) {
70  Optional<uint32_t> ThisMin = X.bytesRemaining(Offset);
71  if (ThisMin.hasValue())
72  Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin;
73  }
74  assert(Min.hasValue() && "Every field must have a maximum length!");
75 
76  return *Min;
77 }
78 
80  if (isReading())
81  return Reader->padToAlignment(Align);
82  return Writer->padToAlignment(Align);
83 }
84 
86  assert(!isWriting() && "Cannot skip padding while writing!");
87 
88  if (Reader->bytesRemaining() == 0)
89  return Error::success();
90 
91  uint8_t Leaf = Reader->peek();
92  if (Leaf < LF_PAD0)
93  return Error::success();
94  // Leaf is greater than 0xf0. We should advance by the number of bytes in
95  // the low 4 bits.
96  unsigned BytesToAdvance = Leaf & 0x0F;
97  return Reader->skip(BytesToAdvance);
98 }
99 
101  const Twine &Comment) {
102  if (isStreaming()) {
103  emitComment(Comment);
104  Streamer->EmitBinaryData(toStringRef(Bytes));
105  incrStreamedLen(Bytes.size());
106  } else if (isWriting()) {
107  if (auto EC = Writer->writeBytes(Bytes))
108  return EC;
109  } else {
110  if (auto EC = Reader->readBytes(Bytes, Reader->bytesRemaining()))
111  return EC;
112  }
113  return Error::success();
114 }
115 
116 Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes,
117  const Twine &Comment) {
118  ArrayRef<uint8_t> BytesRef(Bytes);
119  if (auto EC = mapByteVectorTail(BytesRef, Comment))
120  return EC;
121  if (!isWriting())
122  Bytes.assign(BytesRef.begin(), BytesRef.end());
123 
124  return Error::success();
125 }
126 
128  if (isStreaming()) {
129  emitComment(Comment);
130  Streamer->EmitIntValue(TypeInd.getIndex(), sizeof(TypeInd.getIndex()));
131  incrStreamedLen(sizeof(TypeInd.getIndex()));
132  } else if (isWriting()) {
133  if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
134  return EC;
135  } else {
136  uint32_t I;
137  if (auto EC = Reader->readInteger(I))
138  return EC;
139  TypeInd.setIndex(I);
140  }
141  return Error::success();
142 }
143 
145  const Twine &Comment) {
146  if (isStreaming()) {
147  if (Value >= 0)
148  emitEncodedUnsignedInteger(static_cast<uint64_t>(Value), Comment);
149  else
150  emitEncodedSignedInteger(Value, Comment);
151  } else if (isWriting()) {
152  if (Value >= 0) {
153  if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
154  return EC;
155  } else {
156  if (auto EC = writeEncodedSignedInteger(Value))
157  return EC;
158  }
159  } else {
160  APSInt N;
161  if (auto EC = consume(*Reader, N))
162  return EC;
163  Value = N.getExtValue();
164  }
165 
166  return Error::success();
167 }
168 
170  const Twine &Comment) {
171  if (isStreaming())
172  emitEncodedUnsignedInteger(Value, Comment);
173  else if (isWriting()) {
174  if (auto EC = writeEncodedUnsignedInteger(Value))
175  return EC;
176  } else {
177  APSInt N;
178  if (auto EC = consume(*Reader, N))
179  return EC;
180  Value = N.getZExtValue();
181  }
182  return Error::success();
183 }
184 
186  if (isStreaming()) {
187  if (Value.isSigned())
188  emitEncodedSignedInteger(Value.getSExtValue(), Comment);
189  else
190  emitEncodedUnsignedInteger(Value.getZExtValue(), Comment);
191  } else if (isWriting()) {
192  if (Value.isSigned())
193  return writeEncodedSignedInteger(Value.getSExtValue());
194  return writeEncodedUnsignedInteger(Value.getZExtValue());
195  } else
196  return consume(*Reader, Value);
197  return Error::success();
198 }
199 
201  if (isStreaming()) {
202  auto NullTerminatedString = StringRef(Value.data(), Value.size() + 1);
203  emitComment(Comment);
204  Streamer->EmitBytes(NullTerminatedString);
205  incrStreamedLen(NullTerminatedString.size());
206  } else if (isWriting()) {
207  // Truncate if we attempt to write too much.
208  StringRef S = Value.take_front(maxFieldLength() - 1);
209  if (auto EC = Writer->writeCString(S))
210  return EC;
211  } else {
212  if (auto EC = Reader->readCString(Value))
213  return EC;
214  }
215  return Error::success();
216 }
217 
218 Error CodeViewRecordIO::mapGuid(GUID &Guid, const Twine &Comment) {
219  constexpr uint32_t GuidSize = 16;
220 
221  if (isStreaming()) {
222  StringRef GuidSR =
223  StringRef((reinterpret_cast<const char *>(&Guid)), GuidSize);
224  emitComment(Comment);
225  Streamer->EmitBytes(GuidSR);
226  incrStreamedLen(GuidSize);
227  return Error::success();
228  }
229 
230  if (maxFieldLength() < GuidSize)
231  return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
232 
233  if (isWriting()) {
234  if (auto EC = Writer->writeBytes(Guid.Guid))
235  return EC;
236  } else {
237  ArrayRef<uint8_t> GuidBytes;
238  if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
239  return EC;
240  memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
241  }
242  return Error::success();
243 }
244 
246  const Twine &Comment) {
247 
248  if (!isReading()) {
249  emitComment(Comment);
250  for (auto V : Value) {
251  if (auto EC = mapStringZ(V))
252  return EC;
253  }
254  uint8_t FinalZero = 0;
255  if (auto EC = mapInteger(FinalZero))
256  return EC;
257  } else {
258  StringRef S;
259  if (auto EC = mapStringZ(S))
260  return EC;
261  while (!S.empty()) {
262  Value.push_back(S);
263  if (auto EC = mapStringZ(S))
264  return EC;
265  };
266  }
267  return Error::success();
268 }
269 
270 void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value,
271  const Twine &Comment) {
272  assert(Value < 0 && "Encoded integer is not signed!");
273  if (Value >= std::numeric_limits<int8_t>::min()) {
274  Streamer->EmitIntValue(LF_CHAR, 2);
275  emitComment(Comment);
276  Streamer->EmitIntValue(Value, 1);
277  incrStreamedLen(3);
278  } else if (Value >= std::numeric_limits<int16_t>::min()) {
279  Streamer->EmitIntValue(LF_SHORT, 2);
280  emitComment(Comment);
281  Streamer->EmitIntValue(Value, 2);
282  incrStreamedLen(4);
283  } else if (Value >= std::numeric_limits<int32_t>::min()) {
284  Streamer->EmitIntValue(LF_LONG, 2);
285  emitComment(Comment);
286  Streamer->EmitIntValue(Value, 4);
287  incrStreamedLen(6);
288  } else {
289  Streamer->EmitIntValue(LF_QUADWORD, 2);
290  emitComment(Comment);
291  Streamer->EmitIntValue(Value, 4);
292  incrStreamedLen(6);
293  }
294 }
295 
296 void CodeViewRecordIO::emitEncodedUnsignedInteger(const uint64_t &Value,
297  const Twine &Comment) {
298  if (Value < LF_NUMERIC) {
299  emitComment(Comment);
300  Streamer->EmitIntValue(Value, 2);
301  incrStreamedLen(2);
302  } else if (Value <= std::numeric_limits<uint16_t>::max()) {
303  Streamer->EmitIntValue(LF_USHORT, 2);
304  emitComment(Comment);
305  Streamer->EmitIntValue(Value, 2);
306  incrStreamedLen(4);
307  } else if (Value <= std::numeric_limits<uint32_t>::max()) {
308  Streamer->EmitIntValue(LF_ULONG, 2);
309  emitComment(Comment);
310  Streamer->EmitIntValue(Value, 4);
311  incrStreamedLen(6);
312  } else {
313  Streamer->EmitIntValue(LF_UQUADWORD, 2);
314  emitComment(Comment);
315  Streamer->EmitIntValue(Value, 8);
316  incrStreamedLen(6);
317  }
318 }
319 
320 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
321  assert(Value < 0 && "Encoded integer is not signed!");
322  if (Value >= std::numeric_limits<int8_t>::min()) {
323  if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
324  return EC;
325  if (auto EC = Writer->writeInteger<int8_t>(Value))
326  return EC;
327  } else if (Value >= std::numeric_limits<int16_t>::min()) {
328  if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT))
329  return EC;
330  if (auto EC = Writer->writeInteger<int16_t>(Value))
331  return EC;
332  } else if (Value >= std::numeric_limits<int32_t>::min()) {
333  if (auto EC = Writer->writeInteger<uint16_t>(LF_LONG))
334  return EC;
335  if (auto EC = Writer->writeInteger<int32_t>(Value))
336  return EC;
337  } else {
338  if (auto EC = Writer->writeInteger<uint16_t>(LF_QUADWORD))
339  return EC;
340  if (auto EC = Writer->writeInteger(Value))
341  return EC;
342  }
343  return Error::success();
344 }
345 
346 Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) {
347  if (Value < LF_NUMERIC) {
348  if (auto EC = Writer->writeInteger<uint16_t>(Value))
349  return EC;
350  } else if (Value <= std::numeric_limits<uint16_t>::max()) {
351  if (auto EC = Writer->writeInteger<uint16_t>(LF_USHORT))
352  return EC;
353  if (auto EC = Writer->writeInteger<uint16_t>(Value))
354  return EC;
355  } else if (Value <= std::numeric_limits<uint32_t>::max()) {
356  if (auto EC = Writer->writeInteger<uint16_t>(LF_ULONG))
357  return EC;
358  if (auto EC = Writer->writeInteger<uint32_t>(Value))
359  return EC;
360  } else {
361  if (auto EC = Writer->writeInteger<uint16_t>(LF_UQUADWORD))
362  return EC;
363  if (auto EC = Writer->writeInteger(Value))
364  return EC;
365  }
366 
367  return Error::success();
368 }
LLVM_NODISCARD StringRef take_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with only the first N elements remaining.
Definition: StringRef.h:587
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
Error padToAlignment(uint32_t Align)
Error writeBytes(ArrayRef< uint8_t > Buffer)
Write the bytes specified in Buffer to the underlying stream.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1569
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Error readInteger(T &Dest)
Read an integer of the specified endianness into Dest and update the stream&#39;s offset.
iterator begin() const
Definition: ArrayRef.h:136
void push_back(const T &Elt)
Definition: SmallVector.h:211
Error mapGuid(GUID &Guid, const Twine &Comment="")
uint8_t peek() const
Examine the next byte of the underlying stream without advancing the stream&#39;s offset.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
void setIndex(uint32_t I)
Definition: TypeIndex.h:111
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
Error beginRecord(Optional< uint32_t > MaxLength)
This represents the &#39;GUID&#39; type from windows.h.
Definition: GUID.h:21
Error mapStringZVectorZ(std::vector< StringRef > &Value, const Twine &Comment="")
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
Error readCString(StringRef &Dest)
Read a null terminated string from Dest.
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1581
A 32-bit type reference.
Definition: TypeIndex.h:95
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
Error padToAlignment(uint32_t Align)
uint8_t Guid[16]
Definition: GUID.h:22
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
bool isSigned() const
Definition: APSInt.h:76
virtual void EmitBytes(StringRef Data)=0
Error writeInteger(T Value)
Write the integer Value to the underlying stream in the specified endianness.
StringRef toStringRef(bool B)
Construct a string ref from a boolean.
Definition: StringExtras.h:52
Error mapInteger(TypeIndex &TypeInd, const Twine &Comment="")
const T * data() const
Definition: ArrayRef.h:145
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
uint32_t getIndex() const
Definition: TypeIndex.h:110
virtual void EmitIntValue(uint64_t Value, unsigned Size)=0
Error writeCString(StringRef Str)
Write the string Str to the underlying stream followed by a null terminator.
Error mapByteVectorTail(ArrayRef< uint8_t > &Bytes, const Twine &Comment="")
int64_t getExtValue() const
Get the correctly-extended int64_t value.
Definition: APSInt.h:93
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
Error mapEncodedInteger(int64_t &Value, const Twine &Comment="")
iterator end() const
Definition: ArrayRef.h:137
Error mapStringZ(StringRef &Value, const Twine &Comment="")
bool hasValue() const
Definition: Optional.h:259
Error readBytes(ArrayRef< uint8_t > &Buffer, uint32_t Size)
Read Size bytes from the underlying stream at the current offset and and set Buffer to the resulting ...
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
Error padToAlignment(uint32_t Align)
Error skip(uint32_t Amount)
Advance the stream&#39;s offset by Amount bytes.
uint32_t bytesRemaining() const
Error consume(BinaryStreamReader &Reader)
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:122
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
virtual void EmitBinaryData(StringRef Data)=0