blob: 20e27ef8950c6c39d061339622b4c19e6c26396e (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
//===-- DataBufferHeap.h ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_DataBufferHeap_h_
#define liblldb_DataBufferHeap_h_
#include "lldb/Utility/DataBuffer.h"
#include "lldb/lldb-types.h" // for offset_t
#include "llvm/ADT/StringRef.h" // for StringRef
#include <cstdint> // for uint8_t, uint64_t
#include <vector>
namespace lldb_private {
//----------------------------------------------------------------------
/// @class DataBufferHeap DataBufferHeap.h "lldb/Core/DataBufferHeap.h"
/// @brief A subclass of DataBuffer that stores a data buffer on the heap.
///
/// This class keeps its data in a heap based buffer that is owned by
/// the object. This class is best used to store chunks of data that
/// are created or read from sources that can't intelligently and lazily
/// fault new data pages in. Large amounts of data that comes from files
/// should probably use DataBufferLLVM, which can intelligently determine
/// when memory mapping is optimal.
//----------------------------------------------------------------------
class DataBufferHeap : public DataBuffer {
public:
//------------------------------------------------------------------
/// Default constructor
///
/// Initializes the heap based buffer with no bytes.
//------------------------------------------------------------------
DataBufferHeap();
//------------------------------------------------------------------
/// Construct with size \a n and fill with \a ch.
///
/// Initialize this class with \a n bytes and fills the buffer with
/// \a ch.
///
/// @param[in] n
/// The number of bytes that heap based buffer should contain.
///
/// @param[in] ch
/// The character to use when filling the buffer initially.
//------------------------------------------------------------------
DataBufferHeap(lldb::offset_t n, uint8_t ch);
//------------------------------------------------------------------
/// Construct by making a copy of \a src_len bytes from \a src.
///
/// @param[in] src
/// A pointer to the data to copy.
///
/// @param[in] src_len
/// The number of bytes in \a src to copy.
//------------------------------------------------------------------
DataBufferHeap(const void *src, lldb::offset_t src_len);
//------------------------------------------------------------------
/// Destructor.
///
/// Virtual destructor since this class inherits from a pure virtual
/// base class #DataBuffer.
//------------------------------------------------------------------
~DataBufferHeap() override;
//------------------------------------------------------------------
/// @copydoc DataBuffer::GetBytes()
//------------------------------------------------------------------
uint8_t *GetBytes() override;
//------------------------------------------------------------------
/// @copydoc DataBuffer::GetBytes() const
//------------------------------------------------------------------
const uint8_t *GetBytes() const override;
//------------------------------------------------------------------
/// @copydoc DataBuffer::GetByteSize() const
//------------------------------------------------------------------
lldb::offset_t GetByteSize() const override;
//------------------------------------------------------------------
/// Set the number of bytes in the data buffer.
///
/// Sets the number of bytes that this object should be able to
/// contain. This can be used prior to copying data into the buffer.
///
/// @param[in] byte_size
/// The new size in bytes that this data buffer should attempt
/// to resize itself to.
///
/// @return
/// The size in bytes after that this heap buffer was
/// successfully resized to.
//------------------------------------------------------------------
lldb::offset_t SetByteSize(lldb::offset_t byte_size);
//------------------------------------------------------------------
/// Makes a copy of the \a src_len bytes in \a src.
///
/// Copies the data in \a src into an internal buffer.
///
/// @param[in] src
/// A pointer to the data to copy.
///
/// @param[in] src_len
/// The number of bytes in \a src to copy.
//------------------------------------------------------------------
void CopyData(const void *src, lldb::offset_t src_len);
void CopyData(llvm::StringRef src) { CopyData(src.data(), src.size()); }
void AppendData(const void *src, uint64_t src_len);
void Clear();
private:
//------------------------------------------------------------------
// This object uses a std::vector<uint8_t> to store its data. This
// takes care of free the data when the object is deleted.
//------------------------------------------------------------------
typedef std::vector<uint8_t> buffer_t; ///< Buffer type
buffer_t m_data; ///< The heap based buffer where data is stored
};
} // namespace lldb_private
#endif // liblldb_DataBufferHeap_h_
|
