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 
135 }
136 
137 const char *SBReproducer::Capture() {
138  static std::string error;
139  if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
140  error = llvm::toString(std::move(e));
141  return error.c_str();
142  }
143 
144  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
145  auto &p = g->GetOrCreate<SBProvider>();
146  InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
147  }
148 
149  return nullptr;
150 }
151 
152 const char *SBReproducer::Capture(const char *path) {
153  static std::string error;
154  if (auto e =
155  Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
156  error = llvm::toString(std::move(e));
157  return error.c_str();
158  }
159 
160  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
161  auto &p = g->GetOrCreate<SBProvider>();
162  InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
163  }
164 
165  return nullptr;
166 }
167 
168 const char *SBReproducer::PassiveReplay(const char *path) {
169  static std::string error;
170  if (auto e = Reproducer::Initialize(ReproducerMode::PassiveReplay,
171  FileSpec(path))) {
172  error = llvm::toString(std::move(e));
173  return error.c_str();
174  }
175 
176  if (auto *l = lldb_private::repro::Reproducer::Instance().GetLoader()) {
177  FileSpec file = l->GetFile<SBProvider::Info>();
178  auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
179  if (!error_or_file) {
180  error =
181  "unable to read SB API data: " + error_or_file.getError().message();
182  return error.c_str();
183  }
184  static ReplayData r(std::move(*error_or_file));
185  InstrumentationData::Initialize(r.GetDeserializer(), r.GetRegistry());
186  }
187 
188  return nullptr;
189 }
190 
191 const char *SBReproducer::Replay(const char *path) {
192  SBReplayOptions options;
193  return SBReproducer::Replay(path, options);
194 }
195 
196 const char *SBReproducer::Replay(const char *path, bool skip_version_check) {
197  SBReplayOptions options;
198  options.SetCheckVersion(!skip_version_check);
199  return SBReproducer::Replay(path, options);
200 }
201 
202 const char *SBReproducer::Replay(const char *path,
203  const SBReplayOptions &options) {
204  static std::string error;
205  if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
206  error = llvm::toString(std::move(e));
207  return error.c_str();
208  }
209 
210  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
211  if (!loader) {
212  error = "unable to get replay loader.";
213  return error.c_str();
214  }
215 
216  if (options.GetCheckVersion()) {
217  llvm::Expected<std::string> version = loader->LoadBuffer<VersionProvider>();
218  if (!version) {
219  error = llvm::toString(version.takeError());
220  return error.c_str();
221  }
222  if (lldb_private::GetVersion() != llvm::StringRef(*version).rtrim()) {
223  error = "reproducer capture and replay version don't match:\n";
224  error.append("reproducer captured with:\n");
225  error.append(*version);
226  error.append("reproducer replayed with:\n");
227  error.append(lldb_private::GetVersion());
228  return error.c_str();
229  }
230  }
231 
232  if (options.GetVerify()) {
233  bool verification_failed = false;
234  llvm::raw_string_ostream os(error);
235  auto error_callback = [&](llvm::StringRef error) {
236  verification_failed = true;
237  os << "\nerror: " << error;
238  };
239 
240  auto warning_callback = [&](llvm::StringRef warning) {
241  verification_failed = true;
242  os << "\nwarning: " << warning;
243  };
244 
245  auto note_callback = [&](llvm::StringRef warning) {};
246 
247  Verifier verifier(loader);
248  verifier.Verify(error_callback, warning_callback, note_callback);
249 
250  if (verification_failed) {
251  os.flush();
252  return error.c_str();
253  }
254  }
255 
256  FileSpec file = loader->GetFile<SBProvider::Info>();
257  if (!file) {
258  error = "unable to get replay data from reproducer.";
259  return error.c_str();
260  }
261 
262  SBRegistry registry;
263  registry.Replay(file);
264 
265  return nullptr;
266 }
267 
268 const char *SBReproducer::Finalize(const char *path) {
269  static std::string error;
270  if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
271  error = llvm::toString(std::move(e));
272  return error.c_str();
273  }
274 
275  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
276  if (!loader) {
277  error = "unable to get replay loader.";
278  return error.c_str();
279  }
280 
281  if (auto e = repro::Finalize(loader)) {
282  error = llvm::toString(std::move(e));
283  return error.c_str();
284  }
285 
286  return nullptr;
287 }
288 
290  auto &r = Reproducer::Instance();
291  if (auto generator = r.GetGenerator()) {
292  generator->Keep();
293  return true;
294  }
295  return false;
296 }
297 
299  auto &r = Reproducer::Instance();
300  if (auto generator = r.GetGenerator()) {
301  generator->SetAutoGenerate(b);
302  return true;
303  }
304  return false;
305 }
306 
307 const char *SBReproducer::GetPath() {
308  ConstString path;
309  auto &r = Reproducer::Instance();
310  if (FileSpec reproducer_path = Reproducer::Instance().GetReproducerPath())
311  path = ConstString(r.GetReproducerPath().GetCString());
312  return path.GetCString();
313 }
314 
315 void SBReproducer::SetWorkingDirectory(const char *path) {
316  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
317  auto &wp = g->GetOrCreate<repro::WorkingDirectoryProvider>();
318  wp.SetDirectory(path);
319  auto &fp = g->GetOrCreate<repro::FileProvider>();
320  fp.RecordInterestingDirectory(wp.GetDirectory());
321  }
322 }
323 
325 const char *SBProvider::Info::name = "sbapi";
326 const char *SBProvider::Info::file = "sbapi.bin";
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:1693
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:702
lldb::SBReproducer::Finalize
static const char * Finalize(const char *path)
Definition: SBReproducer.cpp:268
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< SBTraceOptions >
void RegisterMethods< SBTraceOptions >(Registry &R)
Definition: SBTraceOptions.cpp:137
lldb_private::repro::RegisterMethods< SBPlatform >
void RegisterMethods< SBPlatform >(Registry &R)
Definition: SBPlatform.cpp:753
lldb::SBReproducer::PassiveReplay
static const char * PassiveReplay(const char *path)
Definition: SBReproducer.cpp:168
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:38
lldb_private::repro::RegisterMethods< SBDebugger >
void RegisterMethods< SBDebugger >(Registry &R)
Definition: SBDebugger.cpp:1706
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:244
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:374
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:98
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:289
SBBlock.h
lldb_private::breakpad::toString
llvm::StringRef toString(Record::Kind K)
Definition: BreakpadRecords.cpp:483
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:1315
lldb_private::repro::RegisterMethods< SBTrace >
void RegisterMethods< SBTrace >(Registry &R)
Definition: SBTrace.cpp:124
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:1295
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:708
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:38
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:762
lldb::SBReproducer::SetAutoGenerate
static bool SetAutoGenerate(bool b)
Definition: SBReproducer.cpp:298
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:2461
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:703
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:353
lldb_private::repro::RegisterMethods< SBQueue >
void RegisterMethods< SBQueue >(Registry &R)
Definition: SBQueue.cpp:336
lldb_private::repro
Definition: SBReproducer.h:15
lldb_private::repro::RegisterMethods< SBFunction >
void RegisterMethods< SBFunction >(Registry &R)
Definition: SBFunction.cpp:245
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:307
lldb_private::repro::RegisterMethods< SBTypeCategory >
void RegisterMethods< SBTypeCategory >(Registry &R)
Definition: SBTypeCategory.cpp:667
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:241
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:186
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:315
lldb_private::repro::RegisterMethods< SBPlatformShellCommand >
void RegisterMethods< SBPlatformShellCommand >(Registry &R)
Definition: SBPlatform.cpp:728
lldb_private::repro::RegisterMethods< SBEvent >
void RegisterMethods< SBEvent >(Registry &R)
Definition: SBEvent.cpp:214
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:147
lldb_private::repro::ReplayOptions
Definition: Reproducer.h:241
lldb_private::repro::RegisterMethods< SBSymbol >
void RegisterMethods< SBSymbol >(Registry &R)
Definition: SBSymbol.cpp:209
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:137
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:191
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:199
lldb_private::repro::RegisterMethods< SBMemoryRegionInfo >
void RegisterMethods< SBMemoryRegionInfo >(Registry &R)
Definition: SBMemoryRegionInfo.cpp:140
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