llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

   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
   9 #include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h"
  10 #include "llvm/DebugInfo/CodeView/CodeView.h"
  11 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
  12 #include "llvm/Support/BinaryStreamReader.h"
  13 #include "llvm/Support/BinaryStreamWriter.h"
  14
  15 using namespace llvm;
  16 using namespace llvm::codeview;
  17
  18 Error CodeViewRecordIO::beginRecord(Optional<uint32_t> MaxLength) {
  19   RecordLimit Limit;
  20   Limit.MaxLength = MaxLength;
  21   Limit.BeginOffset = getCurrentOffset();
  22   Limits.push_back(Limit);
  23   return Error::success();
  24 }
  25
  26 Error CodeViewRecordIO::endRecord() {
  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
  41     uint32_t Align = getStreamedLen() % 4;
  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
  57 uint32_t CodeViewRecordIO::maxFieldLength() const {
  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
  79 Error CodeViewRecordIO::padToAlignment(uint32_t Align) {
  80   if (isReading())
  81     return Reader->padToAlignment(Align);
  82   return Writer->padToAlignment(Align);
  83 }
  84
  85 Error CodeViewRecordIO::skipPadding() {
  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
 100 Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes,
 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
 127 Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd, const Twine &Comment) {
 128   if (isStreaming()) {
 129     std::string TypeNameStr = Streamer->getTypeName(TypeInd);
 130     if (!TypeNameStr.empty())
 131       emitComment(Comment + ": " + TypeNameStr);
 132     else
 133       emitComment(Comment);
 134     Streamer->emitIntValue(TypeInd.getIndex(), sizeof(TypeInd.getIndex()));
 135     incrStreamedLen(sizeof(TypeInd.getIndex()));
 136   } else if (isWriting()) {
 137     if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
 138       return EC;
 139   } else {
 140     uint32_t I;
 141     if (auto EC = Reader->readInteger(I))
 142       return EC;
 143     TypeInd.setIndex(I);
 144   }
 145   return Error::success();
 146 }
 147
 148 Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value,
 149                                           const Twine &Comment) {
 150   if (isStreaming()) {
 151     if (Value >= 0)
 152       emitEncodedUnsignedInteger(static_cast<uint64_t>(Value), Comment);
 153     else
 154       emitEncodedSignedInteger(Value, Comment);
 155   } else if (isWriting()) {
 156     if (Value >= 0) {
 157       if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
 158         return EC;
 159     } else {
 160       if (auto EC = writeEncodedSignedInteger(Value))
 161         return EC;
 162     }
 163   } else {
 164     APSInt N;
 165     if (auto EC = consume(*Reader, N))
 166       return EC;
 167     Value = N.getExtValue();
 168   }
 169
 170   return Error::success();
 171 }
 172
 173 Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value,
 174                                           const Twine &Comment) {
 175   if (isStreaming())
 176     emitEncodedUnsignedInteger(Value, Comment);
 177   else if (isWriting()) {
 178     if (auto EC = writeEncodedUnsignedInteger(Value))
 179       return EC;
 180   } else {
 181     APSInt N;
 182     if (auto EC = consume(*Reader, N))
 183       return EC;
 184     Value = N.getZExtValue();
 185   }
 186   return Error::success();
 187 }
 188
 189 Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value, const Twine &Comment) {
 190   if (isStreaming()) {
 191     // FIXME: We also need to handle big values here, but it's
 192     //        not clear how we can excercise this code path yet.
 193     if (Value.isSigned())
 194       emitEncodedSignedInteger(Value.getSExtValue(), Comment);
 195     else
 196       emitEncodedUnsignedInteger(Value.getZExtValue(), Comment);
 197   } else if (isWriting()) {
 198     if (Value.isSigned())
 199       return writeEncodedSignedInteger(
 200           Value.isSingleWord() ? Value.getSExtValue() : INT64_MIN);
 201     return writeEncodedUnsignedInteger(Value.getLimitedValue());
 202   } else
 203     return consume(*Reader, Value);
 204   return Error::success();
 205 }
 206
 207 Error CodeViewRecordIO::mapStringZ(StringRef &Value, const Twine &Comment) {
 208   if (isStreaming()) {
 209     auto NullTerminatedString = StringRef(Value.data(), Value.size() + 1);
 210     emitComment(Comment);
 211     Streamer->emitBytes(NullTerminatedString);
 212     incrStreamedLen(NullTerminatedString.size());
 213   } else if (isWriting()) {
 214     // Truncate if we attempt to write too much.
 215     StringRef S = Value.take_front(maxFieldLength() - 1);
 216     if (auto EC = Writer->writeCString(S))
 217       return EC;
 218   } else {
 219     if (auto EC = Reader->readCString(Value))
 220       return EC;
 221   }
 222   return Error::success();
 223 }
 224
 225 Error CodeViewRecordIO::mapGuid(GUID &Guid, const Twine &Comment) {
 226   constexpr uint32_t GuidSize = 16;
 227
 228   if (isStreaming()) {
 229     StringRef GuidSR =
 230         StringRef((reinterpret_cast<const char *>(&Guid)), GuidSize);
 231     emitComment(Comment);
 232     Streamer->emitBytes(GuidSR);
 233     incrStreamedLen(GuidSize);
 234     return Error::success();
 235   }
 236
 237   if (maxFieldLength() < GuidSize)
 238     return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 239
 240   if (isWriting()) {
 241     if (auto EC = Writer->writeBytes(Guid.Guid))
 242       return EC;
 243   } else {
 244     ArrayRef<uint8_t> GuidBytes;
 245     if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
 246       return EC;
 247     memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
 248   }
 249   return Error::success();
 250 }
 251
 252 Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value,
 253                                           const Twine &Comment) {
 254
 255   if (!isReading()) {
 256     emitComment(Comment);
 257     for (auto V : Value) {
 258       if (auto EC = mapStringZ(V))
 259         return EC;
 260     }
 261     uint8_t FinalZero = 0;
 262     if (auto EC = mapInteger(FinalZero))
 263       return EC;
 264   } else {
 265     StringRef S;
 266     if (auto EC = mapStringZ(S))
 267       return EC;
 268     while (!S.empty()) {
 269       Value.push_back(S);
 270       if (auto EC = mapStringZ(S))
 271         return EC;
 272     };
 273   }
 274   return Error::success();
 275 }
 276
 277 void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value,
 278                                                 const Twine &Comment) {
 279   // FIXME: There are no test cases covering this function.
 280   // This may be because we always consider enumerators to be unsigned.
 281   // See FIXME at CodeViewDebug.cpp : CodeViewDebug::lowerTypeEnum.
 282   if (Value >= std::numeric_limits<int8_t>::min()) {
 283     Streamer->emitIntValue(LF_CHAR, 2);
 284     emitComment(Comment);
 285     Streamer->emitIntValue(Value, 1);
 286     incrStreamedLen(3);
 287   } else if (Value >= std::numeric_limits<int16_t>::min()) {
 288     Streamer->emitIntValue(LF_SHORT, 2);
 289     emitComment(Comment);
 290     Streamer->emitIntValue(Value, 2);
 291     incrStreamedLen(4);
 292   } else if (Value >= std::numeric_limits<int32_t>::min()) {
 293     Streamer->emitIntValue(LF_LONG, 2);
 294     emitComment(Comment);
 295     Streamer->emitIntValue(Value, 4);
 296     incrStreamedLen(6);
 297   } else {
 298     Streamer->emitIntValue(LF_QUADWORD, 2);
 299     emitComment(Comment);
 300     Streamer->emitIntValue(Value, 4); // FIXME: Why not 8 (size of quadword)?
 301     incrStreamedLen(6);               // FIXME: Why not 10 (8 + 2)?
 302   }
 303 }
 304
 305 void CodeViewRecordIO::emitEncodedUnsignedInteger(const uint64_t &Value,
 306                                                   const Twine &Comment) {
 307   if (Value < LF_NUMERIC) {
 308     emitComment(Comment);
 309     Streamer->emitIntValue(Value, 2);
 310     incrStreamedLen(2);
 311   } else if (Value <= std::numeric_limits<uint16_t>::max()) {
 312     Streamer->emitIntValue(LF_USHORT, 2);
 313     emitComment(Comment);
 314     Streamer->emitIntValue(Value, 2);
 315     incrStreamedLen(4);
 316   } else if (Value <= std::numeric_limits<uint32_t>::max()) {
 317     Streamer->emitIntValue(LF_ULONG, 2);
 318     emitComment(Comment);
 319     Streamer->emitIntValue(Value, 4);
 320     incrStreamedLen(6);
 321   } else {
 322     // FIXME: There are no test cases covering this block.
 323     Streamer->emitIntValue(LF_UQUADWORD, 2);
 324     emitComment(Comment);
 325     Streamer->emitIntValue(Value, 8);
 326     incrStreamedLen(6); // FIXME: Why not 10 (8 + 2)?
 327   }
 328 }
 329
 330 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
 331   if (Value >= std::numeric_limits<int8_t>::min()) {
 332     if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
 333       return EC;
 334     if (auto EC = Writer->writeInteger<int8_t>(Value))
 335       return EC;
 336   } else if (Value >= std::numeric_limits<int16_t>::min()) {
 337     if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT))
 338       return EC;
 339     if (auto EC = Writer->writeInteger<int16_t>(Value))
 340       return EC;
 341   } else if (Value >= std::numeric_limits<int32_t>::min()) {
 342     if (auto EC = Writer->writeInteger<uint16_t>(LF_LONG))
 343       return EC;
 344     if (auto EC = Writer->writeInteger<int32_t>(Value))
 345       return EC;
 346   } else {
 347     if (auto EC = Writer->writeInteger<uint16_t>(LF_QUADWORD))
 348       return EC;
 349     if (auto EC = Writer->writeInteger(Value))
 350       return EC;
 351   }
 352   return Error::success();
 353 }
 354
 355 Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) {
 356   if (Value < LF_NUMERIC) {
 357     if (auto EC = Writer->writeInteger<uint16_t>(Value))
 358       return EC;
 359   } else if (Value <= std::numeric_limits<uint16_t>::max()) {
 360     if (auto EC = Writer->writeInteger<uint16_t>(LF_USHORT))
 361       return EC;
 362     if (auto EC = Writer->writeInteger<uint16_t>(Value))
 363       return EC;
 364   } else if (Value <= std::numeric_limits<uint32_t>::max()) {
 365     if (auto EC = Writer->writeInteger<uint16_t>(LF_ULONG))
 366       return EC;
 367     if (auto EC = Writer->writeInteger<uint32_t>(Value))
 368       return EC;
 369   } else {
 370     if (auto EC = Writer->writeInteger<uint16_t>(LF_UQUADWORD))
 371       return EC;
 372     if (auto EC = Writer->writeInteger(Value))
 373       return EC;
 374   }
 375
 376   return Error::success();
 377 }