[intel-pt] Simplify Python API configuration

[wallace]

Summary

Depends on D84791.
The existing way to configure Intel PT tracing through the Python API isn't
trivial. Thus, I'm creating a helper method GetDefaultTraceOptions, which
creates an SBTraceOptions object ready to be used for tracing. This simplifies
the Python code and even some existing C++ code.

[wallace]

After syncing up with Greg, we decided to redo this in a different way

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

def test_basic_flow_with_python_api(self):
 
         decoder = lldbIntelFeatures.PTDecoder(self.dbg)
 
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
         tid = process.GetProcessID()
 
         # We configure the tracing options
-        trace_opts = lldb.SBTraceOptions()
+        trace_opts = lldbIntelFeatures.PTDecoder.GetDefaultTraceOptions()
         trace_opts.setThreadID(tid)
-        trace_opts.setType(lldb.eTraceTypeProcessorTrace)
-        trace_opts.setMetaDataBufferSize(0)
-        trace_opts.setTraceBufferSize(4096)
-
-        stream = lldb.SBStream()
-        stream.Print('{"trace-tech":"intel-pt"}')
-        custom_params = lldb.SBStructuredData()
-        self.assertSuccess(custom_params.SetFromJSON(stream))
-        trace_opts.setTraceParams(custom_params)
 
         # We start tracing
         error = lldb.SBError()
         decoder.StartProcessorTrace(process, trace_opts, error)
         self.assertSuccess(error)
 
         # We check the trace after the for loop
         self.runCmd("b " + str(line_number('main.cpp', '// Break 1')))

lldb/tools/intel-features/intel-pt/Decoder.h

 #define Decoder_h_
 
 // C/C++ Includes
 #include <map>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/lldb-enumerations.h"
public:
   void GetInstructionLogAtOffset(lldb::SBProcess &sbprocess, lldb::tid_t tid,
                                  uint32_t offset, uint32_t count,
                                  InstructionList &result_list,
                                  lldb::SBError &sberror);
 
   void GetProcessorTraceInfo(lldb::SBProcess &sbprocess, lldb::tid_t tid,
                              TraceOptions &traceinfo, lldb::SBError &sberror);
 
+  static lldb::SBTraceOptions GetDefaultTraceOptions();
+
 private:
   class ThreadTraceInfo;
   typedef std::vector<uint8_t> Buffer;
 
   // internal class to manage inferior's read-execute section information
   class ReadExecuteSectionInfo {
   public:
     uint64_t load_address;

lldb/tools/intel-features/intel-pt/Decoder.cpp

void Decoder::CheckDebuggerID(lldb::SBProcess &sbprocess,
   if (sbdebugger.GetID() != m_debugger_user_id) {
     sberror.SetErrorStringWithFormat(
         "process belongs to a different SBDebugger instance than the one for "
         "which the tool is instantiated; ProcessID = %" PRIu64,
         sbprocess.GetProcessID());
     return;
   }
 }
+
+lldb::SBTraceOptions Decoder::GetDefaultTraceOptions() {
+  lldb::SBTraceOptions trace_opts;
+  trace_opts.setThreadID(LLDB_INVALID_THREAD_ID);
+  trace_opts.setType(lldb::TraceType::eTraceTypeProcessorTrace);
+  trace_opts.setTraceBufferSize(4096); // 1 page
+  trace_opts.setMetaDataBufferSize(0);
+
+  lldb::SBStream sb_stream;
+  sb_stream.Printf("{\"trace-tech\":\"intel-pt\"}");
+  lldb::SBStructuredData custom_params;
+  custom_params.SetFromJSON(sb_stream);
+  trace_opts.setTraceParams(custom_params);
+
+  return trace_opts;
+}

lldb/tools/intel-features/intel-pt/PTDecoder.h

 //===-- PTDecoder.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 PTDecoder_h_
 #define PTDecoder_h_
 
 // C/C++ Includes
 #include <vector>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-types.h"
 
 namespace ptdecoder_private {
public:
   ///     ones with which tracing was asked to be started for this thread during
   ///     StartProcessorTrace() API call).
   ///
   /// \param[out] sberror
   ///     An error with the failure reason if API fails. Else success.
   void GetProcessorTraceInfo(lldb::SBProcess &sbprocess, lldb::tid_t tid,
                              PTTraceOptions &options, lldb::SBError &sberror);
 
+  /// Get an instance of an \a lldb::SBTraceOptions object with a default
+  /// configuration for tracing with Intel(R) Processor Trace. This object
+  /// is ready to be passed as argument to \a PTDecoder::StartProcessorTrace.
+  ///
+  /// The default configuration sets 4096 bytes as trace buffer size per thread.
+  /// Besides, this configuration traces all the running threads of the target
+  /// process.
+  ///
+  /// \return
+  ///     An \a lldb::SBTraceOptions object with a default tracing
+  ///     configuration.
+  static lldb::SBTraceOptions GetDefaultTraceOptions();
+
 private:
   std::shared_ptr<ptdecoder_private::Decoder> m_opaque_sp;
 };
 
 } // namespace ptdecoder
 #endif // PTDecoder_h_

