LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB/Native - NamedStreamMap.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 52 69 75.4 %
Date: 2017-09-14 15:23:50 Functions: 6 8 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- NamedStreamMap.cpp - PDB Named Stream Map --------------------------===//
       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/PDB/Native/NamedStreamMap.h"
      11             : #include "llvm/ADT/StringMap.h"
      12             : #include "llvm/ADT/StringRef.h"
      13             : #include "llvm/ADT/iterator_range.h"
      14             : #include "llvm/DebugInfo/PDB/Native/HashTable.h"
      15             : #include "llvm/DebugInfo/PDB/Native/RawError.h"
      16             : #include "llvm/Support/BinaryStreamReader.h"
      17             : #include "llvm/Support/BinaryStreamRef.h"
      18             : #include "llvm/Support/BinaryStreamWriter.h"
      19             : #include "llvm/Support/Endian.h"
      20             : #include "llvm/Support/Error.h"
      21             : #include <algorithm>
      22             : #include <cassert>
      23             : #include <cstdint>
      24             : #include <tuple>
      25             : 
      26             : using namespace llvm;
      27             : using namespace llvm::pdb;
      28             : 
      29             : // FIXME: This shouldn't be necessary, but if we insert the strings in any
      30             : // other order, cvdump cannot read the generated name map.  This suggests that
      31             : // we may be using the wrong hash function.  A closer inspection of the cvdump
      32             : // source code may reveal something, but for now this at least makes us work,
      33             : // even if only by accident.
      34             : static constexpr const char *OrderedStreamNames[] = {"/LinkInfo", "/names",
      35             :                                                      "/src/headerblock"};
      36             : 
      37             : NamedStreamMap::NamedStreamMap() = default;
      38             : 
      39          68 : Error NamedStreamMap::load(BinaryStreamReader &Stream) {
      40          68 :   Mapping.clear();
      41          68 :   FinalizedHashTable.clear();
      42          68 :   FinalizedInfo.reset();
      43             : 
      44             :   uint32_t StringBufferSize;
      45         204 :   if (auto EC = Stream.readInteger(StringBufferSize))
      46           0 :     return joinErrors(std::move(EC),
      47           0 :                       make_error<RawError>(raw_error_code::corrupt_file,
      48           0 :                                            "Expected string buffer size"));
      49             : 
      50          68 :   BinaryStreamRef StringsBuffer;
      51         204 :   if (auto EC = Stream.readStreamRef(StringsBuffer, StringBufferSize))
      52           0 :     return EC;
      53             : 
      54         136 :   HashTable OffsetIndexMap;
      55         204 :   if (auto EC = OffsetIndexMap.load(Stream))
      56           0 :     return EC;
      57             : 
      58             :   uint32_t NameOffset;
      59             :   uint32_t NameIndex;
      60         466 :   for (const auto &Entry : OffsetIndexMap) {
      61         330 :     std::tie(NameOffset, NameIndex) = Entry;
      62             : 
      63             :     // Compute the offset of the start of the string relative to the stream.
      64         495 :     BinaryStreamReader NameReader(StringsBuffer);
      65         330 :     NameReader.setOffset(NameOffset);
      66             :     // Pump out our c-string from the stream.
      67         165 :     StringRef Str;
      68         495 :     if (auto EC = NameReader.readCString(Str))
      69           0 :       return joinErrors(std::move(EC),
      70           0 :                         make_error<RawError>(raw_error_code::corrupt_file,
      71           0 :                                              "Expected name map name"));
      72             : 
      73             :     // Add this to a string-map from name to stream number.
      74         495 :     Mapping.insert({Str, NameIndex});
      75             :   }
      76             : 
      77         204 :   return Error::success();
      78             : }
      79             : 
      80          60 : Error NamedStreamMap::commit(BinaryStreamWriter &Writer) const {
      81             :   assert(FinalizedInfo.hasValue());
      82             : 
      83             :   // The first field is the number of bytes of string data.
      84         240 :   if (auto EC = Writer.writeInteger(FinalizedInfo->StringDataBytes))
      85           0 :     return EC;
      86             : 
      87         240 :   for (const auto &Name : OrderedStreamNames) {
      88         360 :     auto Item = Mapping.find(Name);
      89         360 :     if (Item == Mapping.end())
      90          60 :       continue;
      91         480 :     if (auto EC = Writer.writeCString(Item->getKey()))
      92           0 :       return EC;
      93             :   }
      94             : 
      95             :   // And finally the Offset Index map.
      96         180 :   if (auto EC = FinalizedHashTable.commit(Writer))
      97           0 :     return EC;
      98             : 
      99         180 :   return Error::success();
     100             : }
     101             : 
     102          60 : uint32_t NamedStreamMap::finalize() {
     103          60 :   if (FinalizedInfo.hasValue())
     104           0 :     return FinalizedInfo->SerializedLength;
     105             : 
     106             :   // Build the finalized hash table.
     107          60 :   FinalizedHashTable.clear();
     108         120 :   FinalizedInfo.emplace();
     109             : 
     110         240 :   for (const auto &Name : OrderedStreamNames) {
     111         360 :     auto Item = Mapping.find(Name);
     112         360 :     if (Item == Mapping.end())
     113          60 :       continue;
     114         360 :     FinalizedHashTable.set(FinalizedInfo->StringDataBytes, Item->getValue());
     115         360 :     FinalizedInfo->StringDataBytes += Item->getKeyLength() + 1;
     116             :   }
     117             : 
     118             :   // Number of bytes of string data.
     119         120 :   FinalizedInfo->SerializedLength += sizeof(support::ulittle32_t);
     120             :   // Followed by that many actual bytes of string data.
     121         180 :   FinalizedInfo->SerializedLength += FinalizedInfo->StringDataBytes;
     122             :   // Followed by the mapping from Offset to Index.
     123         120 :   FinalizedInfo->SerializedLength +=
     124          60 :       FinalizedHashTable.calculateSerializedLength();
     125         120 :   return FinalizedInfo->SerializedLength;
     126             : }
     127             : 
     128             : iterator_range<StringMapConstIterator<uint32_t>>
     129          11 : NamedStreamMap::entries() const {
     130             :   return make_range<StringMapConstIterator<uint32_t>>(Mapping.begin(),
     131          33 :                                                       Mapping.end());
     132             : }
     133             : 
     134           0 : uint32_t NamedStreamMap::size() const { return Mapping.size(); }
     135             : 
     136          97 : bool NamedStreamMap::get(StringRef Stream, uint32_t &StreamNo) const {
     137          97 :   auto Iter = Mapping.find(Stream);
     138         194 :   if (Iter == Mapping.end())
     139             :     return false;
     140          97 :   StreamNo = Iter->second;
     141          97 :   return true;
     142             : }
     143             : 
     144         120 : void NamedStreamMap::set(StringRef Stream, uint32_t StreamNo) {
     145         120 :   FinalizedInfo.reset();
     146         240 :   Mapping[Stream] = StreamNo;
     147         120 : }
     148             : 
     149           0 : void NamedStreamMap::remove(StringRef Stream) {
     150           0 :   FinalizedInfo.reset();
     151           0 :   Mapping.erase(Stream);
     152           0 : }

Generated by: LCOV version 1.13