blob: a4f10873d6e4e69b93efc1b0a9a1ca6bb990ff05 (
plain)
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
|
//===-- DataBufferHeap.h ----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_DataBufferHeap_h_
#define liblldb_DataBufferHeap_h_
#include "lldb/Utility/DataBuffer.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/StringRef.h"
#include <cstdint>
#include <vector>
namespace lldb_private {
//----------------------------------------------------------------------
/// @class DataBufferHeap DataBufferHeap.h "lldb/Core/DataBufferHeap.h"
/// 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. Note that this
/// zero-initializes up to \p byte_size bytes.
///
/// @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_
|
