[lldb] Remove PluginInterface::GetPluginVersion

[labath]

Summary

In all these years, we haven't found a use for this function (it has
zero callers). Lets just remove the boilerplate.

[JDevlieghere]

LGTM!

[bulbazord]

Thank you!

lldb/include/lldb/Core/PluginInterface.h

 
 class PluginInterface {
 public:
   PluginInterface() = default;
   virtual ~PluginInterface() = default;
 
   virtual ConstString GetPluginName() = 0;
 
-  virtual uint32_t GetPluginVersion() = 0;
-
   PluginInterface(const PluginInterface &) = delete;
   PluginInterface &operator=(const PluginInterface &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_PLUGININTERFACE_H

lldb/include/lldb/Symbol/SymbolVendor.h

public:
 
   void AddSymbolFileRepresentation(const lldb::ObjectFileSP &objfile_sp);
 
   SymbolFile *GetSymbolFile() { return m_sym_file_up.get(); }
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   std::unique_ptr<SymbolFile> m_sym_file_up; // A single symbol file. Subclasses
                                              // can add more of these if needed.
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOLVENDOR_H

lldb/include/lldb/Target/ProcessTrace.h

public:
   void DidAttach(ArchSpec &process_arch) override;
 
   DynamicLoader *GetDynamicLoader() override { return nullptr; }
 
   SystemRuntime *GetSystemRuntime() override { return nullptr; }
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;
 
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",

lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.h

public:
   // PluginInterface protocol
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override;
-
   lldb_private::Status
   SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                        lldb::ValueObjectSP &new_value) override;
 
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
   using ABIAArch64::ABIAArch64; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIMACOSX_ARM64_H

lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp

 }
 
 // PluginInterface protocol
 
 ConstString ABIMacOSX_arm64::GetPluginNameStatic() {
   static ConstString g_plugin_name("ABIMacOSX_arm64");
   return g_plugin_name;
 }
-
-uint32_t ABIMacOSX_arm64::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   lldb::addr_t FixCodeAddress(lldb::addr_t pc) override;
   lldb::addr_t FixDataAddress(lldb::addr_t pc) override;
 
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
   using ABIAArch64::ABIAArch64; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABISYSV_ARM64_H

lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp

 lldb_private::ConstString ABISysV_arm64::GetPluginNameStatic() {
   static ConstString g_name("SysV-arm64");
   return g_name;
 }
 
 // PluginInterface protocol
 
 ConstString ABISysV_arm64::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t ABISysV_arm64::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/ARC/ABISysV_arc.h

public:
   static lldb_private::ConstString GetPluginNameStatic();
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 private:
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool IsRegisterFileReduced(lldb_private::RegisterContext &reg_ctx) const;
 
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 
   using RegisterFileFlag = llvm::Optional<bool>;
   mutable RegisterFileFlag m_is_reg_file_reduced;
 };
 
 #endif // liblldb_ABISysV_arc_h_

lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp

 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 
 ConstString ABISysV_arc::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_arc::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_ARM_ABIMACOSX_ARM_H

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

lldb_private::ConstString ABIMacOSX_arm::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABIMacOSX_arm::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABIMacOSX_arm::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/ARM/ABISysV_arm.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_ARM_ABISYSV_ARM_H

lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp

lldb_private::ConstString ABISysV_arm::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_arm::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_arm::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_HEXAGON_ABISYSV_HEXAGON_H

lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.cpp

 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_hexagon::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ABISysV_hexagon::GetPluginVersion() { return 1; }