lldb/tools/intel-features/intel-pt/PTDecoder.cpp

std::shared_ptr<ptdecoder_private::TraceOptions> trace_options_ptr(
       new TraceOptions());
   m_opaque_sp->GetProcessorTraceInfo(sbprocess, tid, *trace_options_ptr,
                                      sberror);
   if (!sberror.Success())
     return;
 
   options.SetSP(trace_options_ptr);
 }
+
+lldb::SBTraceOptions PTDecoder::GetDefaultTraceOptions() {
+  return Decoder::GetDefaultTraceOptions();
+}

lldb/tools/intel-features/intel-pt/cli-wrapper-pt.cpp

public:
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
     if (!GetProcess(debugger, result, process))
       return false;
 
     // Default initialize API's arguments
-    lldb::SBTraceOptions lldb_SBTraceOptions;
-    uint32_t trace_buffer_size = m_default_trace_buff_size;
+    lldb::SBTraceOptions lldb_SBTraceOptions =
+        ptdecoder::PTDecoder::GetDefaultTraceOptions();
+    uint32_t trace_buffer_size = lldb_SBTraceOptions.getTraceBufferSize();
     lldb::tid_t thread_id;
 
     // Parse Command line options
     bool thread_argument_provided = false;
     if (command) {
       for (uint32_t i = 0; command[i]; i++) {
         if (!strcmp(command[i], "-b")) {
           if (!ParseCommandOption(command, result, i, "-b", trace_buffer_size))
if (!thread_argument_provided) {
       }
       thread_id = thread.GetThreadID();
     }
 
     if (trace_buffer_size > m_max_trace_buff_size)
       trace_buffer_size = m_max_trace_buff_size;
 
     // Set API's arguments with parsed values
-    lldb_SBTraceOptions.setType(lldb::TraceType::eTraceTypeProcessorTrace);
     lldb_SBTraceOptions.setTraceBufferSize(trace_buffer_size);
-    lldb_SBTraceOptions.setMetaDataBufferSize(0);
     lldb_SBTraceOptions.setThreadID(thread_id);
-    lldb::SBStream sb_stream;
-    sb_stream.Printf("{\"trace-tech\":\"intel-pt\"}");
-    lldb::SBStructuredData custom_params;
-    lldb::SBError error = custom_params.SetFromJSON(sb_stream);
-    if (!error.Success()) {
-      result.Printf("error: %s\n", error.GetCString());
-      result.SetStatus(lldb::eReturnStatusFailed);
-      return false;
-    }
-    lldb_SBTraceOptions.setTraceParams(custom_params);
 
     // Start trace
+    lldb::SBError error;
     pt_decoder_sp->StartProcessorTrace(process, lldb_SBTraceOptions, error);
     if (!error.Success()) {
       result.Printf("error: %s\n", error.GetCString());
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
   std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
   const uint32_t m_max_trace_buff_size = 0x3fff;
-  const uint32_t m_default_trace_buff_size = 4096;
 };
 
 class ProcessorTraceInfo : public lldb::SBCommandPluginInterface {
 public:
   ProcessorTraceInfo(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
       : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
 
   ~ProcessorTraceInfo() {}