Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===-- RTDyldMemoryManager.cpp - Memory manager for MC-JIT -----*- 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

//

//===----------------------------------------------------------------------===//

//

// Interface of the runtime dynamic memory manager base class.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H

#define LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H

#include "llvm-c/ExecutionEngine.h"

#include "llvm/ExecutionEngine/JITSymbol.h"

#include "llvm/ExecutionEngine/RuntimeDyld.h"

#include "llvm/Support/CBindingWrapping.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

  /// the memory manager returns from this call.

  ///

  /// Memory managers which are preparing code for execution in an external

  /// address space can use this call to remap the section addresses for the

  /// newly loaded object.

  virtual void notifyObjectLoaded(ExecutionEngine *EE,

                                  const object::ObjectFile &) {}

private:

  void anchor() override;

};

// 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 LegacyJITSymbolResolver {

public:

  RTDyldMemoryManager() = default;

  RTDyldMemoryManager(const RTDyldMemoryManager&) = delete;

  void operator=(const RTDyldMemoryManager&) = delete;

  ~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);

  void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;

  void deregisterEHFrames() override;

  /// This method returns the address of the specified function or variable in

  /// the current process.

  static uint64_t getSymbolAddressInProcess(const std::string &Name);

  /// Legacy symbol lookup - DEPRECATED! Please override findSymbol instead.

  ///

  /// This method returns the address of the specified function or variable.

  /// It is used to resolve symbols during module linking.

  virtual uint64_t getSymbolAddress(const std::string &Name) {

    return getSymbolAddressInProcess(Name);

  }

  /// This method returns a RuntimeDyld::SymbolInfo for the specified function

  /// or variable. It is used to resolve symbols during module linking.

  ///

  /// By default this falls back on the legacy lookup method:

  /// 'getSymbolAddress'. The address returned by getSymbolAddress is treated as

  /// a strong, exported symbol, consistent with historical treatment by

  /// RuntimeDyld.

  ///

  /// Clients writing custom RTDyldMemoryManagers are encouraged to override

  /// this method and return a SymbolInfo with the flags set correctly. This is

  /// necessary for RuntimeDyld to correctly handle weak and non-exported symbols.

  JITSymbol findSymbol(const std::string &Name) override {

    return JITSymbol(getSymbolAddress(Name), JITSymbolFlags::Exported);

  }

  /// Legacy symbol lookup -- DEPRECATED! Please override

  /// findSymbolInLogicalDylib instead.

  ///

  /// Default to treating all modules as separate.

  virtual uint64_t getSymbolAddressInLogicalDylib(const std::string &Name) {

    return 0;

  }

  /// Default to treating all modules as separate.

  ///

  /// By default this falls back on the legacy lookup method:

  /// 'getSymbolAddressInLogicalDylib'. The address returned by

  /// getSymbolAddressInLogicalDylib is treated as a strong, exported symbol,

  /// consistent with historical treatment by RuntimeDyld.

  ///

  /// Clients writing custom RTDyldMemoryManagers are encouraged to override

  /// this method and return a SymbolInfo with the flags set correctly. This is

  /// necessary for RuntimeDyld to correctly handle weak and non-exported symbols.

  JITSymbol

  findSymbolInLogicalDylib(const std::string &Name) override {

    return JITSymbol(getSymbolAddressInLogicalDylib(Name),

                          JITSymbolFlags::Exported);

  }

  /// This method returns the address of the specified function. As such it is

  /// only useful for resolving library symbols, not code generated symbols.

  ///

  /// If \p AbortOnFailure is false and no function with the given name is

  /// found, this function returns a null pointer. Otherwise, it prints a

  /// message to stderr and aborts.

  ///

  /// This function is deprecated for memory managers to be used with

  /// MCJIT or RuntimeDyld.  Use getSymbolAddress instead.

  virtual void *getPointerToNamedFunction(const std::string &Name,

                                          bool AbortOnFailure = true);

protected:

  struct EHFrame {

    uint8_t *Addr;

    size_t Size;

  };

  typedef std::vector<EHFrame> EHFrameInfos;

  EHFrameInfos EHFrames;

private:

  void anchor() override;

};

// Create wrappers for C Binding types (see CBindingWrapping.h).

DEFINE_SIMPLE_CONVERSION_FUNCTIONS(

    RTDyldMemoryManager, LLVMMCJITMemoryManagerRef)

} // end namespace llvm

#endif // LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H