[LLVM] Fix some Clang-tidy modernize-use-default, modernize-use-equals-delete and Include What You Use warnings in ExecutionEngine; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[mehdi_amini]

LGTM.
Thanks.

llvm/trunk/include/llvm/ExecutionEngine/JITEventListener.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H
 #define LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H
 
 #include "RuntimeDyld.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DebugLoc.h"
-#include "llvm/Support/DataTypes.h"
+#include <cstdint>
 #include <vector>
 
 namespace llvm {
-class Function;
+
+class IntelJITEventsWrapper;
 class MachineFunction;
 class OProfileWrapper;
-class IntelJITEventsWrapper;
 
 namespace object {
   class ObjectFile;
-}
+} // end namespace object
 
 /// JITEvent_EmittedFunctionDetails - Helper struct for containing information
 /// about a generated machine code function.
 struct JITEvent_EmittedFunctionDetails {
   struct LineStart {
     /// The address at which the current line changes.
     uintptr_t Address;
 

 /// profilers and debuggers that need to know where functions have been emitted.
 ///
 /// The default implementation of each method does nothing.
 class JITEventListener {
 public:
   typedef JITEvent_EmittedFunctionDetails EmittedFunctionDetails;
 
 public:
-  JITEventListener() {}
-  virtual ~JITEventListener() {}
+  JITEventListener() = default;
+  virtual ~JITEventListener() = default;
 
   /// NotifyObjectEmitted - Called after an object has been successfully
   /// emitted to memory.  NotifyFunctionEmitted will not be called for
   /// individual functions in the object.
   ///
   /// ELF-specific information
   /// The ObjectImage contains the generated object image
   /// with section headers updated to reflect the address at which sections

 #if LLVM_USE_OPROFILE
   // Construct an OProfileJITEventListener
   static JITEventListener *createOProfileJITEventListener();
 
   // Construct an OProfileJITEventListener with a test opagent implementation
   static JITEventListener *createOProfileJITEventListener(
                                       OProfileWrapper* AlternativeImpl);
 #else
-
   static JITEventListener *createOProfileJITEventListener() { return nullptr; }
 
   static JITEventListener *createOProfileJITEventListener(
                                       OProfileWrapper* AlternativeImpl) {
     return nullptr;
   }
 #endif // USE_OPROFILE
+
 private:
   virtual void anchor();
 };
 
-} // end namespace llvm.
+} // end namespace llvm
 
-#endif // defined LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H
+#endif // LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H

llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h

 //===----------- JITSymbol.h - JIT symbol abstraction -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Abstraction for target process addresses.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_JITSYMBOL_H
 #define LLVM_EXECUTIONENGINE_JITSYMBOL_H
 
-#include "llvm/Support/DataTypes.h"
-#include <string>
+#include <algorithm>
 #include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <functional>
+#include <string>
 
 namespace llvm {
 
 class GlobalValue;
 
 namespace object {
   class BasicSymbolRef;
-}
+} // end namespace object
 
 /// @brief Represents an address in the target process's address space.
 typedef uint64_t JITTargetAddress;
 
 /// @brief Flags for symbols in the JIT.
 class JITSymbolFlags {
 public:
-
   typedef uint8_t UnderlyingType;
 
   enum FlagNames : UnderlyingType {
     None = 0,
     Weak = 1U << 0,
     Common = 1U << 1,
     Absolute = 1U << 2,
     Exported = 1U << 3

 
 private:
   UnderlyingType Flags;
 };
 
 /// @brief Represents a symbol that has been evaluated to an address already.
 class JITEvaluatedSymbol {
 public:
-
   /// @brief Create a 'null' symbol.
   JITEvaluatedSymbol(std::nullptr_t)
       : Address(0) {}
 
   /// @brief Create a symbol for the given address and flags.
   JITEvaluatedSymbol(JITTargetAddress Address, JITSymbolFlags Flags)
       : Address(Address), Flags(Flags) {}
 

 private:
   JITTargetAddress Address;
   JITSymbolFlags Flags;
 };
 
 /// @brief Represents a symbol in the JIT.
 class JITSymbol {
 public:
-
   typedef std::function<JITTargetAddress()> GetAddressFtor;
 
   /// @brief Create a 'null' symbol that represents failure to find a symbol
   ///        definition.
   JITSymbol(std::nullptr_t)
       : CachedAddr(0) {}
 
   /// @brief Create a symbol for a definition with a known address.
private:
   GetAddressFtor GetAddress;
   JITTargetAddress CachedAddr;
   JITSymbolFlags Flags;
 };
 
 /// \brief Symbol resolution.
 class JITSymbolResolver {
 public:
-  virtual ~JITSymbolResolver() {}
+  virtual ~JITSymbolResolver() = default;
 
   /// This method returns the address of the specified symbol if it exists
   /// within the logical dynamic library represented by this JITSymbolResolver.
   /// Unlike findSymbol, queries through this interface should return addresses
   /// for hidden symbols.
   ///
   /// This is of particular importance for the Orc JIT APIs, which support lazy
   /// compilation by breaking up modules: Each of those broken out modules
public:
   /// skip all relocations for that symbol, and the client will be responsible
   /// for handling them manually.
   virtual JITSymbol findSymbol(const std::string &Name) = 0;
 
 private:
   virtual void anchor();
 };
 
-} // End namespace llvm.
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITSYMBOL_H

