Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Utility/DataBuffer.h
Line
Count
Source (jump to first uncovered line)
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 <cstdint>
14
#include <cstring>
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.
51
4.45M
  virtual ~DataBuffer() = default;
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
73
0
  llvm::ArrayRef<uint8_t> GetData() const {
74
0
    return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());
75
0
  }
76
77
1.84M
  llvm::MutableArrayRef<uint8_t> GetData() {
78
1.84M
    return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());
79
1.84M
  }
80
};
81
82
class DataBufferUnowned : public DataBuffer {
83
public:
84
  DataBufferUnowned(uint8_t *bytes, lldb::offset_t size)
85
1.47M
      : m_bytes(bytes), m_size(size) {}
86
87
1.66M
  uint8_t *GetBytes() override { return m_bytes; }
88
639k
  const uint8_t *GetBytes() const override { return m_bytes; }
89
2.94M
  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