1 //===-------------------- Layer.cpp - Layer interfaces --------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ExecutionEngine/Orc/Layer.h"
11 #include "llvm/Object/ObjectFile.h"
12 
13 namespace llvm {
14 namespace orc {
15 
16 IRLayer::IRLayer(ExecutionSession &ES) : ES(ES) {}
17 IRLayer::~IRLayer() {}
18 
19 Error IRLayer::add(JITDylib &JD, VModuleKey K, std::unique_ptr<Module> M) {
20   return JD.define(llvm::make_unique<BasicIRLayerMaterializationUnit>(
21       *this, std::move(K), std::move(M)));
22 }
23 
24 IRMaterializationUnit::IRMaterializationUnit(ExecutionSession &ES,
25                                              std::unique_ptr<Module> M)
26   : MaterializationUnit(SymbolFlagsMap()), M(std::move(M)) {
27 
28   MangleAndInterner Mangle(ES, this->M->getDataLayout());
29   for (auto &G : this->M->global_values()) {
30     if (G.hasName() && !G.isDeclaration() && !G.hasLocalLinkage() &&
31         !G.hasAvailableExternallyLinkage() && !G.hasAppendingLinkage()) {
32       auto MangledName = Mangle(G.getName());
33       SymbolFlags[MangledName] = JITSymbolFlags::fromGlobalValue(G);
34       SymbolToDefinition[MangledName] = &G;
35     }
36   }
37 }
38 
39 IRMaterializationUnit::IRMaterializationUnit(
40     std::unique_ptr<Module> M, SymbolFlagsMap SymbolFlags,
41     SymbolNameToDefinitionMap SymbolToDefinition)
42     : MaterializationUnit(std::move(SymbolFlags)), M(std::move(M)),
43       SymbolToDefinition(std::move(SymbolToDefinition)) {}
44 
45 void IRMaterializationUnit::discard(const JITDylib &JD, SymbolStringPtr Name) {
46   auto I = SymbolToDefinition.find(Name);
47   assert(I != SymbolToDefinition.end() &&
48          "Symbol not provided by this MU, or previously discarded");
49   assert(!I->second->isDeclaration() &&
50          "Discard should only apply to definitions");
51   I->second->setLinkage(GlobalValue::AvailableExternallyLinkage);
52   SymbolToDefinition.erase(I);
53 }
54 
55 BasicIRLayerMaterializationUnit::BasicIRLayerMaterializationUnit(
56     IRLayer &L, VModuleKey K, std::unique_ptr<Module> M)
57   : IRMaterializationUnit(L.getExecutionSession(), std::move(M)),
58       L(L), K(std::move(K)) {}
59 
60 void BasicIRLayerMaterializationUnit::materialize(
61     MaterializationResponsibility R) {
62   L.emit(std::move(R), std::move(K), std::move(M));
63 }
64 
65 ObjectLayer::ObjectLayer(ExecutionSession &ES) : ES(ES) {}
66 
67 ObjectLayer::~ObjectLayer() {}
68 
69 Error ObjectLayer::add(JITDylib &JD, VModuleKey K,
70                        std::unique_ptr<MemoryBuffer> O) {
71   auto ObjMU = BasicObjectLayerMaterializationUnit::Create(*this, std::move(K),
72                                                            std::move(O));
73   if (!ObjMU)
74     return ObjMU.takeError();
75   return JD.define(std::move(*ObjMU));
76 }
77 
78 Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
79 BasicObjectLayerMaterializationUnit::Create(ObjectLayer &L, VModuleKey K,
80                                             std::unique_ptr<MemoryBuffer> O) {
81   auto SymbolFlags =
82       getObjectSymbolFlags(L.getExecutionSession(), O->getMemBufferRef());
83 
84   if (!SymbolFlags)
85     return SymbolFlags.takeError();
86 
87   return std::unique_ptr<BasicObjectLayerMaterializationUnit>(
88       new BasicObjectLayerMaterializationUnit(L, K, std::move(O),
89                                               std::move(*SymbolFlags)));
90 }
91 
92 BasicObjectLayerMaterializationUnit::BasicObjectLayerMaterializationUnit(
93     ObjectLayer &L, VModuleKey K, std::unique_ptr<MemoryBuffer> O,
94     SymbolFlagsMap SymbolFlags)
95     : MaterializationUnit(std::move(SymbolFlags)), L(L), K(std::move(K)),
96       O(std::move(O)) {}
97 
98 void BasicObjectLayerMaterializationUnit::materialize(
99     MaterializationResponsibility R) {
100   L.emit(std::move(R), std::move(K), std::move(O));
101 }
102 
103 void BasicObjectLayerMaterializationUnit::discard(const JITDylib &JD,
104                                                   SymbolStringPtr Name) {
105   // FIXME: Support object file level discard. This could be done by building a
106   //        filter to pass to the object layer along with the object itself.
107 }
108 
109 Expected<SymbolFlagsMap> getObjectSymbolFlags(ExecutionSession &ES,
110                                               MemoryBufferRef ObjBuffer) {
111   auto Obj = object::ObjectFile::createObjectFile(ObjBuffer);
112 
113   if (!Obj)
114     return Obj.takeError();
115 
116   SymbolFlagsMap SymbolFlags;
117   for (auto &Sym : (*Obj)->symbols()) {
118     // Skip symbols not defined in this object file.
119     if (Sym.getFlags() & object::BasicSymbolRef::SF_Undefined)
120       continue;
121 
122     // Skip symbols that are not global.
123     if (!(Sym.getFlags() & object::BasicSymbolRef::SF_Global))
124       continue;
125 
126     auto Name = Sym.getName();
127     if (!Name)
128       return Name.takeError();
129     auto InternedName = ES.getSymbolStringPool().intern(*Name);
130     auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
131     if (!SymFlags)
132       return SymFlags.takeError();
133     SymbolFlags[InternedName] = std::move(*SymFlags);
134   }
135 
136   return SymbolFlags;
137 }
138 
139 } // End namespace orc.
140 } // End namespace llvm.
141