[trace] Replace TraceCursorUP with TraceCursorSP

[jj10306]

Summary

The use of std::unique_ptr with TraceCursor adds unnecessary complexity to adding SBTraceCursor bindings
Specifically, since TraceCursor is an abstract class there's no clean
way to provide "deep clone" semantics for TraceCursorUP short of
creating a pure virtual clone() method (afaict).

After discussing with @wallace, we decided there is no strong reason to
favor wrapping TraceCursor with std::unique_ptr over std::shared_ptr, thus this diff
replaces all usages of std::unique_ptr<TraceCursor> with std::shared_ptr<TraceCursor>.

This sets the stage for future diffs to introduce SBTraceCursor
bindings in a more clean fashion.

This diff will be landed after D130924 is landed.

[wallace]

great! that will make all the bindings very easy to handle

lldb/include/lldb/Target/Trace.h

public:
 
   /// \return
   ///     The JSON schema of this Trace plug-in.
   virtual llvm::StringRef GetSchema() = 0;
 
   /// Get a \a TraceCursor for the given thread's trace.
   ///
   /// \return
-  ///     A \a TraceCursorUP. If the thread is not traced or its trace
+  ///     A \a TraceCursorSP. If the thread is not traced or its trace
   ///     information failed to load, an \a llvm::Error is returned.
-  virtual llvm::Expected<lldb::TraceCursorUP>
+  virtual llvm::Expected<lldb::TraceCursorSP>
   CreateNewCursor(Thread &thread) = 0;
 
   /// Dump general info about a given thread's trace. Each Trace plug-in
   /// decides which data to show.
   ///
   /// \param[in] thread
   ///     The thread that owns the trace in question.
   ///

lldb/include/lldb/Target/TraceCursor.h

 ///
 /// Defaults:
 ///   By default, the cursor points at the most recent item in the trace and is
 ///   set up to iterate backwards. See the \a TraceCursor::Next() method for
 ///   more documentation.
 ///
 /// Sample usage:
 ///
-///  TraceCursorUP cursor = trace.GetTrace(thread);
+///  TraceCursorSP cursor = trace.GetTrace(thread);
 ///
 ///  for (; cursor->HasValue(); cursor->Next()) {
 ///     TraceItemKind kind = cursor->GetItemKind();
 ///     switch (cursor->GetItemKind()):
 ///       case eTraceItemKindError:
 ///         cout << "error found: " << cursor->GetError() << endl;
 ///         break;
 ///       case eTraceItemKindEvent:

lldb/include/lldb/Target/TraceDumper.h

public:
   /// \param[in] cursor
   ///     The cursor whose instructions will be dumped.
   ///
   /// \param[in] s
   ///     The stream where to dump the instructions to.
   ///
   /// \param[in] options
   ///     Additional options for configuring the dumping.
