/usr/src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/lldb/source/API/SBFrame.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/lldb/source/API/SBFrame.cpp
Warning:	line 426, column 15 Value stored to 'frame' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SBFrame.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbAPI/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbAPI/../include -I /usr/src/gnu/usr.bin/clang/liblldbAPI/obj -I /usr/src/gnu/usr.bin/clang/liblldbAPI/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/liblldbAPI/../include/lldb/ -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbAPI/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/lldb/source/API/SBFrame.cpp

1	//===-- SBFrame.cpp -------------------------------------------------------===//
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	#include <algorithm>
10	#include <set>
11	#include <string>
12
13	#include "lldb/API/SBFrame.h"
14
15	#include "lldb/lldb-types.h"
16
17	#include "SBReproducerPrivate.h"
18	#include "Utils.h"
19	#include "lldb/Core/Address.h"
20	#include "lldb/Core/StreamFile.h"
21	#include "lldb/Core/ValueObjectRegister.h"
22	#include "lldb/Core/ValueObjectVariable.h"
23	#include "lldb/Expression/ExpressionVariable.h"
24	#include "lldb/Expression/UserExpression.h"
25	#include "lldb/Host/Host.h"
26	#include "lldb/Symbol/Block.h"
27	#include "lldb/Symbol/Function.h"
28	#include "lldb/Symbol/Symbol.h"
29	#include "lldb/Symbol/SymbolContext.h"
30	#include "lldb/Symbol/Variable.h"
31	#include "lldb/Symbol/VariableList.h"
32	#include "lldb/Target/ExecutionContext.h"
33	#include "lldb/Target/Process.h"
34	#include "lldb/Target/RegisterContext.h"
35	#include "lldb/Target/StackFrame.h"
36	#include "lldb/Target/StackFrameRecognizer.h"
37	#include "lldb/Target/StackID.h"
38	#include "lldb/Target/Target.h"
39	#include "lldb/Target/Thread.h"
40	#include "lldb/Utility/ConstString.h"
41	#include "lldb/Utility/Stream.h"
42
43	#include "lldb/API/SBAddress.h"
44	#include "lldb/API/SBDebugger.h"
45	#include "lldb/API/SBExpressionOptions.h"
46	#include "lldb/API/SBStream.h"
47	#include "lldb/API/SBSymbolContext.h"
48	#include "lldb/API/SBThread.h"
49	#include "lldb/API/SBValue.h"
50	#include "lldb/API/SBVariablesOptions.h"
51
52	#include "llvm/Support/PrettyStackTrace.h"
53
54	using namespace lldb;
55	using namespace lldb_private;
56
57	SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
58	LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__); lldb_private::repro::construct<SBFrame()>::handle(lldb_private ::repro::InstrumentationData::Instance(), _recorder, this, lldb_private ::repro::EmptyArg());;
59	}
60
61	SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
62	: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
63	LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__); lldb_private::repro::construct<SBFrame (const lldb::StackFrameSP &)>::handle(lldb_private::repro::InstrumentationData:: Instance(), _recorder, this, lldb_object_sp);
64	lldb_object_sp)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__); lldb_private::repro::construct<SBFrame (const lldb::StackFrameSP &)>::handle(lldb_private::repro::InstrumentationData:: Instance(), _recorder, this, lldb_object_sp);;
65	}
66
67	SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
68	LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__); lldb_private::repro::construct<SBFrame (const lldb::SBFrame &)>::handle(lldb_private::repro::InstrumentationData:: Instance(), _recorder, this, rhs);;
69
70	m_opaque_sp = clone(rhs.m_opaque_sp);
71	}
72
73	SBFrame::~SBFrame() = default;
74
75	const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
76	LLDB_RECORD_METHOD(const lldb::SBFrame &,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, rhs)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<const lldb::SBFrame &(SBFrame ::) (const lldb::SBFrame &)>::method<(&SBFrame ::operator=)>::record, this, rhs); } else if (lldb_private ::repro::Deserializer _deserializer = _data.GetDeserializer( )) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<const lldb::SBFrame &(SBFrame::) (const lldb ::SBFrame &)>::method<(&SBFrame::operator=)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } }
77	SBFrame, operator=,(const lldb::SBFrame &), rhs)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, rhs)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<const lldb::SBFrame &(SBFrame ::) (const lldb::SBFrame &)>::method<(&SBFrame ::operator=)>::record, this, rhs); } else if (lldb_private ::repro::Deserializer _deserializer = _data.GetDeserializer( )) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<const lldb::SBFrame &(SBFrame::) (const lldb ::SBFrame &)>::method<(&SBFrame::operator=)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
78
79	if (this != &rhs)
80	m_opaque_sp = clone(rhs.m_opaque_sp);
81	return LLDB_RECORD_RESULT(this)_recorder.RecordResult(this, true);;
82	}
83
84	StackFrameSP SBFrame::GetFrameSP() const {
85	return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
86	}
87
88	void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
89	return m_opaque_sp->SetFrameSP(lldb_object_sp);
90	}
91
92	bool SBFrame::IsValid() const {
93	LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool (SBFrame::)() const>:: method<(&SBFrame::IsValid)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<bool (SBFrame::)() const>::method<(&SBFrame ::IsValid)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
94	return this->operator bool();
95	}
96	SBFrame::operator bool() const {
97	LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool (SBFrame::)() const>:: method<(&SBFrame::operator bool)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<bool (SBFrame::)() const> ::method<(&SBFrame::operator bool)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
98
99	std::unique_lock<std::recursive_mutex> lock;
100	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
101
102	Target *target = exe_ctx.GetTargetPtr();
103	Process *process = exe_ctx.GetProcessPtr();
104	if (target && process) {
105	Process::StopLocker stop_locker;
106	if (stop_locker.TryLock(&process->GetRunLock()))
107	return GetFrameSP().get() != nullptr;
108	}
109
110	// Without a target & process we can't have a valid stack frame.
111	return false;
112	}
113
114	SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
115	LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, resolve_scope)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBSymbolContext (SBFrame::) (uint32_t) const>::method<(&SBFrame::GetSymbolContext )>::record, this, resolve_scope); } else if (lldb_private:: repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBSymbolContext(SBFrame::) (uint32_t) const >::method<(&SBFrame::GetSymbolContext)>::replay( _recorder, _deserializer, _data.GetRegistry()); } } }
116	(uint32_t), resolve_scope)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, resolve_scope)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBSymbolContext (SBFrame::) (uint32_t) const>::method<(&SBFrame::GetSymbolContext )>::record, this, resolve_scope); } else if (lldb_private:: repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBSymbolContext(SBFrame::) (uint32_t) const >::method<(&SBFrame::GetSymbolContext)>::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
117
118	SBSymbolContext sb_sym_ctx;
119	std::unique_lock<std::recursive_mutex> lock;
120	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
121	SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
122	StackFrame *frame = nullptr;
123	Target *target = exe_ctx.GetTargetPtr();
124	Process *process = exe_ctx.GetProcessPtr();
125	if (target && process) {
126	Process::StopLocker stop_locker;
127	if (stop_locker.TryLock(&process->GetRunLock())) {
128	frame = exe_ctx.GetFramePtr();
129	if (frame)
130	sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(scope));
131	}
132	}
133
134	return LLDB_RECORD_RESULT(sb_sym_ctx)_recorder.RecordResult(sb_sym_ctx, true);;
135	}
136
137	SBModule SBFrame::GetModule() const {
138	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBModule (SBFrame::)() const >::method<(&SBFrame::GetModule)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBModule (SBFrame::)() const>::method<(&SBFrame::GetModule)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
139
140	SBModule sb_module;
141	ModuleSP module_sp;
142	std::unique_lock<std::recursive_mutex> lock;
143	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
144
145	StackFrame *frame = nullptr;
146	Target *target = exe_ctx.GetTargetPtr();
147	Process *process = exe_ctx.GetProcessPtr();
148	if (target && process) {
149	Process::StopLocker stop_locker;
150	if (stop_locker.TryLock(&process->GetRunLock())) {
151	frame = exe_ctx.GetFramePtr();
152	if (frame) {
153	module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp;
154	sb_module.SetSP(module_sp);
155	}
156	}
157	}
158
159	return LLDB_RECORD_RESULT(sb_module)_recorder.RecordResult(sb_module, true);;
160	}
161
162	SBCompileUnit SBFrame::GetCompileUnit() const {
163	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBCompileUnit (SBFrame:: )() const>::method<(&SBFrame::GetCompileUnit)>:: record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBCompileUnit (SBFrame::)() const>::method<(&SBFrame::GetCompileUnit )>::replay( _recorder, _deserializer, _data.GetRegistry() ); } } }
164	GetCompileUnit)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBCompileUnit (SBFrame:: )() const>::method<(&SBFrame::GetCompileUnit)>:: record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBCompileUnit (SBFrame::)() const>::method<(&SBFrame::GetCompileUnit )>::replay( _recorder, _deserializer, _data.GetRegistry() ); } } };
165
166	SBCompileUnit sb_comp_unit;
167	std::unique_lock<std::recursive_mutex> lock;
168	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
169
170	StackFrame *frame = nullptr;
171	Target *target = exe_ctx.GetTargetPtr();
172	Process *process = exe_ctx.GetProcessPtr();
173	if (target && process) {
174	Process::StopLocker stop_locker;
175	if (stop_locker.TryLock(&process->GetRunLock())) {
176	frame = exe_ctx.GetFramePtr();
177	if (frame) {
178	sb_comp_unit.reset(
179	frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit);
180	}
181	}
182	}
183
184	return LLDB_RECORD_RESULT(sb_comp_unit)_recorder.RecordResult(sb_comp_unit, true);;
185	}
186
187	SBFunction SBFrame::GetFunction() const {
188	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBFunction (SBFrame::)( ) const>::method<(&SBFrame::GetFunction)>::record , this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBFunction (SBFrame ::)() const>::method<(&SBFrame::GetFunction)>:: replay( _recorder, _deserializer, _data.GetRegistry()); } } };
189
190	SBFunction sb_function;
191	std::unique_lock<std::recursive_mutex> lock;
192	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
193
194	StackFrame *frame = nullptr;
195	Target *target = exe_ctx.GetTargetPtr();
196	Process *process = exe_ctx.GetProcessPtr();
197	if (target && process) {
198	Process::StopLocker stop_locker;
199	if (stop_locker.TryLock(&process->GetRunLock())) {
200	frame = exe_ctx.GetFramePtr();
201	if (frame) {
202	sb_function.reset(
203	frame->GetSymbolContext(eSymbolContextFunction).function);
204	}
205	}
206	}
207
208	return LLDB_RECORD_RESULT(sb_function)_recorder.RecordResult(sb_function, true);;
209	}
210
211	SBSymbol SBFrame::GetSymbol() const {
212	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBSymbol (SBFrame::)() const >::method<(&SBFrame::GetSymbol)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBSymbol (SBFrame::)() const>::method<(&SBFrame::GetSymbol)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
213
214	SBSymbol sb_symbol;
215	std::unique_lock<std::recursive_mutex> lock;
216	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
217
218	StackFrame *frame = nullptr;
219	Target *target = exe_ctx.GetTargetPtr();
220	Process *process = exe_ctx.GetProcessPtr();
221	if (target && process) {
222	Process::StopLocker stop_locker;
223	if (stop_locker.TryLock(&process->GetRunLock())) {
224	frame = exe_ctx.GetFramePtr();
225	if (frame) {
226	sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol);
227	}
228	}
229	}
230
231	return LLDB_RECORD_RESULT(sb_symbol)_recorder.RecordResult(sb_symbol, true);;
232	}
233
234	SBBlock SBFrame::GetBlock() const {
235	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBBlock (SBFrame::)() const >::method<(&SBFrame::GetBlock)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBBlock (SBFrame::)() const >::method<(&SBFrame::GetBlock)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
236
237	SBBlock sb_block;
238	std::unique_lock<std::recursive_mutex> lock;
239	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
240
241	StackFrame *frame = nullptr;
242	Target *target = exe_ctx.GetTargetPtr();
243	Process *process = exe_ctx.GetProcessPtr();
244	if (target && process) {
245	Process::StopLocker stop_locker;
246	if (stop_locker.TryLock(&process->GetRunLock())) {
247	frame = exe_ctx.GetFramePtr();
248	if (frame)
249	sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
250	}
251	}
252	return LLDB_RECORD_RESULT(sb_block)_recorder.RecordResult(sb_block, true);;
253	}
254
255	SBBlock SBFrame::GetFrameBlock() const {
256	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBBlock (SBFrame::)() const >::method<(&SBFrame::GetFrameBlock)>::record, this ); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBBlock (SBFrame ::)() const>::method<(&SBFrame::GetFrameBlock)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
257
258	SBBlock sb_block;
259	std::unique_lock<std::recursive_mutex> lock;
260	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
261
262	StackFrame *frame = nullptr;
263	Target *target = exe_ctx.GetTargetPtr();
264	Process *process = exe_ctx.GetProcessPtr();
265	if (target && process) {
266	Process::StopLocker stop_locker;
267	if (stop_locker.TryLock(&process->GetRunLock())) {
268	frame = exe_ctx.GetFramePtr();
269	if (frame)
270	sb_block.SetPtr(frame->GetFrameBlock());
271	}
272	}
273	return LLDB_RECORD_RESULT(sb_block)_recorder.RecordResult(sb_block, true);;
274	}
275
276	SBLineEntry SBFrame::GetLineEntry() const {
277	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBLineEntry (SBFrame::) () const>::method<(&SBFrame::GetLineEntry)>::record , this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBLineEntry (SBFrame ::)() const>::method<(&SBFrame::GetLineEntry)>:: replay( _recorder, _deserializer, _data.GetRegistry()); } } };
278
279	SBLineEntry sb_line_entry;
280	std::unique_lock<std::recursive_mutex> lock;
281	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
282
283	StackFrame *frame = nullptr;
284	Target *target = exe_ctx.GetTargetPtr();
285	Process *process = exe_ctx.GetProcessPtr();
286	if (target && process) {
287	Process::StopLocker stop_locker;
288	if (stop_locker.TryLock(&process->GetRunLock())) {
289	frame = exe_ctx.GetFramePtr();
290	if (frame) {
291	sb_line_entry.SetLineEntry(
292	frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
293	}
294	}
295	}
296	return LLDB_RECORD_RESULT(sb_line_entry)_recorder.RecordResult(sb_line_entry, true);;
297	}
298
299	uint32_t SBFrame::GetFrameID() const {
300	LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<uint32_t (SBFrame::)() const> ::method<(&SBFrame::GetFrameID)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<uint32_t (SBFrame::)() const >::method<(&SBFrame::GetFrameID)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
301
302	uint32_t frame_idx = UINT32_MAX0xffffffffU;
303
304	std::unique_lock<std::recursive_mutex> lock;
305	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
306
307	StackFrame *frame = exe_ctx.GetFramePtr();
308	if (frame)
309	frame_idx = frame->GetFrameIndex();
310
311	return frame_idx;
312	}
313
314	lldb::addr_t SBFrame::GetCFA() const {
315	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetCFA)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetCFA)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
316
317	std::unique_lock<std::recursive_mutex> lock;
318	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
319
320	StackFrame *frame = exe_ctx.GetFramePtr();
321	if (frame)
322	return frame->GetStackID().GetCallFrameAddress();
323	return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
324	}
325
326	addr_t SBFrame::GetPC() const {
327	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetPC)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetPC)>::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
328
329	addr_t addr = LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
330	std::unique_lock<std::recursive_mutex> lock;
331	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
332
333	StackFrame *frame = nullptr;
334	Target *target = exe_ctx.GetTargetPtr();
335	Process *process = exe_ctx.GetProcessPtr();
336	if (target && process) {
337	Process::StopLocker stop_locker;
338	if (stop_locker.TryLock(&process->GetRunLock())) {
339	frame = exe_ctx.GetFramePtr();
340	if (frame) {
341	addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
342	target, AddressClass::eCode);
343	}
344	}
345	}
346
347	return addr;
348	}
349
350	bool SBFrame::SetPC(addr_t new_pc) {
351	LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, new_pc)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<bool(SBFrame::) (lldb ::addr_t)>::method<(&SBFrame::SetPC)>::record, this , new_pc); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<bool(SBFrame::) (lldb ::addr_t)>::method<(&SBFrame::SetPC)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
352
353	bool ret_val = false;
354	std::unique_lock<std::recursive_mutex> lock;
355	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
356
357	Target *target = exe_ctx.GetTargetPtr();
358	Process *process = exe_ctx.GetProcessPtr();
359	if (target && process) {
360	Process::StopLocker stop_locker;
361	if (stop_locker.TryLock(&process->GetRunLock())) {
362	if (StackFrame *frame = exe_ctx.GetFramePtr()) {
363	if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
364	ret_val = reg_ctx_sp->SetPC(new_pc);
365	}
366	}
367	}
368	}
369
370	return ret_val;
371	}
372
373	addr_t SBFrame::GetSP() const {
374	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetSP)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetSP)>::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
375
376	addr_t addr = LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
377	std::unique_lock<std::recursive_mutex> lock;
378	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
379
380	Target *target = exe_ctx.GetTargetPtr();
381	Process *process = exe_ctx.GetProcessPtr();
382	if (target && process) {
383	Process::StopLocker stop_locker;
384	if (stop_locker.TryLock(&process->GetRunLock())) {
385	if (StackFrame *frame = exe_ctx.GetFramePtr()) {
386	if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
387	addr = reg_ctx_sp->GetSP();
388	}
389	}
390	}
391	}
392
393	return addr;
394	}
395
396	addr_t SBFrame::GetFP() const {
397	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetFP)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::addr_t (SBFrame::)() const >::method<(&SBFrame::GetFP)>::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
398
399	addr_t addr = LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
400	std::unique_lock<std::recursive_mutex> lock;
401	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
402
403	Target *target = exe_ctx.GetTargetPtr();
404	Process *process = exe_ctx.GetProcessPtr();
405	if (target && process) {
406	Process::StopLocker stop_locker;
407	if (stop_locker.TryLock(&process->GetRunLock())) {
408	if (StackFrame *frame = exe_ctx.GetFramePtr()) {
409	if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
410	addr = reg_ctx_sp->GetFP();
411	}
412	}
413	}
414	}
415
416	return addr;
417	}
418
419	SBAddress SBFrame::GetPCAddress() const {
420	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBAddress (SBFrame::)() const>::method<(&SBFrame::GetPCAddress)>::record , this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBAddress (SBFrame ::)() const>::method<(&SBFrame::GetPCAddress)>:: replay( _recorder, _deserializer, _data.GetRegistry()); } } };
421
422	SBAddress sb_addr;
423	std::unique_lock<std::recursive_mutex> lock;
424	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
425
426	StackFrame *frame = exe_ctx.GetFramePtr();
	Value stored to 'frame' during its initialization is never read
