LLDB  mainline
SBReproducer.cpp
Go to the documentation of this file.
1 //===-- SBReproducer.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 "SBReproducerPrivate.h"
10 
11 #include "lldb/API/LLDB.h"
12 #include "lldb/API/SBAddress.h"
13 #include "lldb/API/SBAttachInfo.h"
14 #include "lldb/API/SBBlock.h"
15 #include "lldb/API/SBBreakpoint.h"
18 #include "lldb/API/SBData.h"
19 #include "lldb/API/SBDebugger.h"
20 #include "lldb/API/SBDeclaration.h"
21 #include "lldb/API/SBError.h"
22 #include "lldb/API/SBFileSpec.h"
23 #include "lldb/API/SBHostOS.h"
24 #include "lldb/API/SBReproducer.h"
25 #include "lldb/Host/FileSystem.h"
26 #include "lldb/lldb-private.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 using namespace lldb_private::repro;
31 
33  : m_opaque_up(std::make_unique<ReplayOptions>()){}
34 
36  : m_opaque_up(std::make_unique<ReplayOptions>(*rhs.m_opaque_up)) {}
37 
39 
41  if (this == &rhs)
42  return *this;
43  *m_opaque_up = *rhs.m_opaque_up;
44  return *this;
45 }
46 
47 void SBReplayOptions::SetVerify(bool verify) { m_opaque_up->verify = verify; }
48 
49 bool SBReplayOptions::GetVerify() const { return m_opaque_up->verify; }
50 
52  m_opaque_up->check_version = check;
53 }
54 
56  return m_opaque_up->check_version;
57 }
58 
59 SBRegistry::SBRegistry() {
60  Registry &R = *this;
61 
134 }
135 
136 const char *SBReproducer::Capture() {
137  static std::string error;
138  if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
139  error = llvm::toString(std::move(e));
140  return error.c_str();
141  }
142 
143  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
144  auto &p = g->GetOrCreate<SBProvider>();
145  InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
146  }
147 
148  return nullptr;
149 }
150 
151 const char *SBReproducer::Capture(const char *path) {
152  static std::string error;
153  if (auto e =
154  Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
155  error = llvm::toString(std::move(e));
156  return error.c_str();
157  }
158 
159  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
160  auto &p = g->GetOrCreate<SBProvider>();
161  InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
162  }
163 
164  return nullptr;
165 }
166 
167 const char *SBReproducer::PassiveReplay(const char *path) {
168  static std::string error;
169  if (auto e = Reproducer::Initialize(ReproducerMode::PassiveReplay,
170  FileSpec(path))) {
171  error = llvm::toString(std::move(e));
172  return error.c_str();
173  }
174 
175  if (auto *l = lldb_private::repro::Reproducer::Instance().GetLoader()) {
176  FileSpec file = l->GetFile<SBProvider::Info>();
177  auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
178  if (!error_or_file) {
179  error =
180  "unable to read SB API data: " + error_or_file.getError().message();
181  return error.c_str();
182  }
183  static ReplayData r(std::move(*error_or_file));
184  InstrumentationData::Initialize(r.GetDeserializer(), r.GetRegistry());
185  }
186 
187  return nullptr;
188 }
189 
190 const char *SBReproducer::Replay(const char *path) {
191  SBReplayOptions options;
192  return SBReproducer::Replay(path, options);
193 }
194 
195 const char *SBReproducer::Replay(const char *path, bool skip_version_check) {
196  SBReplayOptions options;
197  options.SetCheckVersion(!skip_version_check);
198  return SBReproducer::Replay(path, options);
199 }
200 
201 const char *SBReproducer::Replay(const char *path,
202  const SBReplayOptions &options) {
203  static std::string error;
204  if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
205  error = llvm::toString(std::move(e));
206  return error.c_str();
207  }
208 
209  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
210  if (!loader) {
211  error = "unable to get replay loader.";
212  return error.c_str();
213  }
214 
215  if (options.GetCheckVersion()) {
216  llvm::Expected<std::string> version = loader->LoadBuffer<VersionProvider>();
217  if (!version) {
218  error = llvm::toString(version.takeError());
219  return error.c_str();
220  }
221  if (lldb_private::GetVersion() != llvm::StringRef(*version).rtrim()) {
222  error = "reproducer capture and replay version don't match:\n";
223  error.append("reproducer captured with:\n");
224  error.append(*version);
225  error.append("reproducer replayed with:\n");
226  error.append(lldb_private::GetVersion());
227  return error.c_str();
228  }
229  }
230 
231  if (options.GetVerify()) {
232  bool verification_failed = false;
233  llvm::raw_string_ostream os(error);
234  auto error_callback = [&](llvm::StringRef error) {
235  verification_failed = true;
236  os << "\nerror: " << error;
237  };
238 
239  auto warning_callback = [&](llvm::StringRef warning) {
240  verification_failed = true;
241  os << "\nwarning: " << warning;
242  };
243 
244  auto note_callback = [&](llvm::StringRef warning) {};
245 
246  Verifier verifier(loader);
247  verifier.Verify(error_callback, warning_callback, note_callback);
248 
249  if (verification_failed) {
250  os.flush();
251  return error.c_str();
252  }
253  }
254 
255  FileSpec file = loader->GetFile<SBProvider::Info>();
256  if (!file) {
257  error = "unable to get replay data from reproducer.";
258  return error.c_str();
259  }
260 
261  SBRegistry registry;
262  registry.Replay(file);
263 
264  return nullptr;
265 }
266 
267 const char *SBReproducer::Finalize(const char *path) {
268  static std::string error;
269  if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
270  error = llvm::toString(std::move(e));
271  return error.c_str();
272  }
273 
274  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
275  if (!loader) {
276  error = "unable to get replay loader.";
277  return error.c_str();
278  }
279 
280  if (auto e = repro::Finalize(loader)) {
281  error = llvm::toString(std::move(e));
282  return error.c_str();
283  }
284 
285  return nullptr;
286 }
287 
289  auto &r = Reproducer::Instance();
290  if (auto generator = r.GetGenerator()) {
291  generator->Keep();
292  return true;
293  }
294  return false;
295 }
296 
298  auto &r = Reproducer::Instance();
299  if (auto generator = r.GetGenerator()) {
300  generator->SetAutoGenerate(b);
301  return true;
302  }
303  return false;
304 }
305 
306 const char *SBReproducer::GetPath() {
307  ConstString path;
308  auto &r = Reproducer::Instance();
309  if (FileSpec reproducer_path = Reproducer::Instance().GetReproducerPath())
310  path = ConstString(r.GetReproducerPath().GetCString());
311  return path.GetCString();
312 }
313 
314 void SBReproducer::SetWorkingDirectory(const char *path) {
315  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
316  auto &wp = g->GetOrCreate<repro::WorkingDirectoryProvider>();
317  wp.SetDirectory(path);
318  auto &fp = g->GetOrCreate<repro::FileProvider>();
319  fp.RecordInterestingDirectory(wp.GetDirectory());
320  }
321 }
322 
324 const char *SBProvider::Info::name = "sbapi";
325 const char *SBProvider::Info::file = "sbapi.bin";
lldb_private::toString
const char * toString(AppleArm64ExceptionClass EC)
Definition: AppleArm64ExceptionClass.h:38
lldb::SBReplayOptions
Definition: SBReproducer.h:22
SBCommandInterpreterRunOptions.h
lldb_private::repro::RegisterMethods< SBTypeSummary >
void RegisterMethods< SBTypeSummary >(Registry &R)
Definition: SBTypeSummary.cpp:499
lldb_private::repro::RegisterMethods< SBHostOS >
void RegisterMethods< SBHostOS >(Registry &R)
Definition: SBHostOS.cpp:181
lldb_private::repro::RegisterMethods< SBValueList >
void RegisterMethods< SBValueList >(Registry &R)
Definition: SBValueList.cpp:210
FileSystem.h
lldb_private::repro::RegisterMethods< SBType >
void RegisterMethods< SBType >(Registry &R)
Definition: SBType.cpp:930
lldb_private::repro::RegisterMethods< SBInputReader >
void RegisterMethods< SBInputReader >(Registry &R)
Definition: SBDebugger.cpp:1691
lldb_private::repro::RegisterMethods< SBExpressionOptions >
void RegisterMethods< SBExpressionOptions >(Registry &R)
Definition: SBExpressionOptions.cpp:292
lldb_private::repro::RegisterMethods< SBExecutionContext >
void RegisterMethods< SBExecutionContext >(Registry &R)
Definition: SBExecutionContext.cpp:139
lldb_private::repro::RegisterMethods< SBBreakpoint >
void RegisterMethods< SBBreakpoint >(Registry &R)
Definition: SBBreakpoint.cpp:990
lldb_private::repro::RegisterMethods< SBTypeFormat >
void RegisterMethods< SBTypeFormat >(Registry &R)
Definition: SBTypeFormat.cpp:199
lldb_private::repro::SBRegistry
Definition: SBReproducerPrivate.h:29
lldb_private::repro::RegisterMethods< SBBreakpointName >
void RegisterMethods< SBBreakpointName >(Registry &R)
Definition: SBBreakpointName.cpp:701
lldb::SBReproducer::Finalize
static const char * Finalize(const char *path)
Definition: SBReproducer.cpp:267
lldb_private::repro::RegisterMethods< SBWatchpoint >
void RegisterMethods< SBWatchpoint >(Registry &R)
Definition: SBWatchpoint.cpp:311
lldb_private::repro::RegisterMethods< SBBreakpointLocation >
void RegisterMethods< SBBreakpointLocation >(Registry &R)
Definition: SBBreakpointLocation.cpp:475
lldb::SBReplayOptions::GetCheckVersion
bool GetCheckVersion() const
Definition: SBReproducer.cpp:55
lldb_private::repro::RegisterMethods< SBFileSpec >
void RegisterMethods< SBFileSpec >(Registry &R)
Definition: SBFileSpec.cpp:195
lldb_private::repro::RegisterMethods< SBPlatform >
void RegisterMethods< SBPlatform >(Registry &R)
Definition: SBPlatform.cpp:752
lldb::SBReproducer::PassiveReplay
static const char * PassiveReplay(const char *path)
Definition: SBReproducer.cpp:167
lldb_private::repro::RegisterMethods< SBBreakpointList >
void RegisterMethods< SBBreakpointList >(Registry &R)
Definition: SBBreakpoint.cpp:1078
SBReproducerPrivate.h
lldb_private::repro::RegisterMethods< SBLanguageRuntime >
void RegisterMethods< SBLanguageRuntime >(Registry &R)
Definition: SBLanguageRuntime.cpp:37
lldb_private::repro::RegisterMethods< SBDebugger >
void RegisterMethods< SBDebugger >(Registry &R)
Definition: SBDebugger.cpp:1704
LLDB.h
lldb_private::repro::SBProvider::Info
Definition: SBReproducerPrivate.h:36
lldb_private::repro::Loader
Definition: Reproducer.h:158
lldb::SBReplayOptions::~SBReplayOptions
~SBReplayOptions()
lldb_private::repro::FileProvider
Definition: ReproducerProvider.h:111
lldb_private::repro::RegisterMethods< SBAttachInfo >
void RegisterMethods< SBAttachInfo >(Registry &R)
Definition: SBAttachInfo.cpp:266
lldb_private::repro::RegisterMethods< SBModuleSpec >
void RegisterMethods< SBModuleSpec >(Registry &R)
Definition: SBModuleSpec.cpp:251
lldb_private::repro::RegisterMethods< SBLaunchInfo >
void RegisterMethods< SBLaunchInfo >(Registry &R)
Definition: SBLaunchInfo.cpp:401
lldb_private::repro::RegisterMethods< SBFileSpecList >
void RegisterMethods< SBFileSpecList >(Registry &R)
Definition: SBFileSpecList.cpp:131
lldb::SBReplayOptions::SetVerify
void SetVerify(bool verify)
Definition: SBReproducer.cpp:47
lldb_private::repro::RegisterMethods< SBThread >
void RegisterMethods< SBThread >(Registry &R)
Definition: SBThread.cpp:1371
lldb::SBReplayOptions::GetVerify
bool GetVerify() const
Definition: SBReproducer.cpp:49
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::repro::RegisterMethods< SBCompileUnit >
void RegisterMethods< SBCompileUnit >(Registry &R)
Definition: SBCompileUnit.cpp:245
SBData.h
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::repro::RegisterMethods< SBTypeNameSpecifier >
void RegisterMethods< SBTypeNameSpecifier >(Registry &R)
Definition: SBTypeNameSpecifier.cpp:163
lldb_private::repro::RegisterMethods< SBCommandReturnObject >
void RegisterMethods< SBCommandReturnObject >(Registry &R)
Definition: SBCommandReturnObject.cpp:373
lldb_private::repro::RegisterMethods< SBTypeFilter >
void RegisterMethods< SBTypeFilter >(Registry &R)
Definition: SBTypeFilter.cpp:198
lldb_private::repro::Registry::Replay
bool Replay(const FileSpec &file)
Replay functions from a file.
Definition: ReproducerInstrumentation.cpp:101
lldb_private::repro::Verifier::Verify
void Verify(llvm::function_ref< void(llvm::StringRef)> error_callback, llvm::function_ref< void(llvm::StringRef)> warning_callback, llvm::function_ref< void(llvm::StringRef)> note_callback) const
Definition: Reproducer.cpp:258
lldb::SBReproducer::Generate
static bool Generate()
Definition: SBReproducer.cpp:288
SBBlock.h
lldb::SBReplayOptions::operator=
SBReplayOptions & operator=(const SBReplayOptions &rhs)
Definition: SBReproducer.cpp:40
lldb_private::repro::RegisterMethods< SBStringList >
void RegisterMethods< SBStringList >(Registry &R)
Definition: SBStringList.cpp:143
lldb_private::repro::RegisterMethods< SBLineEntry >
void RegisterMethods< SBLineEntry >(Registry &R)
Definition: SBLineEntry.cpp:196
lldb_private::repro::Loader::LoadBuffer
llvm::Expected< std::string > LoadBuffer()
Definition: Reproducer.h:169
lldb_private::repro::RegisterMethods< SBCommunication >
void RegisterMethods< SBCommunication >(Registry &R)
Definition: SBCommunication.cpp:192
lldb_private::repro::RegisterMethods< SBFile >
void RegisterMethods< SBFile >(Registry &R)
Definition: SBFile.cpp:139
SBFileSpec.h
lldb_private::repro::RegisterMethods< SBBroadcaster >
void RegisterMethods< SBBroadcaster >(Registry &R)
Definition: SBBroadcaster.cpp:181
lldb_private::repro::RegisterMethods< SBProcess >
void RegisterMethods< SBProcess >(Registry &R)
Definition: SBProcess.cpp:1340
lldb_private::repro::RegisterMethods< SBTrace >
void RegisterMethods< SBTrace >(Registry &R)
Definition: SBTrace.cpp:100
lldb_private::repro::Finalize
llvm::Error Finalize(Loader *loader)
Definition: Reproducer.cpp:365
lldb_private::ConstString
Definition: ConstString.h:40
SBAttachInfo.h
lldb_private::repro::RegisterMethods< SBError >
void RegisterMethods< SBError >(Registry &R)
Definition: SBError.cpp:191
lldb::SBReplayOptions::SBReplayOptions
SBReplayOptions()
Definition: SBReproducer.cpp:32
SBDeclaration.h
lldb_private::repro::RegisterMethods< SBFrame >
void RegisterMethods< SBFrame >(Registry &R)
Definition: SBFrame.cpp:1279
lldb_private::repro::RegisterMethods< SBCommandInterpreterRunOptions >
void RegisterMethods< SBCommandInterpreterRunOptions >(Registry &R)
Definition: SBCommandInterpreterRunOptions.cpp:255
SBDebugger.h
lldb_private::repro::RegisterMethods< SBTypeSynthetic >
void RegisterMethods< SBTypeSynthetic >(Registry &R)
Definition: SBTypeSynthetic.cpp:217
lldb_private::repro::RegisterMethods< SBPlatformConnectOptions >
void RegisterMethods< SBPlatformConnectOptions >(Registry &R)
Definition: SBPlatform.cpp:707
SBHostOS.h
lldb_private::repro::RegisterMethods< SBEnvironment >
void RegisterMethods< SBEnvironment >(Registry &R)
Definition: SBEnvironment.cpp:136
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::repro::RegisterMethods< SBData >
void RegisterMethods< SBData >(Registry &R)
Definition: SBData.cpp:654
lldb_private::repro::VersionProvider
Provider for the LLDB version number.
Definition: ReproducerProvider.h:144
SBAddress.h
lldb_private::repro::RegisterMethods< SBSymbolContext >
void RegisterMethods< SBSymbolContext >(Registry &R)
Definition: SBSymbolContext.cpp:237
lldb-private.h
lldb_private::repro::RegisterMethods< SBCommandInterpreter >
void RegisterMethods< SBCommandInterpreter >(Registry &R)
Definition: SBCommandInterpreter.cpp:754
lldb::SBReproducer::SetAutoGenerate
static bool SetAutoGenerate(bool b)
Definition: SBReproducer.cpp:297
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb_private::repro::RegisterMethods< SBStream >
void RegisterMethods< SBStream >(Registry &R)
Definition: SBStream.cpp:201
lldb_private::repro::RegisterMethods< SBListener >
void RegisterMethods< SBListener >(Registry &R)
Definition: SBListener.cpp:330
lldb_private::repro::RegisterMethods< SBThreadPlan >
void RegisterMethods< SBThreadPlan >(Registry &R)
Definition: SBThreadPlan.cpp:460
lldb_private::repro::SBProvider
Definition: SBReproducerPrivate.h:34
lldb_private::repro::ReplayData
Definition: SBReproducerPrivate.h:59
warning
static llvm::raw_ostream & warning(Stream &strm)
Definition: CommandReturnObject.cpp:23
lldb_private::repro::RegisterMethods< SBTarget >
void RegisterMethods< SBTarget >(Registry &R)
Definition: SBTarget.cpp:2485
lldb_private::repro::ReplayData::GetDeserializer
Deserializer & GetDeserializer()
Definition: SBReproducerPrivate.h:64
lldb_private::repro::RegisterMethods< SBInstruction >
void RegisterMethods< SBInstruction >(Registry &R)
Definition: SBInstruction.cpp:349
lldb::SBReplayOptions::SetCheckVersion
void SetCheckVersion(bool check)
Definition: SBReproducer.cpp:51
lldb_private::repro::RegisterMethods< SBModule >
void RegisterMethods< SBModule >(Registry &R)
Definition: SBModule.cpp:705
lldb_private::repro::RegisterMethods< SBSection >
void RegisterMethods< SBSection >(Registry &R)
Definition: SBSection.cpp:296
lldb_private::repro::RegisterMethods< SBUnixSignals >
void RegisterMethods< SBUnixSignals >(Registry &R)
Definition: SBUnixSignals.cpp:178
lldb_private::repro::RegisterMethods< SBBlock >
void RegisterMethods< SBBlock >(Registry &R)
Definition: SBBlock.cpp:351
lldb_private::repro::RegisterMethods< SBQueue >
void RegisterMethods< SBQueue >(Registry &R)
Definition: SBQueue.cpp:335
lldb_private::repro
Definition: SBReproducer.h:15
lldb_private::repro::RegisterMethods< SBFunction >
void RegisterMethods< SBFunction >(Registry &R)
Definition: SBFunction.cpp:243
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb::SBReproducer::GetPath
static const char * GetPath()
Definition: SBReproducer.cpp:306
lldb_private::repro::RegisterMethods< SBTypeCategory >
void RegisterMethods< SBTypeCategory >(Registry &R)
Definition: SBTypeCategory.cpp:659
SBReproducer.h
lldb_private::repro::SBProvider::ID
static char ID
Definition: SBReproducerPrivate.h:50
lldb_private::repro::RegisterMethods< SBVariablesOptions >
void RegisterMethods< SBVariablesOptions >(Registry &R)
Definition: SBVariablesOptions.cpp:240
lldb_private::repro::Verifier
Definition: Reproducer.h:230
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::repro::ReplayData::GetRegistry
Registry & GetRegistry()
Definition: SBReproducerPrivate.h:65
lldb_private::repro::RegisterMethods< SBProcessInfo >
void RegisterMethods< SBProcessInfo >(Registry &R)
Definition: SBProcessInfo.cpp:201
lldb::SBReproducer::SetWorkingDirectory
static void SetWorkingDirectory(const char *path)
The working directory is set to the current working directory when the reproducers are initialized.
Definition: SBReproducer.cpp:314
lldb_private::repro::RegisterMethods< SBPlatformShellCommand >
void RegisterMethods< SBPlatformShellCommand >(Registry &R)
Definition: SBPlatform.cpp:727
lldb_private::repro::RegisterMethods< SBEvent >
void RegisterMethods< SBEvent >(Registry &R)
Definition: SBEvent.cpp:212
lldb_private::repro::Loader::GetFile
FileSpec GetFile()
Definition: Reproducer.h:162
lldb_private::repro::RegisterMethods< SBAddress >
void RegisterMethods< SBAddress >(Registry &R)
Definition: SBAddress.cpp:283
SBCommandInterpreter.h
lldb_private::repro::RegisterMethods< SBMemoryRegionInfoList >
void RegisterMethods< SBMemoryRegionInfoList >(Registry &R)
Definition: SBMemoryRegionInfoList.cpp:167
lldb_private::repro::ReplayOptions
Definition: Reproducer.h:241
lldb_private::repro::RegisterMethods< SBSymbol >
void RegisterMethods< SBSymbol >(Registry &R)
Definition: SBSymbol.cpp:207
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:348
lldb_private::repro::RegisterMethods< SBSourceManager >
void RegisterMethods< SBSourceManager >(Registry &R)
Definition: SBSourceManager.cpp:146
lldb_private::repro::RegisterMethods< SBSymbolContextList >
void RegisterMethods< SBSymbolContextList >(Registry &R)
Definition: SBSymbolContextList.cpp:122
fp
@ fp
Definition: CompactUnwindInfo.cpp:1247
lldb_private::repro::RegisterMethods< SBDeclaration >
void RegisterMethods< SBDeclaration >(Registry &R)
Definition: SBDeclaration.cpp:183
lldb_private::repro::Reproducer::Instance
static Reproducer & Instance()
Definition: Reproducer.cpp:23
lldb_private::repro::RegisterMethods< SBQueueItem >
void RegisterMethods< SBQueueItem >(Registry &R)
Definition: SBQueueItem.cpp:123
lldb::SBReproducer::Capture
static const char * Capture()
Definition: SBReproducer.cpp:136
lldb
Definition: SBAddress.h:15
lldb_private::repro::RegisterMethods< SBInstructionList >
void RegisterMethods< SBInstructionList >(Registry &R)
Definition: SBInstructionList.cpp:206
lldb::SBReproducer::Replay
static const char * Replay(const char *path)
Definition: SBReproducer.cpp:190
lldb_private::repro::DirectoryProvider::SetDirectory
void SetDirectory(std::string directory)
Definition: ReproducerProvider.h:164
lldb_private::repro::RegisterMethods< SBValue >
void RegisterMethods< SBValue >(Registry &R)
Definition: SBValue.cpp:1550
SBError.h
lldb_private::repro::WorkingDirectoryProvider
Provider for the current working directory.
Definition: ReproducerProvider.h:186
lldb_private::repro::RegisterMethods< SBThreadCollection >
void RegisterMethods< SBThreadCollection >(Registry &R)
Definition: SBThreadCollection.cpp:95
lldb_private::repro::RegisterMethods< SBTypeSummaryOptions >
void RegisterMethods< SBTypeSummaryOptions >(Registry &R)
Definition: SBTypeSummary.cpp:480
SBBreakpoint.h
lldb_private::repro::RegisterMethods< SBStructuredData >
void RegisterMethods< SBStructuredData >(Registry &R)
Definition: SBStructuredData.cpp:208
lldb_private::repro::RegisterMethods< SBMemoryRegionInfo >
void RegisterMethods< SBMemoryRegionInfo >(Registry &R)
Definition: SBMemoryRegionInfo.cpp:195
lldb::SBReplayOptions::m_opaque_up
std::unique_ptr< lldb_private::repro::ReplayOptions > m_opaque_up
Definition: SBReproducer.h:37
lldb_private::repro::RegisterMethods< SBTypeEnumMember >
void RegisterMethods< SBTypeEnumMember >(Registry &R)
Definition: SBTypeEnumMember.cpp:204