1//===---------------- Layer.h -- Layer interfaces --------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Layer interfaces.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_ORC_LAYER_H
14#define LLVM_EXECUTIONENGINE_ORC_LAYER_H
15
16#include "llvm/ExecutionEngine/Orc/Core.h"
17#include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
18#include "llvm/IR/Module.h"
19#include "llvm/Support/MemoryBuffer.h"
20
21namespace llvm {
22namespace orc {
23
24/// IRMaterializationUnit is a convenient base class for MaterializationUnits
25/// wrapping LLVM IR. Represents materialization responsibility for all symbols
26/// in the given module. If symbols are overridden by other definitions, then
27/// their linkage is changed to available-externally.
28class IRMaterializationUnit : public MaterializationUnit {
29public:
30  struct ManglingOptions {
31    bool EmulatedTLS = false;
32  };
33
34  using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;
35
36  /// Create an IRMaterializationLayer. Scans the module to build the
37  /// SymbolFlags and SymbolToDefinition maps.
38  IRMaterializationUnit(ExecutionSession &ES, const ManglingOptions &MO,
39                        ThreadSafeModule TSM, VModuleKey K);
40
41  /// Create an IRMaterializationLayer from a module, and pre-existing
42  /// SymbolFlags and SymbolToDefinition maps. The maps must provide
43  /// entries for each definition in M.
44  /// This constructor is useful for delegating work from one
45  /// IRMaterializationUnit to another.
46  IRMaterializationUnit(ThreadSafeModule TSM, VModuleKey K,
47                        SymbolFlagsMap SymbolFlags,
48                        SymbolNameToDefinitionMap SymbolToDefinition);
49
50  /// Return the ModuleIdentifier as the name for this MaterializationUnit.
51  StringRef getName() const override;
52
53  const ThreadSafeModule &getModule() const { return TSM; }
54
55protected:
56  ThreadSafeModule TSM;
57  SymbolNameToDefinitionMap SymbolToDefinition;
58
59private:
60  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
61};
62
63/// Interface for layers that accept LLVM IR.
64class IRLayer {
65public:
66  IRLayer(ExecutionSession &ES,
67          const IRMaterializationUnit::ManglingOptions *&MO)
68      : ES(ES), MO(MO) {}
69
70  virtual ~IRLayer();
71
72  /// Returns the ExecutionSession for this layer.
73  ExecutionSession &getExecutionSession() { return ES; }
74
75  /// Get the mangling options for this layer.
76  const IRMaterializationUnit::ManglingOptions *&getManglingOptions() const {
77    return MO;
78  }
79
80  /// Sets the CloneToNewContextOnEmit flag (false by default).
81  ///
82  /// When set, IR modules added to this layer will be cloned on to a new
83  /// context before emit is called. This can be used by clients who want
84  /// to load all IR using one LLVMContext (to save memory via type and
85  /// constant uniquing), but want to move Modules to fresh contexts before
86  /// compiling them to enable concurrent compilation.
87  /// Single threaded clients, or clients who load every module on a new
88  /// context, need not set this.
89  void setCloneToNewContextOnEmit(bool CloneToNewContextOnEmit) {
90    this->CloneToNewContextOnEmit = CloneToNewContextOnEmit;
91  }
92
93  /// Returns the current value of the CloneToNewContextOnEmit flag.
94  bool getCloneToNewContextOnEmit() const { return CloneToNewContextOnEmit; }
95
96  /// Adds a MaterializationUnit representing the given IR to the given
97  /// JITDylib.
98  virtual Error add(JITDylib &JD, ThreadSafeModule TSM,
99                    VModuleKey K = VModuleKey());
100
101  /// Emit should materialize the given IR.
102  virtual void emit(MaterializationResponsibility R, ThreadSafeModule TSM) = 0;
103
104private:
105  bool CloneToNewContextOnEmit = false;
106  ExecutionSession &ES;
107  const IRMaterializationUnit::ManglingOptions *&MO;
108};
109
110/// MaterializationUnit that materializes modules by calling the 'emit' method
111/// on the given IRLayer.
112class BasicIRLayerMaterializationUnit : public IRMaterializationUnit {
113public:
114  BasicIRLayerMaterializationUnit(IRLayer &L, const ManglingOptions &MO,
115                                  ThreadSafeModule TSM, VModuleKey K);
116
117private:
118
119  void materialize(MaterializationResponsibility R) override;
120
121  IRLayer &L;
122  VModuleKey K;
123};
124
125/// Interface for Layers that accept object files.
126class ObjectLayer {
127public:
128  ObjectLayer(ExecutionSession &ES);
129  virtual ~ObjectLayer();
130
131  /// Returns the execution session for this layer.
132  ExecutionSession &getExecutionSession() { return ES; }
133
134  /// Adds a MaterializationUnit representing the given IR to the given
135  /// JITDylib.
136  virtual Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O,
137                    VModuleKey K = VModuleKey());
138
139  /// Emit should materialize the given IR.
140  virtual void emit(MaterializationResponsibility R,
141                    std::unique_ptr<MemoryBuffer> O) = 0;
142
143private:
144  ExecutionSession &ES;
145};
146
147/// Materializes the given object file (represented by a MemoryBuffer
148/// instance) by calling 'emit' on the given ObjectLayer.
149class BasicObjectLayerMaterializationUnit : public MaterializationUnit {
150public:
151  static Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
152  Create(ObjectLayer &L, VModuleKey K, std::unique_ptr<MemoryBuffer> O);
153
154  BasicObjectLayerMaterializationUnit(ObjectLayer &L, VModuleKey K,
155                                      std::unique_ptr<MemoryBuffer> O,
156                                      SymbolFlagsMap SymbolFlags);
157
158  /// Return the buffer's identifier as the name for this MaterializationUnit.
159  StringRef getName() const override;
160
161private:
162
163  void materialize(MaterializationResponsibility R) override;
164  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
165
166  ObjectLayer &L;
167  std::unique_ptr<MemoryBuffer> O;
168};
169
170/// Returns a SymbolFlagsMap for the object file represented by the given
171/// buffer, or an error if the buffer does not contain a valid object file.
172// FIXME: Maybe move to Core.h?
173Expected<SymbolFlagsMap> getObjectSymbolFlags(ExecutionSession &ES,
174                                              MemoryBufferRef ObjBuffer);
175
176} // End namespace orc
177} // End namespace llvm
178
179#endif // LLVM_EXECUTIONENGINE_ORC_LAYER_H
180