lib/DebugInfo/CodeView/DebugCrossImpSubsection.cpp

   1 //===- DebugCrossImpSubsection.cpp ----------------------------------------===//
   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/DebugCrossImpSubsection.h"
  11 #include "llvm/ADT/ArrayRef.h"
  12 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
  13 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
  14 #include "llvm/Support/BinaryStreamReader.h"
  15 #include "llvm/Support/BinaryStreamWriter.h"
  16 #include "llvm/Support/Endian.h"
  17 #include "llvm/Support/Error.h"
  18 #include <algorithm>
  19 #include <cstdint>
  20 #include <utility>
  21 #include <vector>
  22
  23 using namespace llvm;
  24 using namespace llvm::codeview;
  25
  26 Error VarStreamArrayExtractor<CrossModuleImportItem>::
  27 operator()(BinaryStreamRef Stream, uint32_t &Len,
  28            codeview::CrossModuleImportItem &Item) {
  29   BinaryStreamReader Reader(Stream);
  30   if (Reader.bytesRemaining() < sizeof(CrossModuleImport))
  31     return make_error<CodeViewError>(
  32         cv_error_code::insufficient_buffer,
  33         "Not enough bytes for a Cross Module Import Header!");
  34   if (auto EC = Reader.readObject(Item.Header))
  35     return EC;
  36   if (Reader.bytesRemaining() < Item.Header->Count * sizeof(uint32_t))
  37     return make_error<CodeViewError>(
  38         cv_error_code::insufficient_buffer,
  39         "Not enough to read specified number of Cross Module References!");
  40   if (auto EC = Reader.readArray(Item.Imports, Item.Header->Count))
  41     return EC;
  42   return Error::success();
  43 }
  44
  45 Error DebugCrossModuleImportsSubsectionRef::initialize(
  46     BinaryStreamReader Reader) {
  47   return Reader.readArray(References, Reader.bytesRemaining());
  48 }
  49
  50 Error DebugCrossModuleImportsSubsectionRef::initialize(BinaryStreamRef Stream) {
  51   BinaryStreamReader Reader(Stream);
  52   return initialize(Reader);
  53 }
  54
  55 void DebugCrossModuleImportsSubsection::addImport(StringRef Module,
  56                                                   uint32_t ImportId) {
  57   Strings.insert(Module);
  58   std::vector<support::ulittle32_t> Targets = {support::ulittle32_t(ImportId)};
  59   auto Result = Mappings.insert(std::make_pair(Module, Targets));
  60   if (!Result.second)
  61     Result.first->getValue().push_back(Targets[0]);
  62 }
  63
  64 uint32_t DebugCrossModuleImportsSubsection::calculateSerializedSize() const {
  65   uint32_t Size = 0;
  66   for (const auto &Item : Mappings) {
  67     Size += sizeof(CrossModuleImport);
  68     Size += sizeof(support::ulittle32_t) * Item.second.size();
  69   }
  70   return Size;
  71 }
  72
  73 Error DebugCrossModuleImportsSubsection::commit(
  74     BinaryStreamWriter &Writer) const {
  75   using T = decltype(&*Mappings.begin());
  76   std::vector<T> Ids;
  77   Ids.reserve(Mappings.size());
  78
  79   for (const auto &M : Mappings)
  80     Ids.push_back(&M);
  81
  82   llvm::sort(Ids, [this](const T &L1, const T &L2) {
  83     return Strings.getIdForString(L1->getKey()) <
  84            Strings.getIdForString(L2->getKey());
  85   });
  86
  87   for (const auto &Item : Ids) {
  88     CrossModuleImport Imp;
  89     Imp.ModuleNameOffset = Strings.getIdForString(Item->getKey());
  90     Imp.Count = Item->getValue().size();
  91     if (auto EC = Writer.writeObject(Imp))
  92       return EC;
  93     if (auto EC = Writer.writeArray(makeArrayRef(Item->getValue())))
  94       return EC;
  95   }
  96   return Error::success();
  97 }