-
 // get value object specialized to work with llvm IR types
 lldb::ValueObjectSP
 ABISysV_hexagon::GetReturnValueObjectImpl(lldb_private::Thread &thread,
                                           llvm::Type &retType) const {
   Value value;
   ValueObjectSP vObjSP;
 
   // get the current register context

lldb/source/Plugins/ABI/Mips/ABISysV_mips.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS_H

lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp

lldb_private::ConstString ABISysV_mips::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_mips::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_mips::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS64_H

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp

lldb_private::ConstString ABISysV_mips64::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_mips64::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_mips64::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC_H

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

lldb_private::ConstString ABISysV_ppc::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_ppc::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_ppc::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 
   lldb::ByteOrder GetByteOrder() const;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC64_H

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp

lldb_private::ConstString ABISysV_ppc64::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_ppc64::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_ppc64::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_SYSTEMZ_ABISYSV_S390X_H

lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.cpp

lldb_private::ConstString ABISysV_s390x::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_s390x::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_s390x::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   // PluginInterface protocol
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            lldb_private::CompilerType &ast_type) const override;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
   std::string GetMCName(std::string name) override {

lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.cpp

lldb_private::ConstString ABIMacOSX_i386::GetPluginNameStatic() {
   return g_short_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABIMacOSX_i386::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABIMacOSX_i386::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/X86/ABISysV_i386.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   // PluginInterface protocol
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
   using ABIX86::ABIX86; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_I386_H

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.h

public:
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
   uint32_t GetGenericNum(llvm::StringRef reg) override;
 
 private:
   using ABIX86_64::ABIX86_64; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_X86_64_H

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp

lldb_private::ConstString ABISysV_x86_64::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ABISysV_x86_64::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABISysV_x86_64::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.h

public:
   static lldb_private::ConstString GetPluginNameStatic();
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void CreateRegisterMapIfNeeded();
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
   uint32_t GetGenericNum(llvm::StringRef reg) override;
 
 private:
   using ABIX86_64::ABIX86_64; // Call CreateInstance instead.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABIWINDOWS_X86_64_H

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp

 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 
 lldb_private::ConstString ABIWindows_x86_64::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ABIWindows_x86_64::GetPluginVersion() { return 1; }

lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.h

 
 class ArchitectureAArch64 : public Architecture {
 public:
   static ConstString GetPluginNameStatic();
   static void Initialize();
   static void Terminate();
 
   ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
 
   void OverrideStopInfo(Thread &thread) const override{};
 
   const MemoryTagManager *GetMemoryTagManager() const override {
     return &m_memory_tag_manager;
   }
 
 private:
   static std::unique_ptr<Architecture> Create(const ArchSpec &arch);
   ArchitectureAArch64() = default;
   MemoryTagManagerAArch64MTE m_memory_tag_manager;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_ARCHITECTURE_AARCH64_ARCHITECTUREAARCH64_H

lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.cpp

if (machine != llvm::Triple::aarch64 && machine != llvm::Triple::aarch64_be &&
     return nullptr;
   }
   return std::unique_ptr<Architecture>(new ArchitectureAArch64());
 }
 
 ConstString ArchitectureAArch64::GetPluginName() {
   return GetPluginNameStatic();
 }
-uint32_t ArchitectureAArch64::GetPluginVersion() { return 1; }

lldb/source/Plugins/Architecture/Arm/ArchitectureArm.h

 
 class ArchitectureArm : public Architecture {
 public:
   static ConstString GetPluginNameStatic();
   static void Initialize();
   static void Terminate();
 
   ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
 
   void OverrideStopInfo(Thread &thread) const override;
 
   lldb::addr_t GetCallableLoadAddress(lldb::addr_t load_addr,
                                       AddressClass addr_class) const override;
 
   lldb::addr_t GetOpcodeLoadAddress(lldb::addr_t load_addr,
                                     AddressClass addr_class) const override;

lldb/source/Plugins/Architecture/Arm/ArchitectureArm.cpp

 
 std::unique_ptr<Architecture> ArchitectureArm::Create(const ArchSpec &arch) {
   if (arch.GetMachine() != llvm::Triple::arm)
     return nullptr;
   return std::unique_ptr<Architecture>(new ArchitectureArm());
 }
 
 ConstString ArchitectureArm::GetPluginName() { return GetPluginNameStatic(); }
-uint32_t ArchitectureArm::GetPluginVersion() { return 1; }
 
 void ArchitectureArm::OverrideStopInfo(Thread &thread) const {
   // We need to check if we are stopped in Thumb mode in a IT instruction and
   // detect if the condition doesn't pass. If this is the case it means we
   // won't actually execute this instruction. If this happens we need to clear
   // the stop reason to no thread plans think we are stopped for a reason and
   // the plans should keep going.
   //

lldb/source/Plugins/Architecture/Mips/ArchitectureMips.h

 
 class ArchitectureMips : public Architecture {
 public:
   static ConstString GetPluginNameStatic();
   static void Initialize();
   static void Terminate();
 
   ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
 
   void OverrideStopInfo(Thread &thread) const override {}
 
   lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr,
                                        Target &) const override;
 
   lldb::addr_t GetCallableLoadAddress(lldb::addr_t load_addr,
                                       AddressClass addr_class) const override;

lldb/source/Plugins/Architecture/Mips/ArchitectureMips.cpp

 }
 
 std::unique_ptr<Architecture> ArchitectureMips::Create(const ArchSpec &arch) {
   return arch.IsMIPS() ?
       std::unique_ptr<Architecture>(new ArchitectureMips(arch)) : nullptr;
 }
 
 ConstString ArchitectureMips::GetPluginName() { return GetPluginNameStatic(); }
-uint32_t ArchitectureMips::GetPluginVersion() { return 1; }
 
 addr_t ArchitectureMips::GetCallableLoadAddress(addr_t code_addr,
                                                 AddressClass addr_class) const {
   bool is_alternate_isa = false;
 
   switch (addr_class) {
   case AddressClass::eData:
   case AddressClass::eDebug:

lldb/source/Plugins/Architecture/PPC64/ArchitecturePPC64.h

 
 class ArchitecturePPC64 : public Architecture {
 public:
   static ConstString GetPluginNameStatic();
   static void Initialize();
   static void Terminate();
 
   ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
 
   void OverrideStopInfo(Thread &thread) const override {}
 
   /// This method compares current address with current function's
   /// local entry point, returning the bytes to skip if they match.
   size_t GetBytesToSkip(Symbol &func, const Address &curr_addr) const override;
 
   void AdjustBreakpointAddress(const Symbol &func,

lldb/source/Plugins/Architecture/PPC64/ArchitecturePPC64.cpp

 std::unique_ptr<Architecture> ArchitecturePPC64::Create(const ArchSpec &arch) {
   if (arch.GetTriple().isPPC64() &&
       arch.GetTriple().getObjectFormat() == llvm::Triple::ObjectFormatType::ELF)
     return std::unique_ptr<Architecture>(new ArchitecturePPC64());
   return nullptr;
 }
 
 ConstString ArchitecturePPC64::GetPluginName() { return GetPluginNameStatic(); }
-uint32_t ArchitecturePPC64::GetPluginVersion() { return 1; }
 
 static int32_t GetLocalEntryOffset(const Symbol &sym) {
   unsigned char other = sym.GetFlags() >> 8 & 0xFF;
   return llvm::ELF::decodePPC64LocalEntryOffset(other);
 }
 
 size_t ArchitecturePPC64::GetBytesToSkip(Symbol &func,
                                          const Address &curr_addr) const {

lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.h

public:
   size_t DecodeInstructions(const lldb_private::Address &base_addr,
                             const lldb_private::DataExtractor &data,
                             lldb::offset_t data_offset, size_t num_instructions,
                             bool append, bool data_from_file) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   friend class InstructionLLVMC;
 
   bool FlavorValidForArchSpec(const lldb_private::ArchSpec &arch,
                               const char *flavor) override;
 
   bool IsValid() const;
 

lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp

const char *DisassemblerLLVMC::SymbolLookup(uint64_t value, uint64_t *type_ptr,
   // handles.
   *type_ptr = LLVMDisassembler_ReferenceType_InOut_None;
   *name = nullptr;
   return nullptr;
 }
 
 // PluginInterface protocol
 ConstString DisassemblerLLVMC::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t DisassemblerLLVMC::GetPluginVersion() { return 1; }

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h

public:
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
                                                   bool stop_others) override;
 
   lldb_private::Status CanLoadImage() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void PrivateInitialize(lldb_private::Process *process);
 
   void PrivateProcessStateChanged(lldb_private::Process *process,
                                   lldb::StateType state);
 
   void UpdateIfNeeded();
 

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

return "Dynamic loader plug-in that watches for shared library loads/unloads "
          "in the MacOSX kernel.";
 }
 
 // PluginInterface protocol
 lldb_private::ConstString DynamicLoaderDarwinKernel::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t DynamicLoaderDarwinKernel::GetPluginVersion() { return 1; }
-
 lldb::ByteOrder
 DynamicLoaderDarwinKernel::GetByteOrderFromMagic(uint32_t magic) {
   switch (magic) {
   case llvm::MachO::MH_MAGIC:
   case llvm::MachO::MH_MAGIC_64:
     return endian::InlHostByteOrder();
 
   case llvm::MachO::MH_CIGAM:

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h

public:
 
   lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
                                   const lldb::ThreadSP thread,
                                   lldb::addr_t tls_file_addr) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   /// Runtime linker rendezvous structure.
   HexagonDYLDRendezvous m_rendezvous;
 
   /// Virtual load address of the inferior process.
   lldb::addr_t m_load_offset;
 
   /// Virtual entry address of the inferior process.

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

lldb_private::ConstString DynamicLoaderHexagonDYLD::GetPluginNameStatic() {
   return g_name;
 }
 
 const char *DynamicLoaderHexagonDYLD::GetPluginDescriptionStatic() {
   return "Dynamic loader plug-in that watches for shared library "
          "loads/unloads in Hexagon processes.";
 }
 
-uint32_t DynamicLoaderHexagonDYLD::GetPluginVersion() { return 1; }
-
 DynamicLoader *DynamicLoaderHexagonDYLD::CreateInstance(Process *process,
                                                         bool force) {
   bool create = force;
   if (!create) {
     const llvm::Triple &triple_ref =
         process->GetTarget().GetArchitecture().GetTriple();
     if (triple_ref.getArch() == llvm::Triple::hexagon)
       create = true;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h

public:
   bool GetSharedCacheInformation(
       lldb::addr_t &base_address, lldb_private::UUID &uuid,
       lldb_private::LazyBool &using_shared_cache,
       lldb_private::LazyBool &private_shared_cache) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   void PutToLog(lldb_private::Log *log) const;
 
   void DoInitialImageFetch() override;
 
   bool NeedToDoInitialImageFetch() override;
 
   bool DidSetNotificationBreakpoint() override;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

const char *DynamicLoaderMacOS::GetPluginDescriptionStatic() {
   return "Dynamic loader plug-in that watches for shared library loads/unloads "
          "in MacOSX user processes.";
 }
 
 // PluginInterface protocol
 lldb_private::ConstString DynamicLoaderMacOS::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t DynamicLoaderMacOS::GetPluginVersion() { return 1; }

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

public:
   bool GetSharedCacheInformation(
       lldb::addr_t &base_address, lldb_private::UUID &uuid,
       lldb_private::LazyBool &using_shared_cache,
       lldb_private::LazyBool &private_shared_cache) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   bool IsFullyInitialized() override;
 
 protected:
   void PutToLog(lldb_private::Log *log) const;
 
   void DoInitialImageFetch() override;
 
   bool NeedToDoInitialImageFetch() override;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

return "Dynamic loader plug-in that watches for shared library loads/unloads "
          "in MacOSX user processes.";
 }
 
 // PluginInterface protocol
 lldb_private::ConstString DynamicLoaderMacOSXDYLD::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t DynamicLoaderMacOSXDYLD::GetPluginVersion() { return 1; }
-
 uint32_t DynamicLoaderMacOSXDYLD::AddrByteSize() {
   std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
 
   switch (m_dyld.header.magic) {
   case llvm::MachO::MH_MAGIC:
   case llvm::MachO::MH_CIGAM:
     return 4;
 

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

public:
 
   lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
                                   const lldb::ThreadSP thread,
                                   lldb::addr_t tls_file_addr) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   /// Runtime linker rendezvous structure.
   DYLDRendezvous m_rendezvous;
 
   /// Virtual load address of the inferior process.
   lldb::addr_t m_load_offset;
 
   /// Virtual entry address of the inferior process.

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

lldb_private::ConstString DynamicLoaderPOSIXDYLD::GetPluginNameStatic() {
   return g_name;
 }
 
 const char *DynamicLoaderPOSIXDYLD::GetPluginDescriptionStatic() {
   return "Dynamic loader plug-in that watches for shared library "
          "loads/unloads in POSIX processes.";
 }
 
-uint32_t DynamicLoaderPOSIXDYLD::GetPluginVersion() { return 1; }
-
 DynamicLoader *DynamicLoaderPOSIXDYLD::CreateInstance(Process *process,
                                                       bool force) {
   bool create = force;
   if (!create) {
     const llvm::Triple &triple_ref =
         process->GetTarget().GetArchitecture().GetTriple();
     if (triple_ref.getOS() == llvm::Triple::FreeBSD ||
         triple_ref.getOS() == llvm::Triple::Linux ||

lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h

public:
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
                                                   bool stop_others) override;
 
   lldb_private::Status CanLoadImage() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 private:
   void LoadAllImagesAtFileAddresses();
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_STATIC_DYNAMICLOADERSTATIC_H

lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp

const char *DynamicLoaderStatic::GetPluginDescriptionStatic() {
   return "Dynamic loader plug-in that will load any images at the static "
          "addresses contained in each image.";
 }
 
 // PluginInterface protocol
 lldb_private::ConstString DynamicLoaderStatic::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t DynamicLoaderStatic::GetPluginVersion() { return 1; }

lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h

public:
 
   void DidAttach() override;
   void DidLaunch() override;
   Status CanLoadImage() override;
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                   bool stop) override;
 
   ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
 
 protected:
   lldb::addr_t GetLoadAddress(lldb::ModuleSP executable);
 
 private:
   std::map<lldb::ModuleSP, lldb::addr_t> m_loaded_modules;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_WINDOWS_DYLD_DYNAMICLOADERWINDOWSDYLD_H

lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

 }
 
 Status DynamicLoaderWindowsDYLD::CanLoadImage() { return Status(); }
 
 ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
-
 ThreadPlanSP
 DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop) {
   auto arch = m_process->GetTarget().GetArchitecture();
   if (arch.GetMachine() != llvm::Triple::x86) {
     return ThreadPlanSP();
   }
 

lldb/source/Plugins/DynamicLoader/wasm-DYLD/DynamicLoaderWasmDYLD.h

public:
   Status CanLoadImage() override { return Status(); }
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                   bool stop) override;
   /// \}
 
   /// PluginInterface protocol.
   /// \{
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
-  uint32_t GetPluginVersion() override { return 1; }
   /// \}
 };
 
 } // namespace wasm
 } // namespace lldb_private
 
 #endif // liblldb_Plugins_DynamicLoaderWasmDYLD_h_

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.h

SupportsEmulatingInstructionsOfTypeStatic(InstructionType inst_type) {
     }
     return false;
   }
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   bool SetTargetTriple(const ArchSpec &arch) override;
 
   enum Mode { eModeInvalid = -1, eModeARM, eModeThumb };
 
   EmulateInstructionARM(const ArchSpec &arch)
       : EmulateInstruction(arch), m_arm_isa(0), m_opcode_mode(eModeInvalid),
         m_opcode_cpsr(0), m_it_session(), m_ignore_conditions(false) {
     SetArchitecture(arch);

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.h

static bool SupportsEmulatingInstructionsOfTypeStatic(
     case lldb_private::eInstructionTypeAll:
       return false;
     }
     return false;
   }
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   bool SetTargetTriple(const lldb_private::ArchSpec &arch) override;
 
   bool SupportsEmulatingInstructionsOfType(
       lldb_private::InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }
 
   bool ReadInstruction() override;

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.h

static bool SupportsEmulatingInstructionsOfTypeStatic(
     case lldb_private::eInstructionTypeAll:
       return false;
     }
     return false;
   }
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   bool SetTargetTriple(const lldb_private::ArchSpec &arch) override;
 
   EmulateInstructionMIPS(const lldb_private::ArchSpec &arch);
 
   bool SupportsEmulatingInstructionsOfType(
       lldb_private::InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h

static bool SupportsEmulatingInstructionsOfTypeStatic(
     case lldb_private::eInstructionTypeAll:
       return false;
     }
     return false;
   }
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   bool SetTargetTriple(const lldb_private::ArchSpec &arch) override;
 
   bool SupportsEmulatingInstructionsOfType(
       lldb_private::InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }
 
   bool ReadInstruction() override;

lldb/source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.h

SupportsEmulatingInstructionsOfTypeStatic(InstructionType inst_type) {
     case eInstructionTypeAll:
       return false;
     }
     return false;
   }
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   bool SetTargetTriple(const ArchSpec &arch) override;
 
   bool SupportsEmulatingInstructionsOfType(InstructionType inst_type) override {
     return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
   }
 
   bool ReadInstruction() override;
 

lldb/source/Plugins/InstrumentationRuntime/ASan/InstrumentationRuntimeASan.h

public:
   static lldb::InstrumentationRuntimeType GetTypeStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
   virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
 private:
   InstrumentationRuntimeASan(const lldb::ProcessSP &process_sp)
       : lldb_private::InstrumentationRuntime(process_sp) {}
 
   const RegularExpression &GetPatternForRuntimeLibrary() override;
 
   bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
 

lldb/source/Plugins/InstrumentationRuntime/MainThreadChecker/InstrumentationRuntimeMainThreadChecker.h

public:
   static lldb::InstrumentationRuntimeType GetTypeStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
   virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   lldb::ThreadCollectionSP
   GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
 
 private:
   InstrumentationRuntimeMainThreadChecker(const lldb::ProcessSP &process_sp)
       : lldb_private::InstrumentationRuntime(process_sp) {}
 
   const RegularExpression &GetPatternForRuntimeLibrary() override;

lldb/source/Plugins/InstrumentationRuntime/TSan/InstrumentationRuntimeTSan.h

public:
   static lldb::InstrumentationRuntimeType GetTypeStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
   virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   lldb::ThreadCollectionSP
   GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
 
 private:
   InstrumentationRuntimeTSan(const lldb::ProcessSP &process_sp)
       : lldb_private::InstrumentationRuntime(process_sp) {}
 
   const RegularExpression &GetPatternForRuntimeLibrary() override;

lldb/source/Plugins/InstrumentationRuntime/UBSan/InstrumentationRuntimeUBSan.h

public:
   static lldb::InstrumentationRuntimeType GetTypeStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
   virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   lldb::ThreadCollectionSP
   GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
 
 private:
   InstrumentationRuntimeUBSan(const lldb::ProcessSP &process_sp)
       : lldb_private::InstrumentationRuntime(process_sp) {}
 
   const RegularExpression &GetPatternForRuntimeLibrary() override;

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.h

public:
   static lldb::JITLoaderSP CreateInstance(lldb_private::Process *process,
                                           bool force);
 
   static void DebuggerInitialize(lldb_private::Debugger &debugger);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // JITLoader interface
   void DidAttach() override;
 
   void DidLaunch() override;
 
   void ModulesDidLoad(lldb_private::ModuleList &module_list) override;
 
 private:

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

const char *JITLoaderGDB::GetPluginDescriptionStatic() {
   return "JIT loader plug-in that watches for JIT events using the GDB "
          "interface.";
 }
 
 lldb_private::ConstString JITLoaderGDB::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t JITLoaderGDB::GetPluginVersion() { return 1; }
-
 void JITLoaderGDB::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
                                 DebuggerInitialize);
 }
 
 void JITLoaderGDB::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

