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
12#include <cstdint>
13#include <cstring>
14
15#include "lldb/lldb-types.h"
16
17#include "llvm/ADT/ArrayRef.h"
18
19namespace lldb_private {
20
21/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
22/// A pure virtual protocol class for abstracted read only data buffers.
23///
24/// DataBuffer is an abstract class that gets packaged into a shared
25/// pointer that can use to implement various ways to store data (on the heap,
26/// memory mapped, cached inferior memory). It gets used by DataExtractor so
27/// many DataExtractor objects can share the same data and sub-ranges of that
28/// shared data, and the last object that contains a reference to the shared
29/// data will free it.
30///
31/// Subclasses can implement as many different constructors or member
32/// functions that allow data to be stored in the object's buffer prior to
33/// handing the shared data to clients that use these buffers.
34///
35/// All subclasses must override all of the pure virtual functions as they are
36/// used by clients to access the data. Having a common interface allows
37/// different ways of storing data, yet using it in one common way.
38///
39/// This class currently expects all data to be available without any extra
40/// calls being made, but we can modify it to optionally get data on demand
41/// with some extra function calls to load the data before it gets accessed.
42class DataBuffer {
43public:
44 virtual ~DataBuffer() = default;
45
46 /// Get the number of bytes in the data buffer.
47 ///
48 /// \return
49 /// The number of bytes this object currently contains.
50 virtual lldb::offset_t GetByteSize() const = 0;
51
52 /// Get a const pointer to the data.
53 ///
54 /// \return
55 /// A const pointer to the bytes owned by this object, or NULL
56 /// if the object contains no bytes.
57 const uint8_t *GetBytes() const { return GetBytesImpl(); }
58
59 llvm::ArrayRef<uint8_t> GetData() const {
60 return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());
61 }
62
63 /// LLVM RTTI support.
64 /// {
65 static char ID;
66 virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
67 static bool classof(const DataBuffer *data_buffer) {
68 return data_buffer->isA(ClassID: &ID);
69 }
70 /// }
71
72protected:
73 /// Get a const pointer to the data.
74 ///
75 /// \return
76 /// A const pointer to the bytes owned by this object, or NULL
77 /// if the object contains no bytes.
78 virtual const uint8_t *GetBytesImpl() const = 0;
79};
80
81/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
82/// A pure virtual protocol class for abstracted writable data buffers.
83///
84/// DataBuffer is an abstract class that gets packaged into a shared pointer
85/// that can use to implement various ways to store data (on the heap, memory
86/// mapped, cached inferior memory). It gets used by DataExtractor so many
87/// DataExtractor objects can share the same data and sub-ranges of that
88/// shared data, and the last object that contains a reference to the shared
89/// data will free it.
90class WritableDataBuffer : public DataBuffer {
91public:
92 /// Destructor
93 ///
94 /// The destructor is virtual as other classes will inherit from this class
95 /// and be downcast to the DataBuffer pure virtual interface. The virtual
96 /// destructor ensures that destructing the base class will destruct the
97 /// class that inherited from it correctly.
98 ~WritableDataBuffer() override = default;
99
100 using DataBuffer::GetBytes;
101 using DataBuffer::GetData;
102
103 /// Get a pointer to the data.
104 ///
105 /// \return
106 /// A pointer to the bytes owned by this object, or NULL if the
107 /// object contains no bytes.
108 uint8_t *GetBytes() { return const_cast<uint8_t *>(GetBytesImpl()); }
109
110 llvm::MutableArrayRef<uint8_t> GetData() {
111 return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());
112 }
113
114 /// LLVM RTTI support.
115 /// {
116 static char ID;
117 bool isA(const void *ClassID) const override {
118 return ClassID == &ID || DataBuffer::isA(ClassID);
119 }
120 static bool classof(const DataBuffer *data_buffer) {
121 return data_buffer->isA(ClassID: &ID);
122 }
123 /// }
124};
125
126class DataBufferUnowned : public WritableDataBuffer {
127public:
128 DataBufferUnowned(uint8_t *bytes, lldb::offset_t size)
129 : m_bytes(bytes), m_size(size) {}
130
131 const uint8_t *GetBytesImpl() const override { return m_bytes; }
132 lldb::offset_t GetByteSize() const override { return m_size; }
133
134 /// LLVM RTTI support.
135 /// {
136 static char ID;
137 bool isA(const void *ClassID) const override {
138 return ClassID == &ID || WritableDataBuffer::isA(ClassID);
139 }
140 static bool classof(const DataBuffer *data_buffer) {
141 return data_buffer->isA(ClassID: &ID);
142 }
143 /// }
144private:
145 uint8_t *m_bytes;
146 lldb::offset_t m_size;
147};
148
149} // namespace lldb_private
150
151#endif // LLDB_UTILITY_DATABUFFER_H
152

source code of lldb/include/lldb/Utility/DataBuffer.h