Home | History | Annotate | Line # | Download | only in MSF 
      1 //==- MappedBlockStream.h - Discontiguous stream data in an MSF --*- C++ -*-==//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 
      9 #ifndef LLVM_DEBUGINFO_MSF_MAPPEDBLOCKSTREAM_H
     10 #define LLVM_DEBUGINFO_MSF_MAPPEDBLOCKSTREAM_H
     11 
     12 #include "llvm/ADT/ArrayRef.h"
     13 #include "llvm/ADT/DenseMap.h"
     14 #include "llvm/DebugInfo/MSF/MSFCommon.h"
     15 #include "llvm/Support/Allocator.h"
     16 #include "llvm/Support/BinaryStream.h"
     17 #include "llvm/Support/BinaryStreamRef.h"
     18 #include "llvm/Support/Endian.h"
     19 #include "llvm/Support/Error.h"
     20 #include <cstdint>
     21 #include <memory>
     22 #include <vector>
     23 
     24 namespace llvm {
     25 namespace msf {
     26 
     27 /// MappedBlockStream represents data stored in an MSF file into chunks of a
     28 /// particular size (called the Block Size), and whose chunks may not be
     29 /// necessarily contiguous.  The arrangement of these chunks MSF the file
     30 /// is described by some other metadata contained within the MSF file.  In
     31 /// the case of a standard MSF Stream, the layout of the stream's blocks
     32 /// is described by the MSF "directory", but in the case of the directory
     33 /// itself, the layout is described by an array at a fixed location within
     34 /// the MSF.  MappedBlockStream provides methods for reading from and writing
     35 /// to one of these streams transparently, as if it were a contiguous sequence
     36 /// of bytes.
     37 class MappedBlockStream : public BinaryStream {
     38   friend class WritableMappedBlockStream;
     39 
     40 public:
     41   static std::unique_ptr<MappedBlockStream>
     42   createStream(uint32_t BlockSize, const MSFStreamLayout &Layout,
     43                BinaryStreamRef MsfData, BumpPtrAllocator &Allocator);
     44 
     45   static std::unique_ptr<MappedBlockStream>
     46   createIndexedStream(const MSFLayout &Layout, BinaryStreamRef MsfData,
     47                       uint32_t StreamIndex, BumpPtrAllocator &Allocator);
     48 
     49   static std::unique_ptr<MappedBlockStream>
     50   createFpmStream(const MSFLayout &Layout, BinaryStreamRef MsfData,
     51                   BumpPtrAllocator &Allocator);
     52 
     53   static std::unique_ptr<MappedBlockStream>
     54   createDirectoryStream(const MSFLayout &Layout, BinaryStreamRef MsfData,
     55                         BumpPtrAllocator &Allocator);
     56 
     57   support::endianness getEndian() const override {
     58     return support::little;
     59   }
     60 
     61   Error readBytes(uint32_t Offset, uint32_t Size,
     62                   ArrayRef<uint8_t> &Buffer) override;
     63   Error readLongestContiguousChunk(uint32_t Offset,
     64                                    ArrayRef<uint8_t> &Buffer) override;
     65 
     66   uint32_t getLength() override;
     67 
     68   BumpPtrAllocator &getAllocator() { return Allocator; }
     69 
     70   void invalidateCache();
     71 
     72   uint32_t getBlockSize() const { return BlockSize; }
     73   uint32_t getNumBlocks() const { return StreamLayout.Blocks.size(); }
     74   uint32_t getStreamLength() const { return StreamLayout.Length; }
     75 
     76 protected:
     77   MappedBlockStream(uint32_t BlockSize, const MSFStreamLayout &StreamLayout,
     78                     BinaryStreamRef MsfData, BumpPtrAllocator &Allocator);
     79 
     80 private:
     81   const MSFStreamLayout &getStreamLayout() const { return StreamLayout; }
     82   void fixCacheAfterWrite(uint32_t Offset, ArrayRef<uint8_t> Data) const;
     83 
     84   Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer);
     85   bool tryReadContiguously(uint32_t Offset, uint32_t Size,
     86                            ArrayRef<uint8_t> &Buffer);
     87 
     88   const uint32_t BlockSize;
     89   const MSFStreamLayout StreamLayout;
     90   BinaryStreamRef MsfData;
     91 
     92   using CacheEntry = MutableArrayRef<uint8_t>;
     93 
     94   // We just store the allocator by reference.  We use this to allocate
     95   // contiguous memory for things like arrays or strings that cross a block
     96   // boundary, and this memory is expected to outlive the stream.  For example,
     97   // someone could create a stream, read some stuff, then close the stream, and
     98   // we would like outstanding references to fields to remain valid since the
     99   // entire file is mapped anyway.  Because of that, the user must supply the
    100   // allocator to allocate broken records from.
    101   BumpPtrAllocator &Allocator;
    102   DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap;
    103 };
    104 
    105 class WritableMappedBlockStream : public WritableBinaryStream {
    106 public:
    107   static std::unique_ptr<WritableMappedBlockStream>
    108   createStream(uint32_t BlockSize, const MSFStreamLayout &Layout,
    109                WritableBinaryStreamRef MsfData, BumpPtrAllocator &Allocator);
    110 
    111   static std::unique_ptr<WritableMappedBlockStream>
    112   createIndexedStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData,
    113                       uint32_t StreamIndex, BumpPtrAllocator &Allocator);
    114 
    115   static std::unique_ptr<WritableMappedBlockStream>
    116   createDirectoryStream(const MSFLayout &Layout,
    117                         WritableBinaryStreamRef MsfData,
    118                         BumpPtrAllocator &Allocator);
    119 
    120   static std::unique_ptr<WritableMappedBlockStream>
    121   createFpmStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData,
    122                   BumpPtrAllocator &Allocator, bool AltFpm = false);
    123 
    124   support::endianness getEndian() const override {
    125     return support::little;
    126   }
    127 
    128   Error readBytes(uint32_t Offset, uint32_t Size,
    129                   ArrayRef<uint8_t> &Buffer) override;
    130   Error readLongestContiguousChunk(uint32_t Offset,
    131                                    ArrayRef<uint8_t> &Buffer) override;
    132   uint32_t getLength() override;
    133 
    134   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override;
    135 
    136   Error commit() override;
    137 
    138   const MSFStreamLayout &getStreamLayout() const {
    139     return ReadInterface.getStreamLayout();
    140   }
    141 
    142   uint32_t getBlockSize() const { return ReadInterface.getBlockSize(); }
    143   uint32_t getNumBlocks() const { return ReadInterface.getNumBlocks(); }
    144   uint32_t getStreamLength() const { return ReadInterface.getStreamLength(); }
    145 
    146 protected:
    147   WritableMappedBlockStream(uint32_t BlockSize,
    148                             const MSFStreamLayout &StreamLayout,
    149                             WritableBinaryStreamRef MsfData,
    150                             BumpPtrAllocator &Allocator);
    151 
    152 private:
    153   MappedBlockStream ReadInterface;
    154   WritableBinaryStreamRef WriteInterface;
    155 };
    156 
    157 } // end namespace pdb
    158 } // end namespace llvm
    159 
    160 #endif // LLVM_DEBUGINFO_MSF_MAPPEDBLOCKSTREAM_H
    161