public:
   // Given a mangled function name, calculates some alternative manglings since
   // the compiler mangling may not line up with the symbol we are expecting
   static uint32_t
   FindAlternateFunctionManglings(const ConstString mangled,
                                  std::set<ConstString> &candidates);
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSLANGUAGE_H

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString CPlusPlusLanguage::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t CPlusPlusLanguage::GetPluginVersion() { return 1; }
-
 // Static Functions
 
 Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) {
   // Use plugin for C++ but not for Objective-C++ (which has its own plugin).
   if (Language::LanguageIsCPlusPlus(language) &&
       language != eLanguageTypeObjC_plus_plus)
     return new CPlusPlusLanguage();
   return nullptr;

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

static bool IsPossibleObjCSelector(const char *name) {
     else if (name[strlen(name) - 1] == ':')
       return true;
     else
       return false;
   }
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_OBJCLANGUAGE_H

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

 }
 
 // PluginInterface protocol
 
 lldb_private::ConstString ObjCLanguage::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjCLanguage::GetPluginVersion() { return 1; }
-
 // Static Functions
 
 Language *ObjCLanguage::CreateInstance(lldb::LanguageType language) {
   switch (language) {
   case lldb::eLanguageTypeObjC:
     return new ObjCLanguage();
   default:
     return nullptr;

lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h

public:
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_OBJCPLUSPLUS_OBJCPLUSPLUSLANGUAGE_H

lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.cpp

lldb_private::ConstString ObjCPlusPlusLanguage::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjCPlusPlusLanguage::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjCPlusPlusLanguage::GetPluginVersion() { return 1; }
-
 // Static Functions
 Language *ObjCPlusPlusLanguage::CreateInstance(lldb::LanguageType language) {
   switch (language) {
   case lldb::eLanguageTypeObjC_plus_plus:
     return new ObjCPlusPlusLanguage();
   default:
     return nullptr;
   }
 }

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h

public:
   lldb::SearchFilterSP CreateExceptionSearchFilter() override;
   
   lldb::ValueObjectSP GetExceptionObjectForThread(
       lldb::ThreadSP thread_sp) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   lldb::BreakpointResolverSP
   CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
                           bool catch_bp, bool throw_bp, bool for_expressions);
 
   lldb::BreakpointSP CreateExceptionBreakpoint(bool catch_bp, bool throw_bp,
                                                bool for_expressions,
                                                bool is_internal);

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

lldb_private::ConstString ItaniumABILanguageRuntime::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ItaniumABILanguageRuntime::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ItaniumABILanguageRuntime::GetPluginVersion() { return 1; }
-
 BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver(
     const BreakpointSP &bkpt, bool catch_bp, bool throw_bp) {
   return CreateExceptionResolver(bkpt, catch_bp, throw_bp, false);
 }
 
 BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver(
     const BreakpointSP &bkpt, bool catch_bp, bool throw_bp,
     bool for_expressions) {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h

bool GetDynamicTypeAndAddress(ValueObject &in_value,
                                 Value::ValueType &value_type) override;
 
   llvm::Expected<std::unique_ptr<UtilityFunction>>
   CreateObjectChecker(std::string, ExecutionContext &exe_ctx) override;
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   ObjCRuntimeVersions GetRuntimeVersion() const override {
     return ObjCRuntimeVersions::eAppleObjC_V1;
   }
 
   void UpdateISAToDescriptorMapIfNeeded() override;
 
   DeclVendor *GetDeclVendor() override;
 

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

lldb_private::ConstString AppleObjCRuntimeV1::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 ConstString AppleObjCRuntimeV1::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t AppleObjCRuntimeV1::GetPluginVersion() { return 1; }
-
 BreakpointResolverSP
 AppleObjCRuntimeV1::CreateExceptionResolver(const BreakpointSP &bkpt,
                                             bool catch_bp, bool throw_bp) {
   BreakpointResolverSP resolver_sp;
 
   if (throw_bp)
     resolver_sp = std::make_shared<BreakpointResolverName>(
         bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

bool GetDynamicTypeAndAddress(ValueObject &in_value,
                                 Address &address,
                                 Value::ValueType &value_type) override;
 
   llvm::Expected<std::unique_ptr<UtilityFunction>>
   CreateObjectChecker(std::string name, ExecutionContext &exe_ctx) override;
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   ObjCRuntimeVersions GetRuntimeVersion() const override {
     return ObjCRuntimeVersions::eAppleObjC_V2;
   }
 
   size_t GetByteOffsetForIvar(CompilerType &parent_qual_type,
                               const char *ivar_name) override;
 
   void UpdateISAToDescriptorMapIfNeeded() override;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

lldb_private::ConstString AppleObjCRuntimeV2::GetPluginNameStatic() {
   return g_name;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString AppleObjCRuntimeV2::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t AppleObjCRuntimeV2::GetPluginVersion() { return 1; }
-
 BreakpointResolverSP
 AppleObjCRuntimeV2::CreateExceptionResolver(const BreakpointSP &bkpt,
                                             bool catch_bp, bool throw_bp) {
   BreakpointResolverSP resolver_sp;
 
   if (throw_bp)
     resolver_sp = std::make_shared<BreakpointResolverName>(
         bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

bool IsKnownKernel(ConstString name) {
     return false;
   }
 
   bool GetOverrideExprOptions(clang::TargetOptions &prototype);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   static bool GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord,
                                   Thread *thread_ptr);
 
   bool ResolveKernelName(lldb::addr_t kernel_address, ConstString &name);
 
 protected:
   struct ScriptDetails;
   struct AllocationDetails;

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

void RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list) {
   }
 }
 
 // PluginInterface protocol
 lldb_private::ConstString RenderScriptRuntime::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t RenderScriptRuntime::GetPluginVersion() { return 1; }
-
 bool RenderScriptRuntime::GetDynamicTypeAndAddress(
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &address,
     Value::ValueType &value_type) {
   return false;
 }
 
 TypeAndOrName

lldb/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.h

public:
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   lldb_private::HistoryThreads GetHistoryThreads(lldb::addr_t address) override;
 
 private:
   MemoryHistoryASan(const lldb::ProcessSP &process_sp);
 
   lldb::ProcessWP m_process_wp;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_MEMORYHISTORY_ASAN_MEMORYHISTORYASAN_H

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

public:
 
   void Dump(lldb_private::Stream *s) const override;
 
   lldb::ObjectFileSP GetObjectFile(const lldb_private::FileSpec *file) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   struct Object {
     Object();
 
     void Clear();
 
     lldb::offset_t Extract(const lldb_private::DataExtractor &data,
                            lldb::offset_t offset);

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

ObjectFileSP ObjectContainerBSDArchive::GetObjectFile(const FileSpec *file) {
   return ObjectFileSP();
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjectContainerBSDArchive::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjectContainerBSDArchive::GetPluginVersion() { return 1; }
-
 size_t ObjectContainerBSDArchive::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
 
   // We have data, which means this is the first 512 bytes of the file Check to
   // see if the magic bytes match and if they do, read the entire table of
   // contents for the archive and cache it

lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h

public:
   bool GetArchitectureAtIndex(uint32_t cpu_idx,
                               lldb_private::ArchSpec &arch) const override;
 
   lldb::ObjectFileSP GetObjectFile(const lldb_private::FileSpec *file) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   llvm::MachO::fat_header m_header;
   std::vector<llvm::MachO::fat_arch> m_fat_archs;
 
   static bool ParseHeader(lldb_private::DataExtractor &data,
                           llvm::MachO::fat_header &header,
                           std::vector<llvm::MachO::fat_arch> &fat_archs);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTCONTAINER_UNIVERSAL_MACH_O_OBJECTCONTAINERUNIVERSALMACHO_H

lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

ObjectContainerUniversalMachO::GetObjectFile(const FileSpec *file) {
   return ObjectFileSP();
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjectContainerUniversalMachO::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjectContainerUniversalMachO::GetPluginVersion() { return 1; }
-
 size_t ObjectContainerUniversalMachO::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
   const size_t initial_count = specs.GetSize();
 
   DataExtractor data;
   data.SetData(data_sp, data_offset, data_sp->GetByteSize());

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h

static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   // PluginInterface protocol
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // LLVM RTTI support
   static char ID;
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || ObjectFile::isA(ClassID);
   }
   static bool classof(const ObjectFile *obj) { return obj->isA(&ID); }
 
   // ObjectFile Protocol.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
                                         lldb_private::ModuleSpecList &specs);
 
   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset,
                               lldb::addr_t length);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // LLVM RTTI support
   static char ID;
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || ObjectFile::isA(ClassID);
   }
   static bool classof(const ObjectFile *obj) { return obj->isA(&ID); }
 
   // ObjectFile Protocol.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

size_t ObjectFileELF::GetModuleSpecifications(
   return specs.GetSize() - initial_count;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjectFileELF::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjectFileELF::GetPluginVersion() { return m_plugin_version; }
 // ObjectFile protocol
 
 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
                              DataBufferSP &data_sp, lldb::offset_t data_offset,
                              const FileSpec *file, lldb::offset_t file_offset,
                              lldb::offset_t length)
     : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) {
   if (file)

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

public:
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   lldb::ObjectFileJITDelegateWP m_delegate_wp;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_JIT_OBJECTFILEJIT_H

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

ArchSpec ObjectFileJIT::GetArchitecture() {
   return ArchSpec();
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjectFileJIT::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjectFileJIT::GetPluginVersion() { return 1; }
-
 bool ObjectFileJIT::SetLoadAddress(Target &target, lldb::addr_t value,
                                    bool value_is_offset) {
   size_t num_loaded_sections = 0;
   SectionList *section_list = GetSectionList();
   if (section_list) {
     const size_t num_sections = section_list->GetSize();
     // "value" is an offset to apply to each top level segment
     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

static bool ParseHeader(lldb_private::DataExtractor &data,
                           lldb::offset_t *data_offset_ptr,
                           llvm::MachO::mach_header &header);
 
   bool AllowAssemblyEmulationUnwindPlans() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   static lldb_private::UUID
   GetUUID(const llvm::MachO::mach_header &header,
           const lldb_private::DataExtractor &data,
           lldb::offset_t lc_offset); // Offset to the first load command
 
   static lldb_private::ArchSpec GetArchitecture(
       lldb::ModuleSP module_sp, const llvm::MachO::mach_header &header,

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

bool ObjectFileMachO::AllowAssemblyEmulationUnwindPlans() {
   return m_allow_assembly_emulation_unwind_plans;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString ObjectFileMachO::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ObjectFileMachO::GetPluginVersion() { return 1; }
-
 Section *ObjectFileMachO::GetMachHeaderSection() {
   // Find the first address of the mach header which is the first non-zero file
   // sized section whose file offset is zero. This is the base file address of
   // the mach-o file which can be subtracted from the vmaddr of the other
   // segments found in memory and added to the load address
   ModuleSP module_sp = GetModule();
   if (!module_sp)
     return nullptr;

lldb/source/Plugins/ObjectFile/Minidump/ObjectFileMinidump.h

public:
 
   static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         lldb_private::ModuleSpecList &specs);
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // Saves dump in Minidump file format
   static bool SaveCore(const lldb::ProcessSP &process_sp,
                        const lldb_private::FileSpec &outfile,
                        lldb::SaveCoreStyle &core_style,
                        lldb_private::Status &error);
 
 private:
   ObjectFileMinidump() = default;
 };
 
-#endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_MINIDUMP_OBJECTFILEMINIDUMP_H
+#endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_MINIDUMP_OBJECTFILEMINIDUMP_H
 

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.h

static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   // PluginInterface protocol
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // LLVM RTTI support
   static char ID;
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || ObjectFile::isA(ClassID);
   }
   static bool classof(const ObjectFile *obj) { return obj->isA(&ID); }
 
   // ObjectFile Protocol.

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

public:
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   bool IsWindowsSubsystem();
 
   uint32_t GetRVA(const lldb_private::Address &addr) const;
   lldb_private::Address GetAddress(uint32_t rva);
   lldb::addr_t GetFileAddress(uint32_t rva) const;
 
   lldb_private::DataExtractor ReadImageData(uint32_t offset, size_t size);
   lldb_private::DataExtractor ReadImageDataByRVA(uint32_t rva, size_t size);

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

ObjectFile::Type ObjectFilePECOFF::CalculateType() {
   }
   return eTypeExecutable;
 }
 
 ObjectFile::Strata ObjectFilePECOFF::CalculateStrata() { return eStrataUser; }
 
 // PluginInterface protocol
 ConstString ObjectFilePECOFF::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t ObjectFilePECOFF::GetPluginVersion() { return 1; }

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.h

static size_t GetModuleSpecifications(const FileSpec &file,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         ModuleSpecList &specs);
 
   /// PluginInterface protocol.
   /// \{
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
-  uint32_t GetPluginVersion() override { return 1; }
   /// \}
 
   /// LLVM RTTI support
   /// \{
   static char ID;
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || ObjectFile::isA(ClassID);
   }

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h

public:
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   // lldb_private::PluginInterface Methods
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // lldb_private::OperatingSystem Methods
   bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
                         lldb_private::ThreadList &real_thread_list,
                         lldb_private::ThreadList &new_thread_list) override;
 
   void ThreadWasSelected(lldb_private::Thread *thread) override;
 
   lldb::RegisterContextSP

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

DynamicRegisterInfo *OperatingSystemPython::GetDynamicRegisterInfo() {
   return m_register_info_up.get();
 }
 
 // PluginInterface protocol
 ConstString OperatingSystemPython::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t OperatingSystemPython::GetPluginVersion() { return 1; }
-
 bool OperatingSystemPython::UpdateThreadList(ThreadList &old_thread_list,
                                              ThreadList &core_thread_list,
                                              ThreadList &new_thread_list) {
   if (!m_interpreter || !m_python_object_sp)
     return false;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
 

lldb/source/Plugins/Platform/Android/PlatformAndroid.h

public:
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic(bool is_host);
 
   static const char *GetPluginDescriptionStatic(bool is_host);
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
 
   Status ConnectRemote(Args &args) override;
 
   Status GetFile(const FileSpec &source, const FileSpec &destination) override;
 
   Status PutFile(const FileSpec &source, const FileSpec &destination,
                  uint32_t uid = UINT32_MAX, uint32_t gid = UINT32_MAX) override;

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

public:
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic(bool is_host);
 
   static const char *GetPluginDescriptionStatic(bool is_host);
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   const char *GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

public:
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic(bool is_host);
 
   static const char *GetPluginDescriptionStatic(bool is_host);
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   const char *GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;

lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.h

CreateInstance(const char *class_name, const char *description,
                  llvm::StringRef sdk, lldb_private::XcodeSDK::Type sdk_type,
                  CoreSimulatorSupport::DeviceType::ProductFamilyID kind,
                  bool force, const lldb_private::ArchSpec *arch);
 
   virtual ~PlatformAppleSimulator();
 
   lldb_private::ConstString GetPluginName() override { return m_plugin_name; }
   const char *GetDescription() override { return m_description; }
-  uint32_t GetPluginVersion() override { return 1; }
 
   lldb_private::Status
   LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
 
   void GetStatus(lldb_private::Stream &strm) override;
 
   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
 

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.h

public:
 
   virtual ~PlatformDarwinKernel();
 
   // lldb_private::PluginInterface functions
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   const char *GetDescription() override { return GetDescriptionStatic(); }
 
   void GetStatus(lldb_private::Stream &strm) override;
 
   lldb_private::Status
   GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                   lldb_private::Process *process, lldb::ModuleSP &module_sp,

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.h

public:
 
   static const char *GetDescriptionStatic();
 
   // lldb_private::PluginInterface functions
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   lldb_private::Status
   GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                   lldb_private::Process *process, lldb::ModuleSP &module_sp,
                   const lldb_private::FileSpecList *module_search_paths_ptr,
                   llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules,
                   bool *did_create_ptr) override;
 
   const char *GetDescription() override { return GetDescriptionStatic(); }

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleBridge.h

public:
 
   static const char *GetDescriptionStatic();
 
   // lldb_private::PluginInterface functions
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
 
   const char *GetDescription() override { return GetDescriptionStatic(); }
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
 protected:
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLEBRIDGE_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h

public:
 
   static const char *GetDescriptionStatic();
 
   // lldb_private::PluginInterface functions
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
 
   const char *GetDescription() override { return GetDescriptionStatic(); }
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
 protected:
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLETV_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h

public:
 
   const char *GetDescription() override { return GetDescriptionStatic(); }
 
   // lldb_private::PluginInterface functions
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
 protected:
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLEWATCH_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteMacOSX.h

public:
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetDescriptionStatic();
 
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   const char *GetDescription() override { return GetDescriptionStatic(); }
 
   lldb_private::Status
   GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                   const lldb_private::UUID *uuid_ptr,
                   lldb_private::FileSpec &local_file) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

public:
 
   const char *GetDescription() override { return GetDescriptionStatic(); }
 
   // lldb_private::PluginInterface functions
   lldb_private::ConstString GetPluginName() override {
     return GetPluginNameStatic();
   }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
 protected:
   llvm::StringRef GetDeviceSupportDirectoryName() override;
   llvm::StringRef GetPlatformName() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEIOS_H

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

public:
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic(bool is_host);
 
   static const char *GetPluginDescriptionStatic(bool is_host);
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   const char *GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.h

public:
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic(bool is_host);
 
   static const char *GetPluginDescriptionStatic(bool is_host);
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   const char *GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   void GetStatus(Stream &strm) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

static lldb::PlatformSP CreateInstance(bool force,
                                          const lldb_private::ArchSpec *arch);
 
   static lldb_private::ConstString GetPluginNameStatic(bool is_host);
 
   static const char *GetPluginDescriptionStatic(bool is_host);
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   const char *GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
 
   lldb_private::Status DisconnectRemote() override;

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

public:
 
   PlatformRemoteGDBServer();
 
   ~PlatformRemoteGDBServer() override;
 
   // lldb_private::PluginInterface functions
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
 
-  uint32_t GetPluginVersion() override { return 1; }
-
   // lldb_private::Platform functions
   Status
   ResolveExecutable(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
                     const FileSpecList *module_search_paths_ptr) override;
 
   bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
                      ModuleSpec &module_spec) override;
 

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h

public:
 
   lldb::addr_t GetImageInfoAddress() override;
 
   lldb_private::DynamicLoader *GetDynamicLoader() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // Process Control
   lldb_private::Status WillResume() override;
 
   lldb_private::Status DoResume() override;
 
   lldb_private::Status DoHalt(bool &caused_stop) override;
 
   lldb_private::Status DoDetach(bool keep_stopped) override;

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

ProcessKDP::~ProcessKDP() {
   Finalize();
 }
 
 // PluginInterface
 lldb_private::ConstString ProcessKDP::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ProcessKDP::GetPluginVersion() { return 1; }
-
 Status ProcessKDP::WillLaunch(Module *module) {
   Status error;
   error.SetErrorString("launching not supported in kdp-remote plug-in");
   return error;
 }
 
 Status ProcessKDP::WillAttachToProcessWithID(lldb::pid_t pid) {
   Status error;

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h

public:
   ~ProcessWindows();
 
   size_t GetSTDOUT(char *buf, size_t buf_size, Status &error) override;
   size_t GetSTDERR(char *buf, size_t buf_size, Status &error) override;
   size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override;
 
   // lldb_private::Process overrides
   ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
 
   Status EnableBreakpointSite(BreakpointSite *bp_site) override;
   Status DisableBreakpointSite(BreakpointSite *bp_site) override;
 
   Status DoDetach(bool keep_stopped) override;
   Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
   Status DoAttachToProcessWithID(
       lldb::pid_t pid,

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

 }
 
 // ProcessInterface protocol.
 
 lldb_private::ConstString ProcessWindows::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ProcessWindows::GetPluginVersion() { return 1; }
-
 Status ProcessWindows::EnableBreakpointSite(BreakpointSite *bp_site) {
   if (bp_site->HardwareRequired())
     return Status("Hardware breakpoints are not supported.");
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_BREAKPOINTS);
   LLDB_LOG(log, "bp_site = {0:x}, id={1}, addr={2:x}", bp_site,
            bp_site->GetID(), bp_site->GetLoadAddress());
 

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

public:
   // Creating a new process, or attaching to an existing one
   lldb_private::Status DoLoadCore() override;
 
   lldb_private::DynamicLoader *GetDynamicLoader() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // Process Control
   lldb_private::Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;
 
   lldb_private::Status WillResume() override {
     lldb_private::Status error;
     error.SetErrorStringWithFormat(

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

ProcessElfCore::~ProcessElfCore() {
   // this class, then Process::~Process() might have problems trying to fully
   // destroy the broadcaster.
   Finalize();
 }
 
 // PluginInterface
 ConstString ProcessElfCore::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t ProcessElfCore::GetPluginVersion() { return 1; }
-
 lldb::addr_t ProcessElfCore::AddAddressRangeFromLoadSegment(
     const elf::ELFProgramHeader &header) {
   const lldb::addr_t addr = header.p_vaddr;
   FileRange file_range(header.p_offset, header.p_filesz);
   VMRangeToFileOffset::Entry range_entry(addr, header.p_memsz, file_range);
 
   // Only add to m_core_aranges if the file size is non zero. Some core files
   // have PT_LOAD segments for all address ranges, but set f_filesz to zero for

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
   DoAttachToProcessWithName(const char *process_name,
                             const ProcessAttachInfo &attach_info) override;
 
   void DidAttach(ArchSpec &process_arch) override;
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // Process Control
   Status WillResume() override;
 
   Status DoResume() override;
 
   Status DoHalt(bool &caused_stop) override;
 
   Status DoDetach(bool keep_stopped) override;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

ProcessGDBRemote::~ProcessGDBRemote() {
   // crash.  So kill it for sure here.
   StopAsyncThread();
   KillDebugserverProcess();
 }
 
 // PluginInterface
 ConstString ProcessGDBRemote::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t ProcessGDBRemote::GetPluginVersion() { return 1; }
-
 bool ProcessGDBRemote::ParsePythonTargetDefinition(
     const FileSpec &target_definition_fspec) {
   ScriptInterpreter *interpreter =
       GetTarget().GetDebugger().GetScriptInterpreter();
   Status error;
   StructuredData::ObjectSP module_object_sp(
       interpreter->LoadPluginModule(target_definition_fspec, error));
   if (module_object_sp) {

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

public:
   // Creating a new process, or attaching to an existing one
   lldb_private::Status DoLoadCore() override;
 
   lldb_private::DynamicLoader *GetDynamicLoader() override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // Process Control
   lldb_private::Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;
 
   // Process Queries
   bool IsAlive() override;
 

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

ProcessMachCore::~ProcessMachCore() {
   // this class, then Process::~Process() might have problems trying to fully
   // destroy the broadcaster.
   Finalize();
 }
 
 // PluginInterface
 ConstString ProcessMachCore::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t ProcessMachCore::GetPluginVersion() { return 1; }
-
 bool ProcessMachCore::GetDynamicLoaderAddress(lldb::addr_t addr) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER |
                                                   LIBLLDB_LOG_PROCESS));
   llvm::MachO::mach_header header;
   Status error;
   if (DoReadMemory(addr, &header, sizeof(header), error) != sizeof(header))
     return false;
   if (header.magic == llvm::MachO::MH_CIGAM ||

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

public:
   CommandObject *GetPluginCommandObject() override;
 
   Status DoLoadCore() override;
 
   DynamicLoader *GetDynamicLoader() override { return nullptr; }
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   SystemRuntime *GetSystemRuntime() override { return nullptr; }
 
   Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;
 
   bool IsAlive() override;
 

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

PlaceholderObjectFile(const lldb::ModuleSP &module_sp,
         m_base(base), m_size(size) {
     m_symtab_up = std::make_unique<Symtab>(this);
   }
 
   static ConstString GetStaticPluginName() {
     return ConstString("placeholder");
   }
   ConstString GetPluginName() override { return GetStaticPluginName(); }
-  uint32_t GetPluginVersion() override { return 1; }
   bool ParseHeader() override { return true; }
   Type CalculateType() override { return eTypeUnknown; }
   Strata CalculateStrata() override { return eStrataUnknown; }
   uint32_t GetDependentModules(FileSpecList &file_list) override { return 0; }
   bool IsExecutable() const override { return false; }
   ArchSpec GetArchitecture() override { return m_arch; }
   UUID GetUUID() override { return m_uuid; }
   Symtab *GetSymtab() override { return m_symtab_up.get(); }
Status ProcessMinidump::DoLoadCore() {
   }
   SetID(pid.getValue());
 
   return error;
 }
 
 ConstString ProcessMinidump::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
-
 Status ProcessMinidump::DoDestroy() { return Status(); }
 
 void ProcessMinidump::RefreshStateAfterStop() {
 
   if (!m_active_exception)
     return;
 
   constexpr uint32_t BreakpadDumpRequested = 0xFFFFFFFF;

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

public:
 
   bool CanDebug(lldb::TargetSP target_sp,
                 bool plugin_specified_by_name) override;
 
   DynamicLoader *GetDynamicLoader() override { return nullptr; }
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   SystemRuntime *GetSystemRuntime() override { return nullptr; }
 
   Status DoLoadCore() override;
 
   Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
 
   void DidLaunch() override;
 

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

 }
 
 void ScriptedProcess::Terminate() {
   PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance);
 }
 
 ConstString ScriptedProcess::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t ScriptedProcess::GetPluginVersion() { return 1; }
-
 Status ScriptedProcess::DoLoadCore() {
   ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
 
   return DoLaunch(nullptr, launch_info);
 }
 
 Status ScriptedProcess::DoLaunch(Module *exe_module,
                                  ProcessLaunchInfo &launch_info) {

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.h

public:
 
   static bool WatchpointCallbackFunction(void *baton,
                                          StoppointCallbackContext *context,
                                          lldb::user_id_t watch_id);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   Lua &GetLua();
 
   llvm::Error EnterSession(lldb::user_id_t debugger_id);
   llvm::Error LeaveSession();
 
   void CollectDataForBreakpointCommandCallback(
       std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
       CommandReturnObject &result) override;

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

 const char *ScriptInterpreterLua::GetPluginDescriptionStatic() {
   return "Lua script interpreter";
 }
 
 lldb_private::ConstString ScriptInterpreterLua::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ScriptInterpreterLua::GetPluginVersion() { return 1; }
-
 Lua &ScriptInterpreterLua::GetLua() { return *m_lua; }

lldb/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h

public:
   static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SCRIPTINTERPRETER_NONE_SCRIPTINTERPRETERNONE_H

lldb/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 
 const char *ScriptInterpreterNone::GetPluginDescriptionStatic() {
   return "Null script interpreter";
 }
 
 lldb_private::ConstString ScriptInterpreterNone::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t ScriptInterpreterNone::GetPluginVersion() { return 1; }

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

ScriptInterpreterPythonImpl::~ScriptInterpreterPythonImpl() {
   m_session_dict.Reset();
   PyGILState_Release(gil_state);
 }
 
 lldb_private::ConstString ScriptInterpreterPythonImpl::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t ScriptInterpreterPythonImpl::GetPluginVersion() { return 1; }
-
 void ScriptInterpreterPythonImpl::IOHandlerActivated(IOHandler &io_handler,
                                                      bool interactive) {
   const char *instructions = nullptr;
 
   switch (m_active_io_handler) {
   case eIOHandlerNone:
     break;
   case eIOHandlerBreakpoint:

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h

public:
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &data) override;
 
   static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   class Locker : public ScriptInterpreterLocker {
   public:
     enum OnEntry {
       AcquireLock = 0x0001,
       InitSession = 0x0002,
       InitGlobals = 0x0004,
       NoSTDIN = 0x0008
     };

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h

public:
   ///      True if DarwinLog support is/will be enabled for existing or
   ///      newly launched/attached processes.
   static bool IsEnabled();
 
   // PluginInterface API
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   // StructuredDataPlugin API
 
   bool SupportsStructuredDataType(ConstString type_name) override;
 
   void HandleArrivalOfStructuredData(
       Process &process, ConstString type_name,
       const StructuredData::ObjectSP &object_sp) override;
 

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 #pragma mark PluginInterface API
 
 // PluginInterface API
 
 ConstString StructuredDataDarwinLog::GetPluginName() {
   return GetStaticPluginName();
 }
 
-uint32_t StructuredDataDarwinLog::GetPluginVersion() { return 1; }
-
 #pragma mark -
 #pragma mark StructuredDataPlugin API
 
 // StructuredDataPlugin API
 
 bool StructuredDataDarwinLog::SupportsStructuredDataType(
     ConstString type_name) {
   return type_name == GetDarwinLogTypeName();

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
 
   llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) override;
 
   lldb::UnwindPlanSP
   GetUnwindPlan(const Address &address,
                 const RegisterInfoResolver &resolver) override;
 
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
-  uint32_t GetPluginVersion() override { return 1; }
 
 private:
   // A class representing a position in the breakpad file. Useful for
   // remembering the position so we can go back to it later and parse more data.
   // Can be converted to/from a LineIterator, but it has a much smaller memory
   // footprint.
   struct Bookmark {
     uint32_t section;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   void PreloadSymbols() override;
 
   std::recursive_mutex &GetModuleMutex() const override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   DWARFDebugAbbrev *DebugAbbrev();
 
   DWARFDebugInfo &DebugInfo();
 
   DWARFDebugRanges *GetDebugRanges();
 
   static bool SupportedVersion(uint16_t version);
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFileDWARF::ParseCallEdgesInFunction(UserID func_id) {
   if (func_die.IsValid())
     return CollectCallEdges(GetObjectFile()->GetModule(), func_die);
   return {};
 }
 
 // PluginInterface protocol
 ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }
-
 void SymbolFileDWARF::Dump(lldb_private::Stream &s) {
   SymbolFile::Dump(s);
   m_index->Dump(s);
 }
 
 void SymbolFileDWARF::DumpClangAST(Stream &s) {
   auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
   if (!ts_or_err)

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   std::vector<std::unique_ptr<lldb_private::CallEdge>>
   ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };
 
   friend class DebugMapModule;
   friend class DWARFASTParserClang;
   friend class DWARFCompileUnit;
   friend class SymbolFileDWARF;
   struct OSOInfo {

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

void SymbolFileDWARFDebugMap::DumpClangAST(Stream &s) {
   });
 }
 
 // PluginInterface protocol
 lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t SymbolFileDWARFDebugMap::GetPluginVersion() { return 1; }
-
 lldb::CompUnitSP
 SymbolFileDWARFDebugMap::GetCompileUnit(SymbolFileDWARF *oso_dwarf) {
   if (oso_dwarf) {
     const uint32_t cu_count = GetNumCompileUnits();
     for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) {
       SymbolFileDWARF *oso_symfile =
           GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
       if (oso_symfile == oso_dwarf) {

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext &parent_decl_ctx) override;
 
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   llvm::pdb::PDBFile &GetPDBFile() { return m_index->pdb(); }
   const llvm::pdb::PDBFile &GetPDBFile() const { return m_index->pdb(); }
 
   void DumpClangAST(Stream &s) override;
 
 private:
   uint32_t CalculateNumCompileUnits() override;
 

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   }
   return type_system_or_err;
 }
 
 ConstString SymbolFileNativePDB::GetPluginName() {
   static ConstString g_name("pdb");
   return g_name;
 }
-
-uint32_t SymbolFileNativePDB::GetPluginVersion() { return 1; }

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       lldb_private::ConstString name,
       const lldb_private::CompilerDeclContext &parent_decl_ctx) override;
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   llvm::pdb::IPDBSession &GetPDBSession();
 
   const llvm::pdb::IPDBSession &GetPDBSession() const;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
 private:
   struct SecContribInfo {

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

SymbolFilePDB::FindNamespace(lldb_private::ConstString name,
   return clang_type_system->CreateDeclContext(namespace_decl);
 }
 
 lldb_private::ConstString SymbolFilePDB::GetPluginName() {
   static ConstString g_name("pdb");
   return g_name;
 }
 
-uint32_t SymbolFilePDB::GetPluginVersion() { return 1; }
-
 IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; }
 
 const IPDBSession &SymbolFilePDB::GetPDBSession() const {
   return *m_session_up;
 }
 
 lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
                                                        uint32_t index) {

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
 
   void GetTypes(lldb_private::SymbolContextScope *sc_scope,
                 lldb::TypeClass type_mask,
                 lldb_private::TypeList &type_list) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   uint32_t CalculateNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   typedef std::map<lldb_private::ConstString, lldb::TypeSP> TypeMap;
 
   lldb_private::Symtab::IndexCollection m_source_indexes;
   lldb_private::Symtab::IndexCollection m_func_indexes;
   lldb_private::Symtab::IndexCollection m_code_indexes;
   lldb_private::Symtab::IndexCollection m_data_indexes;
   lldb_private::Symtab::NameToIndexMap m_objc_class_name_to_index;
   TypeMap m_objc_class_types;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_SYMTAB_SYMBOLFILESYMTAB_H

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
   }
   return resolved_flags;
 }
 
 // PluginInterface protocol
 lldb_private::ConstString SymbolFileSymtab::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; }

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.h

public:
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolVendor *
   CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_ELF_SYMBOLVENDORELF_H

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
   }
 
   symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
   return symbol_vendor;
 }
 
 // PluginInterface protocol
 ConstString SymbolVendorELF::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t SymbolVendorELF::GetPluginVersion() { return 1; }

lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h

public:
   CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
 
   // Constructors and Destructors
   SymbolVendorMacOSX(const lldb::ModuleSP &module_sp);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_MACOSX_SYMBOLVENDORMACOSX_H

lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

SymbolVendorMacOSX::CreateInstance(const lldb::ModuleSP &module_sp,
   }
   return symbol_vendor;
 }
 
 // PluginInterface protocol
 ConstString SymbolVendorMacOSX::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t SymbolVendorMacOSX::GetPluginVersion() { return 1; }