llvm/trunk/include/llvm/ExecutionEngine/ObjectCache.h

-//===-- ObjectCache.h - Class definition for the ObjectCache -----C++ -*-===//
+//===-- ObjectCache.h - Class definition for the ObjectCache ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_OBJECTCACHE_H
 #define LLVM_EXECUTIONENGINE_OBJECTCACHE_H
 
 #include "llvm/Support/MemoryBuffer.h"
+#include <memory>
 
 namespace llvm {
 
 class Module;
 
 /// This is the base ObjectCache type which can be provided to an
 /// ExecutionEngine for the purpose of avoiding compilation for Modules that
 /// have already been compiled and an object file is available.
 class ObjectCache {
   virtual void anchor();
+
 public:
-  ObjectCache() { }
+  ObjectCache() = default;
 
-  virtual ~ObjectCache() { }
+  virtual ~ObjectCache() = default;
 
   /// notifyObjectCompiled - Provides a pointer to compiled code for Module M.
   virtual void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) = 0;
 
   /// Returns a pointer to a newly allocated MemoryBuffer that contains the
   /// object which corresponds with Module M, or 0 if an object is not
   /// available.
   virtual std::unique_ptr<MemoryBuffer> getObject(const Module* M) = 0;
 };
 
-}
+} // end namespace llvm
 
-#endif
+#endif // LLVM_EXECUTIONENGINE_OBJECTCACHE_H

llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

 // JIT layer for breaking up modules and inserting callbacks to allow
 // individual functions to be compiled on demand.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_COMPILEONDEMANDLAYER_H
 #define LLVM_EXECUTIONENGINE_ORC_COMPILEONDEMANDLAYER_H
 
-#include "IndirectionUtils.h"
-#include "LambdaResolver.h"
+#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
+#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Mangler.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <iterator>
 #include <list>
 #include <memory>
 #include <set>
+#include <string>
 #include <utility>
