Line data    Source code

       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         857 : DebugStringTableSubsectionRef::DebugStringTableSubsectionRef()
      24        1714 :     : DebugSubsectionRef(DebugSubsectionKind::StringTable) {}
      25             : 
      26         343 : Error DebugStringTableSubsectionRef::initialize(BinaryStreamRef Contents) {
      27             :   Stream = Contents;
      28         343 :   return Error::success();
      29             : }
      30             : 
      31           5 : Error DebugStringTableSubsectionRef::initialize(BinaryStreamReader &Reader) {
      32           5 :   return Reader.readStreamRef(Stream);
      33             : }
      34             : 
      35             : Expected<StringRef>
      36        2256 : DebugStringTableSubsectionRef::getString(uint32_t Offset) const {
      37        4512 :   BinaryStreamReader Reader(Stream);
      38             :   Reader.setOffset(Offset);
      39        2256 :   StringRef Result;
      40        4512 :   if (auto EC = Reader.readCString(Result))
      41             :     return std::move(EC);
      42             :   return Result;
      43             : }
      44             : 
      45         419 : DebugStringTableSubsection::DebugStringTableSubsection()
      46         419 :     : DebugSubsection(DebugSubsectionKind::StringTable) {}
      47             : 
      48         501 : uint32_t DebugStringTableSubsection::insert(StringRef S) {
      49         501 :   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         501 :   if (P.second) {
      54         375 :     IdToString.insert({P.first->getValue(), P.first->getKey()});
      55         375 :     StringSize += S.size() + 1; // +1 for '\0'
      56             :   }
      57             : 
      58         501 :   return P.first->second;
      59             : }
      60             : 
      61         861 : uint32_t DebugStringTableSubsection::calculateSerializedSize() const {
      62         861 :   return StringSize;
      63             : }
      64             : 
      65         266 : Error DebugStringTableSubsection::commit(BinaryStreamWriter &Writer) const {
      66         266 :   uint32_t Begin = Writer.getOffset();
      67         266 :   uint32_t End = Begin + StringSize;
      68             : 
      69             :   // Write a null string at the beginning.
      70         266 :   if (auto EC = Writer.writeCString(StringRef()))
      71             :     return EC;
      72             : 
      73         856 :   for (auto &Pair : StringToId) {
      74         324 :     StringRef S = Pair.getKey();
      75         324 :     uint32_t Offset = Begin + Pair.getValue();
      76             :     Writer.setOffset(Offset);
      77         648 :     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         988 : uint32_t DebugStringTableSubsection::size() const { return StringToId.size(); }
      88             : 
      89           0 : std::vector<uint32_t> DebugStringTableSubsection::sortedIds() const {
      90             :   std::vector<uint32_t> Result;
      91           0 :   Result.reserve(IdToString.size());
      92           0 :   for (const auto &Entry : IdToString)
      93           0 :     Result.push_back(Entry.first);
      94             :   llvm::sort(Result);
      95           0 :   return Result;
      96             : }
      97             : 
      98          54 : uint32_t DebugStringTableSubsection::getIdForString(StringRef S) const {
      99          54 :   auto Iter = StringToId.find(S);
     100             :   assert(Iter != StringToId.end());
     101          54 :   return Iter->second;
     102             : }
     103             : 
     104           0 : StringRef DebugStringTableSubsection::getStringForId(uint32_t Id) const {
     105           0 :   auto Iter = IdToString.find(Id);
     106             :   assert(Iter != IdToString.end());
     107           0 :   return Iter->second;
     108             : }