lldb/source/Plugins/SymbolVendor/wasm/SymbolVendorWasm.h

public:
 
   static lldb_private::SymbolVendor *
   CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
 
   /// PluginInterface protocol.
   /// \{
   lldb_private::ConstString GetPluginName() override;
-  uint32_t GetPluginVersion() override;
   /// \}
 };
 
 } // namespace wasm
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_WASM_SYMBOLVENDORWASM_H

lldb/source/Plugins/SymbolVendor/wasm/SymbolVendorWasm.cpp

SymbolVendorWasm::CreateInstance(const lldb::ModuleSP &module_sp,
   }
 
   symbol_vendor->AddSymbolFileRepresentation(sym_objfile_sp);
   return symbol_vendor;
 }
 
 // PluginInterface protocol
 ConstString SymbolVendorWasm::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t SymbolVendorWasm::GetPluginVersion() { return 1; }

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

public:
   void AddThreadExtendedInfoPacketHints(
       lldb_private::StructuredData::ObjectSP dict) override;
 
   bool SafeToCallFunctionsOnThisThread(lldb::ThreadSP thread_sp) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 protected:
   lldb::user_id_t m_break_id;
   mutable std::recursive_mutex m_mutex;
 
 private:
   struct libBacktraceRecording_info {
     uint16_t queue_info_version = 0;
     uint16_t queue_info_data_offset = 0;

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 const char *SystemRuntimeMacOSX::GetPluginDescriptionStatic() {
   return "System runtime plugin for Mac OS X native libraries.";
 }
 
 // PluginInterface protocol
 lldb_private::ConstString SystemRuntimeMacOSX::GetPluginName() {
   return GetPluginNameStatic();
 }
-
-uint32_t SystemRuntimeMacOSX::GetPluginVersion() { return 1; }

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

public:
   CreateInstanceForSessionFile(const llvm::json::Value &trace_session_file,
                                llvm::StringRef session_file_dir,
                                Debugger &debugger);
 
   static llvm::Expected<lldb::TraceSP>
   CreateInstanceForLiveProcess(Process &process);
 
   static ConstString GetPluginNameStatic();
-
-  uint32_t GetPluginVersion() override;
   /// \}
 
   lldb::CommandObjectSP
   GetProcessTraceStartCommand(CommandInterpreter &interpreter) override;
 
   lldb::CommandObjectSP
   GetThreadTraceStartCommand(CommandInterpreter &interpreter) override;
 

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

 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 
 ConstString TraceIntelPT::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t TraceIntelPT::GetPluginVersion() { return 1; }
-
 void TraceIntelPT::Dump(Stream *s) const {}
 
 llvm::Error TraceIntelPT::SaveLiveTraceToDisk(FileSpec directory) {
   RefreshLiveProcessState();
   return TraceIntelPTSessionSaver().SaveToDisk(*this, directory);
 }
 
 Expected<TraceSP> TraceIntelPT::CreateInstanceForSessionFile(

lldb/source/Plugins/TraceExporter/ctf/TraceExporterCTF.h

public:
 
   ConstString GetPluginName() override;
 
   static void Initialize();
 
   static void Terminate();
 
   static ConstString GetPluginNameStatic();
-
-  uint32_t GetPluginVersion() override;
   /// \}
 };
 
 } // namespace ctf
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_EXPORTER_CTF_H

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

 
 ConstString TraceExporterCTF::GetPluginNameStatic() {
   static ConstString g_name("ctf");
   return g_name;
 }
 
 ConstString TraceExporterCTF::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t TraceExporterCTF::GetPluginVersion() { return 1; }