+#include <vector>
 
 namespace llvm {
 namespace orc {
 
 /// @brief Compile-on-demand layer.
 ///
 ///   When a module is added to this layer a stub is created for each of its
 /// function definitions. The stubs and other global values are immediately
 /// added to the layer below. When a stub is called it triggers the extraction
 /// of the function body from the original module. The extracted body is then
 /// compiled and executed.
 template <typename BaseLayerT,
           typename CompileCallbackMgrT = JITCompileCallbackManager,
           typename IndirectStubsMgrT = IndirectStubsManager>
 class CompileOnDemandLayer {
 private:
-
   template <typename MaterializerFtor>
   class LambdaMaterializer final : public ValueMaterializer {
   public:
     LambdaMaterializer(MaterializerFtor M) : M(std::move(M)) {}
+
     Value *materialize(Value *V) final { return M(V); }
 
   private:
     MaterializerFtor M;
   };
 
   template <typename MaterializerFtor>
   LambdaMaterializer<MaterializerFtor>
   createLambdaMaterializer(MaterializerFtor M) {
     return LambdaMaterializer<MaterializerFtor>(std::move(M));
   }
 
   typedef typename BaseLayerT::ModuleSetHandleT BaseLayerModuleSetHandleT;
 
   // Provide type-erasure for the Modules and MemoryManagers.
   template <typename ResourceT>
   class ResourceOwner {
   public:
     ResourceOwner() = default;
     ResourceOwner(const ResourceOwner&) = delete;
     ResourceOwner& operator=(const ResourceOwner&) = delete;
-    virtual ~ResourceOwner() { }
+    virtual ~ResourceOwner() = default;
+
     virtual ResourceT& getResource() const = 0;
   };
 
   template <typename ResourceT, typename ResourcePtrT>
   class ResourceOwnerImpl : public ResourceOwner<ResourceT> {
   public:
     ResourceOwnerImpl(ResourcePtrT ResourcePtr)
       : ResourcePtr(std::move(ResourcePtr)) {}
+
     ResourceT& getResource() const override { return *ResourcePtr; }
+
   private:
     ResourcePtrT ResourcePtr;
   };
 
   template <typename ResourceT, typename ResourcePtrT>
   std::unique_ptr<ResourceOwner<ResourceT>>
   wrapOwnership(ResourcePtrT ResourcePtr) {
     typedef ResourceOwnerImpl<ResourceT, ResourcePtrT> RO;
struct LogicalDylib {
     ModuleAdderFtor ModuleAdder;
     SourceModulesList SourceModules;
     std::vector<BaseLayerModuleSetHandleT> BaseLayerHandles;
   };
 
   typedef std::list<LogicalDylib> LogicalDylibList;
 
 public:
-
   /// @brief Handle to a set of loaded modules.
   typedef typename LogicalDylibList::iterator ModuleSetHandleT;
 
   /// @brief Module partitioning functor.
   typedef std::function<std::set<Function*>(Function&)> PartitioningFtor;
 
   /// @brief Builder for IndirectStubsManagers.
   typedef std::function<std::unique_ptr<IndirectStubsMgrT>()>
public:
   // FIXME: Return Error once the JIT APIs are Errorized.
   bool updatePointer(std::string FuncName, JITTargetAddress FnBodyAddr) {
     //Find out which logical dylib contains our symbol
     auto LDI = LogicalDylibs.begin();
     for (auto LDE = LogicalDylibs.end(); LDI != LDE; ++LDI) {
       if (auto LMResources = LDI->getLogicalModuleResourcesForSymbol(FuncName, false)) {
         Module &SrcM = LMResources->SourceModule->getResource();
         std::string CalledFnName = mangle(FuncName, SrcM.getDataLayout());
-        if (auto EC = LMResources->StubsMgr->updatePointer(CalledFnName, FnBodyAddr)) {
+        if (auto EC = LMResources->StubsMgr->updatePointer(CalledFnName, FnBodyAddr))
           return false;
-        }
         else
           return true;
       }
     }
     return false;
   }
 
 private:
-
   template <typename ModulePtrT>
   void addLogicalModule(LogicalDylib &LD, ModulePtrT SrcMPtr) {
 
     // Rename all static functions / globals to $static.X :
     // This will unique the names across all modules in the logical dylib,
     // simplifying symbol lookup.
     LD.StaticRenamer.rename(*SrcMPtr);
 
private:
   PartitioningFtor Partition;
   CompileCallbackMgrT &CompileCallbackMgr;
   IndirectStubsManagerBuilderT CreateIndirectStubsManager;
 
   LogicalDylibList LogicalDylibs;
   bool CloneStubsIntoPartitions;
 };
 
-} // End namespace orc.
-} // End namespace llvm.
+} // end namespace orc
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEONDEMANDLAYER_H

llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

 //===-- IndirectionUtils.h - Utilities for adding indirections --*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Contains utilities for adding indirections and breaking up modules.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H
 #define LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H
 
-#include "LambdaResolver.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Memory.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <system_error>
+#include <utility>
+#include <vector>
 
 namespace llvm {
 namespace orc {
 
 /// @brief Target-independent base class for compile callback management.
 class JITCompileCallbackManager {
 public:
   typedef std::function<JITTargetAddress()> CompileFtor;
public:
   };
 
   /// @brief Construct a JITCompileCallbackManager.
   /// @param ErrorHandlerAddress The address of an error handler in the target
   ///                            process to be used if a compile callback fails.
   JITCompileCallbackManager(JITTargetAddress ErrorHandlerAddress)
       : ErrorHandlerAddress(ErrorHandlerAddress) {}
 
-  virtual ~JITCompileCallbackManager() {}
+  virtual ~JITCompileCallbackManager() = default;
 
   /// @brief Execute the callback for the given trampoline id. Called by the JIT
   ///        to compile functions on demand.
   JITTargetAddress executeCompileCallback(JITTargetAddress TrampolineAddr) {
     auto I = ActiveTrampolines.find(TrampolineAddr);
     // FIXME: Also raise an error in the Orc error-handler when we finally have
     //        one.
     if (I == ActiveTrampolines.end())

 };
 
 /// @brief Base class for managing collections of named indirect stubs.
 class IndirectStubsManager {
 public:
   /// @brief Map type for initializing the manager. See init.
   typedef StringMap<std::pair<JITTargetAddress, JITSymbolFlags>> StubInitsMap;
 
-  virtual ~IndirectStubsManager() {}
+  virtual ~IndirectStubsManager() = default;
 
   /// @brief Create a single stub with the given name, target address and flags.
   virtual Error createStub(StringRef StubName, JITTargetAddress StubAddr,
                            JITSymbolFlags StubFlags) = 0;
 
   /// @brief Create StubInits.size() stubs with the given names, target
   ///        addresses, and flags.
   virtual Error createStubs(const StubInitsMap &StubInits) = 0;

 /// @brief Clone a global alias declaration into a new module.
 GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
                                   ValueToValueMapTy &VMap);
 
 /// @brief Clone module flags metadata into the destination module.
 void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
                               ValueToValueMapTy &VMap);
 
-} // End namespace orc.
-} // End namespace llvm.
+} // end namespace orc
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H

