[trace][RFC] create skeleton for thread decoder

[wallace]

Summary

Depends on D86670.

I first just want to get feedback about the structures of the class in this patch, later I con polish it.

This adds the skeleton for decoding traces of threads. The first step is having the plug-in implementation decode its trace into raw instructions. Individual instructions can sometimes fail to be decoded, so the instruction class should have an is_error flag. Error are quite sporadic though.
I'm adding a TraceThread class that contains all the information needed to decode a trace. I'm creating another class TraceDecodedThread will is obtained by calling TraceThread::Decode and its existance indicates that decoding didn't fail and you can use that class for inspecting the decoding trace.
This means that TraceThread is like an initialization object, and then the analysis is done by the TraceDecodedTrace class, which splits responsibilities and makes error handling easier.

I added some comments in Trace.h as well.

[clayborg]

I am not sure we need any of the classes in Trace.h: TraceInstruction, TraceDecodedThread, or TraceThread.

We should be able to use history thread objects for threads that are currently vended by TraceThread. Each thread will have a current set of hard coded stack frames, which is what history threads already contain.

The only reason to put anything in the Trace.h file is for things that the plug-in will vend and we don't need any abstractions exposed at the plug-in level (TraceInstruction, TraceDecodedThread). Those can be abstracted inside of each Trace plug-in and no one will need to make their trace data fit into a specific mold (TraceInstruction, TraceDecodedThread).

The way I think about it trace plug-ins should be able to:

• load from JSON + files on disk
• dump all trace data
• step/continue backward/forward and produce history threads at any time we stop and be able to show backtraces for any and all history threads for the current stop point

So none of this requires any changes to Trace.h IMHO, but I am open to opinions, that is just my initial train of thought.

lldb/include/lldb/Target/Trace.h

 //===-- Trace.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_TARGET_TRACE_H
 #define LLDB_TARGET_TRACE_H
 
 #include "llvm/Support/JSON.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Target/TraceSettingsParser.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
+/// Base class that represents an instructions. As decoding a trace can fail to
+/// decode a instruction, we keep a flag to signal it is an error or not. For
+/// intel-pt, this happens sporadically when there's an internal buffer
+/// overflow, for example.
+class TraceInstruction {
+public:
+  TraceInstruction(uint64_t ip) : m_ip(ip), m_is_error(false) {}
+  TraceInstruction() : m_is_error(true) {}
+
+  uint64_t GetIP() const { return m_ip; }
+
+  bool IsError() const { return m_is_error; }
+
+private:
+  /// instruction address at runtime
+  uint64_t m_ip;
+  /// Useful to signal a decoding error
+  bool m_is_error;
+};
+
+/// A decoded thread trace ready to be analized or traversed. An instance of
+/// this object indicates that the entirity of decoding didn't fail. Individual
+/// instructions could have failed to decode, though.
+class TraceDecodedThread {
+public:
+  TraceDecodedThread() : m_instructions(){};
+  TraceDecodedThread(const std::vector<TraceInstruction> &instructions)
+      : m_instructions(std::move(instructions)) {}
+
+  const std::vector<TraceInstruction> &GetInstructions() const {
+    return m_instructions;
+  }
+
+private:
+  std::vector<TraceInstruction> m_instructions;
+};
+
+/// A class that represents a trace of a given thread. In order to use the
+/// decoded trace, you need to first do
+///
+/// if (llvm::Expected<TraceDecodedThread &> decoded_thread =
+/// trace_thread::Decode()) {
+///   // do stuff
+/// }
+class TraceThread {
+public:
+  TraceThread(const lldb::ThreadSP &thread_sp, const FileSpec &trace_file)
+      : m_thread_sp(thread_sp), m_trace_file(trace_file), m_decoded_thread(),
+        m_decoding_status(), m_already_decoded(false) {}
+
+  virtual ~TraceThread(){};
+
+  /// Functions that performs the decoding and caches the result value or error.
+  llvm::Expected<TraceDecodedThread &> Decode() {
+    if (!m_already_decoded) {
+      if (llvm::Expected<std::vector<TraceInstruction>> instructions =
+              DecodeInstructions()) {
+        m_decoding_status.Clear();
+        m_decoded_thread = TraceDecodedThread(std::move(*instructions));
+      } else {
+        m_decoding_status = instructions.takeError();
+      }
+      m_already_decoded = true;
+    }
+    if (m_decoding_status.Success())
+      return m_decoded_thread;
+    return m_decoding_status.ToError();
+  }
+
+  const FileSpec &GetTraceFile() const { return m_trace_file; }
+
+protected:
+  virtual llvm::Expected<std::vector<TraceInstruction>>
+  DecodeInstructions() = 0;
+
+private:
+  lldb::ThreadSP m_thread_sp;
+  FileSpec m_trace_file;
+
+  TraceDecodedThread m_decoded_thread;
+  Status m_decoding_status;
+  bool m_already_decoded;
+};
+
 /// \class Trace Trace.h "lldb/Target/Trace.h"
 /// A plug-in interface definition class for trace information.
 ///
 /// Trace plug-ins allow processor trace information to be loaded into LLDB so
 /// that the data can be dumped, used for reverse and forward stepping to allow
 /// introspection into the reason your process crashed or found its way to its
 /// current state.
 ///
