[lldb][NFC] Remove misleading ModulePass base class for IRForTarget

[teemperor]

Summary

IRForTarget is never used by a pass manager or any other interface that requires this class to inherit from Pass.

Also IRForTarget doesn't implement the current interface correctly because it uses the runOnModule return value to indicate success/failure instead of changed/not-changed, so if this ever ends up being used as a pass it would most likely not work as intended.

[JDevlieghere]

LGTM

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h

 //===-- IRForTarget.h ---------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRFORTARGET_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRFORTARGET_H
 
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-public.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/Pass.h"
 

 /// Once an expression has been parsed and converted to IR, it can run in two
 /// contexts: interpreted by LLDB as a DWARF location expression, or compiled
 /// by the JIT and inserted into the target process for execution.
 ///
 /// IRForTarget makes the second possible, by applying a series of
 /// transformations to the IR which make it relocatable.  These
 /// transformations are discussed in more detail next to their relevant
 /// functions.
-class IRForTarget : public llvm::ModulePass {
+class IRForTarget {
 public:
   enum class LookupResult { Success, Fail, Ignore };
 
   /// Constructor
   ///
   /// \param[in] decl_map
   ///     The list of externally-referenced variables for the expression,
   ///     for use in looking up globals and allocating the argument
public:
   ///
   /// \param[in] func_name
   ///     The name of the function to prepare for execution in the target.
   IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map, bool resolve_vars,
               lldb_private::IRExecutionUnit &execution_unit,
               lldb_private::Stream &error_stream,
               const char *func_name = "$__lldb_expr");
 
-  /// Destructor
-  ~IRForTarget() override;
-
   /// Run this IR transformer on a single module
   ///
   /// Implementation of the llvm::ModulePass::runOnModule() function.
   ///
   /// \param[in] llvm_module
   ///     The module to run on.  This module is searched for the function
   ///     $__lldb_expr, and that function is passed to the passes one by
   ///     one.
   ///
   /// \return
   ///     True on success; false otherwise
-  bool runOnModule(llvm::Module &llvm_module) override;
-
-  /// Interface stub
-  ///
-  /// Implementation of the llvm::ModulePass::assignPassManager() function.
-  void assignPassManager(llvm::PMStack &pass_mgr_stack,
-                         llvm::PassManagerType pass_mgr_type =
-                             llvm::PMT_ModulePassManager) override;
-
-  /// Returns PMT_ModulePassManager
-  ///
-  /// Implementation of the llvm::ModulePass::getPotentialPassManagerType()
-  /// function.
-  llvm::PassManagerType getPotentialPassManagerType() const override;
+  bool runOnModule(llvm::Module &llvm_module);
 
 private:
   /// Ensures that the current function's linkage is set to external.
   /// Otherwise the JIT may not return an address for it.
   ///
   /// \param[in] llvm_function
   ///     The function whose linkage is to be fixed.
   ///

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <map>
 
 using namespace llvm;
 
-static char ID;
-
 typedef SmallVector<Instruction *, 2> InstrList;
 
 IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker)
     : m_maker(maker), m_values() {}
 
 IRForTarget::FunctionValueCache::~FunctionValueCache() {}
 
 llvm::Value *
static llvm::Value *FindEntryInstruction(llvm::Function *function) {
   return function->getEntryBlock().getFirstNonPHIOrDbg();
 }
 
 IRForTarget::IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map,
                          bool resolve_vars,
                          lldb_private::IRExecutionUnit &execution_unit,
                          lldb_private::Stream &error_stream,
                          const char *func_name)
-    : ModulePass(ID), m_resolve_vars(resolve_vars), m_func_name(func_name),
+    : m_resolve_vars(resolve_vars), m_func_name(func_name),
       m_decl_map(decl_map), m_error_stream(error_stream),
       m_execution_unit(execution_unit),
       m_entry_instruction_finder(FindEntryInstruction) {}
 
 /* Handy utility functions used at several places in the code */
 
 static std::string PrintValue(const Value *value, bool truncate = false) {
   std::string s;
static std::string PrintType(const llvm::Type *type, bool truncate = false) {
   raw_string_ostream rso(s);
   type->print(rso);
   rso.flush();
   if (truncate)
     s.resize(s.length() - 1);
   return s;
 }
 
-IRForTarget::~IRForTarget() {}
-
 bool IRForTarget::FixFunctionLinkage(llvm::Function &llvm_function) {
   llvm_function.setLinkage(GlobalValue::ExternalLinkage);
 
   return true;
 }
 
 clang::NamedDecl *IRForTarget::DeclForGlobal(const GlobalValue *global_val,
                                              Module *module) {
if (log && log->GetVerbose()) {
 
     oss.flush();
 
     LLDB_LOG(log, "Module after preparing for execution: \n\"{0}\"", s);
   }
 
   return true;
 }
-
-void IRForTarget::assignPassManager(PMStack &pass_mgr_stack,
-                                    PassManagerType pass_mgr_type) {}
-
-PassManagerType IRForTarget::getPotentialPassManagerType() const {
-  return PMT_ModulePassManager;
-}