[lldb/interpreter] Add ability to save lldb session to a file

[mib]

Summary

This patch introduce a new feature that allows the users to save their
debugging session's transcript (commands + outputs) to a file.

It differs from the reproducers since it doesn't require to capture a
session preemptively and replay the reproducer file in lldb.
The user can choose the save its session manually using the session save
command or automatically by setting the interpreter.save-session-on-quit
on their init file.

To do so, the patch adds a Stream object to the CommandInterpreter that
will hold the input command from the IOHandler and the CommandReturnObject
output and error. This way, that stream object accumulates passively all
the interactions throughout the session and will save them to disk on demand.

The user can specify a file path where the session's transcript will be
saved. However, it is optional, and when it is not provided, lldb will
create a temporary file name according to the session date and time.

rdar://63347792

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Hey folks, this is a first implementation of the patch and surely there will be several other revisions before landing it.

Some functionalities are not supported yet, like:

• Multi-line expression
• Python/Lua? Interactive script interpreter
• Outputs that aren't in the CommandReturnObject

I didn't provide tests because it's still WIP (obviously, it will come it the next revisions) , but at the moment, I'm not sure what would be a good test plan for this feature (suggestions are welcomed).

Thanks in advance for the feedback.

[JDevlieghere]

lldb/source/Commands/CommandObjectSession.cpp

10

Remove

43

StringRef is empty by default, remove = ""

48

Inline the variable below.

64

Missing period.

lldb/source/Commands/CommandObjectSession.h

20

Remove

26

Remove

lldb/source/Interpreter/CommandInterpreter.cpp

124

use make_shared

2815

this won't work for things like unambiguous abbreviations like sess save. The command should do the saving.

2913

If you're going to convert the StringRef to a std::string you might as well have that passed in by value so that the caller could move it when appropriate.

2929

Why are you going through the FileCache?

2941

I think we have a constant LLDB_INVALID_FILE_DESCRIPTOR or something? If not you should use std::numeric_limits.

[mib]

lldb/source/Interpreter/CommandInterpreter.cpp

2929

I was thinking if the user saves several times during his session to the same file, that might be useful. Looking at the implementation, it uses the FileSystem instance, so I'm not sure why that would a problem ...

May be you could elaborate why I shouldn't use it ?

[labath]

This seems like it could be useful in some circumstances, though for the use cases I am imagining (bug reporting) it would be easier to just copy-paste the terminal contents.