-
 Expected<TraceExporterUP> TraceExporterCTF::CreateInstance() {
   return std::make_unique<TraceExporterCTF>();
 }

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

public:
 
   ~TypeSystemClang() override;
 
   void Finalize() override;
 
   // PluginInterface functions
   ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
   static ConstString GetPluginNameStatic();
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Module *module, Target *target);
 
   static LanguageSet GetSupportedLanguagesForTypes();
   static LanguageSet GetSupportedLanguagesForExpressions();
 

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 ConstString TypeSystemClang::GetPluginNameStatic() {
   return ConstString("clang");
 }
 
 ConstString TypeSystemClang::GetPluginName() {
   return TypeSystemClang::GetPluginNameStatic();
 }
 
-uint32_t TypeSystemClang::GetPluginVersion() { return 1; }
-
 lldb::TypeSystemSP TypeSystemClang::CreateInstance(lldb::LanguageType language,
                                                    lldb_private::Module *module,
                                                    Target *target) {
   if (!TypeSystemClangSupportsLanguage(language))
     return lldb::TypeSystemSP();
   ArchSpec arch;
   if (module)
     arch = module->GetArchitecture();

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

public:
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 private:
   // Call CreateInstance to get an instance of this class
   UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch,
                               lldb_private::EmulateInstruction *inst_emulator)
       : UnwindAssembly(arch), m_inst_emulator_up(inst_emulator),
         m_range_ptr(nullptr), m_unwind_plan_ptr(nullptr), m_curr_row(),
         m_cfa_reg_info(), m_fp_is_cfa(false), m_register_values(),
         m_pushed_regs(), m_curr_row_modified(false),

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

