1 //===-- DataBuffer.h --------------------------------------------*- 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 LLDB_UTILITY_DATABUFFER_H
10 #define LLDB_UTILITY_DATABUFFER_H
11 #if defined(__cplusplus)
12 
13 #include <cstdint>
14 #include <cstring>
15 
16 #include "lldb/lldb-types.h"
17 
18 #include "llvm/ADT/ArrayRef.h"
19 
20 namespace lldb_private {
21 
22 /// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
23 /// A pure virtual protocol class for abstracted data buffers.
24 ///
25 /// DataBuffer is an abstract class that gets packaged into a shared pointer
26 /// that can use to implement various ways to store data (on the heap, memory
27 /// mapped, cached inferior memory). It gets used by DataExtractor so many
28 /// DataExtractor objects can share the same data and sub-ranges of that
29 /// shared data, and the last object that contains a reference to the shared
30 /// data will free it.
31 ///
32 /// Subclasses can implement as many different constructors or member
33 /// functions that allow data to be stored in the object's buffer prior to
34 /// handing the shared data to clients that use these buffers.
35 ///
36 /// All subclasses must override all of the pure virtual functions as they are
37 /// used by clients to access the data. Having a common interface allows
38 /// different ways of storing data, yet using it in one common way.
39 ///
40 /// This class currently expects all data to be available without any extra
41 /// calls being made, but we can modify it to optionally get data on demand
42 /// with some extra function calls to load the data before it gets accessed.
43 class DataBuffer {
44 public:
45   /// Destructor
46   ///
47   /// The destructor is virtual as other classes will inherit from this class
48   /// and be downcast to the DataBuffer pure virtual interface. The virtual
49   /// destructor ensures that destructing the base class will destruct the
50   /// class that inherited from it correctly.
51   virtual ~DataBuffer() = default;
52 
53   /// Get a pointer to the data.
54   ///
55   /// \return
56   ///     A pointer to the bytes owned by this object, or NULL if the
57   ///     object contains no bytes.
58   virtual uint8_t *GetBytes() = 0;
59 
60   /// Get a const pointer to the data.
61   ///
62   /// \return
63   ///     A const pointer to the bytes owned by this object, or NULL
64   ///     if the object contains no bytes.
65   virtual const uint8_t *GetBytes() const = 0;
66 
67   /// Get the number of bytes in the data buffer.
68   ///
69   /// \return
70   ///     The number of bytes this object currently contains.
71   virtual lldb::offset_t GetByteSize() const = 0;
72 
73   llvm::ArrayRef<uint8_t> GetData() const {
74     return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());
75   }
76 
77   llvm::MutableArrayRef<uint8_t> GetData() {
78     return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());
79   }
80 };
81 
82 class DataBufferUnowned : public DataBuffer {
83 public:
84   DataBufferUnowned(uint8_t *bytes, lldb::offset_t size)
85       : m_bytes(bytes), m_size(size) {}
86 
87   uint8_t *GetBytes() override { return m_bytes; }
88   const uint8_t *GetBytes() const override { return m_bytes; }
89   lldb::offset_t GetByteSize() const override { return m_size; }
90 
91 private:
92   uint8_t *m_bytes;
93   lldb::offset_t m_size;
94 };
95 
96 } // namespace lldb_private
97 
98 #endif /// #if defined(__cplusplus)
99 #endif // LLDB_UTILITY_DATABUFFER_H
100