As for the implementation, if the intention is for this to eventually capture all debugger output, then I am not sure if this is the right design. I think it would be fine for python/lua interpreters as those are invoked from the lldb command interpreter, but I have a feeling that routing the output printed via Debugger::PrintAsync back to the command interpreter would look pretty weird. It may make sense for the core logic of this to live in the Debugger or the IOHandler(Stack) classes -- though I am not exactly sure about that either as the Debugger and CommandIntepreter classes are fairly tightly coupled. However, I think that would be consistent with the long term goal of reimplementing the command interpreter on top of the SB API (in which case the Debugger object should not know anything about the command interpreter (but it would still need to to "something" with the PrintAsync output).

The test plan sounds fairly straight forward -- run lldb, execute a bunch of commands, and finish it off with "session save". Then, verify that the file has the "right" contents (e.g. with FileCheck). Besides multiline commands, commands which do recursive processing are also interesting to exercise -- e.g. "command source" or breakpoint callbacks. You also should decide what do you want to happen with commands that are executed through the SB interface (SBCommandInterpreter::HandleCommand) -- those will not normally go to the debugger output, but I believe they will still be captured in the current design...

lldb/source/Interpreter/CommandInterpreter.cpp

2815

I don't think it's unreasonable to write to the "transcript" here, but the string matching is obviously suboptimal. However, it's not clear to me why is it even needed -- having the "save" command in the transcript does not necessarily seem like a bad thing, and I believe the way it is implemented means that the command will not show up in the session file that is currently being saved (only in the subsequent ones).

2820

These !empty() checks are pointless.

2827

As is this flush call.

2929

FileCache is a very specialist class, so I believe the default should be to _not_ use it. However, if you are looking for reasons, I can name a few:

• the way you are using it means you get no caching benefits whatsoever -- each OpenFile call creates a new file descriptor
• it makes it very easy to leak that descriptor (as you did here)

2945

Why not make m_session_transcripts a shared_ptr<StreamString> (or even a plain StreamString) in the first place?

[mib]

Addressed Pavel's and Jonas' comments

[mib]

Ran clang-format

[labath]

The code looks fine to me, though it sounds like there are still issues to be sorted out w.r.t commands run from inside data formatters, through sb apis, etc. And it needs tests, of course.

lldb/source/Commands/CommandObjectSession.h

23–27

You don't have to do this, but personally I'd delete all of this stuff -- the copy operations are implicitly deleted due to them being deleted in the base class, and the destructor will be implicitly overridden anyway.

lldb/source/Interpreter/CommandInterpreter.cpp

2938

It would be nice if this error message actually contained the reason why the open operation failed (similar to what we did with the core file patch a while back).

2945

Much better, though a plain StreamString would be even nicer (and AFAICT there is nothing preventing that).

[mib]

• Address previous comments
• Add test

[mib]

Reformat.

[JDevlieghere]

lldb/include/lldb/Interpreter/CommandInterpreter.h

531

• Is there more than one transcript?
• Maybe make the string optional as you have logic to deal with that so you can call SaveTranscripts() instead of SaveTranscripts("") which looks a bit messy.
• Add a Doxygen comment documenting the empty-string behavior.

629

The current name isn't very descriptive of what this object is exactly, especially since it's plural. How about m_transcript_stream?

lldb/source/Commands/CommandObjectSession.cpp

26

I changed the CommandArgumentData constructor so you can do

arg1.emplace_back(eArgTypePath, eArgRepeatOptional)

lldb/source/Commands/CommandObjectSession.h

17

Redundant.

lldb/source/Interpreter/CommandInterpreter.cpp

2925

Something that's called from a command should not write to the debugger's output/error stream directly. This should return an Error instead which then can be dealt with in the caller. If the caller is a CommandObject, it can write it to the return object. If the caller is something else it can still decide to write it to the debugger's error stream.

lldb/test/API/commands/session/save/TestSessionSave.py

42 ↗

(On Diff #279519)

You probably didn't mean to leave this around.

[mib]

Address @JDevlieghere comments.

[mib]

Reformat patch.

[JDevlieghere]

LGTM

lldb/source/Interpreter/CommandInterpreter.cpp

2951

I'd write this to the CommandReturnObject and include it in the transcript.

[labath]

lldb/source/Commands/CommandObjectQuit.cpp

75–80

I think this should be done only after we have done all the validation and decided that we actually want to quit (i.e. line ~109).

I am also not sure that a failure to save the transcript should abort the quit. Maybe it just print an error message but quit nonetheless?

lldb/source/Interpreter/CommandInterpreter.cpp

506–519

/me wonders how this file escaped Jonas's make_shared-ification.

lldb/test/API/commands/session/save/TestSessionSave.py

16–18 ↗

(On Diff #279639)

This will modify the global configuration object. Best just set the relevant settings manually...

[mib]

Address @labath comments

[JDevlieghere]

lldb/source/Interpreter/CommandInterpreter.cpp

506–519

Oh my god. Let's fix that ASAP: https://reviews.llvm.org/D84336

lldb/include/lldb/Interpreter/CommandInterpreter.h

 //===-- CommandInterpreter.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_INTERPRETER_COMMANDINTERPRETER_H
 #define LLDB_INTERPRETER_COMMANDINTERPRETER_H
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Interpreter/CommandAlias.h"
 #include "lldb/Interpreter/CommandHistory.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/CompletionRequest.h"
void GetPythonCommandsFromIOHandler(const char *prompt,
                                       void *baton = nullptr);
 
   const char *GetCommandPrefix();
 
   // Properties
   bool GetExpandRegexAliases() const;
 
   bool GetPromptOnQuit() const;
-
   void SetPromptOnQuit(bool enable);
 
+  bool GetSaveSessionOnQuit() const;
+  void SetSaveSessionOnQuit(bool enable);
+
   bool GetEchoCommands() const;
   void SetEchoCommands(bool enable);
 
   bool GetEchoCommentCommands() const;
   void SetEchoCommentCommands(bool enable);
 
   const CommandObject::CommandMap &GetUserCommands() const {
     return m_user_dict;
public:
   bool GetStopCmdSourceOnError() const;
 
   lldb::IOHandlerSP
   GetIOHandler(bool force_create = false,
                CommandInterpreterRunOptions *options = nullptr);
 
   bool GetSpaceReplPrompts() const;
 
+  bool SaveTranscripts(llvm::StringRef file_path);
+
 protected:
   friend class Debugger;
 
   // IOHandlerDelegate functions
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
 
   ConstString IOHandlerGetControlSequence(char ch) override {
private:
   std::vector<uint32_t> m_command_source_flags;
   CommandInterpreterRunResult m_result;
 
   // The exit code the user has requested when calling the 'quit' command.
   // No value means the user hasn't set a custom exit code so far.
   llvm::Optional<int> m_quit_exit_code;
   // If the driver is accepts custom exit codes for the 'quit' command.
   bool m_allow_exit_code = false;
+
+  lldb::StreamSP m_session_transcripts;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDINTERPRETER_H

lldb/source/Commands/CMakeLists.txt

 lldb_tablegen(CommandOptions.inc -gen-lldb-option-defs
   SOURCE Options.td
   TARGET LLDBOptionsGen)
 
 add_lldb_library(lldbCommands
   CommandCompletions.cpp
   CommandObjectApropos.cpp
   CommandObjectBreakpoint.cpp
   CommandObjectBreakpointCommand.cpp
   CommandObjectCommands.cpp
   CommandObjectDisassemble.cpp
   CommandObjectExpression.cpp
   CommandObjectFrame.cpp
   CommandObjectGUI.cpp
   CommandObjectHelp.cpp
+  CommandObjectLanguage.cpp
   CommandObjectLog.cpp
   CommandObjectMemory.cpp
   CommandObjectMultiword.cpp
   CommandObjectPlatform.cpp
   CommandObjectPlugin.cpp
   CommandObjectProcess.cpp
   CommandObjectQuit.cpp
   CommandObjectRegister.cpp
   CommandObjectReproducer.cpp
+  CommandObjectSession.cpp
   CommandObjectSettings.cpp
   CommandObjectSource.cpp
   CommandObjectStats.cpp
   CommandObjectTarget.cpp
   CommandObjectThread.cpp
   CommandObjectType.cpp
   CommandObjectVersion.cpp
   CommandObjectWatchpoint.cpp
   CommandObjectWatchpointCommand.cpp
-  CommandObjectLanguage.cpp
 
   LINK_LIBS
     lldbBase
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbExpression
     lldbHost

lldb/source/Commands/CommandObjectQuit.cpp

message.Printf("Quitting LLDB will %s one or more processes. Do you really "
                    "want to proceed",
                    (is_a_detach ? "detach from" : "kill"));
     if (!m_interpreter.Confirm(message.GetString(), true)) {
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
   }
 
+  if (m_interpreter.GetSaveSessionOnQuit()) {
+    if (!m_interpreter.SaveTranscripts("")) {
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+  }
+
   if (command.GetArgumentCount() > 1) {
     result.AppendError("Too many arguments for 'quit'. Only an optional exit "
                        "code is allowed");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   // We parse the exit code argument if there is one.

lldb/source/Commands/CommandObjectSession.h

+//===-- CommandObjectSession.h ----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_COMMANDS_COMMANDOBJECTSESSION_H
+#define LLDB_SOURCE_COMMANDS_COMMANDOBJECTSESSION_H
+
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+
+namespace lldb_private {
+
+// CommandObjectSession
+
+class CommandObjectSession : public CommandObjectMultiword {
+public:
+  // Constructors and Destructors
+  CommandObjectSession(CommandInterpreter &interpreter);
+
+  ~CommandObjectSession() override;
+
+private:
+  // For CommandObjectSession only
+  CommandObjectSession(const CommandObjectSession &) = delete;
+  const CommandObjectSession &operator=(const CommandObjectSession &) = delete;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTSESSION_H

lldb/source/Commands/CommandObjectSession.cpp

+#include "CommandObjectSession.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+class CommandObjectSessionSave : public CommandObjectParsed {
+public:
+  // Constructors and Destructors
+  CommandObjectSessionSave(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "session save",
+                            "Save the current session transcripts to a file.\n"
+                            "If no file if specified, transcripts will be "
+                            "saved to a temporary file.",
+                            "session save [file]") {
+    CommandArgumentEntry arg1;
+    CommandArgumentData channel_arg;
+
+    // Define the first (and only) variant of this arg.
+    channel_arg.arg_type = eArgTypePath;
+    channel_arg.arg_repetition = eArgRepeatOptional;
+
+    // There is only one variant this argument could be; put it into the
+    // argument entry.
+    arg1.push_back(channel_arg);
+
+    m_arguments.push_back(arg1);
+  }
+
+  ~CommandObjectSessionSave() override = default;
+
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
+        request, nullptr);
+  }
+
+protected:
+  bool DoExecute(Args &args, CommandReturnObject &result) override {
+    llvm::StringRef file_path = "";
+
+    if (!args.empty())
+      file_path = args[0].ref();
+
+    bool success = m_interpreter.SaveTranscripts(file_path);
+
+    if (success)
+      result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    else
+      result.SetStatus(eReturnStatusFailed);
+    return result.Succeeded();
+  }
+};
+
+CommandObjectSession::CommandObjectSession(CommandInterpreter &interpreter)
+    : CommandObjectMultiword(interpreter, "session",
+                             "Commands controlling LLDB session.",
+                             "session <subcommand> [<command-options>]") {
+  LoadSubCommand("save",
+                 CommandObjectSP(new CommandObjectSessionSave(interpreter)));
+  //  TODO: Move 'history' subcommand from CommandObjectCommands
+}
+
+CommandObjectSession::~CommandObjectSession() = default;

lldb/source/Interpreter/CommandInterpreter.cpp

 #include "Commands/CommandObjectLog.h"
 #include "Commands/CommandObjectMemory.h"
 #include "Commands/CommandObjectPlatform.h"
 #include "Commands/CommandObjectPlugin.h"
 #include "Commands/CommandObjectProcess.h"
 #include "Commands/CommandObjectQuit.h"
 #include "Commands/CommandObjectRegister.h"
 #include "Commands/CommandObjectReproducer.h"
+#include "Commands/CommandObjectSession.h"
 #include "Commands/CommandObjectSettings.h"
 #include "Commands/CommandObjectSource.h"
 #include "Commands/CommandObjectStats.h"
 #include "Commands/CommandObjectTarget.h"
 #include "Commands/CommandObjectThread.h"
 #include "Commands/CommandObjectType.h"
 #include "Commands/CommandObjectVersion.h"
 #include "Commands/CommandObjectWatchpoint.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #include "lldb/Host/Config.h"
 #if LLDB_ENABLE_LIBEDIT
 #include "lldb/Host/Editline.h"
 #endif
+#include "lldb/Host/File.h"
+#include "lldb/Host/FileCache.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Utility/Args.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnixSignals.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
+#include "llvm/Support/ScopedPrinter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const char *k_white_space = " \t\v";
 
 static constexpr const char *InitFileWarning =
     "There is a .lldbinit file in the current directory which is not being "
: Broadcaster(debugger.GetBroadcasterManager(),
                   CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
       Properties(OptionValuePropertiesSP(
           new OptionValueProperties(ConstString("interpreter")))),
       IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
       m_debugger(debugger), m_synchronous_execution(true),
       m_skip_lldbinit_files(false), m_skip_app_init_files(false),
       m_command_io_handler_sp(), m_comment_char('#'),
       m_batch_command_mode(false), m_truncation_warning(eNoTruncation),
-      m_command_source_depth(0), m_result() {
+      m_command_source_depth(0), m_result(),
+      m_session_transcripts(new StreamString()) {
   SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
   SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
   SetEventName(eBroadcastBitQuitCommandReceived, "quit");
   SetSynchronous(synchronous_execution);
   CheckInWithManager();
   m_collection_sp->Initialize(g_interpreter_properties);
 }
 
return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
 }
 
 void CommandInterpreter::SetPromptOnQuit(bool enable) {
   const uint32_t idx = ePropertyPromptOnQuit;
   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, enable);
 }
 
+bool CommandInterpreter::GetSaveSessionOnQuit() const {
+  const uint32_t idx = ePropertySaveSessionOnQuit;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
+}
+
+void CommandInterpreter::SetSaveSessionOnQuit(bool enable) {
+  const uint32_t idx = ePropertySaveSessionOnQuit;
+  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, enable);
+}
+
 bool CommandInterpreter::GetEchoCommands() const {
   const uint32_t idx = ePropertyEchoCommands;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
 }
 
 void CommandInterpreter::SetEchoCommands(bool enable) {
   const uint32_t idx = ePropertyEchoCommands;
void CommandInterpreter::LoadCommandDictionary() {
   m_command_dict["log"] = CommandObjectSP(new CommandObjectLog(*this));
   m_command_dict["memory"] = CommandObjectSP(new CommandObjectMemory(*this));
   m_command_dict["platform"] =
       CommandObjectSP(new CommandObjectPlatform(*this));
   m_command_dict["plugin"] = CommandObjectSP(new CommandObjectPlugin(*this));
   m_command_dict["process"] =
       CommandObjectSP(new CommandObjectMultiwordProcess(*this));
   m_command_dict["quit"] = CommandObjectSP(new CommandObjectQuit(*this));
   m_command_dict["register"] =
       CommandObjectSP(new CommandObjectRegister(*this));
   m_command_dict["reproducer"] =
       CommandObjectSP(new CommandObjectReproducer(*this));
   m_command_dict["script"] =
       CommandObjectSP(new CommandObjectScript(*this, script_language));
+  m_command_dict["session"] = CommandObjectSP(new CommandObjectSession(*this));
   m_command_dict["settings"] =
       CommandObjectSP(new CommandObjectMultiwordSettings(*this));
   m_command_dict["source"] =
       CommandObjectSP(new CommandObjectMultiwordSource(*this));
   m_command_dict["statistics"] = CommandObjectSP(new CommandObjectStats(*this));
   m_command_dict["target"] =
       CommandObjectSP(new CommandObjectMultiwordTarget(*this));
   m_command_dict["thread"] =
       CommandObjectSP(new CommandObjectMultiwordThread(*this));
   m_command_dict["type"] = CommandObjectSP(new CommandObjectType(*this));
   m_command_dict["version"] = CommandObjectSP(new CommandObjectVersion(*this));
   m_command_dict["watchpoint"] =
       CommandObjectSP(new CommandObjectMultiwordWatchpoint(*this));
   m_command_dict["language"] =
       CommandObjectSP(new CommandObjectLanguage(*this));
if (EchoCommandNonInteractive(line, io_handler.GetFlags()))
           "%s%s\n", io_handler.GetPrompt(), line.c_str());
   }
 
   StartHandlingCommand();
 
   lldb_private::CommandReturnObject result(m_debugger.GetUseColor());
   HandleCommand(line.c_str(), eLazyBoolCalculate, result);
 
+  if (line.find("session save") == line.npos) {
+    *m_session_transcripts << io_handler.GetPrompt() << ' ' << line.c_str()
+                           << '\n';
+
+    llvm::StringRef result_output = result.GetOutputData();
+    if (!result_output.empty())
+      *m_session_transcripts << result_output;
+
+    llvm::StringRef result_error = result.GetErrorData();
+    if (!result_error.empty())
+      *m_session_transcripts << result_error;
+
+    m_session_transcripts->Flush();
+  }
+
   // Now emit the command output text from the command we just executed
   if ((result.Succeeded() &&
        io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) ||
       io_handler.GetFlags().Test(eHandleCommandFlagPrintErrors)) {
     // Display any STDOUT/STDERR _prior_ to emitting the command result text
     GetProcessOutput();
 
     if (!result.GetImmediateOutputStream()) {
ScriptInterpreter *script_interpreter =
       m_debugger.GetScriptInterpreter(false);
   if (script_interpreter) {
     if (script_interpreter->Interrupt())
       return true;
   }
   return false;
 }
 
+bool CommandInterpreter::SaveTranscripts(llvm::StringRef file_path) {
+  std::string output_file = file_path.str();
+
+  if (file_path.empty()) {
+    std::string now = llvm::to_string(std::chrono::system_clock::now());
+    std::replace(now.begin(), now.end(), ' ', '_');
+    const std::string file_name = "lldb_session_" + now + ".log";
+    FileSpec tmp = HostInfo::GetGlobalTempDir();
+    tmp.AppendPathComponent(file_name);
+    output_file = tmp.GetPath();
+  }
+
+  File::OpenOptions flags = File::eOpenOptionWrite |
+                            File::eOpenOptionCanCreate |
+                            File::eOpenOptionTruncate;
+
+  Status error;
+  user_id_t fd_dst = FileCache::GetInstance().OpenFile(
+      FileSpec(output_file), flags, lldb::eFilePermissionsFileDefault, error);
+
+  auto error_out = [&](llvm::StringRef error_message) {
+    LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS), "{0} ({1})",
+             error_message, output_file);
+    StreamSP error_stream = GetDebugger().GetErrorStreamSP();
+    *error_stream << "Failed to save session's transcripts to " << output_file
+                  << "!" << '\n';
+    return false;
+  };
+
+  if (fd_dst == UINT64_MAX || error.Fail())
+    return error_out("Unable to create file");
+
+  auto string_stream =
+      std::static_pointer_cast<StreamString>(m_session_transcripts);
+  size_t stream_size = string_stream->GetSize();
+
+  size_t bytes_written = FileCache::GetInstance().WriteFile(
+      fd_dst, 0, string_stream->GetData(), stream_size, error);
+  if (bytes_written != stream_size || error.Fail())
+    return error_out("Unable to write to destination file");
+
+  GetDebugger().GetOutputStreamSP()->Printf(
+      "Session's transcripts saved to %s\n", output_file.c_str());
+
+  return true;
+}
+
 void CommandInterpreter::GetLLDBCommandsFromIOHandler(
     const char *prompt, IOHandlerDelegate &delegate, void *baton) {
   Debugger &debugger = GetDebugger();
   IOHandlerSP io_handler_sp(
       new IOHandlerEditline(debugger, IOHandler::Type::CommandList,
                             "lldb", // Name of input reader for history
                             llvm::StringRef::withNullAsEmpty(prompt), // Prompt
                             llvm::StringRef(), // Continuation prompt

lldb/source/Interpreter/InterpreterProperties.td

 include "../../include/lldb/Core/PropertiesBase.td"
 
 let Definition = "interpreter" in {
   def ExpandRegexAliases: Property<"expand-regex-aliases", "Boolean">,
     Global,
     DefaultFalse,
     Desc<"If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands.">;
   def PromptOnQuit: Property<"prompt-on-quit", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case.">;
+  def SaveSessionOnQuit: Property<"save-session-on-quit", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, LLDB will save the session's transcripts before quitting.">;
   def StopCmdSourceOnError: Property<"stop-command-source-on-error", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, LLDB will stop running a 'command source' script upon encountering an error.">;
   def SpaceReplPrompts: Property<"space-repl-prompts", "Boolean">,
     Global,
     DefaultFalse,
     Desc<"If true, blank lines will be printed between between REPL submissions.">;