UnwindAssemblyInstEmulation::CreateInstance(const ArchSpec &arch) {
   return nullptr;
 }
 
 // PluginInterface protocol in UnwindAssemblyParser_x86
 ConstString UnwindAssemblyInstEmulation::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t UnwindAssemblyInstEmulation::GetPluginVersion() { return 1; }
-
 void UnwindAssemblyInstEmulation::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }
 
 void UnwindAssemblyInstEmulation::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }

lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h

public:
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   lldb_private::ConstString GetPluginName() override;
 
-  uint32_t GetPluginVersion() override;
-
 private:
   UnwindAssembly_x86(const lldb_private::ArchSpec &arch);
 
   lldb_private::ArchSpec m_arch;
 
   lldb_private::x86AssemblyInspectionEngine *m_assembly_inspection_engine;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_X86_UNWINDASSEMBLY_X86_H

lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp

 }
 
 // PluginInterface protocol in UnwindAssemblyParser_x86
 
 ConstString UnwindAssembly_x86::GetPluginName() {
   return GetPluginNameStatic();
 }
 
-uint32_t UnwindAssembly_x86::GetPluginVersion() { return 1; }
-
 void UnwindAssembly_x86::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }
 
 void UnwindAssembly_x86::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }

lldb/source/Symbol/SymbolVendor.cpp

