1 files changed, 151 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/include/lldb/Utility/DataBuffer.h b/contrib/llvm-project/lldb/include/lldb/Utility/DataBuffer.h
new file mode 100644
index 000000000000..5529afec5530
--- /dev/null
+++ b/contrib/llvm-project/lldb/include/lldb/Utility/DataBuffer.h
@@ -0,0 +1,151 @@
+//===-- DataBuffer.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 LLDB_UTILITY_DATABUFFER_H
+#define LLDB_UTILITY_DATABUFFER_H
+
+#include <cstdint>
+#include <cstring>
+
+#include "lldb/lldb-types.h"
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace lldb_private {
+
+/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
+/// A pure virtual protocol class for abstracted read only data buffers.
+///
+/// DataBuffer is an abstract class that gets packaged into a shared
+/// pointer that can use to implement various ways to store data (on the heap,
+/// memory mapped, cached inferior memory). It gets used by DataExtractor so
+/// many DataExtractor objects can share the same data and sub-ranges of that
+/// shared data, and the last object that contains a reference to the shared
+/// data will free it.
+///
+/// Subclasses can implement as many different constructors or member
+/// functions that allow data to be stored in the object's buffer prior to
+/// handing the shared data to clients that use these buffers.
+///
+/// All subclasses must override all of the pure virtual functions as they are
+/// used by clients to access the data. Having a common interface allows
+/// different ways of storing data, yet using it in one common way.
+///
+/// This class currently expects all data to be available without any extra
+/// calls being made, but we can modify it to optionally get data on demand
+/// with some extra function calls to load the data before it gets accessed.
+class DataBuffer {
+public:
+  virtual ~DataBuffer() = default;
+
+  /// Get the number of bytes in the data buffer.
+  ///
+  /// \return
+  ///     The number of bytes this object currently contains.
+  virtual lldb::offset_t GetByteSize() const = 0;
+
+  /// Get a const pointer to the data.
+  ///
+  /// \return
+  ///     A const pointer to the bytes owned by this object, or NULL
+  ///     if the object contains no bytes.
+  const uint8_t *GetBytes() const { return GetBytesImpl(); }
+
+  llvm::ArrayRef<uint8_t> GetData() const {
+    return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());
+  }
+
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+
+protected:
+  /// Get a const pointer to the data.
+  ///
+  /// \return
+  ///     A const pointer to the bytes owned by this object, or NULL
+  ///     if the object contains no bytes.
+  virtual const uint8_t *GetBytesImpl() const = 0;
+};
+
+/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
+/// A pure virtual protocol class for abstracted writable data buffers.
+///
+/// DataBuffer is an abstract class that gets packaged into a shared pointer
+/// that can use to implement various ways to store data (on the heap, memory
+/// mapped, cached inferior memory). It gets used by DataExtractor so many
+/// DataExtractor objects can share the same data and sub-ranges of that
+/// shared data, and the last object that contains a reference to the shared
+/// data will free it.
+class WritableDataBuffer : public DataBuffer {
+public:
+  /// Destructor
+  ///
+  /// The destructor is virtual as other classes will inherit from this class
+  /// and be downcast to the DataBuffer pure virtual interface. The virtual
+  /// destructor ensures that destructing the base class will destruct the
+  /// class that inherited from it correctly.
+  ~WritableDataBuffer() override = default;
+
+  using DataBuffer::GetBytes;
+  using DataBuffer::GetData;
+
+  /// Get a pointer to the data.
+  ///
+  /// \return
+  ///     A pointer to the bytes owned by this object, or NULL if the
+  ///     object contains no bytes.
+  uint8_t *GetBytes() { return const_cast<uint8_t *>(GetBytesImpl()); }
+
+  llvm::MutableArrayRef<uint8_t> GetData() {
+    return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());
+  }
+
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || DataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+};
+
+class DataBufferUnowned : public WritableDataBuffer {
+public:
+  DataBufferUnowned(uint8_t *bytes, lldb::offset_t size)
+      : m_bytes(bytes), m_size(size) {}
+
+  const uint8_t *GetBytesImpl() const override { return m_bytes; }
+  lldb::offset_t GetByteSize() const override { return m_size; }
+
+  /// LLVM RTTI support.
+  /// {
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || WritableDataBuffer::isA(ClassID);
+  }
+  static bool classof(const DataBuffer *data_buffer) {
+    return data_buffer->isA(&ID);
+  }
+  /// }
+private:
+  uint8_t *m_bytes;
+  lldb::offset_t m_size;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_DATABUFFER_H