Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===---------------- Layer.h -- Layer interfaces --------------*- 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

//

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

//

// Layer interfaces.

//

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

#ifndef LLVM_EXECUTIONENGINE_ORC_LAYER_H

#define LLVM_EXECUTIONENGINE_ORC_LAYER_H

#include "llvm/ExecutionEngine/Orc/Core.h"

#include "llvm/ExecutionEngine/Orc/Mangling.h"

#include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"

#include "llvm/IR/Module.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/ExtensibleRTTI.h"

#include "llvm/Support/MemoryBuffer.h"

namespace llvm {

namespace orc {

/// IRMaterializationUnit is a convenient base class for MaterializationUnits

/// wrapping LLVM IR. Represents materialization responsibility for all symbols

/// in the given module. If symbols are overridden by other definitions, then

/// their linkage is changed to available-externally.

class IRMaterializationUnit : public MaterializationUnit {

public:

  using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;

  /// Create an IRMaterializationLayer. Scans the module to build the

  /// SymbolFlags and SymbolToDefinition maps.

  IRMaterializationUnit(ExecutionSession &ES,

                        const IRSymbolMapper::ManglingOptions &MO,

                        ThreadSafeModule TSM);

  /// Create an IRMaterializationLayer from a module, and pre-existing

  /// SymbolFlags and SymbolToDefinition maps. The maps must provide

  /// entries for each definition in M.

  /// This constructor is useful for delegating work from one

  /// IRMaterializationUnit to another.

  IRMaterializationUnit(ThreadSafeModule TSM, Interface I,

                        SymbolNameToDefinitionMap SymbolToDefinition);

  /// Return the ModuleIdentifier as the name for this MaterializationUnit.

  StringRef getName() const override;

  /// Return a reference to the contained ThreadSafeModule.

  const ThreadSafeModule &getModule() const { return TSM; }

protected:

  ThreadSafeModule TSM;

  SymbolNameToDefinitionMap SymbolToDefinition;

private:

  static SymbolStringPtr getInitSymbol(ExecutionSession &ES,

                                       const ThreadSafeModule &TSM);

  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;

};

/// Interface for layers that accept LLVM IR.

class IRLayer {

public:

  IRLayer(ExecutionSession &ES, const IRSymbolMapper::ManglingOptions *&MO)

      : ES(ES), MO(MO) {}

  virtual ~IRLayer();

  /// Returns the ExecutionSession for this layer.

  ExecutionSession &getExecutionSession() { return ES; }

  /// Get the mangling options for this layer.

  const IRSymbolMapper::ManglingOptions *&getManglingOptions() const {

    return MO;

  }

  /// Sets the CloneToNewContextOnEmit flag (false by default).

  ///

  /// When set, IR modules added to this layer will be cloned on to a new

  /// context before emit is called. This can be used by clients who want

  /// to load all IR using one LLVMContext (to save memory via type and

  /// constant uniquing), but want to move Modules to fresh contexts before

  /// compiling them to enable concurrent compilation.

  /// Single threaded clients, or clients who load every module on a new

  /// context, need not set this.

  void setCloneToNewContextOnEmit(bool CloneToNewContextOnEmit) {

    this->CloneToNewContextOnEmit = CloneToNewContextOnEmit;

  }

  /// Returns the current value of the CloneToNewContextOnEmit flag.

  bool getCloneToNewContextOnEmit() const { return CloneToNewContextOnEmit; }

  /// Add a MaterializatinoUnit representing the given IR to the JITDylib

  /// targeted by the given tracker.

  virtual Error add(ResourceTrackerSP RT, ThreadSafeModule TSM);

  /// Adds a MaterializationUnit representing the given IR to the given

  /// JITDylib. If RT is not specif

  Error add(JITDylib &JD, ThreadSafeModule TSM) {

    return add(JD.getDefaultResourceTracker(), std::move(TSM));

  }

  /// Emit should materialize the given IR.

  virtual void emit(std::unique_ptr<MaterializationResponsibility> R,

                    ThreadSafeModule TSM) = 0;

private:

  bool CloneToNewContextOnEmit = false;

  ExecutionSession &ES;

  const IRSymbolMapper::ManglingOptions *&MO;

};

/// MaterializationUnit that materializes modules by calling the 'emit' method

/// on the given IRLayer.

class BasicIRLayerMaterializationUnit : public IRMaterializationUnit {

public:

  BasicIRLayerMaterializationUnit(IRLayer &L,

                                  const IRSymbolMapper::ManglingOptions &MO,

                                  ThreadSafeModule TSM);

private:

  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;

  IRLayer &L;

};

/// Interface for Layers that accept object files.

class ObjectLayer : public RTTIExtends<ObjectLayer, RTTIRoot> {

public:

  static char ID;

  ObjectLayer(ExecutionSession &ES);

  virtual ~ObjectLayer();

  /// Returns the execution session for this layer.

  ExecutionSession &getExecutionSession() { return ES; }

  /// Adds a MaterializationUnit for the object file in the given memory buffer

  /// to the JITDylib for the given ResourceTracker.

  virtual Error add(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> O,

                    MaterializationUnit::Interface I);

  /// Adds a MaterializationUnit for the object file in the given memory buffer

  /// to the JITDylib for the given ResourceTracker. The interface for the

  /// object will be built using the default object interface builder.

  Error add(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> O);

  /// Adds a MaterializationUnit for the object file in the given memory buffer

  /// to the given JITDylib.

  Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O,

            MaterializationUnit::Interface I) {

    return add(JD.getDefaultResourceTracker(), std::move(O), std::move(I));

  }

  /// Adds a MaterializationUnit for the object file in the given memory buffer

  /// to the given JITDylib. The interface for the object will be built using

  /// the default object interface builder.

  Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O);

  /// Emit should materialize the given IR.

  virtual void emit(std::unique_ptr<MaterializationResponsibility> R,

                    std::unique_ptr<MemoryBuffer> O) = 0;

private:

  ExecutionSession &ES;

};

/// Materializes the given object file (represented by a MemoryBuffer

/// instance) by calling 'emit' on the given ObjectLayer.

class BasicObjectLayerMaterializationUnit : public MaterializationUnit {

public:

  /// Create using the default object interface builder function.

  static Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>

  Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> O);

  BasicObjectLayerMaterializationUnit(ObjectLayer &L,

                                      std::unique_ptr<MemoryBuffer> O,

                                      Interface I);

  /// Return the buffer's identifier as the name for this MaterializationUnit.

  StringRef getName() const override;

private:

  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;

  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;

  ObjectLayer &L;

  std::unique_ptr<MemoryBuffer> O;

};

} // End namespace orc

} // End namespace llvm

#endif // LLVM_EXECUTIONENGINE_ORC_LAYER_H