void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
   }
 }
 
 // PluginInterface protocol
 lldb_private::ConstString SymbolVendor::GetPluginName() {
   static ConstString g_name("vendor-default");
   return g_name;
 }
-
-uint32_t SymbolVendor::GetPluginVersion() { return 1; }

lldb/source/Target/ProcessTrace.cpp

ProcessTrace::~ProcessTrace() {
   // make sure all of the broadcaster cleanup goes as planned. If we destruct
   // this class, then Process::~Process() might have problems trying to fully
   // destroy the broadcaster.
   Finalize();
 }
 
 ConstString ProcessTrace::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t ProcessTrace::GetPluginVersion() { return 1; }
-
 void ProcessTrace::DidAttach(ArchSpec &process_arch) {
   ListenerSP listener_sp(
       Listener::MakeListener("lldb.process_trace.did_attach_listener"));
   HijackProcessEvents(listener_sp);
 
   SetCanJIT(false);
   StartPrivateStateThread();
   SetPrivateState(eStateStopped);

lldb/unittests/Expression/DWARFExpressionTest.cpp

 }
 
 TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit0, DW_OP_deref}), llvm::Failed());
 
   struct MockProcess : Process {
     using Process::Process;
     ConstString GetPluginName() override { return ConstString("mock process"); }
-    uint32_t GetPluginVersion() override { return 0; }
     bool CanDebug(lldb::TargetSP target,
                   bool plugin_specified_by_name) override {
       return false;
     };
     Status DoDestroy() override { return {}; }
     void RefreshStateAfterStop() override {}
     bool DoUpdateThreadList(ThreadList &old_thread_list,
                             ThreadList &new_thread_list) override {

lldb/unittests/Process/ProcessEventDataTest.cpp

size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
                       Status &error) override {
     return 0;
   }
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override {
     return false;
   }
   ConstString GetPluginName() override { return ConstString("Dummy"); }
-  uint32_t GetPluginVersion() override { return 0; }
 
   ProcessModID &GetModIDNonConstRef() { return m_mod_id; }
 };
 
 class DummyThread : public Thread {
 public:
   using Thread::Thread;
 

lldb/unittests/Target/ExecutionContextTest.cpp

size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
                       Status &error) override {
     return 0;
   }
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override {
     return false;
   }
   ConstString GetPluginName() override { return ConstString("Dummy"); }
