Home | History | Annotate | Line # | Download | only in Orc 
      1 //===---------- speculation.cpp - Utilities for Speculation ----------===//
      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/Speculation.h"
     10 #include "llvm/IR/BasicBlock.h"
     11 #include "llvm/IR/Function.h"
     12 #include "llvm/IR/IRBuilder.h"
     13 #include "llvm/IR/Instruction.h"
     14 #include "llvm/IR/Instructions.h"
     15 #include "llvm/IR/LLVMContext.h"
     16 #include "llvm/IR/Module.h"
     17 #include "llvm/IR/Type.h"
     18 #include "llvm/IR/Verifier.h"
     19 
     20 namespace llvm {
     21 
     22 namespace orc {
     23 
     24 // ImplSymbolMap methods
     25 void ImplSymbolMap::trackImpls(SymbolAliasMap ImplMaps, JITDylib *SrcJD) {
     26   assert(SrcJD && "Tracking on Null Source .impl dylib");
     27   std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
     28   for (auto &I : ImplMaps) {
     29     auto It = Maps.insert({I.first, {I.second.Aliasee, SrcJD}});
     30     // check rationale when independent dylibs have same symbol name?
     31     assert(It.second && "ImplSymbols are already tracked for this Symbol?");
     32     (void)(It);
     33   }
     34 }
     35 
     36 // Trigger Speculative Compiles.
     37 void Speculator::speculateForEntryPoint(Speculator *Ptr, uint64_t StubId) {
     38   assert(Ptr && " Null Address Received in orc_speculate_for ");
     39   Ptr->speculateFor(StubId);
     40 }
     41 
     42 Error Speculator::addSpeculationRuntime(JITDylib &JD,
     43                                         MangleAndInterner &Mangle) {
     44   JITEvaluatedSymbol ThisPtr(pointerToJITTargetAddress(this),
     45                              JITSymbolFlags::Exported);
     46   JITEvaluatedSymbol SpeculateForEntryPtr(
     47       pointerToJITTargetAddress(&speculateForEntryPoint),
     48       JITSymbolFlags::Exported);
     49   return JD.define(absoluteSymbols({
     50       {Mangle("__orc_speculator"), ThisPtr},                // Data Symbol
     51       {Mangle("__orc_speculate_for"), SpeculateForEntryPtr} // Callable Symbol
     52   }));
     53 }
     54 
     55 // If two modules, share the same LLVMContext, different threads must
     56 // not access them concurrently without locking the associated LLVMContext
     57 // this implementation follows this contract.
     58 void IRSpeculationLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
     59                               ThreadSafeModule TSM) {
     60 
     61   assert(TSM && "Speculation Layer received Null Module ?");
     62   assert(TSM.getContext().getContext() != nullptr &&
     63          "Module with null LLVMContext?");
     64 
     65   // Instrumentation of runtime calls, lock the Module
     66   TSM.withModuleDo([this, &R](Module &M) {
     67     auto &MContext = M.getContext();
     68     auto SpeculatorVTy = StructType::create(MContext, "Class.Speculator");
     69     auto RuntimeCallTy = FunctionType::get(
     70         Type::getVoidTy(MContext),
     71         {SpeculatorVTy->getPointerTo(), Type::getInt64Ty(MContext)}, false);
     72     auto RuntimeCall =
     73         Function::Create(RuntimeCallTy, Function::LinkageTypes::ExternalLinkage,
     74                          "__orc_speculate_for", &M);
     75     auto SpeclAddr = new GlobalVariable(
     76         M, SpeculatorVTy, false, GlobalValue::LinkageTypes::ExternalLinkage,
     77         nullptr, "__orc_speculator");
     78 
     79     IRBuilder<> Mutator(MContext);
     80 
     81     // QueryAnalysis allowed to transform the IR source, one such example is
     82     // Simplify CFG helps the static branch prediction heuristics!
     83     for (auto &Fn : M.getFunctionList()) {
     84       if (!Fn.isDeclaration()) {
     85 
     86         auto IRNames = QueryAnalysis(Fn);
     87         // Instrument and register if Query has result
     88         if (IRNames.hasValue()) {
     89 
     90           // Emit globals for each function.
     91           auto LoadValueTy = Type::getInt8Ty(MContext);
     92           auto SpeculatorGuard = new GlobalVariable(
     93               M, LoadValueTy, false, GlobalValue::LinkageTypes::InternalLinkage,
     94               ConstantInt::get(LoadValueTy, 0),
     95               "__orc_speculate.guard.for." + Fn.getName());
     96           SpeculatorGuard->setAlignment(Align(1));
     97           SpeculatorGuard->setUnnamedAddr(GlobalValue::UnnamedAddr::Local);
     98 
     99           BasicBlock &ProgramEntry = Fn.getEntryBlock();
    100           // Create BasicBlocks before the program's entry basicblock
    101           BasicBlock *SpeculateBlock = BasicBlock::Create(
    102               MContext, "__orc_speculate.block", &Fn, &ProgramEntry);
    103           BasicBlock *SpeculateDecisionBlock = BasicBlock::Create(
    104               MContext, "__orc_speculate.decision.block", &Fn, SpeculateBlock);
    105 
    106           assert(SpeculateDecisionBlock == &Fn.getEntryBlock() &&
    107                  "SpeculateDecisionBlock not updated?");
    108           Mutator.SetInsertPoint(SpeculateDecisionBlock);
    109 
    110           auto LoadGuard =
    111               Mutator.CreateLoad(LoadValueTy, SpeculatorGuard, "guard.value");
    112           // if just loaded value equal to 0,return true.
    113           auto CanSpeculate =
    114               Mutator.CreateICmpEQ(LoadGuard, ConstantInt::get(LoadValueTy, 0),
    115                                    "compare.to.speculate");
    116           Mutator.CreateCondBr(CanSpeculate, SpeculateBlock, &ProgramEntry);
    117 
    118           Mutator.SetInsertPoint(SpeculateBlock);
    119           auto ImplAddrToUint =
    120               Mutator.CreatePtrToInt(&Fn, Type::getInt64Ty(MContext));
    121           Mutator.CreateCall(RuntimeCallTy, RuntimeCall,
    122                              {SpeclAddr, ImplAddrToUint});
    123           Mutator.CreateStore(ConstantInt::get(LoadValueTy, 1),
    124                               SpeculatorGuard);
    125           Mutator.CreateBr(&ProgramEntry);
    126 
    127           assert(Mutator.GetInsertBlock()->getParent() == &Fn &&
    128                  "IR builder association mismatch?");
    129           S.registerSymbols(internToJITSymbols(IRNames.getValue()),
    130                             &R->getTargetJITDylib());
    131         }
    132       }
    133     }
    134   });
    135 
    136   assert(!TSM.withModuleDo([](const Module &M) { return verifyModule(M); }) &&
    137          "Speculation Instrumentation breaks IR?");
    138 
    139   NextLayer.emit(std::move(R), std::move(TSM));
    140 }
    141 
    142 } // namespace orc
    143 } // namespace llvm
    144