lib/DebugInfo/CodeView/DebugStringTableSubsection.cpp

   1 //===- DebugStringTableSubsection.cpp - CodeView String Table -------------===//
   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/DebugStringTableSubsection.h"
  11 #include "llvm/ADT/StringRef.h"
  12 #include "llvm/DebugInfo/CodeView/CodeView.h"
  13 #include "llvm/Support/BinaryStreamReader.h"
  14 #include "llvm/Support/BinaryStreamWriter.h"
  15 #include "llvm/Support/Error.h"
  16 #include <algorithm>
  17 #include <cassert>
  18 #include <cstdint>
  19
  20 using namespace llvm;
  21 using namespace llvm::codeview;
  22
  23 DebugStringTableSubsectionRef::DebugStringTableSubsectionRef()
  24     : DebugSubsectionRef(DebugSubsectionKind::StringTable) {}
  25
  26 Error DebugStringTableSubsectionRef::initialize(BinaryStreamRef Contents) {
  27   Stream = Contents;
  28   return Error::success();
  29 }
  30
  31 Error DebugStringTableSubsectionRef::initialize(BinaryStreamReader &Reader) {
  32   return Reader.readStreamRef(Stream);
  33 }
  34
  35 Expected<StringRef>
  36 DebugStringTableSubsectionRef::getString(uint32_t Offset) const {
  37   BinaryStreamReader Reader(Stream);
  38   Reader.setOffset(Offset);
  39   StringRef Result;
  40   if (auto EC = Reader.readCString(Result))
  41     return std::move(EC);
  42   return Result;
  43 }
  44
  45 DebugStringTableSubsection::DebugStringTableSubsection()
  46     : DebugSubsection(DebugSubsectionKind::StringTable) {}
  47
  48 uint32_t DebugStringTableSubsection::insert(StringRef S) {
  49   auto P = StringToId.insert({S, StringSize});
  50
  51   // If a given string didn't exist in the string table, we want to increment
  52   // the string table size and insert it into the reverse lookup.
  53   if (P.second) {
  54     IdToString.insert({P.first->getValue(), P.first->getKey()});
  55     StringSize += S.size() + 1; // +1 for '\0'
  56   }
  57
  58   return P.first->second;
  59 }
  60
  61 uint32_t DebugStringTableSubsection::calculateSerializedSize() const {
  62   return StringSize;
  63 }
  64
  65 Error DebugStringTableSubsection::commit(BinaryStreamWriter &Writer) const {
  66   uint32_t Begin = Writer.getOffset();
  67   uint32_t End = Begin + StringSize;
  68
  69   // Write a null string at the beginning.
  70   if (auto EC = Writer.writeCString(StringRef()))
  71     return EC;
  72
  73   for (auto &Pair : StringToId) {
  74     StringRef S = Pair.getKey();
  75     uint32_t Offset = Begin + Pair.getValue();
  76     Writer.setOffset(Offset);
  77     if (auto EC = Writer.writeCString(S))
  78       return EC;
  79     assert(Writer.getOffset() <= End);
  80   }
  81
  82   Writer.setOffset(End);
  83   assert((End - Begin) == StringSize);
  84   return Error::success();
  85 }
  86
  87 uint32_t DebugStringTableSubsection::size() const { return StringToId.size(); }
  88
  89 std::vector<uint32_t> DebugStringTableSubsection::sortedIds() const {
  90   std::vector<uint32_t> Result;
  91   Result.reserve(IdToString.size());
  92   for (const auto &Entry : IdToString)
  93     Result.push_back(Entry.first);
  94   llvm::sort(Result);
  95   return Result;
  96 }
  97
  98 uint32_t DebugStringTableSubsection::getIdForString(StringRef S) const {
  99   auto Iter = StringToId.find(S);
 100   assert(Iter != StringToId.end());
 101   return Iter->second;
 102 }
 103
 104 StringRef DebugStringTableSubsection::getStringForId(uint32_t Id) const {
 105   auto Iter = IdToString.find(Id);
 106   assert(Iter != IdToString.end());
 107   return Iter->second;
 108 }