public:
   llvm::Error ParseSettings(Debugger &debugger);
 
   /// Get the JSON schema of the settings for the trace plug-in.
   llvm::StringRef GetSchema();
 
 protected:
   Trace() {}
 
+  virtual std::unique_ptr<TraceThread>
+  CreateTraceThread(const lldb::ThreadSP &thread,
+                    const FileSpec &trace_file) = 0;
+
   /// The actual plug-in should define its own implementaiton of \a
   /// TraceSettingsParser for doing any custom parsing.
   virtual const TraceSettingsParser &GetParser() const = 0;
 
   virtual TraceSettingsParser &GetParser() = 0;
 
-  const std::map<lldb::pid_t, std::map<lldb::tid_t, lldb_private::FileSpec>> &
-  GetThreadToTraceFileMap() const;
+  const std::map<lldb::pid_t,
+                 std::map<lldb::tid_t, std::unique_ptr<TraceThread>>> &
+  GetTraceThreads() const;
 
   const llvm::json::Object &GetSettings() const;
 
   const llvm::StringRef GetSettingsDir() const;
 
   const std::vector<lldb::TargetSP> &GetTargets() const;
 
 private:
   Trace(const Trace &) = delete;
   const Trace &operator=(const Trace &) = delete;
+
+  std::map<lldb::pid_t, std::map<lldb::tid_t, std::unique_ptr<TraceThread>>>
+      m_trace_threads;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_H

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.h

 //===-- TraceIntelPT.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 liblldb_TraceIntelPT_h_
 #define liblldb_TraceIntelPT_h_
 
 #include "intel-pt.h"
 #include "llvm/ADT/Optional.h"
 
 #include "TraceIntelPTSettingsParser.h"
 #include "lldb/Target/Trace.h"
 #include "lldb/lldb-private.h"
 
+class TraceIntelPTThread : public lldb_private::TraceThread {
+public:
+  ~TraceIntelPTThread() override = default;
+
+  TraceIntelPTThread(const lldb::ThreadSP &thread_sp,
+                     const lldb_private::FileSpec &trace_file)
+      : lldb_private::TraceThread(thread_sp, trace_file) {}
+
+  llvm::Expected<std::vector<lldb_private::TraceInstruction>>
+  DecodeInstructions() override;
+};
+
 class TraceIntelPT : public lldb_private::Trace {
 public:
   void Dump(lldb_private::Stream &s, lldb_private::Process *process,
             lldb_private::Thread *thread, bool verbose) const override;
 
   /// PluginInterface protocol
   /// \{
   lldb_private::ConstString GetPluginName() override;

 protected:
   TraceIntelPT(const llvm::json::Object &settings, llvm::StringRef settings_dir)
       : Trace(), m_parser(settings, settings_dir) {}
 
   const TraceIntelPTSettingsParser &GetParser() const override;
 
   TraceIntelPTSettingsParser &GetParser() override;
 
+  std::unique_ptr<lldb_private::TraceThread>
+  CreateTraceThread(const lldb::ThreadSP &thread,
+                    const lldb_private::FileSpec &trace_file) override;
+
 private:
   const pt_cpu &GetPTCPU() const;
 
   TraceIntelPTSettingsParser m_parser;
 };
 
 #endif // liblldb_TraceIntelPT_h_

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 
 ConstString TraceIntelPT::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t TraceIntelPT::GetPluginVersion() { return 1; }
 
