Revert "[msf] Rename Msf to MSF."
[lldb.git] / llvm / include / llvm / DebugInfo / Msf / MappedBlockStream.h
1 //===- MappedBlockStream.h - Discontiguous stream data in an Msf -*- C++
2 //-*-===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10
11 #ifndef LLVM_DEBUGINFO_MSF_MAPPEDBLOCKSTREAM_H
12 #define LLVM_DEBUGINFO_MSF_MAPPEDBLOCKSTREAM_H
13
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/DenseMap.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/DebugInfo/Msf/MsfStreamLayout.h"
18 #include "llvm/DebugInfo/Msf/StreamInterface.h"
19 #include "llvm/Support/Allocator.h"
20 #include "llvm/Support/Endian.h"
21 #include "llvm/Support/Error.h"
22 #include <cstdint>
23 #include <vector>
24
25 namespace llvm {
26 namespace msf {
27
28 struct MsfLayout;
29
30 /// MappedBlockStream represents data stored in an Msf file into chunks of a
31 /// particular size (called the Block Size), and whose chunks may not be
32 /// necessarily contiguous.  The arrangement of these chunks within the file
33 /// is described by some other metadata contained within the Msf file.  In
34 /// the case of a standard Msf Stream, the layout of the stream's blocks
35 /// is described by the Msf "directory", but in the case of the directory
36 /// itself, the layout is described by an array at a fixed location within
37 /// the Msf.  MappedBlockStream provides methods for reading from and writing
38 /// to one of these streams transparently, as if it were a contiguous sequence
39 /// of bytes.
40 class MappedBlockStream : public ReadableStream {
41   friend class WritableMappedBlockStream;
42
43 public:
44   static std::unique_ptr<MappedBlockStream>
45   createStream(uint32_t BlockSize, uint32_t NumBlocks,
46                const MsfStreamLayout &Layout, const ReadableStream &MsfData);
47
48   static std::unique_ptr<MappedBlockStream>
49   createIndexedStream(const MsfLayout &Layout, const ReadableStream &MsfData,
50                       uint32_t StreamIndex);
51
52   static std::unique_ptr<MappedBlockStream>
53   createDirectoryStream(const MsfLayout &Layout, const ReadableStream &MsfData);
54
55   Error readBytes(uint32_t Offset, uint32_t Size,
56                   ArrayRef<uint8_t> &Buffer) const override;
57   Error readLongestContiguousChunk(uint32_t Offset,
58                                    ArrayRef<uint8_t> &Buffer) const override;
59
60   uint32_t getLength() const override;
61
62   uint32_t getNumBytesCopied() const;
63
64   llvm::BumpPtrAllocator &getAllocator() { return Pool; }
65
66   void invalidateCache();
67
68   uint32_t getBlockSize() const { return BlockSize; }
69   uint32_t getNumBlocks() const { return NumBlocks; }
70   uint32_t getStreamLength() const { return StreamLayout.Length; }
71
72 protected:
73   MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks,
74                     const MsfStreamLayout &StreamLayout,
75                     const ReadableStream &MsfData);
76
77 private:
78   const MsfStreamLayout &getStreamLayout() const { return StreamLayout; }
79   void fixCacheAfterWrite(uint32_t Offset, ArrayRef<uint8_t> Data) const;
80
81   Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer) const;
82   bool tryReadContiguously(uint32_t Offset, uint32_t Size,
83                            ArrayRef<uint8_t> &Buffer) const;
84
85   const uint32_t BlockSize;
86   const uint32_t NumBlocks;
87   const MsfStreamLayout StreamLayout;
88   const ReadableStream &MsfData;
89
90   typedef MutableArrayRef<uint8_t> CacheEntry;
91   mutable llvm::BumpPtrAllocator Pool;
92   mutable DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap;
93 };
94
95 class WritableMappedBlockStream : public WritableStream {
96 public:
97   static std::unique_ptr<WritableMappedBlockStream>
98   createStream(uint32_t BlockSize, uint32_t NumBlocks,
99                const MsfStreamLayout &Layout, const WritableStream &MsfData);
100
101   static std::unique_ptr<WritableMappedBlockStream>
102   createIndexedStream(const MsfLayout &Layout, const WritableStream &MsfData,
103                       uint32_t StreamIndex);
104
105   static std::unique_ptr<WritableMappedBlockStream>
106   createDirectoryStream(const MsfLayout &Layout, const WritableStream &MsfData);
107
108   Error readBytes(uint32_t Offset, uint32_t Size,
109                   ArrayRef<uint8_t> &Buffer) const override;
110   Error readLongestContiguousChunk(uint32_t Offset,
111                                    ArrayRef<uint8_t> &Buffer) const override;
112   uint32_t getLength() const override;
113
114   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) const override;
115
116   Error commit() const override;
117
118   const MsfStreamLayout &getStreamLayout() const {
119     return ReadInterface.getStreamLayout();
120   }
121   uint32_t getBlockSize() const { return ReadInterface.getBlockSize(); }
122   uint32_t getNumBlocks() const { return ReadInterface.getNumBlocks(); }
123   uint32_t getStreamLength() const { return ReadInterface.getStreamLength(); }
124
125 protected:
126   WritableMappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks,
127                             const MsfStreamLayout &StreamLayout,
128                             const WritableStream &MsfData);
129
130 private:
131   MappedBlockStream ReadInterface;
132
133   const WritableStream &WriteInterface;
134 };
135
136 } // end namespace pdb
137 } // end namespace llvm
138
139 #endif // LLVM_DEBUGINFO_MSF_MAPPEDBLOCKSTREAM_H