Add a generic Process method to dump plugin history

[jingham]

Summary

I need to dump the gdb-remote communication history when we fail the "stepping or not" assertion Jason added to StopInfoMachException a week or so ago. But that's a feature of GDBRemoteCommunication, or at best ProcessGDBRemote, and it really doesn't make sense to include that in StopInfoMachException.

However the notion of "dumping the low level plugin history for a process" seems like a generally useful one. So I made a Process API for this, and then routed the other uses through that, and added dumping this when the assert is triggered.

[jasonmolenda]

Ah excellent, thanks for adding this.

lldb/include/lldb/Target/Process.h

/// UnregisterNotificationCallbacks (const Notifications&)
   ///
   ///     (lldb) process command <args>
   ///
   /// \return
   ///     A CommandObject which can be one of the concrete subclasses
   ///     of CommandObject like CommandObjectRaw, CommandObjectParsed,
   ///     or CommandObjectMultiword.
   virtual CommandObject *GetPluginCommandObject() { return nullptr; }
   
+  /// The underlying plugin might store the low-level communication history for
+  /// this session.  Dump it into the provided stream.
+  virtual void DumpPluginHistory(Stream &s) { return; }
+
   /// Launch a new process.
   ///
   /// Launch a new process by spawning a new process using the target object's
   /// executable module's file as the file to launch.
   ///
   /// This function is not meant to be overridden by Process subclasses. It
   /// will first call Process::WillLaunch (Module *) and if that returns \b
   /// true, Process::DoLaunch (Module*, char const *[],char const *[],const

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

#ifndef NDEBUG
             if (const RegisterInfo *ri = regctx->GetRegisterInfoByName("esr")) {
               uint32_t esr =
                   (uint32_t)regctx->ReadRegisterAsUnsigned(ri, UINT32_MAX);
               if (esr != UINT32_MAX) {
                 s.Printf(" esr value: 0x%" PRIx32, esr);
               }
             }
           }
+          thread.GetProcess()->DumpPluginHistory(s);
           llvm::report_fatal_error(s.GetData());
           lldbassert(
               false &&
               "CreateStopReasonWithMachException got EXC_BREAKPOINT [1,0] "
               "indicating trace event, but thread was not doing a step.");
         }
 #endif
       }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

if (lock) {
 
         return success;
       }
     } else {
       Log *log(GetLog(GDBRLog::Thread | GDBRLog::Packets));
       if (log) {
         if (log->GetVerbose()) {
           StreamString strm;
-          gdb_comm.DumpHistory(strm);
+          process->DumpPluginHistory(strm);
           LLDB_LOGF(log,
                     "error: failed to get packet sequence mutex, not sending "
                     "write register for \"%s\":\n%s",
                     reg_info->name, strm.GetData());
         } else
           LLDB_LOGF(log,
                     "error: failed to get packet sequence mutex, not sending "
                     "write register for \"%s\"",
data_sp = std::make_shared<DataBufferHeap>(
         m_reg_data.GetDataStart(), m_reg_info_sp->GetRegisterDataByteSize());
     return true;
   } else {
 
     Log *log(GetLog(GDBRLog::Thread | GDBRLog::Packets));
     if (log) {
       if (log->GetVerbose()) {
         StreamString strm;
-        gdb_comm.DumpHistory(strm);
+        process->DumpPluginHistory(strm);
         LLDB_LOGF(log,
                   "error: failed to get packet sequence mutex, not sending "
                   "read all registers:\n%s",
                   strm.GetData());
       } else
         LLDB_LOGF(log,
                   "error: failed to get packet sequence mutex, not sending "
                   "read all registers");
if (use_g_packet) {
       }
       return num_restored > 0;
     }
   } else {
     Log *log(GetLog(GDBRLog::Thread | GDBRLog::Packets));
     if (log) {
       if (log->GetVerbose()) {
         StreamString strm;
-        gdb_comm.DumpHistory(strm);
+        process->DumpPluginHistory(strm);
         LLDB_LOGF(log,
                   "error: failed to get packet sequence mutex, not sending "
                   "write all registers:\n%s",
                   strm.GetData());
       } else
         LLDB_LOGF(log,
                   "error: failed to get packet sequence mutex, not sending "
                   "write all registers");

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
 
   ArchSpec GetSystemArchitecture() override;
 
   // Check if a given Process
   bool CanDebug(lldb::TargetSP target_sp,
                 bool plugin_specified_by_name) override;
 
   CommandObject *GetPluginCommandObject() override;
   
+  void DumpPluginHistory(Stream &s) override;
+
   // Creating a new process, or attaching to an existing one
   Status DoWillLaunch(Module *module) override;
 
   Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
 
   void DidLaunch() override;
 
   Status DoWillAttachToProcessWithID(lldb::pid_t pid) override;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
   auto file = FileSystem::Instance().Open(
       FileSpec(path), File::eOpenOptionWriteOnly | File::eOpenOptionCanCreate);
   if (!file) {
     llvm::consumeError(file.takeError());
     return;
   }
   StreamFile stream(std::move(file.get()));
-  ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(stream);
+  ((Process *)p)->DumpPluginHistory(stream);
 }
 } // namespace lldb
 
 namespace {
 
 #define LLDB_PROPERTIES_processgdbremote
 #include "ProcessGDBRemoteProperties.inc"
 
lldb::ProcessSP ProcessGDBRemote::CreateInstance(
     const FileSpec *crash_file_path, bool can_connect) {
   lldb::ProcessSP process_sp;
   if (crash_file_path == nullptr)
     process_sp = std::shared_ptr<ProcessGDBRemote>(
         new ProcessGDBRemote(target_sp, listener_sp));
   return process_sp;
 }
 
+void ProcessGDBRemote::DumpPluginHistory(Stream &s) {
+  GDBRemoteCommunicationClient &gdb_comm(GetGDBRemote());
+  gdb_comm.DumpHistory(s);
+}
+
 std::chrono::seconds ProcessGDBRemote::GetPacketTimeout() {
   return std::chrono::seconds(GetGlobalPluginProperties().GetPacketTimeout());
 }
 
 ArchSpec ProcessGDBRemote::GetSystemArchitecture() {
   return m_gdb_comm.GetHostArchitecture();
 }
 
CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter)
                             "Dumps the packet history buffer. ", nullptr) {}
 
   ~CommandObjectProcessGDBRemotePacketHistory() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     ProcessGDBRemote *process =
         (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
     if (process) {
-      process->GetGDBRemote().DumpHistory(result.GetOutputStream());
+      process->DumpPluginHistory(result.GetOutputStream());
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     }
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 };