+lldb::TraceSP TraceIntelPT::CreateInstance(const llvm::json::Object &settings,
+                                           StringRef settings_dir) {
+  return lldb::TraceSP(new TraceIntelPT(settings, settings_dir));
+}
+
+//------------------------------------------------------------------
+// TraceIntelPT
+//------------------------------------------------------------------
+
 void TraceIntelPT::Dump(Stream &s, Process *process, Thread *thread,
                         bool verbose) const {
   if (verbose) {
     s << "Settings:\n";
     s.Indent();
     std::string str;
     llvm::raw_string_ostream OS(str);
     json::Object obj = GetSettings();
     OS << llvm::formatv("{0:2}", json::Value(std::move(obj)));
     OS.flush();
     s << OS.str();
     s.IndentLess();
 
     s << "\n\nSettings directory:\n";
     s.Indent();
     s << GetSettingsDir() << "\n\n";
     s.IndentLess();
   }
   s << "Trace files:";
 
   // We go through all the processes and threads even when there are filters as
   // a way to simplify the implementation.
-  for (const auto &process_it : GetThreadToTraceFileMap()) {
+  for (const auto &process_it : GetTraceThreads()) {
     if (!process || process->GetID() == process_it.first) {
       for (const auto &thread_it : process_it.second) {
         if (!thread || thread->GetID() == thread_it.first) {
           s.Printf("\npid: '%" PRIu64 "', tid: '%" PRIu64 "' -> ",
                    process_it.first, thread_it.first);
-          s << thread_it.second;
+          s << thread_it.second->GetTraceFile();
         }
       }
     }
   }
 }
 
-lldb::TraceSP TraceIntelPT::CreateInstance(const llvm::json::Object &settings,
-                                           StringRef settings_dir) {
-  return lldb::TraceSP(new TraceIntelPT(settings, settings_dir));
+std::unique_ptr<TraceThread>
+TraceIntelPT::CreateTraceThread(const ThreadSP &thread,
+                                const FileSpec &trace_file) {
+  return std::make_unique<TraceIntelPTThread>(thread, trace_file);
+}
+
+//------------------------------------------------------------------
+// TraceIntelPTThread
+//------------------------------------------------------------------
+
+llvm::Expected<std::vector<TraceInstruction>>
+TraceIntelPTThread::DecodeInstructions() {
+  std::vector<TraceInstruction> v;
+  return std::move(v);
 }

lldb/source/Target/Trace.cpp

 //===-- Trace.cpp ---------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Trace.h"
 
 #include <regex>
 #include <sstream>
 
 #include "llvm/Support/Format.h"
 
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
 llvm::Expected<lldb::TraceSP> Trace::FindPlugin(const json::Value &settings,
                                                 StringRef info_dir) {
   llvm::Expected<const json::Object *> settings_obj =

 }
 
 llvm::Error Trace::ParseSettings(Debugger &debugger) {
   if (llvm::Error err = GetParser().ParseSettings(debugger))
     return err;
 
   for (auto target_sp : GetTargets())
     target_sp->SetTrace(shared_from_this());
+
+  for (auto process_it : GetParser().m_thread_to_trace_file_map) {
+    lldb::pid_t pid = process_it.first;
+    ThreadList &thread_list =
+        debugger.FindTargetWithProcessID(pid)->GetProcessSP()->GetThreadList();
+    for (auto thread_it : process_it.second) {
+      lldb::tid_t tid = thread_it.first;
+      m_trace_threads[pid].emplace(
+          tid,
+          CreateTraceThread(thread_list.FindThreadByID(tid), thread_it.second));
+    }
+  }
   return llvm::Error::success();
 }
 
 llvm::StringRef Trace::GetSchema() { return GetParser().GetSchema(); }
 
-const std::map<lldb::pid_t, std::map<lldb::tid_t, lldb_private::FileSpec>> &
-Trace::GetThreadToTraceFileMap() const {
-  return GetParser().m_thread_to_trace_file_map;
+const std::map<lldb::pid_t, std::map<lldb::tid_t, std::unique_ptr<TraceThread>>>
+    &Trace::GetTraceThreads() const {
+  return m_trace_threads;
 }
 
 const llvm::json::Object &Trace::GetSettings() const {
   return GetParser().m_settings;
 }
 
 const llvm::StringRef Trace::GetSettingsDir() const {
   return GetParser().m_settings_dir;
 }
 
 const std::vector<lldb::TargetSP> &Trace::GetTargets() const {
   return GetParser().m_targets;
 }