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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
//===-- SwiftArray.h --------------------------------------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_SwiftArray_h_
#define liblldb_SwiftArray_h_
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Target.h"
namespace lldb_private {
namespace formatters {
namespace swift {
// Some part of the buffer handling logic needs to be shared between summary and
// synthetic children
// If I was only making synthetic children, this would be best modelled as
// different FrontEnds
class SwiftArrayBufferHandler {
public:
virtual size_t GetCount() = 0;
virtual size_t GetCapacity() = 0;
virtual lldb_private::CompilerType GetElementType() = 0;
virtual lldb::ValueObjectSP GetElementAtIndex(size_t) = 0;
static std::unique_ptr<SwiftArrayBufferHandler>
CreateBufferHandler(ValueObject &valobj);
virtual bool IsValid() = 0;
virtual ~SwiftArrayBufferHandler() {}
protected:
static bool DoesTypeEntailIndirectBuffer(const CompilerType &element_type);
};
class SwiftArrayEmptyBufferHandler : public SwiftArrayBufferHandler {
public:
size_t GetCount() override { return 0; }
size_t GetCapacity() override { return 0; }
lldb_private::CompilerType GetElementType() override { return m_elem_type; }
lldb::ValueObjectSP GetElementAtIndex(size_t) override {
return lldb::ValueObjectSP();
}
bool IsValid() override { return true; }
protected:
SwiftArrayEmptyBufferHandler(CompilerType elem_type)
: m_elem_type(elem_type) {}
friend class SwiftArrayBufferHandler;
private:
lldb_private::CompilerType m_elem_type;
};
class SwiftArrayNativeBufferHandler : public SwiftArrayBufferHandler {
public:
size_t GetCount() override;
size_t GetCapacity() override;
lldb_private::CompilerType GetElementType() override;
lldb::ValueObjectSP GetElementAtIndex(size_t) override;
bool IsValid() override;
protected:
SwiftArrayNativeBufferHandler(ValueObject &valobj, lldb::addr_t native_ptr,
CompilerType elem_type);
friend class SwiftArrayBufferHandler;
private:
lldb::addr_t m_metadata_ptr;
uint64_t m_reserved_word;
lldb::addr_t m_size;
lldb::addr_t m_capacity;
lldb::addr_t m_first_elem_ptr;
lldb_private::CompilerType m_elem_type;
size_t m_element_size;
size_t m_element_stride;
lldb_private::ExecutionContextRef m_exe_ctx_ref;
};
class SwiftArrayBridgedBufferHandler : public SwiftArrayBufferHandler {
public:
size_t GetCount() override;
size_t GetCapacity() override;
lldb_private::CompilerType GetElementType() override;
lldb::ValueObjectSP GetElementAtIndex(size_t) override;
bool IsValid() override;
protected:
SwiftArrayBridgedBufferHandler(lldb::ProcessSP, lldb::addr_t);
friend class SwiftArrayBufferHandler;
private:
CompilerType m_elem_type;
lldb::ValueObjectSP m_synth_array_sp;
SyntheticChildrenFrontEnd *m_frontend;
};
class SwiftArraySliceBufferHandler : public SwiftArrayBufferHandler {
public:
size_t GetCount() override;
size_t GetCapacity() override;
lldb_private::CompilerType GetElementType() override;
lldb::ValueObjectSP GetElementAtIndex(size_t) override;
bool IsValid() override;
protected:
SwiftArraySliceBufferHandler(ValueObject &valobj, CompilerType elem_type);
friend class SwiftArrayBufferHandler;
private:
lldb::addr_t m_size;
lldb::addr_t m_first_elem_ptr;
lldb_private::CompilerType m_elem_type;
size_t m_element_size;
size_t m_element_stride;
lldb_private::ExecutionContextRef m_exe_ctx_ref;
bool m_native_buffer;
uint64_t m_start_index;
};
class SwiftSyntheticFrontEndBufferHandler : public SwiftArrayBufferHandler {
public:
size_t GetCount() override;
size_t GetCapacity() override;
lldb_private::CompilerType GetElementType() override;
lldb::ValueObjectSP GetElementAtIndex(size_t) override;
bool IsValid() override;
protected:
SwiftSyntheticFrontEndBufferHandler(lldb::ValueObjectSP valobj_sp);
friend class SwiftArrayBufferHandler;
private:
/// Reader beware: this entails you must only pass self-rooted valueobjects
/// to this class.
lldb::ValueObjectSP m_valobj_sp;
std::unique_ptr<SyntheticChildrenFrontEnd> m_frontend;
};
bool Array_SummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options);
class ArraySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public:
ArraySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
llvm::Expected<uint32_t> CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override;
lldb::ChildCacheState Update() override;
bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(ConstString name) override;
bool IsValid();
private:
std::unique_ptr<SwiftArrayBufferHandler> m_array_buffer;
};
SyntheticChildrenFrontEnd *ArraySyntheticFrontEndCreator(CXXSyntheticChildren *,
lldb::ValueObjectSP);
}
}
}
#endif // liblldb_SwiftArray_h_
|
