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 <stdint.h> 14 #include <string.h> 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. ~DataBuffer()51 virtual ~DataBuffer() {} 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 GetData()73 llvm::ArrayRef<uint8_t> GetData() const { 74 return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize()); 75 } 76 GetData()77 llvm::MutableArrayRef<uint8_t> GetData() { 78 return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize()); 79 } 80 }; 81 82 class DataBufferUnowned : public DataBuffer { 83 public: DataBufferUnowned(uint8_t * bytes,lldb::offset_t size)84 DataBufferUnowned(uint8_t *bytes, lldb::offset_t size) 85 : m_bytes(bytes), m_size(size) {} 86 GetBytes()87 uint8_t *GetBytes() override { return m_bytes; } GetBytes()88 const uint8_t *GetBytes() const override { return m_bytes; } GetByteSize()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