1 //===-- CommandObjectReproducer.cpp -----------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #include "CommandObjectReproducer.h"
11 #include "lldb/Host/OptionParser.h"
12 #include "lldb/Utility/GDBRemote.h"
13 #include "lldb/Utility/Reproducer.h"
15 #include "lldb/Interpreter/CommandInterpreter.h"
16 #include "lldb/Interpreter/CommandReturnObject.h"
17 #include "lldb/Interpreter/OptionArgParser.h"
23 using namespace lldb_private;
24 using namespace lldb_private::repro;
26 enum ReproducerProvider {
27 eReproducerProviderCommands,
28 eReproducerProviderFiles,
29 eReproducerProviderGDB,
30 eReproducerProviderVersion,
31 eReproducerProviderWorkingDirectory,
32 eReproducerProviderNone
35 static constexpr OptionEnumValueElement g_reproducer_provider_type[] = {
37 eReproducerProviderCommands,
39 "Command Interpreter Commands",
42 eReproducerProviderFiles,
47 eReproducerProviderGDB,
52 eReproducerProviderVersion,
57 eReproducerProviderWorkingDirectory,
62 eReproducerProviderNone,
68 static constexpr OptionEnumValues ReproducerProviderType() {
69 return OptionEnumValues(g_reproducer_provider_type);
72 #define LLDB_OPTIONS_reproducer_dump
73 #include "CommandOptions.inc"
75 enum ReproducerCrashSignal {
76 eReproducerCrashSigill,
77 eReproducerCrashSigsegv,
80 static constexpr OptionEnumValueElement g_reproducer_signaltype[] = {
82 eReproducerCrashSigill,
84 "Illegal instruction",
87 eReproducerCrashSigsegv,
93 static constexpr OptionEnumValues ReproducerSignalType() {
94 return OptionEnumValues(g_reproducer_signaltype);
97 #define LLDB_OPTIONS_reproducer_xcrash
98 #include "CommandOptions.inc"
100 class CommandObjectReproducerGenerate : public CommandObjectParsed {
102 CommandObjectReproducerGenerate(CommandInterpreter &interpreter)
103 : CommandObjectParsed(
104 interpreter, "reproducer generate",
105 "Generate reproducer on disk. When the debugger is in capture "
106 "mode, this command will output the reproducer to a directory on "
107 "disk and quit. In replay mode this command in a no-op.",
110 ~CommandObjectReproducerGenerate() override = default;
113 bool DoExecute(Args &command, CommandReturnObject &result) override {
114 if (!command.empty()) {
115 result.AppendErrorWithFormat("'%s' takes no arguments",
120 auto &r = Reproducer::Instance();
121 if (auto generator = r.GetGenerator()) {
123 } else if (r.IsReplaying()) {
124 // Make this operation a NO-OP in replay mode.
125 result.SetStatus(eReturnStatusSuccessFinishNoResult);
126 return result.Succeeded();
128 result.AppendErrorWithFormat("Unable to get the reproducer generator");
129 result.SetStatus(eReturnStatusFailed);
133 result.GetOutputStream()
134 << "Reproducer written to '" << r.GetReproducerPath() << "'\n";
135 result.GetOutputStream()
136 << "Please have a look at the directory to assess if you're willing to "
137 "share the contained information.\n";
139 m_interpreter.BroadcastEvent(
140 CommandInterpreter::eBroadcastBitQuitCommandReceived);
141 result.SetStatus(eReturnStatusQuit);
142 return result.Succeeded();
146 class CommandObjectReproducerXCrash : public CommandObjectParsed {
148 CommandObjectReproducerXCrash(CommandInterpreter &interpreter)
149 : CommandObjectParsed(interpreter, "reproducer xcrash",
150 "Intentionally force the debugger to crash in "
151 "order to trigger and test reproducer generation.",
154 ~CommandObjectReproducerXCrash() override = default;
156 Options *GetOptions() override { return &m_options; }
158 class CommandOptions : public Options {
160 CommandOptions() : Options() {}
162 ~CommandOptions() override = default;
164 Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
165 ExecutionContext *execution_context) override {
167 const int short_option = m_getopt_table[option_idx].val;
169 switch (short_option) {
171 signal = (ReproducerCrashSignal)OptionArgParser::ToOptionEnum(
172 option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
173 if (!error.Success())
174 error.SetErrorStringWithFormat("unrecognized value for signal '%s'",
175 option_arg.str().c_str());
178 llvm_unreachable("Unimplemented option");
184 void OptionParsingStarting(ExecutionContext *execution_context) override {
185 signal = eReproducerCrashSigsegv;
188 ArrayRef<OptionDefinition> GetDefinitions() override {
189 return makeArrayRef(g_reproducer_xcrash_options);
192 ReproducerCrashSignal signal = eReproducerCrashSigsegv;
196 bool DoExecute(Args &command, CommandReturnObject &result) override {
197 if (!command.empty()) {
198 result.AppendErrorWithFormat("'%s' takes no arguments",
203 auto &r = Reproducer::Instance();
205 if (!r.IsCapturing() && !r.IsReplaying()) {
207 "forcing a crash is only supported when capturing a reproducer.");
208 result.SetStatus(eReturnStatusSuccessFinishNoResult);
212 switch (m_options.signal) {
213 case eReproducerCrashSigill:
216 case eReproducerCrashSigsegv:
221 result.SetStatus(eReturnStatusQuit);
222 return result.Succeeded();
226 CommandOptions m_options;
229 class CommandObjectReproducerStatus : public CommandObjectParsed {
231 CommandObjectReproducerStatus(CommandInterpreter &interpreter)
232 : CommandObjectParsed(
233 interpreter, "reproducer status",
234 "Show the current reproducer status. In capture mode the "
236 "is collecting all the information it needs to create a "
237 "reproducer. In replay mode the reproducer is replaying a "
238 "reproducer. When the reproducers are off, no data is collected "
239 "and no reproducer can be generated.",
242 ~CommandObjectReproducerStatus() override = default;
245 bool DoExecute(Args &command, CommandReturnObject &result) override {
246 if (!command.empty()) {
247 result.AppendErrorWithFormat("'%s' takes no arguments",
252 auto &r = Reproducer::Instance();
253 if (r.IsCapturing()) {
254 result.GetOutputStream() << "Reproducer is in capture mode.\n";
255 } else if (r.IsReplaying()) {
256 result.GetOutputStream() << "Reproducer is in replay mode.\n";
258 result.GetOutputStream() << "Reproducer is off.\n";
261 result.SetStatus(eReturnStatusSuccessFinishResult);
262 return result.Succeeded();
266 static void SetError(CommandReturnObject &result, Error err) {
267 result.GetErrorStream().Printf("error: %s\n",
268 toString(std::move(err)).c_str());
269 result.SetStatus(eReturnStatusFailed);
272 class CommandObjectReproducerDump : public CommandObjectParsed {
274 CommandObjectReproducerDump(CommandInterpreter &interpreter)
275 : CommandObjectParsed(interpreter, "reproducer dump",
276 "Dump the information contained in a reproducer. "
277 "If no reproducer is specified during replay, it "
278 "dumps the content of the current reproducer.",
281 ~CommandObjectReproducerDump() override = default;
283 Options *GetOptions() override { return &m_options; }
285 class CommandOptions : public Options {
287 CommandOptions() : Options(), file() {}
289 ~CommandOptions() override = default;
291 Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
292 ExecutionContext *execution_context) override {
294 const int short_option = m_getopt_table[option_idx].val;
296 switch (short_option) {
298 file.SetFile(option_arg, FileSpec::Style::native);
299 FileSystem::Instance().Resolve(file);
302 provider = (ReproducerProvider)OptionArgParser::ToOptionEnum(
303 option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
304 if (!error.Success())
305 error.SetErrorStringWithFormat("unrecognized value for provider '%s'",
306 option_arg.str().c_str());
309 llvm_unreachable("Unimplemented option");
315 void OptionParsingStarting(ExecutionContext *execution_context) override {
317 provider = eReproducerProviderNone;
320 ArrayRef<OptionDefinition> GetDefinitions() override {
321 return makeArrayRef(g_reproducer_dump_options);
325 ReproducerProvider provider = eReproducerProviderNone;
329 bool DoExecute(Args &command, CommandReturnObject &result) override {
330 if (!command.empty()) {
331 result.AppendErrorWithFormat("'%s' takes no arguments",
336 // If no reproducer path is specified, use the loader currently used for
337 // replay. Otherwise create a new loader just for dumping.
338 llvm::Optional<Loader> loader_storage;
339 Loader *loader = nullptr;
340 if (!m_options.file) {
341 loader = Reproducer::Instance().GetLoader();
342 if (loader == nullptr) {
344 "Not specifying a reproducer is only support during replay.");
345 result.SetStatus(eReturnStatusSuccessFinishNoResult);
349 loader_storage.emplace(m_options.file);
350 loader = &(*loader_storage);
351 if (Error err = loader->LoadIndex()) {
352 SetError(result, std::move(err));
357 // If we get here we should have a valid loader.
360 switch (m_options.provider) {
361 case eReproducerProviderFiles: {
362 FileSpec vfs_mapping = loader->GetFile<FileProvider::Info>();
364 // Read the VFS mapping.
365 ErrorOr<std::unique_ptr<MemoryBuffer>> buffer =
366 vfs::getRealFileSystem()->getBufferForFile(vfs_mapping.GetPath());
368 SetError(result, errorCodeToError(buffer.getError()));
372 // Initialize a VFS from the given mapping.
373 IntrusiveRefCntPtr<vfs::FileSystem> vfs = vfs::getVFSFromYAML(
374 std::move(buffer.get()), nullptr, vfs_mapping.GetPath());
376 // Dump the VFS to a buffer.
378 raw_string_ostream os(str);
379 static_cast<vfs::RedirectingFileSystem &>(*vfs).dump(os);
382 // Return the string.
383 result.AppendMessage(str);
384 result.SetStatus(eReturnStatusSuccessFinishResult);
387 case eReproducerProviderVersion: {
388 Expected<std::string> version = loader->LoadBuffer<VersionProvider>();
390 SetError(result, version.takeError());
393 result.AppendMessage(*version);
394 result.SetStatus(eReturnStatusSuccessFinishResult);
397 case eReproducerProviderWorkingDirectory: {
398 Expected<std::string> cwd =
399 loader->LoadBuffer<WorkingDirectoryProvider>();
401 SetError(result, cwd.takeError());
404 result.AppendMessage(*cwd);
405 result.SetStatus(eReturnStatusSuccessFinishResult);
408 case eReproducerProviderCommands: {
409 std::unique_ptr<repro::MultiLoader<repro::CommandProvider>> multi_loader =
410 repro::MultiLoader<repro::CommandProvider>::Create(loader);
413 make_error<StringError>(llvm::inconvertibleErrorCode(),
414 "Unable to create command loader."));
418 // Iterate over the command files and dump them.
419 llvm::Optional<std::string> command_file;
420 while ((command_file = multi_loader->GetNextFile())) {
424 auto command_buffer = llvm::MemoryBuffer::getFile(*command_file);
425 if (auto err = command_buffer.getError()) {
426 SetError(result, errorCodeToError(err));
429 result.AppendMessage((*command_buffer)->getBuffer());
432 result.SetStatus(eReturnStatusSuccessFinishResult);
435 case eReproducerProviderGDB: {
436 std::unique_ptr<repro::MultiLoader<repro::GDBRemoteProvider>>
438 repro::MultiLoader<repro::GDBRemoteProvider>::Create(loader);
439 llvm::Optional<std::string> gdb_file;
440 while ((gdb_file = multi_loader->GetNextFile())) {
441 auto error_or_file = MemoryBuffer::getFile(*gdb_file);
442 if (auto err = error_or_file.getError()) {
443 SetError(result, errorCodeToError(err));
447 std::vector<GDBRemotePacket> packets;
448 yaml::Input yin((*error_or_file)->getBuffer());
451 if (auto err = yin.error()) {
452 SetError(result, errorCodeToError(err));
456 for (GDBRemotePacket &packet : packets) {
457 packet.Dump(result.GetOutputStream());
461 result.SetStatus(eReturnStatusSuccessFinishResult);
464 case eReproducerProviderNone:
465 result.SetError("No valid provider specified.");
469 result.SetStatus(eReturnStatusSuccessFinishNoResult);
470 return result.Succeeded();
474 CommandOptions m_options;
477 CommandObjectReproducer::CommandObjectReproducer(
478 CommandInterpreter &interpreter)
479 : CommandObjectMultiword(
480 interpreter, "reproducer",
481 "Commands for manipulating reproducers. Reproducers make it "
483 "to capture full debug sessions with all its dependencies. The "
484 "resulting reproducer is used to replay the debug session while "
485 "debugging the debugger.\n"
486 "Because reproducers need the whole the debug session from "
487 "beginning to end, you need to launch the debugger in capture or "
488 "replay mode, commonly though the command line driver.\n"
489 "Reproducers are unrelated record-replay debugging, as you cannot "
490 "interact with the debugger during replay.\n",
491 "reproducer <subcommand> [<subcommand-options>]") {
494 CommandObjectSP(new CommandObjectReproducerGenerate(interpreter)));
495 LoadSubCommand("status", CommandObjectSP(
496 new CommandObjectReproducerStatus(interpreter)));
497 LoadSubCommand("dump",
498 CommandObjectSP(new CommandObjectReproducerDump(interpreter)));
499 LoadSubCommand("xcrash", CommandObjectSP(
500 new CommandObjectReproducerXCrash(interpreter)));
503 CommandObjectReproducer::~CommandObjectReproducer() = default;