lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp

   1 //===----- CompileOnDemandLayer.cpp - Lazily emit IR on first call --------===//
   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 #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
  10 #include "llvm/IR/Mangler.h"
  11 #include "llvm/IR/Module.h"
  12
  13 using namespace llvm;
  14 using namespace llvm::orc;
  15
  16 static ThreadSafeModule extractSubModule(ThreadSafeModule &TSM,
  17                                          StringRef Suffix,
  18                                          GVPredicate ShouldExtract) {
  19
  20   auto DeleteExtractedDefs = [](GlobalValue &GV) {
  21     // Bump the linkage: this global will be provided by the external module.
  22     GV.setLinkage(GlobalValue::ExternalLinkage);
  23
  24     // Delete the definition in the source module.
  25     if (isa<Function>(GV)) {
  26       auto &F = cast<Function>(GV);
  27       F.deleteBody();
  28       F.setPersonalityFn(nullptr);
  29     } else if (isa<GlobalVariable>(GV)) {
  30       cast<GlobalVariable>(GV).setInitializer(nullptr);
  31     } else if (isa<GlobalAlias>(GV)) {
  32       // We need to turn deleted aliases into function or variable decls based
  33       // on the type of their aliasee.
  34       auto &A = cast<GlobalAlias>(GV);
  35       Constant *Aliasee = A.getAliasee();
  36       assert(A.hasName() && "Anonymous alias?");
  37       assert(Aliasee->hasName() && "Anonymous aliasee");
  38       std::string AliasName = A.getName();
  39
  40       if (isa<Function>(Aliasee)) {
  41         auto *F = cloneFunctionDecl(*A.getParent(), *cast<Function>(Aliasee));
  42         A.replaceAllUsesWith(F);
  43         A.eraseFromParent();
  44         F->setName(AliasName);
  45       } else if (isa<GlobalVariable>(Aliasee)) {
  46         auto *G = cloneGlobalVariableDecl(*A.getParent(),
  47                                           *cast<GlobalVariable>(Aliasee));
  48         A.replaceAllUsesWith(G);
  49         A.eraseFromParent();
  50         G->setName(AliasName);
  51       } else
  52         llvm_unreachable("Alias to unsupported type");
  53     } else
  54       llvm_unreachable("Unsupported global type");
  55   };
  56
  57   auto NewTSM = cloneToNewContext(TSM, ShouldExtract, DeleteExtractedDefs);
  58   NewTSM.withModuleDo([&](Module &M) {
  59     M.setModuleIdentifier((M.getModuleIdentifier() + Suffix).str());
  60   });
  61
  62   return NewTSM;
  63 }
  64
  65 namespace llvm {
  66 namespace orc {
  67
  68 class PartitioningIRMaterializationUnit : public IRMaterializationUnit {
  69 public:
  70   PartitioningIRMaterializationUnit(ExecutionSession &ES, ThreadSafeModule TSM,
  71                                     VModuleKey K, CompileOnDemandLayer &Parent)
  72       : IRMaterializationUnit(ES, std::move(TSM), std::move(K)),
  73         Parent(Parent) {}
  74
  75   PartitioningIRMaterializationUnit(
  76       ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags,
  77       SymbolNameToDefinitionMap SymbolToDefinition,
  78       CompileOnDemandLayer &Parent)
  79       : IRMaterializationUnit(std::move(TSM), std::move(K),
  80                               std::move(SymbolFlags),
  81                               std::move(SymbolToDefinition)),
  82         Parent(Parent) {}
  83
  84 private:
  85   void materialize(MaterializationResponsibility R) override {
  86     Parent.emitPartition(std::move(R), std::move(TSM),
  87                          std::move(SymbolToDefinition));
  88   }
  89
  90   void discard(const JITDylib &V, const SymbolStringPtr &Name) override {
  91     // All original symbols were materialized by the CODLayer and should be
  92     // final. The function bodies provided by M should never be overridden.
  93     llvm_unreachable("Discard should never be called on an "
  94                      "ExtractingIRMaterializationUnit");
  95   }
  96
  97   mutable std::mutex SourceModuleMutex;
  98   CompileOnDemandLayer &Parent;
  99 };
 100
 101 Optional<CompileOnDemandLayer::GlobalValueSet>
 102 CompileOnDemandLayer::compileRequested(GlobalValueSet Requested) {
 103   return std::move(Requested);
 104 }
 105
 106 Optional<CompileOnDemandLayer::GlobalValueSet>
 107 CompileOnDemandLayer::compileWholeModule(GlobalValueSet Requested) {
 108   return None;
 109 }
 110
 111 CompileOnDemandLayer::CompileOnDemandLayer(
 112     ExecutionSession &ES, IRLayer &BaseLayer, LazyCallThroughManager &LCTMgr,
 113     IndirectStubsManagerBuilder BuildIndirectStubsManager)
 114     : IRLayer(ES), BaseLayer(BaseLayer), LCTMgr(LCTMgr),
 115       BuildIndirectStubsManager(std::move(BuildIndirectStubsManager)) {}
 116
 117 void CompileOnDemandLayer::setPartitionFunction(PartitionFunction Partition) {
 118   this->Partition = std::move(Partition);
 119 }
 120
 121 void CompileOnDemandLayer::setImplMap(ImplSymbolMap *Imp) {
 122   this->AliaseeImpls = Imp;
 123 }
 124 void CompileOnDemandLayer::emit(MaterializationResponsibility R,
 125                                 ThreadSafeModule TSM) {
 126   assert(TSM && "Null module");
 127
 128   auto &ES = getExecutionSession();
 129
 130   // Sort the callables and non-callables, build re-exports and lodge the
 131   // actual module with the implementation dylib.
 132   auto &PDR = getPerDylibResources(R.getTargetJITDylib());
 133
 134   SymbolAliasMap NonCallables;
 135   SymbolAliasMap Callables;
 136   TSM.withModuleDo([&](Module &M) {
 137     // First, do some cleanup on the module:
 138     cleanUpModule(M);
 139
 140     MangleAndInterner Mangle(ES, M.getDataLayout());
 141     for (auto &GV : M.global_values()) {
 142       if (GV.isDeclaration() || GV.hasLocalLinkage() ||
 143           GV.hasAppendingLinkage())
 144         continue;
 145
 146       auto Name = Mangle(GV.getName());
 147       auto Flags = JITSymbolFlags::fromGlobalValue(GV);
 148       if (Flags.isCallable())
 149         Callables[Name] = SymbolAliasMapEntry(Name, Flags);
 150       else
 151         NonCallables[Name] = SymbolAliasMapEntry(Name, Flags);
 152     }
 153   });
 154
 155   // Create a partitioning materialization unit and lodge it with the
 156   // implementation dylib.
 157   if (auto Err = PDR.getImplDylib().define(
 158           std::make_unique<PartitioningIRMaterializationUnit>(
 159               ES, std::move(TSM), R.getVModuleKey(), *this))) {
 160     ES.reportError(std::move(Err));
 161     R.failMaterialization();
 162     return;
 163   }
 164
 165   R.replace(reexports(PDR.getImplDylib(), std::move(NonCallables), true));
 166   R.replace(lazyReexports(LCTMgr, PDR.getISManager(), PDR.getImplDylib(),
 167                           std::move(Callables), AliaseeImpls));
 168 }
 169
 170 CompileOnDemandLayer::PerDylibResources &
 171 CompileOnDemandLayer::getPerDylibResources(JITDylib &TargetD) {
 172   auto I = DylibResources.find(&TargetD);
 173   if (I == DylibResources.end()) {
 174     auto &ImplD = getExecutionSession().createJITDylib(
 175         TargetD.getName() + ".impl", false);
 176     TargetD.withSearchOrderDo([&](const JITDylibSearchList &TargetSearchOrder) {
 177       auto NewSearchOrder = TargetSearchOrder;
 178       assert(!NewSearchOrder.empty() &&
 179              NewSearchOrder.front().first == &TargetD &&
 180              NewSearchOrder.front().second == true &&
 181              "TargetD must be at the front of its own search order and match "
 182              "non-exported symbol");
 183       NewSearchOrder.insert(std::next(NewSearchOrder.begin()), {&ImplD, true});
 184       ImplD.setSearchOrder(std::move(NewSearchOrder), false);
 185     });
 186     PerDylibResources PDR(ImplD, BuildIndirectStubsManager());
 187     I = DylibResources.insert(std::make_pair(&TargetD, std::move(PDR))).first;
 188   }
 189
 190   return I->second;
 191 }
 192
 193 void CompileOnDemandLayer::cleanUpModule(Module &M) {
 194   for (auto &F : M.functions()) {
 195     if (F.isDeclaration())
 196       continue;
 197
 198     if (F.hasAvailableExternallyLinkage()) {
 199       F.deleteBody();
 200       F.setPersonalityFn(nullptr);
 201       continue;
 202     }
 203   }
 204 }
 205
 206 void CompileOnDemandLayer::expandPartition(GlobalValueSet &Partition) {
 207   // Expands the partition to ensure the following rules hold:
 208   // (1) If any alias is in the partition, its aliasee is also in the partition.
 209   // (2) If any aliasee is in the partition, its aliases are also in the
 210   //     partiton.
 211   // (3) If any global variable is in the partition then all global variables
 212   //     are in the partition.
 213   assert(!Partition.empty() && "Unexpected empty partition");
 214
 215   const Module &M = *(*Partition.begin())->getParent();
 216   bool ContainsGlobalVariables = false;
 217   std::vector<const GlobalValue *> GVsToAdd;
 218
 219   for (auto *GV : Partition)
 220     if (isa<GlobalAlias>(GV))
 221       GVsToAdd.push_back(
 222           cast<GlobalValue>(cast<GlobalAlias>(GV)->getAliasee()));
 223     else if (isa<GlobalVariable>(GV))
 224       ContainsGlobalVariables = true;
 225
 226   for (auto &A : M.aliases())
 227     if (Partition.count(cast<GlobalValue>(A.getAliasee())))
 228       GVsToAdd.push_back(&A);
 229
 230   if (ContainsGlobalVariables)
 231     for (auto &G : M.globals())
 232       GVsToAdd.push_back(&G);
 233
 234   for (auto *GV : GVsToAdd)
 235     Partition.insert(GV);
 236 }
 237
 238 void CompileOnDemandLayer::emitPartition(
 239     MaterializationResponsibility R, ThreadSafeModule TSM,
 240     IRMaterializationUnit::SymbolNameToDefinitionMap Defs) {
 241
 242   // FIXME: Need a 'notify lazy-extracting/emitting' callback to tie the
 243   //        extracted module key, extracted module, and source module key
 244   //        together. This could be used, for example, to provide a specific
 245   //        memory manager instance to the linking layer.
 246
 247   auto &ES = getExecutionSession();
 248   GlobalValueSet RequestedGVs;
 249   for (auto &Name : R.getRequestedSymbols()) {
 250     assert(Defs.count(Name) && "No definition for symbol");
 251     RequestedGVs.insert(Defs[Name]);
 252   }
 253
 254   /// Perform partitioning with the context lock held, since the partition
 255   /// function is allowed to access the globals to compute the partition.
 256   auto GVsToExtract =
 257       TSM.withModuleDo([&](Module &M) { return Partition(RequestedGVs); });
 258
 259   // Take a 'None' partition to mean the whole module (as opposed to an empty
 260   // partition, which means "materialize nothing"). Emit the whole module
 261   // unmodified to the base layer.
 262   if (GVsToExtract == None) {
 263     Defs.clear();
 264     BaseLayer.emit(std::move(R), std::move(TSM));
 265     return;
 266   }
 267
 268   // If the partition is empty, return the whole module to the symbol table.
 269   if (GVsToExtract->empty()) {
 270     R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
 271         std::move(TSM), R.getSymbols(), std::move(Defs), *this));
 272     return;
 273   }
 274
 275   // Ok -- we actually need to partition the symbols. Promote the symbol
 276   // linkages/names, expand the partition to include any required symbols
 277   // (i.e. symbols that can't be separated from our partition), and
 278   // then extract the partition.
 279   //
 280   // FIXME: We apply this promotion once per partitioning. It's safe, but
 281   // overkill.
 282
 283   auto ExtractedTSM =
 284       TSM.withModuleDo([&](Module &M) -> Expected<ThreadSafeModule> {
 285         auto PromotedGlobals = PromoteSymbols(M);
 286         if (!PromotedGlobals.empty()) {
 287           MangleAndInterner Mangle(ES, M.getDataLayout());
 288           SymbolFlagsMap SymbolFlags;
 289           for (auto &GV : PromotedGlobals)
 290             SymbolFlags[Mangle(GV->getName())] =
 291                 JITSymbolFlags::fromGlobalValue(*GV);
 292           if (auto Err = R.defineMaterializing(SymbolFlags))
 293             return std::move(Err);
 294         }
 295
 296         expandPartition(*GVsToExtract);
 297
 298         // Extract the requested partiton (plus any necessary aliases) and
 299         // put the rest back into the impl dylib.
 300         auto ShouldExtract = [&](const GlobalValue &GV) -> bool {
 301           return GVsToExtract->count(&GV);
 302         };
 303
 304         return extractSubModule(TSM, ".submodule", ShouldExtract);
 305       });
 306
 307   if (!ExtractedTSM) {
 308     ES.reportError(ExtractedTSM.takeError());
 309     R.failMaterialization();
 310     return;
 311   }
 312
 313   R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
 314       ES, std::move(TSM), R.getVModuleKey(), *this));
 315   BaseLayer.emit(std::move(R), std::move(*ExtractedTSM));
 316 }
 317
 318 } // end namespace orc
 319 } // end namespace llvm