[intel-pt] Refactor 1: rename the namespace

[wallace]

Summary

Depends on D84810.
The existing namespace name ptdecoder is really not good, as this extension
does more things beyond decoding, and will have even more features soon.
So I'm renaming the namespace to intelpt, which is clearer.

[wallace]

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

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"
 #include "lldb/lldb-types.h"
 
 #include "intel-pt.h"
 
-namespace ptdecoder_private {
+namespace intelpt_private {
 /// \class Instruction
 /// Represents an assembly instruction containing raw
 ///     instruction bytes, instruction address along with information
 ///     regarding execution flow context and Intel(R) Processor Trace
 ///     context.
 class Instruction {
 public:
   Instruction() : ip(0), data(), error(), iclass(ptic_error), speculative(0) {}
private:
   MapProcessUID_MapThreadID_TraceInfo
       m_mapProcessUID_mapThreadID_TraceInfo; // to store trace information for
                                              // each process and its associated
                                              // threads
   lldb::user_id_t m_debugger_user_id; // SBDebugger instance which is associated
                                       // to this Decoder instance
 };
 
-} // namespace ptdecoder_private
+} // namespace intelpt_private
 #endif // Decoder_h_

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

 // C/C++ Includes
 #include <cinttypes>
 #include <cstring>
 
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThread.h"
 
-using namespace ptdecoder_private;
+using namespace intelpt_private;
 
 // This function removes entries of all the processes/threads which were once
 // registered in the class but are not alive anymore because they died or
 // finished executing.
 void Decoder::RemoveDeadProcessesAndThreads(lldb::SBProcess &sbprocess) {
   lldb::SBTarget sbtarget = sbprocess.GetTarget();
   lldb::SBDebugger sbdebugger = sbtarget.GetDebugger();
   uint32_t num_targets = sbdebugger.GetNumTargets();

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 {
+namespace intelpt_private {
 class Instruction;
 class InstructionList;
 class TraceOptions;
 class Decoder;
-} // namespace ptdecoder_private
+} // namespace intelpt_private
 
-namespace ptdecoder {
+namespace intelpt {
 
 /// \class PTInstruction
 /// Represents an assembly instruction containing raw
 ///     instruction bytes, instruction address along with information
 ///     regarding execution flow context and Intel(R) Processor Trace
 ///     context.
 class PTInstruction {
 public:
   PTInstruction() = default;
 
-  PTInstruction(const std::shared_ptr<ptdecoder_private::Instruction> &ptr);
+  PTInstruction(const std::shared_ptr<intelpt_private::Instruction> &ptr);
 
   ~PTInstruction();
 
   // Get instruction address in inferior's memory image
   uint64_t GetInsnAddress() const;
 
   /// Get raw bytes of the instruction in the buffer.
   ///
public:
   // Get error string if it represents an invalid instruction. For a valid
   // instruction, an empty string is returned
   std::string GetError() const;
 
   // Instruction was executed speculatively or not
   bool GetSpeculative() const;
 
 private:
-  std::shared_ptr<ptdecoder_private::Instruction> m_opaque_sp;
+  std::shared_ptr<intelpt_private::Instruction> m_opaque_sp;
 };
 
 /// \class PTInstructionList
 /// Represents a list of assembly instructions. Each instruction is of
 ///     type PTInstruction.
 class PTInstructionList {
 public:
   // Get number of instructions in the list
   size_t GetSize() const;
 
   // Get instruction at index
   PTInstruction GetInstructionAtIndex(uint32_t idx);
 
   void Clear();
 
 private:
   friend class PTDecoder;
 
-  void SetSP(const std::shared_ptr<ptdecoder_private::InstructionList> &ptr);
+  void SetSP(const std::shared_ptr<intelpt_private::InstructionList> &ptr);
 
-  std::shared_ptr<ptdecoder_private::InstructionList> m_opaque_sp;
+  std::shared_ptr<intelpt_private::InstructionList> m_opaque_sp;
 };
 
 /// \class PTTraceOptions
 /// Provides configuration options like trace type, trace buffer size,
 ///     meta data buffer size along with other Intel(R) Processor Trace
 ///     specific options.
 class PTTraceOptions {
 public:
public:
   ///
   /// \return
   ///     A string formatted as json text {"Name":Value,"Name":Value}
   lldb::SBStructuredData GetTraceParams(lldb::SBError &error);
 
 private:
   friend class PTDecoder;
 
-  void SetSP(const std::shared_ptr<ptdecoder_private::TraceOptions> &ptr);
+  void SetSP(const std::shared_ptr<intelpt_private::TraceOptions> &ptr);
 
-  std::shared_ptr<ptdecoder_private::TraceOptions> m_opaque_sp;
+  std::shared_ptr<intelpt_private::TraceOptions> m_opaque_sp;
 };
 
 /// \class PTDecoder
 /// This class makes use of Intel(R) Processor Trace hardware feature
 ///     (implememted inside LLDB) to gather trace data for an inferior (being
 ///     debugged with LLDB) to provide meaningful information out of it.
 ///
 ///     Currently the meaningful information comprises of the execution flow
public:
   /// 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;
+  std::shared_ptr<intelpt_private::Decoder> m_opaque_sp;
 };
 
-} // namespace ptdecoder
+} // namespace intelpt
 #endif // PTDecoder_h_

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

 //===-- PTDecoder.cpp -------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "PTDecoder.h"
 #include "Decoder.h"
 