-  uint32_t GetPluginVersion() override { return 0; }
 };
 } // namespace
 
 TEST_F(ExecutionContextTest, GetByteOrder) {
   ExecutionContext exe_ctx(nullptr, nullptr, nullptr);
   EXPECT_EQ(endian::InlHostByteOrder(), exe_ctx.GetByteOrder());
 }
 

lldb/unittests/Target/RemoteAwarePlatformTest.cpp

 using namespace lldb;
 using namespace testing;
 
 class RemoteAwarePlatformTester : public RemoteAwarePlatform {
 public:
   using RemoteAwarePlatform::RemoteAwarePlatform;
 
   MOCK_METHOD0(GetDescription, const char *());
-  MOCK_METHOD0(GetPluginVersion, uint32_t());
   MOCK_METHOD0(GetPluginName, ConstString());
   MOCK_METHOD2(GetSupportedArchitectureAtIndex, bool(uint32_t, ArchSpec &));
   MOCK_METHOD4(Attach,
                ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
   MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
 
   void SetRemotePlatform(lldb::PlatformSP platform) {
     m_remote_platform_sp = platform;
   }
 };
 
 class TargetPlatformTester : public Platform {
 public:
   using Platform::Platform;
 
   MOCK_METHOD0(GetDescription, const char *());
-  MOCK_METHOD0(GetPluginVersion, uint32_t());
   MOCK_METHOD0(GetPluginName, ConstString());
   MOCK_METHOD2(GetSupportedArchitectureAtIndex, bool(uint32_t, ArchSpec &));
   MOCK_METHOD4(Attach,
                ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
   MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
   MOCK_METHOD0(GetUserIDResolver, UserIDResolver &());
 
   MOCK_METHOD2(ResolveExecutable,

lldb/unittests/Thread/ThreadTest.cpp

size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
                       Status &error) override {
     return 0;
   }
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override {
     return false;
   }
   ConstString GetPluginName() override { return ConstString("Dummy"); }
-  uint32_t GetPluginVersion() override { return 0; }
 
   ProcessModID &GetModIDNonConstRef() { return m_mod_id; }
 };
 
 class DummyThread : public Thread {
 public:
   using Thread::Thread;