427	Target *target = exe_ctx.GetTargetPtr();
428	Process *process = exe_ctx.GetProcessPtr();
429	if (target && process) {
430	Process::StopLocker stop_locker;
431	if (stop_locker.TryLock(&process->GetRunLock())) {
432	frame = exe_ctx.GetFramePtr();
433	if (frame)
434	sb_addr.SetAddress(frame->GetFrameCodeAddress());
435	}
436	}
437	return LLDB_RECORD_RESULT(sb_addr)_recorder.RecordResult(sb_addr, true);;
438	}
439
440	void SBFrame::Clear() {
441	LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<void (SBFrame::)()>::method <(&SBFrame::Clear)>::record, this); } else if (lldb_private ::repro::Deserializer _deserializer = _data.GetDeserializer( )) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<void (SBFrame::)()>::method<(&SBFrame:: Clear)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
442
443	m_opaque_sp->Clear();
444	}
445
446	lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
447	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, var_path)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::GetValueForVariablePath )>::record, this, var_path); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <lldb::SBValue(SBFrame::) (const char )>::method<( &SBFrame::GetValueForVariablePath)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } }
448	(const char ), var_path)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, var_path)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::GetValueForVariablePath )>::record, this, var_path); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <lldb::SBValue(SBFrame::) (const char )>::method<( &SBFrame::GetValueForVariablePath)>::replay( _recorder , *_deserializer, _data.GetRegistry()); } } };
449
450	SBValue sb_value;
451	std::unique_lock<std::recursive_mutex> lock;
452	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
453
454	StackFrame *frame = exe_ctx.GetFramePtr();
455	Target *target = exe_ctx.GetTargetPtr();
456	if (frame && target) {
457	lldb::DynamicValueType use_dynamic =
458	frame->CalculateTarget()->GetPreferDynamicValue();
459	sb_value = GetValueForVariablePath(var_path, use_dynamic);
460	}
461	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
462	}
463
464	lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
465	DynamicValueType use_dynamic) {
466	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, var_path, use_dynamic)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::GetValueForVariablePath)>::record, this, var_path , use_dynamic); } else if (lldb_private::repro::Deserializer * _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::GetValueForVariablePath)>::replay( _recorder, *_deserializer , _data.GetRegistry()); } } }
467	(const char , lldb::DynamicValueType), var_path,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, var_path, use_dynamic)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::GetValueForVariablePath)>::record, this, var_path , use_dynamic); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::GetValueForVariablePath)>::replay( _recorder, *_deserializer , _data.GetRegistry()); } } }
468	use_dynamic)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, var_path, use_dynamic)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::GetValueForVariablePath)>::record, this, var_path , use_dynamic); } else if (lldb_private::repro::Deserializer * _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::GetValueForVariablePath)>::replay( _recorder, *_deserializer , _data.GetRegistry()); } } };
469
470	SBValue sb_value;
471	if (var_path == nullptr \|\| var_path[0] == '\0') {
472	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
473	}
474
475	std::unique_lock<std::recursive_mutex> lock;
476	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
477
478	StackFrame *frame = nullptr;
479	Target *target = exe_ctx.GetTargetPtr();
480	Process *process = exe_ctx.GetProcessPtr();
481	if (target && process) {
482	Process::StopLocker stop_locker;
483	if (stop_locker.TryLock(&process->GetRunLock())) {
484	frame = exe_ctx.GetFramePtr();
485	if (frame) {
486	VariableSP var_sp;
487	Status error;
488	ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
489	var_path, eNoDynamicValues,
490	StackFrame::eExpressionPathOptionCheckPtrVsMember \|
491	StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
492	var_sp, error));
493	sb_value.SetSP(value_sp, use_dynamic);
494	}
495	}
496	}
497	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
498	}
499
500	SBValue SBFrame::FindVariable(const char *name) {
501	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char ),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::FindVariable)>::record , this, name); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::FindVariable )>::replay( _recorder, *_deserializer, _data.GetRegistry() ); } } }
502	name)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::FindVariable)>::record , this, name); } else if (lldb_private::repro::Deserializer * _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::FindVariable )>::replay( _recorder, *_deserializer, _data.GetRegistry() ); } } };
503
504	SBValue value;
505	std::unique_lock<std::recursive_mutex> lock;
506	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
507
508	StackFrame *frame = exe_ctx.GetFramePtr();
509	Target *target = exe_ctx.GetTargetPtr();
510	if (frame && target) {
511	lldb::DynamicValueType use_dynamic =
512	frame->CalculateTarget()->GetPreferDynamicValue();
513	value = FindVariable(name, use_dynamic);
514	}
515	return LLDB_RECORD_RESULT(value)_recorder.RecordResult(value, true);;
516	}
517
518	SBValue SBFrame::FindVariable(const char *name,
519	lldb::DynamicValueType use_dynamic) {
520	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, use_dynamic)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::FindVariable)>::record, this, name, use_dynamic); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame ::FindVariable)>::replay( _recorder, _deserializer, _data .GetRegistry()); } } }
521	(const char , lldb::DynamicValueType), name, use_dynamic)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, use_dynamic)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::FindVariable)>::record, this, name, use_dynamic); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame ::FindVariable)>::replay( _recorder, *_deserializer, _data .GetRegistry()); } } };
522
523	VariableSP var_sp;
524	SBValue sb_value;
525
526	if (name == nullptr \|\| name[0] == '\0') {
527	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
528	}
529
530	ValueObjectSP value_sp;
531	std::unique_lock<std::recursive_mutex> lock;
532	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
533
534	StackFrame *frame = nullptr;
535	Target *target = exe_ctx.GetTargetPtr();
536	Process *process = exe_ctx.GetProcessPtr();
537	if (target && process) {
538	Process::StopLocker stop_locker;
539	if (stop_locker.TryLock(&process->GetRunLock())) {
540	frame = exe_ctx.GetFramePtr();
541	if (frame) {
542	value_sp = frame->FindVariable(ConstString(name));
543
544	if (value_sp)
545	sb_value.SetSP(value_sp, use_dynamic);
546	}
547	}
548	}
549
550	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
551	}
552
553	SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
554	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, value_type)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::ValueType)>::method<(&SBFrame ::FindValue)>::record, this, name, value_type); } else if ( lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType )>::method<(&SBFrame::FindValue)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } }
555	(const char , lldb::ValueType), name, value_type)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, value_type)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::ValueType)>::method<(&SBFrame ::FindValue)>::record, this, name, value_type); } else if ( lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType )>::method<(&SBFrame::FindValue)>::replay( _recorder , *_deserializer, _data.GetRegistry()); } } };
556
557	SBValue value;
558	std::unique_lock<std::recursive_mutex> lock;
559	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
560
561	StackFrame *frame = exe_ctx.GetFramePtr();
562	Target *target = exe_ctx.GetTargetPtr();
563	if (frame && target) {
564	lldb::DynamicValueType use_dynamic =
565	frame->CalculateTarget()->GetPreferDynamicValue();
566	value = FindValue(name, value_type, use_dynamic);
567	}
568	return LLDB_RECORD_RESULT(value)_recorder.RecordResult(value, true);;
569	}
570
571	SBValue SBFrame::FindValue(const char *name, ValueType value_type,
572	lldb::DynamicValueType use_dynamic) {
573	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, value_type, use_dynamic)); if (lldb_private::repro ::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType )>::method<(&SBFrame::FindValue)>::record, this, name, value_type, use_dynamic); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <lldb::SBValue(SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType)>::method<(&SBFrame::FindValue )>::replay( _recorder, _deserializer, _data.GetRegistry() ); } } }
574	(const char , lldb::ValueType, lldb::DynamicValueType),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, value_type, use_dynamic)); if (lldb_private::repro ::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType )>::method<(&SBFrame::FindValue)>::record, this, name, value_type, use_dynamic); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <lldb::SBValue(SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType)>::method<(&SBFrame::FindValue )>::replay( _recorder, *_deserializer, _data.GetRegistry() ); } } }
575	name, value_type, use_dynamic)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name, value_type, use_dynamic)); if (lldb_private::repro ::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType )>::method<(&SBFrame::FindValue)>::record, this, name, value_type, use_dynamic); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <lldb::SBValue(SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType)>::method<(&SBFrame::FindValue )>::replay( _recorder, _deserializer, _data.GetRegistry() ); } } };
576
577	SBValue sb_value;
578
579	if (name == nullptr \|\| name[0] == '\0') {
580	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
581	}
582
583	ValueObjectSP value_sp;
584	std::unique_lock<std::recursive_mutex> lock;
585	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
586
587	StackFrame *frame = nullptr;
588	Target *target = exe_ctx.GetTargetPtr();
589	Process *process = exe_ctx.GetProcessPtr();
590	if (target && process) {
591	Process::StopLocker stop_locker;
592	if (stop_locker.TryLock(&process->GetRunLock())) {
593	frame = exe_ctx.GetFramePtr();
594	if (frame) {
595	VariableList variable_list;
596
597	switch (value_type) {
598	case eValueTypeVariableGlobal: // global variable
599	case eValueTypeVariableStatic: // static variable
600	case eValueTypeVariableArgument: // function argument variables
601	case eValueTypeVariableLocal: // function local variables
602	case eValueTypeVariableThreadLocal: // thread local variables
603	{
604	SymbolContext sc(frame->GetSymbolContext(eSymbolContextBlock));
605
606	const bool can_create = true;
607	const bool get_parent_variables = true;
608	const bool stop_if_block_is_inlined_function = true;
609
610	if (sc.block)
611	sc.block->AppendVariables(
612	can_create, get_parent_variables,
613	stop_if_block_is_inlined_function,
614	[frame](Variable *v) { return v->IsInScope(frame); },
615	&variable_list);
616	if (value_type == eValueTypeVariableGlobal) {
617	const bool get_file_globals = true;
618	VariableList *frame_vars = frame->GetVariableList(get_file_globals);
619	if (frame_vars)
620	frame_vars->AppendVariablesIfUnique(variable_list);
621	}
622	ConstString const_name(name);
623	VariableSP variable_sp(
624	variable_list.FindVariable(const_name, value_type));
625	if (variable_sp) {
626	value_sp = frame->GetValueObjectForFrameVariable(variable_sp,
627	eNoDynamicValues);
628	sb_value.SetSP(value_sp, use_dynamic);
629	}
630	} break;
631
632	case eValueTypeRegister: // stack frame register value
633	{
634	RegisterContextSP reg_ctx(frame->GetRegisterContext());
635	if (reg_ctx) {
636	const uint32_t num_regs = reg_ctx->GetRegisterCount();
637	for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
638	const RegisterInfo *reg_info =
639	reg_ctx->GetRegisterInfoAtIndex(reg_idx);
640	if (reg_info &&
641	((reg_info->name && strcasecmp(reg_info->name, name) == 0) \|\|
642	(reg_info->alt_name &&
643	strcasecmp(reg_info->alt_name, name) == 0))) {
644	value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
645	sb_value.SetSP(value_sp);
646	break;
647	}
648	}
649	}
650	} break;
651
652	case eValueTypeRegisterSet: // A collection of stack frame register
653	// values
654	{
655	RegisterContextSP reg_ctx(frame->GetRegisterContext());
656	if (reg_ctx) {
657	const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
658	for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
659	const RegisterSet *reg_set = reg_ctx->GetRegisterSet(set_idx);
660	if (reg_set &&
661	((reg_set->name && strcasecmp(reg_set->name, name) == 0) \|\|
662	(reg_set->short_name &&
663	strcasecmp(reg_set->short_name, name) == 0))) {
664	value_sp =
665	ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx);
666	sb_value.SetSP(value_sp);
667	break;
668	}
669	}
670	}
671	} break;
672
673	case eValueTypeConstResult: // constant result variables
674	{
675	ConstString const_name(name);
676	ExpressionVariableSP expr_var_sp(
677	target->GetPersistentVariable(const_name));
678	if (expr_var_sp) {
679	value_sp = expr_var_sp->GetValueObject();
680	sb_value.SetSP(value_sp, use_dynamic);
681	}
682	} break;
683
684	default:
685	break;
686	}
687	}
688	}
689	}
690
691	return LLDB_RECORD_RESULT(sb_value)_recorder.RecordResult(sb_value, true);;
692	}
693
694	bool SBFrame::IsEqual(const SBFrame &that) const {
695	LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, that)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool(SBFrame::) (const lldb:: SBFrame &) const>::method<(&SBFrame::IsEqual)> ::record, this, that); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<bool(SBFrame::) ( const lldb::SBFrame &) const>::method<(&SBFrame ::IsEqual)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } }
696	that)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, that)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool(SBFrame::) (const lldb:: SBFrame &) const>::method<(&SBFrame::IsEqual)> ::record, this, that); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<bool(SBFrame::) ( const lldb::SBFrame &) const>::method<(&SBFrame ::IsEqual)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
697
698	lldb::StackFrameSP this_sp = GetFrameSP();
699	lldb::StackFrameSP that_sp = that.GetFrameSP();
700	return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
701	}
702
703	bool SBFrame::operator==(const SBFrame &rhs) const {
704	LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, rhs)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool(SBFrame::) (const lldb:: SBFrame &) const>::method<(&SBFrame::operator== )>::record, this, rhs); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<bool(SBFrame::) ( const lldb::SBFrame &) const>::method<(&SBFrame ::operator==)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } }
705	rhs)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, rhs)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool(SBFrame::) (const lldb:: SBFrame &) const>::method<(&SBFrame::operator== )>::record, this, rhs); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<bool(SBFrame::) ( const lldb::SBFrame &) const>::method<(&SBFrame ::operator==)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
706
707	return IsEqual(rhs);
708	}
709
710	bool SBFrame::operator!=(const SBFrame &rhs) const {
711	LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, rhs)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool(SBFrame::) (const lldb:: SBFrame &) const>::method<(&SBFrame::operator!= )>::record, this, rhs); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<bool(SBFrame::) ( const lldb::SBFrame &) const>::method<(&SBFrame ::operator!=)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } }
712	rhs)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, rhs)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool(SBFrame::) (const lldb:: SBFrame &) const>::method<(&SBFrame::operator!= )>::record, this, rhs); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<bool(SBFrame::) ( const lldb::SBFrame &) const>::method<(&SBFrame ::operator!=)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
713
714	return !IsEqual(rhs);
715	}
716
717	SBThread SBFrame::GetThread() const {
718	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBThread (SBFrame::)() const >::method<(&SBFrame::GetThread)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBThread (SBFrame::)() const>::method<(&SBFrame::GetThread)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
719
720	std::unique_lock<std::recursive_mutex> lock;
721	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
722
723	ThreadSP thread_sp(exe_ctx.GetThreadSP());
724	SBThread sb_thread(thread_sp);
725
726	return LLDB_RECORD_RESULT(sb_thread)_recorder.RecordResult(sb_thread, true);;
727	}
728
729	const char *SBFrame::Disassemble() const {
730	LLDB_RECORD_METHOD_CONST_NO_ARGS(const char , SBFrame, Disassemble)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<const char (SBFrame::)() const >::method<(&SBFrame::Disassemble)>::record, this ); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<const char * (SBFrame:: )() const>::method<(&SBFrame::Disassemble)>::replay ( _recorder, _deserializer, _data.GetRegistry()); } } };
731
732	const char *disassembly = nullptr;
733	std::unique_lock<std::recursive_mutex> lock;
734	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
735
736	StackFrame *frame = nullptr;
737	Target *target = exe_ctx.GetTargetPtr();
738	Process *process = exe_ctx.GetProcessPtr();
739	if (target && process) {
740	Process::StopLocker stop_locker;
741	if (stop_locker.TryLock(&process->GetRunLock())) {
742	frame = exe_ctx.GetFramePtr();
743	if (frame) {
744	disassembly = frame->Disassemble();
745	}
746	}
747	}
748
749	return disassembly;
750	}
751
752	SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
753	bool in_scope_only) {
754	LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, arguments, locals, statics, in_scope_only)); if (lldb_private ::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool)>::method<(&SBFrame ::GetVariables)>::record, this, arguments, locals, statics , in_scope_only); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool)>::method<(&SBFrame ::GetVariables)>::replay( _recorder, _deserializer, _data .GetRegistry()); } } }
755	(bool, bool, bool, bool), arguments, locals, statics,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, arguments, locals, statics, in_scope_only)); if (lldb_private ::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool)>::method<(&SBFrame ::GetVariables)>::record, this, arguments, locals, statics , in_scope_only); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool)>::method<(&SBFrame ::GetVariables)>::replay( _recorder, _deserializer, _data .GetRegistry()); } } }
756	in_scope_only)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, arguments, locals, statics, in_scope_only)); if (lldb_private ::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool)>::method<(&SBFrame ::GetVariables)>::record, this, arguments, locals, statics , in_scope_only); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool)>::method<(&SBFrame ::GetVariables)>::replay( _recorder, _deserializer, _data .GetRegistry()); } } };
757
758	SBValueList value_list;
759	std::unique_lock<std::recursive_mutex> lock;
760	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
761
762	StackFrame *frame = exe_ctx.GetFramePtr();
763	Target *target = exe_ctx.GetTargetPtr();
764	if (frame && target) {
765	lldb::DynamicValueType use_dynamic =
766	frame->CalculateTarget()->GetPreferDynamicValue();
767	const bool include_runtime_support_values =
768	target ? target->GetDisplayRuntimeSupportValues() : false;
769
770	SBVariablesOptions options;
771	options.SetIncludeArguments(arguments);
772	options.SetIncludeLocals(locals);
773	options.SetIncludeStatics(statics);
774	options.SetInScopeOnly(in_scope_only);
775	options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
776	options.SetUseDynamic(use_dynamic);
777
778	value_list = GetVariables(options);
779	}
780	return LLDB_RECORD_RESULT(value_list)_recorder.RecordResult(value_list, true);;
781	}
782
783	lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
784	bool statics, bool in_scope_only,
785	lldb::DynamicValueType use_dynamic) {
786	LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, arguments, locals, statics, in_scope_only, use_dynamic )); if (lldb_private::repro::InstrumentationData _data = lldb_private ::repro::InstrumentationData::Instance()) { if (lldb_private:: repro::Serializer _serializer = _data.GetSerializer()) { _recorder .Record(_serializer, _data.GetRegistry(), &lldb_private:: repro::invoke<lldb::SBValueList(SBFrame::) (bool, bool, bool , bool, lldb::DynamicValueType)>::method<(&SBFrame:: GetVariables)>::record, this, arguments, locals, statics, in_scope_only , use_dynamic); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool, lldb::DynamicValueType) >::method<(&SBFrame::GetVariables)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } }
787	(bool, bool, bool, bool, lldb::DynamicValueType),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, arguments, locals, statics, in_scope_only, use_dynamic )); if (lldb_private::repro::InstrumentationData _data = lldb_private ::repro::InstrumentationData::Instance()) { if (lldb_private:: repro::Serializer _serializer = _data.GetSerializer()) { _recorder .Record(_serializer, _data.GetRegistry(), &lldb_private:: repro::invoke<lldb::SBValueList(SBFrame::) (bool, bool, bool , bool, lldb::DynamicValueType)>::method<(&SBFrame:: GetVariables)>::record, this, arguments, locals, statics, in_scope_only , use_dynamic); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool, lldb::DynamicValueType) >::method<(&SBFrame::GetVariables)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } }
788	arguments, locals, statics, in_scope_only, use_dynamic)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, arguments, locals, statics, in_scope_only, use_dynamic )); if (lldb_private::repro::InstrumentationData _data = lldb_private ::repro::InstrumentationData::Instance()) { if (lldb_private:: repro::Serializer _serializer = _data.GetSerializer()) { _recorder .Record(_serializer, _data.GetRegistry(), &lldb_private:: repro::invoke<lldb::SBValueList(SBFrame::) (bool, bool, bool , bool, lldb::DynamicValueType)>::method<(&SBFrame:: GetVariables)>::record, this, arguments, locals, statics, in_scope_only , use_dynamic); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) (bool, bool, bool, bool, lldb::DynamicValueType) >::method<(&SBFrame::GetVariables)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
789
790	std::unique_lock<std::recursive_mutex> lock;
791	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
792
793	Target *target = exe_ctx.GetTargetPtr();
794	const bool include_runtime_support_values =
795	target ? target->GetDisplayRuntimeSupportValues() : false;
796	SBVariablesOptions options;
797	options.SetIncludeArguments(arguments);
798	options.SetIncludeLocals(locals);
799	options.SetIncludeStatics(statics);
800	options.SetInScopeOnly(in_scope_only);
801	options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
802	options.SetUseDynamic(use_dynamic);
803	return LLDB_RECORD_RESULT(GetVariables(options))_recorder.RecordResult(GetVariables(options), true);;
804	}
805
806	SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
807	LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, options)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValueList(SBFrame ::) (const lldb::SBVariablesOptions &)>::method<(& SBFrame::GetVariables)>::record, this, options); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValueList(SBFrame::) (const lldb::SBVariablesOptions &)>::method<(&SBFrame::GetVariables)>::replay ( _recorder, _deserializer, _data.GetRegistry()); } } }
808	(const lldb::SBVariablesOptions &), options)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, options)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValueList(SBFrame ::) (const lldb::SBVariablesOptions &)>::method<(& SBFrame::GetVariables)>::record, this, options); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValueList(SBFrame::) (const lldb::SBVariablesOptions &)>::method<(&SBFrame::GetVariables)>::replay ( _recorder, _deserializer, _data.GetRegistry()); } } };
809
810	SBValueList value_list;
811	std::unique_lock<std::recursive_mutex> lock;
812	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
813
814	StackFrame *frame = nullptr;
815	Target *target = exe_ctx.GetTargetPtr();
816
817	const bool statics = options.GetIncludeStatics();
818	const bool arguments = options.GetIncludeArguments();
819	const bool recognized_arguments =
820	options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP()));
821	const bool locals = options.GetIncludeLocals();
822	const bool in_scope_only = options.GetInScopeOnly();
823	const bool include_runtime_support_values =
824	options.GetIncludeRuntimeSupportValues();
825	const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
826
827
828	std::set<VariableSP> variable_set;
829	Process *process = exe_ctx.GetProcessPtr();
830	if (target && process) {
831	Process::StopLocker stop_locker;
832	if (stop_locker.TryLock(&process->GetRunLock())) {
833	frame = exe_ctx.GetFramePtr();
834	if (frame) {
835	VariableList *variable_list = nullptr;
836	variable_list = frame->GetVariableList(true);
837	if (variable_list) {
838	const size_t num_variables = variable_list->GetSize();
839	if (num_variables) {
840	for (const VariableSP &variable_sp : *variable_list) {
841	if (variable_sp) {
842	bool add_variable = false;
843	switch (variable_sp->GetScope()) {
844	case eValueTypeVariableGlobal:
845	case eValueTypeVariableStatic:
846	case eValueTypeVariableThreadLocal:
847	add_variable = statics;
848	break;
849
850	case eValueTypeVariableArgument:
851	add_variable = arguments;
852	break;
853
854	case eValueTypeVariableLocal:
855	add_variable = locals;
856	break;
857
858	default:
859	break;
860	}
861	if (add_variable) {
862	// Only add variables once so we don't end up with duplicates
863	if (variable_set.find(variable_sp) == variable_set.end())
864	variable_set.insert(variable_sp);
865	else
866	continue;
867
868	if (in_scope_only && !variable_sp->IsInScope(frame))
869	continue;
870
871	ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable(
872	variable_sp, eNoDynamicValues));
873
874	if (!include_runtime_support_values && valobj_sp != nullptr &&
875	valobj_sp->IsRuntimeSupportValue())
876	continue;
877
878	SBValue value_sb;
879	value_sb.SetSP(valobj_sp, use_dynamic);
880	value_list.Append(value_sb);
881	}
882	}
883	}
884	}
885	}
886	if (recognized_arguments) {
887	auto recognized_frame = frame->GetRecognizedFrame();
888	if (recognized_frame) {
889	ValueObjectListSP recognized_arg_list =
890	recognized_frame->GetRecognizedArguments();
891	if (recognized_arg_list) {
892	for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
893	SBValue value_sb;
894	value_sb.SetSP(rec_value_sp, use_dynamic);
895	value_list.Append(value_sb);
896	}
897	}
898	}
899	}
900	}
901	}
902	}
903
904	return LLDB_RECORD_RESULT(value_list)_recorder.RecordResult(value_list, true);;
905	}
906
907	SBValueList SBFrame::GetRegisters() {
908	LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValueList (SBFrame::) ()>::method<(&SBFrame::GetRegisters)>::record, this ); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::SBValueList (SBFrame ::)()>::method<(&SBFrame::GetRegisters)>::replay ( _recorder, _deserializer, _data.GetRegistry()); } } };
909
910	SBValueList value_list;
911	std::unique_lock<std::recursive_mutex> lock;
912	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
913
914	StackFrame *frame = nullptr;
915	Target *target = exe_ctx.GetTargetPtr();
916	Process *process = exe_ctx.GetProcessPtr();
917	if (target && process) {
918	Process::StopLocker stop_locker;
919	if (stop_locker.TryLock(&process->GetRunLock())) {
920	frame = exe_ctx.GetFramePtr();
921	if (frame) {
922	RegisterContextSP reg_ctx(frame->GetRegisterContext());
923	if (reg_ctx) {
924	const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
925	for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
926	value_list.Append(
927	ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx));
928	}
929	}
930	}
931	}
932	}
933
934	return LLDB_RECORD_RESULT(value_list)_recorder.RecordResult(value_list, true);;
935	}
936
937	SBValue SBFrame::FindRegister(const char *name) {
938	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char ),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::FindRegister)>::record , this, name); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::FindRegister )>::replay( _recorder, *_deserializer, _data.GetRegistry() ); } } }
939	name)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, name)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::FindRegister)>::record , this, name); } else if (lldb_private::repro::Deserializer * _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::FindRegister )>::replay( _recorder, *_deserializer, _data.GetRegistry() ); } } };
940
941	SBValue result;
942	ValueObjectSP value_sp;
943	std::unique_lock<std::recursive_mutex> lock;
944	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
945
946	StackFrame *frame = nullptr;
947	Target *target = exe_ctx.GetTargetPtr();
948	Process *process = exe_ctx.GetProcessPtr();
949	if (target && process) {
950	Process::StopLocker stop_locker;
951	if (stop_locker.TryLock(&process->GetRunLock())) {
952	frame = exe_ctx.GetFramePtr();
953	if (frame) {
954	RegisterContextSP reg_ctx(frame->GetRegisterContext());
955	if (reg_ctx) {
956	const uint32_t num_regs = reg_ctx->GetRegisterCount();
957	for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
958	const RegisterInfo *reg_info =
959	reg_ctx->GetRegisterInfoAtIndex(reg_idx);
960	if (reg_info &&
961	((reg_info->name && strcasecmp(reg_info->name, name) == 0) \|\|
962	(reg_info->alt_name &&
963	strcasecmp(reg_info->alt_name, name) == 0))) {
964	value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
965	result.SetSP(value_sp);
966	break;
967	}
968	}
969	}
970	}
971	}
972	}
973
974	return LLDB_RECORD_RESULT(result)_recorder.RecordResult(result, true);;
975	}
976
977	bool SBFrame::GetDescription(SBStream &description) {
978	LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, description)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<bool(SBFrame::) (lldb ::SBStream &)>::method<(&SBFrame::GetDescription )>::record, this, description); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <bool(SBFrame::) (lldb::SBStream &)>::method<(& SBFrame::GetDescription)>::replay( _recorder, _deserializer , _data.GetRegistry()); } } }
979	description)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, description)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<bool(SBFrame::) (lldb ::SBStream &)>::method<(&SBFrame::GetDescription )>::record, this, description); } else if (lldb_private::repro ::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke <bool(SBFrame::) (lldb::SBStream &)>::method<(& SBFrame::GetDescription)>::replay( _recorder, _deserializer , _data.GetRegistry()); } } };
980
981	Stream &strm = description.ref();
982
983	std::unique_lock<std::recursive_mutex> lock;
984	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
985
986	StackFrame *frame;
987	Target *target = exe_ctx.GetTargetPtr();
988	Process *process = exe_ctx.GetProcessPtr();
989	if (target && process) {
990	Process::StopLocker stop_locker;
991	if (stop_locker.TryLock(&process->GetRunLock())) {
992	frame = exe_ctx.GetFramePtr();
993	if (frame) {
994	frame->DumpUsingSettingsFormat(&strm);
995	}
996	}
997
998	} else
999	strm.PutCString("No value");
1000
1001	return true;
1002	}
1003
1004	SBValue SBFrame::EvaluateExpression(const char *expr) {
1005	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char ),lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::EvaluateExpression)> ::record, this, expr); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::EvaluateExpression )>::replay( _recorder, *_deserializer, _data.GetRegistry() ); } } }
1006	expr)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::EvaluateExpression)> ::record, this, expr); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char )>::method<(&SBFrame::EvaluateExpression )>::replay( _recorder, _deserializer, _data.GetRegistry() ); } } };
1007
1008	SBValue result;
1009	std::unique_lock<std::recursive_mutex> lock;
1010	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1011
1012	StackFrame *frame = exe_ctx.GetFramePtr();
1013	Target *target = exe_ctx.GetTargetPtr();
1014	if (frame && target) {
1015	SBExpressionOptions options;
1016	lldb::DynamicValueType fetch_dynamic_value =
1017	frame->CalculateTarget()->GetPreferDynamicValue();
1018	options.SetFetchDynamicValue(fetch_dynamic_value);
1019	options.SetUnwindOnError(true);
1020	options.SetIgnoreBreakpoints(true);
1021	if (target->GetLanguage() != eLanguageTypeUnknown)
1022	options.SetLanguage(target->GetLanguage());
1023	else
1024	options.SetLanguage(frame->GetLanguage());
1025	return LLDB_RECORD_RESULT(EvaluateExpression(expr, options))_recorder.RecordResult(EvaluateExpression(expr, options), true );;
1026	}
1027	return LLDB_RECORD_RESULT(result)_recorder.RecordResult(result, true);;
1028	}
1029
1030	SBValue
1031	SBFrame::EvaluateExpression(const char *expr,
1032	lldb::DynamicValueType fetch_dynamic_value) {
1033	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, fetch_dynamic_value)); if (lldb_private::repro:: InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::DynamicValueType)>::method <(&SBFrame::EvaluateExpression)>::record, this, expr , fetch_dynamic_value); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::EvaluateExpression)>::replay( _recorder, _deserializer , _data.GetRegistry()); } } }
1034	(const char , lldb::DynamicValueType), expr,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, fetch_dynamic_value)); if (lldb_private::repro:: InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::DynamicValueType)>::method <(&SBFrame::EvaluateExpression)>::record, this, expr , fetch_dynamic_value); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::EvaluateExpression)>::replay( _recorder, *_deserializer , _data.GetRegistry()); } } }
1035	fetch_dynamic_value)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, fetch_dynamic_value)); if (lldb_private::repro:: InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::DynamicValueType)>::method <(&SBFrame::EvaluateExpression)>::record, this, expr , fetch_dynamic_value); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , lldb::DynamicValueType)>::method<(& SBFrame::EvaluateExpression)>::replay( _recorder, _deserializer , _data.GetRegistry()); } } };
1036
1037	SBExpressionOptions options;
1038	options.SetFetchDynamicValue(fetch_dynamic_value);
1039	options.SetUnwindOnError(true);
1040	options.SetIgnoreBreakpoints(true);
1041	std::unique_lock<std::recursive_mutex> lock;
1042	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1043
1044	StackFrame *frame = exe_ctx.GetFramePtr();
1045	Target *target = exe_ctx.GetTargetPtr();
1046	if (target && target->GetLanguage() != eLanguageTypeUnknown)
1047	options.SetLanguage(target->GetLanguage());
1048	else if (frame)
1049	options.SetLanguage(frame->GetLanguage());
1050	return LLDB_RECORD_RESULT(EvaluateExpression(expr, options))_recorder.RecordResult(EvaluateExpression(expr, options), true );;
1051	}
1052
1053	SBValue SBFrame::EvaluateExpression(const char *expr,
1054	lldb::DynamicValueType fetch_dynamic_value,
1055	bool unwind_on_error) {
1056	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, fetch_dynamic_value, unwind_on_error)); if (lldb_private ::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::DynamicValueType, bool)> ::method<(&SBFrame::EvaluateExpression)>::record, this , expr, fetch_dynamic_value, unwind_on_error); } else if (lldb_private ::repro::Deserializer _deserializer = _data.GetDeserializer( )) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType , bool)>::method<(&SBFrame::EvaluateExpression)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } }
1057	(const char , lldb::DynamicValueType, bool), expr,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, fetch_dynamic_value, unwind_on_error)); if (lldb_private ::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::DynamicValueType, bool)> ::method<(&SBFrame::EvaluateExpression)>::record, this , expr, fetch_dynamic_value, unwind_on_error); } else if (lldb_private ::repro::Deserializer _deserializer = _data.GetDeserializer( )) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType , bool)>::method<(&SBFrame::EvaluateExpression)> ::replay( _recorder, *_deserializer, _data.GetRegistry()); } } }
1058	fetch_dynamic_value, unwind_on_error)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, fetch_dynamic_value, unwind_on_error)); if (lldb_private ::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData ::Instance()) { if (lldb_private::repro::Serializer _serializer = _data.GetSerializer()) { _recorder.Record(_serializer, _data .GetRegistry(), &lldb_private::repro::invoke<lldb::SBValue (SBFrame::) (const char , lldb::DynamicValueType, bool)> ::method<(&SBFrame::EvaluateExpression)>::record, this , expr, fetch_dynamic_value, unwind_on_error); } else if (lldb_private ::repro::Deserializer _deserializer = _data.GetDeserializer( )) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType , bool)>::method<(&SBFrame::EvaluateExpression)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
1059
1060	SBExpressionOptions options;
1061	std::unique_lock<std::recursive_mutex> lock;
1062	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1063
1064	options.SetFetchDynamicValue(fetch_dynamic_value);
1065	options.SetUnwindOnError(unwind_on_error);
1066	options.SetIgnoreBreakpoints(true);
1067	StackFrame *frame = exe_ctx.GetFramePtr();
1068	Target *target = exe_ctx.GetTargetPtr();
1069	if (target && target->GetLanguage() != eLanguageTypeUnknown)
1070	options.SetLanguage(target->GetLanguage());
1071	else if (frame)
1072	options.SetLanguage(frame->GetLanguage());
1073	return LLDB_RECORD_RESULT(EvaluateExpression(expr, options))_recorder.RecordResult(EvaluateExpression(expr, options), true );;
1074	}
1075
1076	lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
1077	const SBExpressionOptions &options) {
1078	LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, options)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , const lldb::SBExpressionOptions &)> ::method<(&SBFrame::EvaluateExpression)>::record, this , expr, options); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , const lldb::SBExpressionOptions &)> ::method<(&SBFrame::EvaluateExpression)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } }
1079	(const char , const lldb::SBExpressionOptions &), expr,lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, options)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , const lldb::SBExpressionOptions &)> ::method<(&SBFrame::EvaluateExpression)>::record, this , expr, options); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , const lldb::SBExpressionOptions &)> ::method<(&SBFrame::EvaluateExpression)>::replay( _recorder , *_deserializer, _data.GetRegistry()); } } }
1080	options)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this, expr, options)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance() ) { if (lldb_private::repro::Serializer _serializer = _data. GetSerializer()) { _recorder.Record(_serializer, _data.GetRegistry (), &lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , const lldb::SBExpressionOptions &)> ::method<(&SBFrame::EvaluateExpression)>::record, this , expr, options); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture ()) { return lldb_private::repro::invoke<lldb::SBValue(SBFrame ::) (const char , const lldb::SBExpressionOptions &)> ::method<(&SBFrame::EvaluateExpression)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
1081
1082	Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1083
1084	SBValue expr_result;
1085
1086	if (expr == nullptr \|\| expr[0] == '\0') {
1087	return LLDB_RECORD_RESULT(expr_result)_recorder.RecordResult(expr_result, true);;
1088	}
1089
1090	ValueObjectSP expr_value_sp;
1091
1092	std::unique_lock<std::recursive_mutex> lock;
1093	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1094
1095
1096	StackFrame *frame = nullptr;
1097	Target *target = exe_ctx.GetTargetPtr();
1098	Process *process = exe_ctx.GetProcessPtr();
1099
1100	if (target && process) {
1101	Process::StopLocker stop_locker;
1102	if (stop_locker.TryLock(&process->GetRunLock())) {
1103	frame = exe_ctx.GetFramePtr();
1104	if (frame) {
1105	std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace;
1106	if (target->GetDisplayExpressionsInCrashlogs()) {
1107	StreamString frame_description;
1108	frame->DumpUsingSettingsFormat(&frame_description);
1109	stack_trace = std::make_unique<llvm::PrettyStackTraceFormat>(
1110	"SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
1111	"= %u) %s",
1112	expr, options.GetFetchDynamicValue(),
1113	frame_description.GetData());
1114	}
1115
1116	target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
1117	expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
1118	}
1119	}
1120	}
1121
1122	LLDB_LOGF(expr_log,do { ::lldb_private::Log log_private = (expr_log); if (log_private ) log_private->Printf("* [SBFrame::EvaluateExpression] Expression result is " "%s, summary %s **", expr_result.GetValue(), expr_result.GetSummary ()); } while (0)
1123	"** [SBFrame::EvaluateExpression] Expression result is "do { ::lldb_private::Log log_private = (expr_log); if (log_private ) log_private->Printf("* [SBFrame::EvaluateExpression] Expression result is " "%s, summary %s **", expr_result.GetValue(), expr_result.GetSummary ()); } while (0)
1124	"%s, summary %s *",do { ::lldb_private::Log log_private = (expr_log); if (log_private ) log_private->Printf(" [SBFrame::EvaluateExpression] Expression result is " "%s, summary %s ", expr_result.GetValue(), expr_result.GetSummary ()); } while (0)
1125	expr_result.GetValue(), expr_result.GetSummary())do { ::lldb_private::Log log_private = (expr_log); if (log_private ) log_private->Printf("* [SBFrame::EvaluateExpression] Expression result is " "%s, summary %s **", expr_result.GetValue(), expr_result.GetSummary ()); } while (0);
1126
1127	return LLDB_RECORD_RESULT(expr_result)_recorder.RecordResult(expr_result, true);;
1128	}
1129
1130	bool SBFrame::IsInlined() {
1131	LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool (SBFrame::)()>::method <(&SBFrame::IsInlined)>::record, this); } else if ( lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<bool (SBFrame::)()>::method<(&SBFrame:: IsInlined)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
1132
1133	return static_cast<const SBFrame *>(this)->IsInlined();
1134	}
1135
1136	bool SBFrame::IsInlined() const {
1137	LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool (SBFrame::)() const>:: method<(&SBFrame::IsInlined)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<bool (SBFrame::)() const> ::method<(&SBFrame::IsInlined)>::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
1138
1139	std::unique_lock<std::recursive_mutex> lock;
1140	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1141
1142	StackFrame *frame = nullptr;
1143	Target *target = exe_ctx.GetTargetPtr();
1144	Process *process = exe_ctx.GetProcessPtr();
1145	if (target && process) {
1146	Process::StopLocker stop_locker;
1147	if (stop_locker.TryLock(&process->GetRunLock())) {
1148	frame = exe_ctx.GetFramePtr();
1149	if (frame) {
1150
1151	Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
1152	if (block)
1153	return block->GetContainingInlinedBlock() != nullptr;
1154	}
1155	}
1156	}
1157	return false;
1158	}
1159
1160	bool SBFrame::IsArtificial() {
1161	LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool (SBFrame::)()>::method <(&SBFrame::IsArtificial)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer ()) { if (_recorder.ShouldCapture()) { return lldb_private::repro ::invoke<bool (SBFrame::)()>::method<(&SBFrame:: IsArtificial)>::replay( _recorder, _deserializer, _data.GetRegistry ()); } } };
1162
1163	return static_cast<const SBFrame *>(this)->IsArtificial();
1164	}
1165
1166	bool SBFrame::IsArtificial() const {
1167	LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<bool (SBFrame::)() const>:: method<(&SBFrame::IsArtificial)>::record, this); } else if (lldb_private::repro::Deserializer _deserializer = _data .GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<bool (SBFrame::)() const> ::method<(&SBFrame::IsArtificial)>::replay( _recorder , _deserializer, _data.GetRegistry()); } } };
1168
1169	std::unique_lock<std::recursive_mutex> lock;
1170	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1171
1172	StackFrame *frame = exe_ctx.GetFramePtr();
1173	if (frame)
1174	return frame->IsArtificial();
1175
1176	return false;
1177	}
1178
1179	const char *SBFrame::GetFunctionName() {
1180	LLDB_RECORD_METHOD_NO_ARGS(const char , SBFrame, GetFunctionName)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<const char (SBFrame::)()> ::method<(&SBFrame::GetFunctionName)>::record, this ); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<const char * (SBFrame:: )()>::method<(&SBFrame::GetFunctionName)>::replay ( _recorder, _deserializer, _data.GetRegistry()); } } };
1181
1182	return static_cast<const SBFrame *>(this)->GetFunctionName();
1183	}
1184
1185	lldb::LanguageType SBFrame::GuessLanguage() const {
1186	LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<lldb::LanguageType (SBFrame::* )() const>::method<(&SBFrame::GuessLanguage)>::record , this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<lldb::LanguageType (SBFrame ::)() const>::method<(&SBFrame::GuessLanguage)> ::replay( _recorder, *_deserializer, _data.GetRegistry()); } } };
1187
1188	std::unique_lock<std::recursive_mutex> lock;
1189	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1190
1191	StackFrame *frame = nullptr;
1192	Target *target = exe_ctx.GetTargetPtr();
1193	Process *process = exe_ctx.GetProcessPtr();
1194	if (target && process) {
1195	Process::StopLocker stop_locker;
1196	if (stop_locker.TryLock(&process->GetRunLock())) {
1197	frame = exe_ctx.GetFramePtr();
1198	if (frame) {
1199	return frame->GuessLanguage();
1200	}
1201	}
1202	}
1203	return eLanguageTypeUnknown;
1204	}
1205
1206	const char *SBFrame::GetFunctionName() const {
1207	LLDB_RECORD_METHOD_CONST_NO_ARGS(const char , SBFrame, GetFunctionName)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<const char (SBFrame::)() const >::method<(&SBFrame::GetFunctionName)>::record, this ); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<const char * (SBFrame:: )() const>::method<(&SBFrame::GetFunctionName)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
1208
1209	const char *name = nullptr;
1210	std::unique_lock<std::recursive_mutex> lock;
1211	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1212
1213	StackFrame *frame = nullptr;
1214	Target *target = exe_ctx.GetTargetPtr();
1215	Process *process = exe_ctx.GetProcessPtr();
1216	if (target && process) {
1217	Process::StopLocker stop_locker;
1218	if (stop_locker.TryLock(&process->GetRunLock())) {
1219	frame = exe_ctx.GetFramePtr();
1220	if (frame) {
1221	SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction \|
1222	eSymbolContextBlock \|
1223	eSymbolContextSymbol));
1224	if (sc.block) {
1225	Block *inlined_block = sc.block->GetContainingInlinedBlock();
1226	if (inlined_block) {
1227	const InlineFunctionInfo *inlined_info =
1228	inlined_block->GetInlinedFunctionInfo();
1229	name = inlined_info->GetName().AsCString();
1230	}
1231	}
1232
1233	if (name == nullptr) {
1234	if (sc.function)
1235	name = sc.function->GetName().GetCString();
1236	}
1237
1238	if (name == nullptr) {
1239	if (sc.symbol)
1240	name = sc.symbol->GetName().GetCString();
1241	}
1242	}
1243	}
1244	}
1245	return name;
1246	}
1247
1248	const char *SBFrame::GetDisplayFunctionName() {
1249	LLDB_RECORD_METHOD_NO_ARGS(const char , SBFrame, GetDisplayFunctionName)lldb_private::repro::Recorder _recorder(__PRETTY_FUNCTION__, stringify_args (this)); if (lldb_private::repro::InstrumentationData _data = lldb_private::repro::InstrumentationData::Instance()) { if ( lldb_private::repro::Serializer _serializer = _data.GetSerializer ()) { _recorder.Record(_serializer, _data.GetRegistry(), & lldb_private::repro::invoke<const char (SBFrame::)()> ::method<(&SBFrame::GetDisplayFunctionName)>::record , this); } else if (lldb_private::repro::Deserializer _deserializer = _data.GetDeserializer()) { if (_recorder.ShouldCapture()) { return lldb_private::repro::invoke<const char * (SBFrame:: )()>::method<(&SBFrame::GetDisplayFunctionName)> ::replay( _recorder, _deserializer, _data.GetRegistry()); } } };
1250
1251	const char *name = nullptr;
1252
1253	std::unique_lock<std::recursive_mutex> lock;
1254	ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1255
1256	StackFrame *frame = nullptr;
1257	Target *target = exe_ctx.GetTargetPtr();
1258	Process *process = exe_ctx.GetProcessPtr();
1259	if (target && process) {
1260	Process::StopLocker stop_locker;
1261	if (stop_locker.TryLock(&process->GetRunLock())) {
1262	frame = exe_ctx.GetFramePtr();
1263	if (frame) {
1264	SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction \|
1265	eSymbolContextBlock \|
1266	eSymbolContextSymbol));
1267	if (sc.block) {
1268	Block *inlined_block = sc.block->GetContainingInlinedBlock();
1269	if (inlined_block) {
1270	const InlineFunctionInfo *inlined_info =
1271	inlined_block->GetInlinedFunctionInfo();
1272	name = inlined_info->GetDisplayName().AsCString();
1273	}
1274	}
1275
1276	if (name == nullptr) {
1277	if (sc.function)
1278	name = sc.function->GetDisplayName().GetCString();
1279	}
1280
1281	if (name == nullptr) {
1282	if (sc.symbol)
1283	name = sc.symbol->GetDisplayName().GetCString();
1284	}
1285	}
1286	}
1287	}
1288	return name;
1289	}
1290
1291	namespace lldb_private {
1292	namespace repro {
1293
1294	template <>
1295	void RegisterMethods<SBFrame>(Registry &R) {
1296	LLDB_REGISTER_CONSTRUCTOR(SBFrame, ())R.Register<SBFrame * ()>(&construct<SBFrame ()> ::record, "", "SBFrame", "SBFrame", "()");
1297	LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &))R.Register<SBFrame * (const lldb::StackFrameSP &)>( &construct<SBFrame (const lldb::StackFrameSP &)> ::record, "", "SBFrame", "SBFrame", "(const lldb::StackFrameSP &)" );
1298	LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &))R.Register<SBFrame * (const lldb::SBFrame &)>(& construct<SBFrame (const lldb::SBFrame &)>::record, "", "SBFrame", "SBFrame", "(const lldb::SBFrame &)");
1299	LLDB_REGISTER_METHOD(const lldb::SBFrame &,R.Register( &invoke<const lldb::SBFrame &(SBFrame:: *) (const lldb::SBFrame &)>::method<(&SBFrame:: operator=)>::record, "const lldb::SBFrame &", "SBFrame" , "operator=", "(const lldb::SBFrame &)")
1300	SBFrame, operator=,(const lldb::SBFrame &))R.Register( &invoke<const lldb::SBFrame &(SBFrame:: *) (const lldb::SBFrame &)>::method<(&SBFrame:: operator=)>::record, "const lldb::SBFrame &", "SBFrame" , "operator=", "(const lldb::SBFrame &)");
1301	LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ())R.Register(&invoke<bool(SBFrame::*) () const>::method <(&SBFrame::IsValid)>::record, "bool", "SBFrame", "IsValid" , "()");
1302	LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ())R.Register(&invoke<bool(SBFrame::*) () const>::method <(&SBFrame::operator bool)>::record, "bool", "SBFrame" , "operator bool", "()");
1303	LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,R.Register(&invoke<lldb::SBSymbolContext(SBFrame::*) ( uint32_t) const>::method<(&SBFrame::GetSymbolContext )>::record, "lldb::SBSymbolContext", "SBFrame", "GetSymbolContext" , "(uint32_t)")
1304	(uint32_t))R.Register(&invoke<lldb::SBSymbolContext(SBFrame::*) ( uint32_t) const>::method<(&SBFrame::GetSymbolContext )>::record, "lldb::SBSymbolContext", "SBFrame", "GetSymbolContext" , "(uint32_t)");
1305	LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ())R.Register(&invoke<lldb::SBModule(SBFrame::*) () const >::method<(&SBFrame::GetModule)>::record, "lldb::SBModule" , "SBFrame", "GetModule", "()");
1306	LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,R.Register(&invoke<lldb::SBCompileUnit(SBFrame::*) () const >::method<(&SBFrame::GetCompileUnit)>::record, "lldb::SBCompileUnit" , "SBFrame", "GetCompileUnit", "()")
1307	())R.Register(&invoke<lldb::SBCompileUnit(SBFrame::*) () const >::method<(&SBFrame::GetCompileUnit)>::record, "lldb::SBCompileUnit" , "SBFrame", "GetCompileUnit", "()");
1308	LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ())R.Register(&invoke<lldb::SBFunction(SBFrame::*) () const >::method<(&SBFrame::GetFunction)>::record, "lldb::SBFunction" , "SBFrame", "GetFunction", "()");
1309	LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ())R.Register(&invoke<lldb::SBSymbol(SBFrame::*) () const >::method<(&SBFrame::GetSymbol)>::record, "lldb::SBSymbol" , "SBFrame", "GetSymbol", "()");
1310	LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ())R.Register(&invoke<lldb::SBBlock(SBFrame::*) () const> ::method<(&SBFrame::GetBlock)>::record, "lldb::SBBlock" , "SBFrame", "GetBlock", "()");
1311	LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ())R.Register(&invoke<lldb::SBBlock(SBFrame::*) () const> ::method<(&SBFrame::GetFrameBlock)>::record, "lldb::SBBlock" , "SBFrame", "GetFrameBlock", "()");
1312	LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ())R.Register(&invoke<lldb::SBLineEntry(SBFrame::*) () const >::method<(&SBFrame::GetLineEntry)>::record, "lldb::SBLineEntry" , "SBFrame", "GetLineEntry", "()");
1313	LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ())R.Register(&invoke<uint32_t(SBFrame::*) () const>:: method<(&SBFrame::GetFrameID)>::record, "uint32_t", "SBFrame", "GetFrameID", "()");
1314	LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ())R.Register(&invoke<lldb::addr_t(SBFrame::*) () const> ::method<(&SBFrame::GetCFA)>::record, "lldb::addr_t" , "SBFrame", "GetCFA", "()");
1315	LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ())R.Register(&invoke<lldb::addr_t(SBFrame::*) () const> ::method<(&SBFrame::GetPC)>::record, "lldb::addr_t" , "SBFrame", "GetPC", "()");
1316	LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t))R.Register( &invoke<bool(SBFrame::*) (lldb::addr_t)> ::method<(&SBFrame::SetPC)>::record, "bool", "SBFrame" , "SetPC", "(lldb::addr_t)");
1317	LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ())R.Register(&invoke<lldb::addr_t(SBFrame::*) () const> ::method<(&SBFrame::GetSP)>::record, "lldb::addr_t" , "SBFrame", "GetSP", "()");
1318	LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ())R.Register(&invoke<lldb::addr_t(SBFrame::*) () const> ::method<(&SBFrame::GetFP)>::record, "lldb::addr_t" , "SBFrame", "GetFP", "()");
1319	LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ())R.Register(&invoke<lldb::SBAddress(SBFrame::*) () const >::method<(&SBFrame::GetPCAddress)>::record, "lldb::SBAddress" , "SBFrame", "GetPCAddress", "()");
1320	LLDB_REGISTER_METHOD(void, SBFrame, Clear, ())R.Register( &invoke<void(SBFrame::*) ()>::method< (&SBFrame::Clear)>::record, "void", "SBFrame", "Clear" , "()");
1321	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::GetValueForVariablePath)> ::record, "lldb::SBValue", "SBFrame", "GetValueForVariablePath" , "(const char *)")
1322	(const char ))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::GetValueForVariablePath)> ::record, "lldb::SBValue", "SBFrame", "GetValueForVariablePath" , "(const char )");
1323	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame::GetValueForVariablePath )>::record, "lldb::SBValue", "SBFrame", "GetValueForVariablePath" , "(const char *, lldb::DynamicValueType)")
1324	(const char , lldb::DynamicValueType))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame::GetValueForVariablePath )>::record, "lldb::SBValue", "SBFrame", "GetValueForVariablePath" , "(const char , lldb::DynamicValueType)");
1325	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char ))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::FindVariable)>::record, "lldb::SBValue" , "SBFrame", "FindVariable", "(const char )");
1326	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame::FindVariable )>::record, "lldb::SBValue", "SBFrame", "FindVariable", "(const char *, lldb::DynamicValueType)" )
1327	(const char , lldb::DynamicValueType))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame::FindVariable )>::record, "lldb::SBValue", "SBFrame", "FindVariable", "(const char , lldb::DynamicValueType)" );
1328	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType)>::method<(&SBFrame::FindValue) >::record, "lldb::SBValue", "SBFrame", "FindValue", "(const char *, lldb::ValueType)" )
1329	(const char , lldb::ValueType))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType)>::method<(&SBFrame::FindValue) >::record, "lldb::SBValue", "SBFrame", "FindValue", "(const char , lldb::ValueType)" );
1330	LLDB_REGISTER_METHOD(R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType)>::method<( &SBFrame::FindValue)>::record, "lldb::SBValue", "SBFrame" , "FindValue", "(const char *, lldb::ValueType, lldb::DynamicValueType)" )
1331	lldb::SBValue, SBFrame, FindValue,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType)>::method<( &SBFrame::FindValue)>::record, "lldb::SBValue", "SBFrame" , "FindValue", "(const char *, lldb::ValueType, lldb::DynamicValueType)" )
1332	(const char , lldb::ValueType, lldb::DynamicValueType))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::ValueType, lldb::DynamicValueType)>::method<( &SBFrame::FindValue)>::record, "lldb::SBValue", "SBFrame" , "FindValue", "(const char , lldb::ValueType, lldb::DynamicValueType)" );
1333	LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &))R.Register(&invoke<bool(SBFrame::*) (const lldb::SBFrame &) const>::method<(&SBFrame::IsEqual)>::record , "bool", "SBFrame", "IsEqual", "(const lldb::SBFrame &)" );
1334	LLDB_REGISTER_METHOD_CONST(bool,R.Register(&invoke<bool(SBFrame::*) (const lldb::SBFrame &) const>::method<(&SBFrame::operator==)>:: record, "bool", "SBFrame", "operator==", "(const lldb::SBFrame &)" )
1335	SBFrame, operator==,(const lldb::SBFrame &))R.Register(&invoke<bool(SBFrame::*) (const lldb::SBFrame &) const>::method<(&SBFrame::operator==)>:: record, "bool", "SBFrame", "operator==", "(const lldb::SBFrame &)" );
1336	LLDB_REGISTER_METHOD_CONST(bool,R.Register(&invoke<bool(SBFrame::*) (const lldb::SBFrame &) const>::method<(&SBFrame::operator!=)>:: record, "bool", "SBFrame", "operator!=", "(const lldb::SBFrame &)" )
1337	SBFrame, operator!=,(const lldb::SBFrame &))R.Register(&invoke<bool(SBFrame::*) (const lldb::SBFrame &) const>::method<(&SBFrame::operator!=)>:: record, "bool", "SBFrame", "operator!=", "(const lldb::SBFrame &)" );
1338	LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ())R.Register(&invoke<lldb::SBThread(SBFrame::*) () const >::method<(&SBFrame::GetThread)>::record, "lldb::SBThread" , "SBFrame", "GetThread", "()");
1339	LLDB_REGISTER_METHOD_CONST(const char , SBFrame, Disassemble, ())R.Register(&invoke<const char (SBFrame::) () const> ::method<(&SBFrame::Disassemble)>::record, "const char " , "SBFrame", "Disassemble", "()");
1340	LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,R.Register( &invoke<lldb::SBValueList(SBFrame::*) (bool , bool, bool, bool)>::method<(&SBFrame::GetVariables )>::record, "lldb::SBValueList", "SBFrame", "GetVariables" , "(bool, bool, bool, bool)")
1341	(bool, bool, bool, bool))R.Register( &invoke<lldb::SBValueList(SBFrame::*) (bool , bool, bool, bool)>::method<(&SBFrame::GetVariables )>::record, "lldb::SBValueList", "SBFrame", "GetVariables" , "(bool, bool, bool, bool)");
1342	LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,R.Register( &invoke<lldb::SBValueList(SBFrame::*) (bool , bool, bool, bool, lldb::DynamicValueType)>::method<(& SBFrame::GetVariables)>::record, "lldb::SBValueList", "SBFrame" , "GetVariables", "(bool, bool, bool, bool, lldb::DynamicValueType)" )
1343	(bool, bool, bool, bool, lldb::DynamicValueType))R.Register( &invoke<lldb::SBValueList(SBFrame::*) (bool , bool, bool, bool, lldb::DynamicValueType)>::method<(& SBFrame::GetVariables)>::record, "lldb::SBValueList", "SBFrame" , "GetVariables", "(bool, bool, bool, bool, lldb::DynamicValueType)" );
1344	LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,R.Register( &invoke<lldb::SBValueList(SBFrame::*) (const lldb::SBVariablesOptions &)>::method<(&SBFrame ::GetVariables)>::record, "lldb::SBValueList", "SBFrame", "GetVariables" , "(const lldb::SBVariablesOptions &)")
1345	(const lldb::SBVariablesOptions &))R.Register( &invoke<lldb::SBValueList(SBFrame::*) (const lldb::SBVariablesOptions &)>::method<(&SBFrame ::GetVariables)>::record, "lldb::SBValueList", "SBFrame", "GetVariables" , "(const lldb::SBVariablesOptions &)");
1346	LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ())R.Register( &invoke<lldb::SBValueList(SBFrame::*) ()> ::method<(&SBFrame::GetRegisters)>::record, "lldb::SBValueList" , "SBFrame", "GetRegisters", "()");
1347	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char ))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::FindRegister)>::record, "lldb::SBValue" , "SBFrame", "FindRegister", "(const char )");
1348	LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &))R.Register( &invoke<bool(SBFrame::*) (lldb::SBStream & )>::method<(&SBFrame::GetDescription)>::record, "bool" , "SBFrame", "GetDescription", "(lldb::SBStream &)");
1349	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::EvaluateExpression)>::record , "lldb::SBValue", "SBFrame", "EvaluateExpression", "(const char *)" )
1350	(const char ))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char )>::method<(&SBFrame::EvaluateExpression)>::record , "lldb::SBValue", "SBFrame", "EvaluateExpression", "(const char )" );
1351	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame::EvaluateExpression )>::record, "lldb::SBValue", "SBFrame", "EvaluateExpression" , "(const char *, lldb::DynamicValueType)")
1352	(const char , lldb::DynamicValueType))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType)>::method<(&SBFrame::EvaluateExpression )>::record, "lldb::SBValue", "SBFrame", "EvaluateExpression" , "(const char , lldb::DynamicValueType)");
1353	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType, bool)>::method<(&SBFrame ::EvaluateExpression)>::record, "lldb::SBValue", "SBFrame" , "EvaluateExpression", "(const char *, lldb::DynamicValueType, bool)" )
1354	(const char , lldb::DynamicValueType, bool))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , lldb::DynamicValueType, bool)>::method<(&SBFrame ::EvaluateExpression)>::record, "lldb::SBValue", "SBFrame" , "EvaluateExpression", "(const char , lldb::DynamicValueType, bool)" );
1355	LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , const lldb::SBExpressionOptions &)>::method<(& SBFrame::EvaluateExpression)>::record, "lldb::SBValue", "SBFrame" , "EvaluateExpression", "(const char *, const lldb::SBExpressionOptions &)" )
1356	(const char , const lldb::SBExpressionOptions &))R.Register( &invoke<lldb::SBValue(SBFrame::) (const char , const lldb::SBExpressionOptions &)>::method<(& SBFrame::EvaluateExpression)>::record, "lldb::SBValue", "SBFrame" , "EvaluateExpression", "(const char , const lldb::SBExpressionOptions &)" );
1357	LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ())R.Register( &invoke<bool(SBFrame::*) ()>::method< (&SBFrame::IsInlined)>::record, "bool", "SBFrame", "IsInlined" , "()");
1358	LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ())R.Register(&invoke<bool(SBFrame::*) () const>::method <(&SBFrame::IsInlined)>::record, "bool", "SBFrame", "IsInlined", "()");
1359	LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ())R.Register( &invoke<bool(SBFrame::*) ()>::method< (&SBFrame::IsArtificial)>::record, "bool", "SBFrame", "IsArtificial" , "()");
1360	LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ())R.Register(&invoke<bool(SBFrame::*) () const>::method <(&SBFrame::IsArtificial)>::record, "bool", "SBFrame" , "IsArtificial", "()");
1361	LLDB_REGISTER_METHOD(const char , SBFrame, GetFunctionName, ())R.Register( &invoke<const char (SBFrame::) ()>::method <(&SBFrame::GetFunctionName)>::record, "const char " , "SBFrame", "GetFunctionName", "()");
1362	LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ())R.Register(&invoke<lldb::LanguageType(SBFrame::*) () const >::method<(&SBFrame::GuessLanguage)>::record, "lldb::LanguageType" , "SBFrame", "GuessLanguage", "()");
1363	LLDB_REGISTER_METHOD_CONST(const char , SBFrame, GetFunctionName, ())R.Register(&invoke<const char (SBFrame::) () const> ::method<(&SBFrame::GetFunctionName)>::record, "const char " , "SBFrame", "GetFunctionName", "()");
1364	LLDB_REGISTER_METHOD(const char , SBFrame, GetDisplayFunctionName, ())R.Register( &invoke<const char (SBFrame::) ()>::method <(&SBFrame::GetDisplayFunctionName)>::record, "const char " , "SBFrame", "GetDisplayFunctionName", "()");
1365	}
1366
1367	}
1368	}