-using namespace ptdecoder;
-using namespace ptdecoder_private;
+using namespace intelpt;
+using namespace intelpt_private;
 
 // PTInstruction class member functions definitions
 PTInstruction::PTInstruction(
-    const std::shared_ptr<ptdecoder_private::Instruction> &ptr)
+    const std::shared_ptr<intelpt_private::Instruction> &ptr)
     : m_opaque_sp(ptr) {}
 
 PTInstruction::~PTInstruction() {}
 
 uint64_t PTInstruction::GetInsnAddress() const {
   return (m_opaque_sp ? m_opaque_sp->GetInsnAddress() : 0);
 }
 

 
 // PTInstructionList class member functions definitions
 size_t PTInstructionList::GetSize() const {
   return (m_opaque_sp ? m_opaque_sp->GetSize() : 0);
 }
 
 PTInstruction PTInstructionList::GetInstructionAtIndex(uint32_t idx) {
   if (m_opaque_sp)
-    return PTInstruction(std::shared_ptr<ptdecoder_private::Instruction>(
+    return PTInstruction(std::shared_ptr<intelpt_private::Instruction>(
         new Instruction(m_opaque_sp->GetInstructionAtIndex(idx))));
 
-  return PTInstruction(std::shared_ptr<ptdecoder_private::Instruction>(
+  return PTInstruction(std::shared_ptr<intelpt_private::Instruction>(
       new Instruction("invalid instruction")));
 }
 
 void PTInstructionList::SetSP(
-    const std::shared_ptr<ptdecoder_private::InstructionList> &ptr) {
+    const std::shared_ptr<intelpt_private::InstructionList> &ptr) {
   m_opaque_sp = ptr;
 }
 void PTInstructionList::Clear() {
   if (!m_opaque_sp)
     return;
   m_opaque_sp.reset();
 }
 

 lldb::SBStructuredData PTTraceOptions::GetTraceParams(lldb::SBError &error) {
   if (!m_opaque_sp)
     error.SetErrorString("null pointer");
   return (m_opaque_sp ? m_opaque_sp->getTraceParams(error)
                       : lldb::SBStructuredData());
 }
 
 void PTTraceOptions::SetSP(
-    const std::shared_ptr<ptdecoder_private::TraceOptions> &ptr) {
+    const std::shared_ptr<intelpt_private::TraceOptions> &ptr) {
   m_opaque_sp = ptr;
 }
 
 // PTDecoder class member functions definitions
 PTDecoder::PTDecoder(lldb::SBDebugger &sbdebugger)
-    : m_opaque_sp(new ptdecoder_private::Decoder(sbdebugger)) {}
+    : m_opaque_sp(new intelpt_private::Decoder(sbdebugger)) {}
 
 void PTDecoder::StartProcessorTrace(lldb::SBProcess &sbprocess,
                                     lldb::SBTraceOptions &sbtraceoptions,
                                     lldb::SBError &sberror) {
   if (m_opaque_sp == nullptr) {
     sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
     return;
   }
void PTDecoder::GetInstructionLogAtOffset(lldb::SBProcess &sbprocess,
                                           uint32_t count,
                                           PTInstructionList &result_list,
                                           lldb::SBError &sberror) {
   if (m_opaque_sp == nullptr) {
     sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
     return;
   }
 
-  std::shared_ptr<ptdecoder_private::InstructionList> insn_list_ptr(
+  std::shared_ptr<intelpt_private::InstructionList> insn_list_ptr(
       new InstructionList());
   m_opaque_sp->GetInstructionLogAtOffset(sbprocess, tid, offset, count,
                                          *insn_list_ptr, sberror);
   if (!sberror.Success())
     return;
 
   result_list.SetSP(insn_list_ptr);
 }
 
 void PTDecoder::GetProcessorTraceInfo(lldb::SBProcess &sbprocess,
                                       lldb::tid_t tid, PTTraceOptions &options,
                                       lldb::SBError &sberror) {
   if (m_opaque_sp == nullptr) {
     sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
     return;
   }
 
-  std::shared_ptr<ptdecoder_private::TraceOptions> trace_options_ptr(
+  std::shared_ptr<intelpt_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

else {
     }
     thread_id = thread.GetThreadID();
   }
   return true;
 }
 
 class ProcessorTraceStart : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceStart(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
+  ProcessorTraceStart(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
       : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
 
   ~ProcessorTraceStart() {}
 
   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 =
-        ptdecoder::PTDecoder::GetDefaultTraceOptions();
+        intelpt::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 (!error.Success()) {
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
-  std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
+  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
   const uint32_t m_max_trace_buff_size = 0x3fff;
 };
 
 class ProcessorTraceInfo : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceInfo(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
+  ProcessorTraceInfo(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
       : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
 
   ~ProcessorTraceInfo() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
for (size_t i = 0; i < loop_count; i++) {
       res.Clear();
 
       if (entire_process_tracing)
         thread = process.GetThreadAtIndex(i);
       else
         thread = process.GetThreadByID(thread_id);
       thread_id = thread.GetThreadID();
 
-      ptdecoder::PTTraceOptions options;
+      intelpt::PTTraceOptions options;
       pt_decoder_sp->GetProcessorTraceInfo(process, thread_id, options, error);
       if (!error.Success()) {
         res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
                    thread.GetIndexID(), thread_id, error.GetCString());
         result.AppendMessage(res.GetOutput());
         continue;
       }
 
for (size_t i = 0; i < loop_count; i++) {
                  s.GetData());
       result.AppendMessage(res.GetOutput());
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
-  std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
+  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
 };
 
 class ProcessorTraceShowInstrLog : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceShowInstrLog(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
+  ProcessorTraceShowInstrLog(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
       : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
 
   ~ProcessorTraceShowInstrLog() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
for (size_t i = 0; i < loop_count; i++) {
       thread_id = thread.GetThreadID();
 
       // If offset is not provided then calculate a default offset (to display
       // last 'count' number of instructions)
       if (!offset_provided)
         offset = count - 1;
 
       // Get the instruction log
-      ptdecoder::PTInstructionList insn_list;
+      intelpt::PTInstructionList insn_list;
       pt_decoder_sp->GetInstructionLogAtOffset(process, thread_id, offset,
                                                count, insn_list, error);
       if (!error.Success()) {
         res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
                    thread.GetIndexID(), thread_id, error.GetCString());
         result.AppendMessage(res.GetOutput());
         continue;
       }
 
       // Disassemble the instruction log
       std::string disassembler_command("dis -c 1 -s ");
       res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 "\n", thread.GetIndexID(),
                  thread_id);
       lldb::SBCommandInterpreter sb_cmnd_interpreter(
           debugger.GetCommandInterpreter());
       lldb::SBCommandReturnObject result_obj;
       for (size_t i = 0; i < insn_list.GetSize(); i++) {
-        ptdecoder::PTInstruction insn = insn_list.GetInstructionAtIndex(i);
+        intelpt::PTInstruction insn = insn_list.GetInstructionAtIndex(i);
         uint64_t addr = insn.GetInsnAddress();
         std::string error = insn.GetError();
         if (!error.empty()) {
           res.AppendMessage(error.c_str());
           continue;
         }
 
         result_obj.Clear();
for (size_t i = 0; i < loop_count; i++) {
       }
       result.AppendMessage(res.GetOutput());
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
-  std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
+  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
   const uint32_t m_default_count = 10;
 };
 
 class ProcessorTraceStop : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceStop(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
+  ProcessorTraceStop(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
       : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
 
   ~ProcessorTraceStop() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
if (!error.Success()) {
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
-  std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
+  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
 };
 
 bool PTPluginInitialize(lldb::SBDebugger &debugger) {
   lldb::SBCommandInterpreter interpreter = debugger.GetCommandInterpreter();
   lldb::SBCommand proc_trace = interpreter.AddMultiwordCommand(
       "processor-trace", "Intel(R) Processor Trace for thread/process");
 
-  std::shared_ptr<ptdecoder::PTDecoder> PTDecoderSP(
-      new ptdecoder::PTDecoder(debugger));
+  std::shared_ptr<intelpt::PTDecoder> PTDecoderSP(
+      new intelpt::PTDecoder(debugger));
 
   lldb::SBCommandPluginInterface *proc_trace_start =
       new ProcessorTraceStart(PTDecoderSP);
   const char *help_proc_trace_start = "start Intel(R) Processor Trace on a "
                                       "specific thread or on the whole process";
   const char *syntax_proc_trace_start =
       "processor-trace start  <cmd-options>\n\n"
       "\rcmd-options Usage:\n"

lldb/tools/intel-features/scripts/lldb-intel-features.swig

 #error Swig versions 3.0.9 and 3.0.10 are incompatible with lldb.
 #endif
 
 %module(moduleimport=MODULEIMPORT) lldbIntelFeatures
 
 %{
 #include "lldb/lldb-public.h"
 #include "intel-pt/PTDecoder.h"
-using namespace ptdecoder;
+using namespace intelpt;
 %}
 
 /* Undefine GCC keyword to make Swig happy when processing glibc's stdint.h */
 #define __extension__
 
 /* Combined python typemap for all features */
 %include "python-typemaps.txt"
 
 /* Feature specific python interface files*/
 %include "../intel-pt/interface/PTDecoder.i"