llvm/trunk/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h

 //===- LazyEmittingLayer.h - Lazily emit IR to lower JIT layers -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Contains the definition for a lazy-emitting layer for the JIT.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H
 #define LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H
 
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
 #include <list>
+#include <memory>
+#include <string>
 
 namespace llvm {
 namespace orc {
 
 /// @brief Lazy-emitting IR layer.
 ///
 ///   This layer accepts sets of LLVM IR Modules (via addModuleSet), but does
 /// not immediately emit them the layer below. Instead, emissing to the base
 /// layer is deferred until the first time the client requests the address
 /// (via JITSymbol::getAddress) for a symbol contained in this layer.
 template <typename BaseLayerT> class LazyEmittingLayer {
 public:
   typedef typename BaseLayerT::ModuleSetHandleT BaseLayerHandleT;
 
 private:
   class EmissionDeferredSet {
   public:
-    EmissionDeferredSet() : EmitState(NotEmitted) {}
-    virtual ~EmissionDeferredSet() {}
+    EmissionDeferredSet() = default;
+    virtual ~EmissionDeferredSet() = default;
 
     JITSymbol find(StringRef Name, bool ExportedSymbolsOnly, BaseLayerT &B) {
       switch (EmitState) {
       case NotEmitted:
         if (auto GV = searchGVs(Name, ExportedSymbolsOnly)) {
           // Create a std::string version of Name to capture here - the argument
           // (a StringRef) may go away before the lambda is executed.
           // FIXME: Use capture-init when we move to C++14.
create(BaseLayerT &B, ModuleSetT Ms, MemoryManagerPtrT MemMgr,
            SymbolResolverPtrT Resolver);
 
   protected:
     virtual const GlobalValue* searchGVs(StringRef Name,
                                          bool ExportedSymbolsOnly) const = 0;
     virtual BaseLayerHandleT emitToBaseLayer(BaseLayerT &BaseLayer) = 0;
 
   private:
-    enum { NotEmitted, Emitting, Emitted } EmitState;
+    enum { NotEmitted, Emitting, Emitted } EmitState = NotEmitted;
     BaseLayerHandleT Handle;
   };
 
   template <typename ModuleSetT, typename MemoryManagerPtrT,
             typename SymbolResolverPtrT>
   class EmissionDeferredSetImpl : public EmissionDeferredSet {
   public:
     EmissionDeferredSetImpl(ModuleSetT Ms,
                             MemoryManagerPtrT MemMgr,
                             SymbolResolverPtrT Resolver)
         : Ms(std::move(Ms)), MemMgr(std::move(MemMgr)),
           Resolver(std::move(Resolver)) {}
 
   protected:
-
     const GlobalValue* searchGVs(StringRef Name,
                                  bool ExportedSymbolsOnly) const override {
       // FIXME: We could clean all this up if we had a way to reliably demangle
       //        names: We could just demangle name and search, rather than
       //        mangling everything else.
 
       // If we have already built the mangled name set then just search it.
       if (MangledSymbols) {
public:
   }
 
   /// @brief Immediately emit and finalize the moduleOB set represented by the
   ///        given handle.
   /// @param H Handle for module set to emit/finalize.
   void emitAndFinalize(ModuleSetHandleT H) {
     (*H)->emitAndFinalize(BaseLayer);
   }
-
 };
 
 template <typename BaseLayerT>
 template <typename ModuleSetT, typename MemoryManagerPtrT,
           typename SymbolResolverPtrT>
 std::unique_ptr<typename LazyEmittingLayer<BaseLayerT>::EmissionDeferredSet>
 LazyEmittingLayer<BaseLayerT>::EmissionDeferredSet::create(
     BaseLayerT &B, ModuleSetT Ms, MemoryManagerPtrT MemMgr,
     SymbolResolverPtrT Resolver) {
   typedef EmissionDeferredSetImpl<ModuleSetT, MemoryManagerPtrT, SymbolResolverPtrT>
     EDS;
   return llvm::make_unique<EDS>(std::move(Ms), std::move(MemMgr),
                                 std::move(Resolver));
 }
 
-} // End namespace orc.
-} // End namespace llvm.
+} // end namespace orc
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H

llvm/trunk/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

 // Contains the definition for the object layer of the JIT.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_OBJECTLINKINGLAYER_H
 #define LLVM_EXECUTIONENGINE_ORC_OBJECTLINKINGLAYER_H
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Error.h"
+#include <cassert>
+#include <algorithm>
+#include <functional>
 #include <list>
 #include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace llvm {
 namespace orc {
 
 class ObjectLinkingLayerBase {
 protected:
   /// @brief Holds a set of objects to be allocated/linked as a unit in the JIT.
   ///
   /// An instance of this class will be created for each set of objects added
   /// via JITObjectLayer::addObjectSet. Deleting the instance (via
   /// removeObjectSet) frees its memory, removing all symbol definitions that
   /// had been provided by this instance. Higher level layers are responsible
   /// for taking any action required to handle the missing symbols.
   class LinkedObjectSet {
-    LinkedObjectSet(const LinkedObjectSet&) = delete;
-    void operator=(const LinkedObjectSet&) = delete;
   public:
     LinkedObjectSet() = default;
-    virtual ~LinkedObjectSet() {}
+    LinkedObjectSet(const LinkedObjectSet&) = delete;
+    void operator=(const LinkedObjectSet&) = delete;
+    virtual ~LinkedObjectSet() = default;
 
     virtual void finalize() = 0;
 
     virtual JITSymbol::GetAddressFtor
     getSymbolMaterializer(std::string Name) = 0;
 
     virtual void mapSectionAddress(const void *LocalAddress,
                                    JITTargetAddress TargetAddr) const = 0;
 
     JITSymbol getSymbol(StringRef Name, bool ExportedSymbolsOnly) {
       auto SymEntry = SymbolTable.find(Name);
       if (SymEntry == SymbolTable.end())
         return nullptr;
       if (!SymEntry->second.getFlags().isExported() && ExportedSymbolsOnly)
         return nullptr;
       if (!Finalized)
         return JITSymbol(getSymbolMaterializer(Name),
                          SymEntry->second.getFlags());
       return JITSymbol(SymEntry->second);
     }
+
   protected:
     StringMap<JITEvaluatedSymbol> SymbolTable;
     bool Finalized = false;
   };
 
   typedef std::list<std::unique_ptr<LinkedObjectSet>> LinkedObjectSetListT;
 
 public:
   /// @brief Handle to a set of loaded objects.
   typedef LinkedObjectSetListT::iterator ObjSetHandleT;
 };
 
-
 /// @brief Default (no-op) action to perform when loading objects.
 class DoNothingOnNotifyLoaded {
 public:
   template <typename ObjSetT, typename LoadResult>
   void operator()(ObjectLinkingLayerBase::ObjSetHandleT, const ObjSetT &,
                   const LoadResult &) {}
 };
 
 /// @brief Bare bones object linking layer.
 ///
 ///   This class is intended to be used as the base layer for a JIT. It allows
 /// object files to be loaded into memory, linked, and the addresses of their
 /// symbols queried. All objects added to this layer can see each other's
 /// symbols.
 template <typename NotifyLoadedFtor = DoNothingOnNotifyLoaded>
 class ObjectLinkingLayer : public ObjectLinkingLayerBase {
 public:
-
   /// @brief Functor for receiving finalization notifications.
   typedef std::function<void(ObjSetHandleT)> NotifyFinalizedFtor;
 
 private:
-
   template <typename ObjSetT, typename MemoryManagerPtrT,
             typename SymbolResolverPtrT, typename FinalizerFtor>
   class ConcreteLinkedObjectSet : public LinkedObjectSet {
   public:
     ConcreteLinkedObjectSet(ObjSetT Objects, MemoryManagerPtrT MemMgr,
                             SymbolResolverPtrT Resolver,
                             FinalizerFtor Finalizer,
                             bool ProcessAllSections)
public:
     void mapSectionAddress(const void *LocalAddress,
                            JITTargetAddress TargetAddr) const override {
       assert(PFC && "mapSectionAddress called on finalized LinkedObjectSet");
       assert(PFC->RTDyld && "mapSectionAddress called on raw LinkedObjectSet");
       PFC->RTDyld->mapSectionAddress(LocalAddress, TargetAddr);
     }
 
   private:
-
     void buildInitialSymbolTable(const ObjSetT &Objects) {
       for (const auto &Obj : Objects)
         for (auto &Symbol : getObject(*Obj).symbols()) {
           if (Symbol.getFlags() & object::SymbolRef::SF_Undefined)
             continue;
           Expected<StringRef> SymbolName = Symbol.getName();
           // FIXME: Raise an error for bad symbols.
           if (!SymbolName) {
createLinkedObjectSet(ObjSetT Objects, MemoryManagerPtrT MemMgr,
     typedef ConcreteLinkedObjectSet<ObjSetT, MemoryManagerPtrT,
                                     SymbolResolverPtrT, FinalizerFtor> LOS;
     return llvm::make_unique<LOS>(std::move(Objects), std::move(MemMgr),
                                   std::move(Resolver), std::move(Finalizer),
                                   ProcessAllSections);
   }
 
 public:
-
   /// @brief LoadedObjectInfo list. Contains a list of owning pointers to
   ///        RuntimeDyld::LoadedObjectInfo instances.
   typedef std::vector<std::unique_ptr<RuntimeDyld::LoadedObjectInfo>>
       LoadedObjInfoList;
 
   /// @brief Construct an ObjectLinkingLayer with the given NotifyLoaded,
   ///        and NotifyFinalized functors.
   ObjectLinkingLayer(
public:
   /// @return A handle that can be used to refer to the loaded objects (for 
   ///         symbol searching, finalization, freeing memory, etc.).
   template <typename ObjSetT,
             typename MemoryManagerPtrT,
             typename SymbolResolverPtrT>
   ObjSetHandleT addObjectSet(ObjSetT Objects,
                              MemoryManagerPtrT MemMgr,
                              SymbolResolverPtrT Resolver) {
-
     auto Finalizer = [&](ObjSetHandleT H, RuntimeDyld &RTDyld,
                          const ObjSetT &Objs,
                          std::function<void()> LOSHandleLoad) {
       LoadedObjInfoList LoadedObjInfos;
 
       for (auto &Obj : Objs)
         LoadedObjInfos.push_back(RTDyld.loadObject(this->getObject(*Obj)));
 
public:
   /// @brief Immediately emit and finalize the object set represented by the
   ///        given handle.
   /// @param H Handle for object set to emit/finalize.
   void emitAndFinalize(ObjSetHandleT H) {
     (*H)->finalize();
   }
 
 private:
-
   static const object::ObjectFile& getObject(const object::ObjectFile &Obj) {
     return Obj;
   }
 
   template <typename ObjT>
   static const object::ObjectFile&
   getObject(const object::OwningBinary<ObjT> &Obj) {
     return *Obj.getBinary();
   }
 
   LinkedObjectSetListT LinkedObjSetList;
   NotifyLoadedFtor NotifyLoaded;
   NotifyFinalizedFtor NotifyFinalized;
   bool ProcessAllSections;
 };
 
-} // End namespace orc.
-} // End namespace llvm
+} // end namespace orc
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_OBJECTLINKINGLAYER_H

llvm/trunk/include/llvm/ExecutionEngine/RTDyldMemoryManager.h

 //===-- RTDyldMemoryManager.cpp - Memory manager for MC-JIT -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Interface of the runtime dynamic memory manager base class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H
 #define LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H
 
-#include "RuntimeDyld.h"
-#include "llvm-c/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/Support/CBindingWrapping.h"
-#include "llvm/Support/Memory.h"
+#include "llvm-c/ExecutionEngine.h"
+#include <cstddef>
+#include <cstdint>
+#include <string>
 
 namespace llvm {
 
 class ExecutionEngine;
 
-  namespace object {
-    class ObjectFile;
-  }
+} // end namespace object
 
 class MCJITMemoryManager : public RuntimeDyld::MemoryManager {
 public:
-
   // Don't hide the notifyObjectLoaded method from RuntimeDyld::MemoryManager.
   using RuntimeDyld::MemoryManager::notifyObjectLoaded;
 
   /// This method is called after an object has been loaded into memory but
   /// before relocations are applied to the loaded sections.  The object load
   /// may have been initiated by MCJIT to resolve an external symbol for another
   /// object that is being finalized.  In that case, the object about which
   /// the memory manager is being notified will be finalized immediately after

 // RuntimeDyld clients often want to handle the memory management of
 // what gets placed where. For JIT clients, this is the subset of
 // JITMemoryManager required for dynamic loading of binaries.
 //
 // FIXME: As the RuntimeDyld fills out, additional routines will be needed
 //        for the varying types of objects to be allocated.
 class RTDyldMemoryManager : public MCJITMemoryManager,
                             public JITSymbolResolver {
+public:
+  RTDyldMemoryManager() = default;
   RTDyldMemoryManager(const RTDyldMemoryManager&) = delete;
   void operator=(const RTDyldMemoryManager&) = delete;
-public:
-  RTDyldMemoryManager() {}
   ~RTDyldMemoryManager() override;
 
   /// Register EH frames in the current process.
   static void registerEHFramesInProcess(uint8_t *Addr, size_t Size);
 
   /// Deregister EH frames in the current proces.
   static void deregisterEHFramesInProcess(uint8_t *Addr, size_t Size);
 
public:
   virtual void *getPointerToNamedFunction(const std::string &Name,
                                           bool AbortOnFailure = true);
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(
     RTDyldMemoryManager, LLVMMCJITMemoryManagerRef)
 
-} // namespace llvm
-
+} // end namespace llvm
 
-#endif
+#endif // LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H

llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyld.h

 //===-- RuntimeDyld.h - Run-time dynamic linker for MC-JIT ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Interface for the runtime dynamic linker facilities of the MC-JIT.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H
 #define LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H
 
-#include "JITSymbol.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Object/ObjectFile.h"
-#include "llvm/Support/Memory.h"
+#include "llvm/Support/Error.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <map>
 #include <memory>
-#include <utility>
+#include <string>
+#include <system_error>
 
 namespace llvm {
 
-class StringRef;
-
 namespace object {
-  class ObjectFile;
   template <typename T> class OwningBinary;
-}
+} // end namespace object
 
 /// Base class for errors originating in RuntimeDyld, e.g. missing relocation
 /// support.
 class RuntimeDyldError : public ErrorInfo<RuntimeDyldError> {
 public:
   static char ID;
+
   RuntimeDyldError(std::string ErrMsg) : ErrMsg(std::move(ErrMsg)) {}
+
   void log(raw_ostream &OS) const override;
   const std::string &getErrorMessage() const { return ErrMsg; }
   std::error_code convertToErrorCode() const override;
+
 private:
   std::string ErrMsg;
 };
 
 class RuntimeDyldImpl;
 class RuntimeDyldCheckerImpl;
 
 class RuntimeDyld {
   friend class RuntimeDyldCheckerImpl;
 
-  RuntimeDyld(const RuntimeDyld &) = delete;
-  void operator=(const RuntimeDyld &) = delete;
-
 protected:
   // Change the address associated with a section when resolving relocations.
   // Any relocations already associated with the symbol will be re-resolved.
   void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
-public:
 
+public:
   /// \brief Information about the loaded object.
   class LoadedObjectInfo : public llvm::LoadedObjectInfo {
     friend class RuntimeDyldImpl;
+
   public:
     typedef std::map<object::SectionRef, unsigned> ObjSectionToIDMap;
 
     LoadedObjectInfo(RuntimeDyldImpl &RTDyld, ObjSectionToIDMap ObjSecToIDMap)
         : RTDyld(RTDyld), ObjSecToIDMap(std::move(ObjSecToIDMap)) {}
 
     virtual object::OwningBinary<object::ObjectFile>
     getObjectForDebug(const object::ObjectFile &Obj) const = 0;
public:
   protected:
     LoadedObjectInfoHelper(const LoadedObjectInfoHelper &) = default;
     LoadedObjectInfoHelper() = default;
 
   public:
     LoadedObjectInfoHelper(RuntimeDyldImpl &RTDyld,
                            LoadedObjectInfo::ObjSectionToIDMap ObjSecToIDMap)
         : LoadedObjectInfo(RTDyld, std::move(ObjSecToIDMap)) {}
+
     std::unique_ptr<llvm::LoadedObjectInfo> clone() const override {
       return llvm::make_unique<Derived>(static_cast<const Derived &>(*this));
     }
   };
 
   /// \brief Memory Management.
   class MemoryManager {
     friend class RuntimeDyld;
+
   public:
-    MemoryManager() : FinalizationLocked(false) {}
-    virtual ~MemoryManager() {}
+    MemoryManager() = default;
+    virtual ~MemoryManager() = default;
 
     /// Allocate a memory block of (at least) the given size suitable for
     /// executable code. The SectionID is a unique identifier assigned by the
     /// RuntimeDyld instance, and optionally recorded by the memory manager to
     /// access a loaded section.
     virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                          unsigned SectionID,
                                          StringRef SectionName) = 0;
public:
     /// method should be preferred to its cousin
     /// MCJITMemoryManager::notifyObjectLoaded as this method is compatible with
     /// ORC JIT stacks.
     virtual void notifyObjectLoaded(RuntimeDyld &RTDyld,
                                     const object::ObjectFile &Obj) {}
 
   private:
     virtual void anchor();
-    bool FinalizationLocked;
+
+    bool FinalizationLocked = false;
   };
 
   /// \brief Construct a RuntimeDyld instance.
   RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver);
+  RuntimeDyld(const RuntimeDyld &) = delete;
+  void operator=(const RuntimeDyld &) = delete;
   ~RuntimeDyld();
 
   /// Add the referenced object file to the list of objects to be loaded and
   /// relocated.
   std::unique_ptr<LoadedObjectInfo> loadObject(const object::ObjectFile &O);
 
   /// Get the address of our local copy of the symbol. This may or may not
   /// be the address used for relocation (clients can copy the data around

llvm/trunk/include/llvm/ExecutionEngine/SectionMemoryManager.h

 // the MCJIT execution engine and RuntimeDyld.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_SECTIONMEMORYMANAGER_H
 #define LLVM_EXECUTIONENGINE_SECTIONMEMORYMANAGER_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
-#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Memory.h"
+#include <cstdint>
+#include <string>
+#include <system_error>
 
 namespace llvm {
+
 /// This is a simple memory manager which implements the methods called by
 /// the RuntimeDyld class to allocate memory for section-based loading of
 /// objects, usually those generated by the MCJIT execution engine.
 ///
 /// This memory manager allocates all section memory as read-write.  The
 /// RuntimeDyld will copy JITed section memory into these allocated blocks
 /// and perform any necessary linking and relocations.
 ///
 /// Any client using this memory manager MUST ensure that section-specific
 /// page permissions have been applied before attempting to execute functions
 /// in the JITed object.  Permissions can be applied either by calling
 /// MCJIT::finalizeObject or by calling SectionMemoryManager::finalizeMemory
 /// directly.  Clients of MCJIT should call MCJIT::finalizeObject.
 class SectionMemoryManager : public RTDyldMemoryManager {
+public:
+  SectionMemoryManager() = default;
   SectionMemoryManager(const SectionMemoryManager&) = delete;
   void operator=(const SectionMemoryManager&) = delete;
-
-public:
-  SectionMemoryManager() { }
   ~SectionMemoryManager() override;
 
   /// \brief Allocates a memory block of (at least) the given size suitable for
   /// executable code.
   ///
   /// The value of \p Alignment must be a power of two.  If \p Alignment is zero
   /// a default alignment of 16 will be used.
   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
private:
   std::error_code applyMemoryGroupPermissions(MemoryGroup &MemGroup,
                                               unsigned Permissions);
 
   MemoryGroup CodeMem;
   MemoryGroup RWDataMem;
   MemoryGroup RODataMem;
 };
 
-}
+} // end namespace llvm
 
 #endif // LLVM_EXECUTION_ENGINE_SECTION_MEMORY_MANAGER_H