contrib/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

   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 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();
  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
  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
  60 Error CodeViewRecordIO::padToAlignment(uint32_t Align) {
  61   if (isReading())
  62     return Reader->padToAlignment(Align);
  63   return Writer->padToAlignment(Align);
  64 }
  65
  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
  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
 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);
 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
 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
 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
 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
 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 }