-  TraceDumper(lldb::TraceCursorUP &&cursor_up, Stream &s,
+  TraceDumper(lldb::TraceCursorSP cursor_sp, Stream &s,
               const TraceDumperOptions &options);
 
   /// Dump \a count instructions of the thread trace starting at the current
   /// cursor position.
   ///
   /// This effectively moves the cursor to the next unvisited position, so that
   /// a subsequent call to this method continues where it left off.
   ///
   /// \param[in] count
   ///     The number of instructions to print.
   ///
   /// \return
   ///     The instruction id of the last traversed instruction, or \b llvm::None
   ///     if no instructions were visited.
   llvm::Optional<lldb::user_id_t> DumpInstructions(size_t count);
 
 private:
   /// Create a trace item for the current position without symbol information.
   TraceItem CreatRawTraceItem();
 
-  lldb::TraceCursorUP m_cursor_up;
+  lldb::TraceCursorSP m_cursor_sp;
   TraceDumperOptions m_options;
   std::unique_ptr<OutputWriter> m_writer_up;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_INSTRUCTION_DUMPER_H

lldb/include/lldb/lldb-forward.h

 typedef std::shared_ptr<lldb_private::ThreadCollection> ThreadCollectionSP;
 typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;
 typedef std::shared_ptr<lldb_private::ThreadPostMortemTrace>
     ThreadPostMortemTraceSP;
 typedef std::weak_ptr<lldb_private::ThreadPlan> ThreadPlanWP;
 typedef std::shared_ptr<lldb_private::ThreadPlanTracer> ThreadPlanTracerSP;
 typedef std::shared_ptr<lldb_private::Trace> TraceSP;
 typedef std::unique_ptr<lldb_private::TraceExporter> TraceExporterUP;
-typedef std::unique_ptr<lldb_private::TraceCursor> TraceCursorUP;
+typedef std::shared_ptr<lldb_private::TraceCursor> TraceCursorSP;
 typedef std::shared_ptr<lldb_private::Type> TypeSP;
 typedef std::weak_ptr<lldb_private::Type> TypeWP;
 typedef std::shared_ptr<lldb_private::TypeCategoryImpl> TypeCategoryImplSP;
 typedef std::shared_ptr<lldb_private::TypeImpl> TypeImplSP;
 typedef std::shared_ptr<lldb_private::TypeMemberFunctionImpl>
     TypeMemberFunctionImplSP;
 typedef std::shared_ptr<lldb_private::TypeEnumMemberImpl> TypeEnumMemberImplSP;
 typedef std::shared_ptr<lldb_private::TypeFilterImpl> TypeFilterImplSP;

lldb/source/Commands/CommandObjectThread.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
 
     if (m_options.m_continue && m_last_id) {
       // We set up the options to continue one instruction past where
       // the previous iteration stopped.
       m_options.m_dumper_options.skip = 1;
       m_options.m_dumper_options.id = m_last_id;
     }
 
-    llvm::Expected<TraceCursorUP> cursor_or_error =
+    llvm::Expected<TraceCursorSP> cursor_or_error =
         m_exe_ctx.GetTargetSP()->GetTrace()->CreateNewCursor(*thread_sp);
 
     if (!cursor_or_error) {
       result.AppendError(llvm::toString(cursor_or_error.takeError()));
       return false;
     }
-    TraceCursorUP &cursor_up = *cursor_or_error;
+    TraceCursorSP &cursor_sp = *cursor_or_error;
 
     if (m_options.m_dumper_options.id &&
-        !cursor_up->HasId(*m_options.m_dumper_options.id)) {
+        !cursor_sp->HasId(*m_options.m_dumper_options.id)) {
       result.AppendError("invalid instruction id\n");
       return false;
     }
 
     llvm::Optional<StreamFile> out_file;
     if (m_options.m_output_file) {
       out_file.emplace(m_options.m_output_file->GetPath().c_str(),
                        File::eOpenOptionWriteOnly | File::eOpenOptionCanCreate,
                        lldb::eFilePermissionsFileDefault);
     }
 
     if (m_options.m_continue && !m_last_id) {
       // We need to stop processing data when we already ran out of instructions
       // in a previous command. We can fake this by setting the cursor past the
       // end of the trace.
-      cursor_up->Seek(1, TraceCursor::SeekType::End);
+      cursor_sp->Seek(1, TraceCursor::SeekType::End);
     }
 
-    TraceDumper dumper(std::move(cursor_up),
+    TraceDumper dumper(std::move(cursor_sp),
                        out_file ? *out_file : result.GetOutputStream(),
                        m_options.m_dumper_options);
 
     m_last_id = dumper.DumpInstructions(m_options.m_count);
     return true;
   }
 
   CommandOptions m_options;

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

public:
   lldb::CommandObjectSP
   GetProcessTraceStartCommand(CommandInterpreter &interpreter) override;
 
   lldb::CommandObjectSP
   GetThreadTraceStartCommand(CommandInterpreter &interpreter) override;
 
   llvm::StringRef GetSchema() override;
 
-  llvm::Expected<lldb::TraceCursorUP> CreateNewCursor(Thread &thread) override;
+  llvm::Expected<lldb::TraceCursorSP> CreateNewCursor(Thread &thread) override;
 
   void DumpTraceInfo(Thread &thread, Stream &s, bool verbose,
                      bool json) override;
 
   llvm::Expected<llvm::Optional<uint64_t>> GetRawTraceSize(Thread &thread);
 
   llvm::Error DoRefreshLiveProcessState(TraceGetStateResponse state,
                                         llvm::StringRef json_response) override;

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

Expected<Optional<uint64_t>> TraceIntelPT::FindBeginningOfTimeNanos() {
 
   if (lowest_tsc) {
     storage.beginning_of_time_nanos =
         storage.tsc_conversion->ToNanos(*lowest_tsc);
   }
   return storage.beginning_of_time_nanos;
 }
 
-llvm::Expected<lldb::TraceCursorUP>
+llvm::Expected<lldb::TraceCursorSP>
 TraceIntelPT::CreateNewCursor(Thread &thread) {
   if (Expected<DecodedThreadSP> decoded_thread = Decode(thread)) {
     if (Expected<Optional<uint64_t>> beginning_of_time =
             FindBeginningOfTimeNanos())
-      return std::make_unique<TraceCursorIntelPT>(
+      return std::make_shared<TraceCursorIntelPT>(
           thread.shared_from_this(), *decoded_thread, m_storage.tsc_conversion,
           *beginning_of_time);
     else
       return beginning_of_time.takeError();
   } else
     return decoded_thread.takeError();
 }
 

lldb/source/Plugins/TraceExporter/ctf/CommandObjectThreadTraceExportCTF.cpp

if (thread == nullptr) {
     const uint32_t num_threads = process->GetThreadList().GetSize();
     size_t tid = m_options.m_thread_index.value_or(LLDB_INVALID_THREAD_ID);
     result.AppendErrorWithFormatv(
         "Thread index {0} is out of range (valid values are 1 - {1}).\n", tid,
         num_threads);
     return false;
   } else {
     auto do_work = [&]() -> Error {
-      Expected<TraceCursorUP> cursor = trace_sp->CreateNewCursor(*thread);
+      Expected<TraceCursorSP> cursor = trace_sp->CreateNewCursor(*thread);
       if (!cursor)
         return cursor.takeError();
       TraceHTR htr(*thread, **cursor);
       htr.ExecutePasses();
       return htr.Export(m_options.m_file);
     };
 
     if (llvm::Error err = do_work()) {
       result.AppendErrorWithFormat("%s\n", toString(std::move(err)).c_str());
       return false;
     } else {
       return true;
     }
   }
 }

lldb/source/Target/TraceDumper.cpp

CreateWriter(Stream &s, const TraceDumperOptions &options, Thread &thread) {
   if (options.json)
     return std::unique_ptr<TraceDumper::OutputWriter>(
         new OutputWriterJSON(s, options));
   else
     return std::unique_ptr<TraceDumper::OutputWriter>(
         new OutputWriterCLI(s, options, thread));
 }
 
-TraceDumper::TraceDumper(lldb::TraceCursorUP &&cursor_up, Stream &s,
+TraceDumper::TraceDumper(lldb::TraceCursorSP cursor_sp, Stream &s,
                          const TraceDumperOptions &options)
-    : m_cursor_up(std::move(cursor_up)), m_options(options),
+    : m_cursor_sp(std::move(cursor_sp)), m_options(options),
       m_writer_up(CreateWriter(
-          s, m_options, *m_cursor_up->GetExecutionContextRef().GetThreadSP())) {
+          s, m_options, *m_cursor_sp->GetExecutionContextRef().GetThreadSP())) {
 
   if (m_options.id)
-    m_cursor_up->GoToId(*m_options.id);
+    m_cursor_sp->GoToId(*m_options.id);
   else if (m_options.forwards)
-    m_cursor_up->Seek(0, TraceCursor::SeekType::Beginning);
+    m_cursor_sp->Seek(0, TraceCursor::SeekType::Beginning);
   else
-    m_cursor_up->Seek(0, TraceCursor::SeekType::End);
+    m_cursor_sp->Seek(0, TraceCursor::SeekType::End);
 
-  m_cursor_up->SetForwards(m_options.forwards);
+  m_cursor_sp->SetForwards(m_options.forwards);
   if (m_options.skip) {
-    m_cursor_up->Seek((m_options.forwards ? 1 : -1) * *m_options.skip,
+    m_cursor_sp->Seek((m_options.forwards ? 1 : -1) * *m_options.skip,
                       TraceCursor::SeekType::Current);
   }
 }
 
 TraceDumper::TraceItem TraceDumper::CreatRawTraceItem() {
   TraceItem item = {};
-  item.id = m_cursor_up->GetId();
+  item.id = m_cursor_sp->GetId();
 
   if (m_options.show_timestamps)
-    item.timestamp = m_cursor_up->GetWallClockTime();
+    item.timestamp = m_cursor_sp->GetWallClockTime();
   return item;
 }
 
 /// Find the symbol context for the given address reusing the previous
 /// instruction's symbol context when possible.
 static SymbolContext
 CalculateSymbolContext(const Address &address,
                        const TraceDumper::SymbolInfo &prev_symbol_info) {
CalculateDisass(const TraceDumper::SymbolInfo &symbol_info,
   return std::make_tuple(
       disassembler,
       disassembler ? disassembler->GetInstructionList().GetInstructionAtAddress(
                          symbol_info.address)
                    : InstructionSP());
 }
 
 Optional<lldb::user_id_t> TraceDumper::DumpInstructions(size_t count) {
-  ThreadSP thread_sp = m_cursor_up->GetExecutionContextRef().GetThreadSP();
+  ThreadSP thread_sp = m_cursor_sp->GetExecutionContextRef().GetThreadSP();
 
   SymbolInfo prev_symbol_info;
   Optional<lldb::user_id_t> last_id;
 
   ExecutionContext exe_ctx;
   thread_sp->GetProcess()->GetTarget().CalculateExecutionContext(exe_ctx);
 
-  for (size_t insn_seen = 0; insn_seen < count && m_cursor_up->HasValue();
-       m_cursor_up->Next()) {
+  for (size_t insn_seen = 0; insn_seen < count && m_cursor_sp->HasValue();
+       m_cursor_sp->Next()) {
 
-    last_id = m_cursor_up->GetId();
+    last_id = m_cursor_sp->GetId();
     TraceItem item = CreatRawTraceItem();
 
-    if (m_cursor_up->IsEvent()) {
+    if (m_cursor_sp->IsEvent()) {
       if (!m_options.show_events)
         continue;
-      item.event = m_cursor_up->GetEventType();
+      item.event = m_cursor_sp->GetEventType();
       switch (*item.event) {
       case eTraceEventCPUChanged:
-        item.cpu_id = m_cursor_up->GetCPU();
+        item.cpu_id = m_cursor_sp->GetCPU();
         break;
       case eTraceEventHWClockTick:
-        item.hw_clock = m_cursor_up->GetHWClock();
+        item.hw_clock = m_cursor_sp->GetHWClock();
         break;
       case eTraceEventDisabledHW:
       case eTraceEventDisabledSW:
         break;
       }
-    } else if (m_cursor_up->IsError()) {
-      item.error = m_cursor_up->GetError();
+    } else if (m_cursor_sp->IsError()) {
+      item.error = m_cursor_sp->GetError();
     } else {
       insn_seen++;
-      item.load_address = m_cursor_up->GetLoadAddress();
+      item.load_address = m_cursor_sp->GetLoadAddress();
 
       if (!m_options.raw) {
         SymbolInfo symbol_info;
         symbol_info.exe_ctx = exe_ctx;
         symbol_info.address.SetLoadAddress(item.load_address,
                                            exe_ctx.GetTargetPtr());
         symbol_info.sc =
             CalculateSymbolContext(symbol_info.address, prev_symbol_info);
         std::tie(symbol_info.disassembler, symbol_info.instruction) =
             CalculateDisass(symbol_info, prev_symbol_info, exe_ctx);
         item.prev_symbol_info = prev_symbol_info;
         item.symbol_info = symbol_info;
         prev_symbol_info = symbol_info;
       }
     }
     m_writer_up->TraceItem(item);
   }
-  if (!m_cursor_up->HasValue())
+  if (!m_cursor_sp->HasValue())
     m_writer_up->NoMoreData();
   return last_id;
 }