lldb/source/Target/ProcessTrace.cpp

   1 //===-- ProcessTrace.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 "lldb/Target/ProcessTrace.h"
  10
  11 #include <memory>
  12
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Core/PluginManager.h"
  15 #include "lldb/Core/Section.h"
  16 #include "lldb/Target/ABI.h"
  17 #include "lldb/Target/SectionLoadList.h"
  18 #include "lldb/Target/Target.h"
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22
  23 llvm::StringRef ProcessTrace::GetPluginDescriptionStatic() {
  24   return "Trace process plug-in.";
  25 }
  26
  27 void ProcessTrace::Terminate() {
  28   PluginManager::UnregisterPlugin(ProcessTrace::CreateInstance);
  29 }
  30
  31 ProcessSP ProcessTrace::CreateInstance(TargetSP target_sp,
  32                                        ListenerSP listener_sp,
  33                                        const FileSpec *crash_file,
  34                                        bool can_connect) {
  35   if (can_connect)
  36     return nullptr;
  37   return std::make_shared<ProcessTrace>(target_sp, listener_sp);
  38 }
  39
  40 bool ProcessTrace::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
  41   return plugin_specified_by_name;
  42 }
  43
  44 ProcessTrace::ProcessTrace(TargetSP target_sp, ListenerSP listener_sp)
  45     : PostMortemProcess(target_sp, listener_sp) {}
  46
  47 ProcessTrace::~ProcessTrace() {
  48   Clear();
  49   // We need to call finalize on the process before destroying ourselves to
  50   // make sure all of the broadcaster cleanup goes as planned. If we destruct
  51   // this class, then Process::~Process() might have problems trying to fully
  52   // destroy the broadcaster.
  53   Finalize();
  54 }
  55
  56 void ProcessTrace::DidAttach(ArchSpec &process_arch) {
  57   ListenerSP listener_sp(
  58       Listener::MakeListener("lldb.process_trace.did_attach_listener"));
  59   HijackProcessEvents(listener_sp);
  60
  61   SetCanJIT(false);
  62   StartPrivateStateThread();
  63   SetPrivateState(eStateStopped);
  64
  65   EventSP event_sp;
  66   WaitForProcessToStop(std::nullopt, &event_sp, true, listener_sp);
  67
  68   RestoreProcessEvents();
  69
  70   Process::DidAttach(process_arch);
  71 }
  72
  73 bool ProcessTrace::DoUpdateThreadList(ThreadList &old_thread_list,
  74                                       ThreadList &new_thread_list) {
  75   return false;
  76 }
  77
  78 void ProcessTrace::RefreshStateAfterStop() {}
  79
  80 Status ProcessTrace::DoDestroy() { return Status(); }
  81
  82 size_t ProcessTrace::ReadMemory(addr_t addr, void *buf, size_t size,
  83                                 Status &error) {
  84   if (const ABISP &abi = GetABI())
  85     addr = abi->FixAnyAddress(addr);
  86
  87   // Don't allow the caching that lldb_private::Process::ReadMemory does since
  88   // we have it all cached in the trace files.
  89   return DoReadMemory(addr, buf, size, error);
  90 }
  91
  92 void ProcessTrace::Clear() { m_thread_list.Clear(); }
  93
  94 void ProcessTrace::Initialize() {
  95   static llvm::once_flag g_once_flag;
  96
  97   llvm::call_once(g_once_flag, []() {
  98     PluginManager::RegisterPlugin(GetPluginNameStatic(),
  99                                   GetPluginDescriptionStatic(), CreateInstance);
 100   });
 101 }
 102
 103 ArchSpec ProcessTrace::GetArchitecture() {
 104   return GetTarget().GetArchitecture();
 105 }
 106
 107 bool ProcessTrace::GetProcessInfo(ProcessInstanceInfo &info) {
 108   info.Clear();
 109   info.SetProcessID(GetID());
 110   info.SetArchitecture(GetArchitecture());
 111   ModuleSP module_sp = GetTarget().GetExecutableModule();
 112   if (module_sp) {
 113     const bool add_exe_file_as_first_arg = false;
 114     info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
 115                            add_exe_file_as_first_arg);
 116   }
 117   return true;
 118 }
 119
 120 size_t ProcessTrace::DoReadMemory(addr_t addr, void *buf, size_t size,
 121                                   Status &error) {
 122   Address resolved_address;
 123   GetTarget().GetSectionLoadList().ResolveLoadAddress(addr, resolved_address);
 124
 125   return GetTarget().ReadMemoryFromFileCache(resolved_address, buf, size,
 126                                              error);
 127 }