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(ExecutorAddr(StubId));
40 }
41 
42 Error Speculator::addSpeculationRuntime(JITDylib &JD,
43                                         MangleAndInterner &Mangle) {
44   ExecutorSymbolDef ThisPtr(ExecutorAddr::fromPtr(this),
45                             JITSymbolFlags::Exported);
46   ExecutorSymbolDef SpeculateForEntryPtr(
47       ExecutorAddr::fromPtr(&speculateForEntryPoint), JITSymbolFlags::Exported);
48   return JD.define(absoluteSymbols({
49       {Mangle("__orc_speculator"), ThisPtr},                // Data Symbol
50       {Mangle("__orc_speculate_for"), SpeculateForEntryPtr} // Callable Symbol
51   }));
52 }
53 
54 // If two modules, share the same LLVMContext, different threads must
55 // not access them concurrently without locking the associated LLVMContext
56 // this implementation follows this contract.
57 void IRSpeculationLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
58                               ThreadSafeModule TSM) {
59 
60   assert(TSM && "Speculation Layer received Null Module ?");
61   assert(TSM.getContext().getContext() != nullptr &&
62          "Module with null LLVMContext?");
63 
64   // Instrumentation of runtime calls, lock the Module
65   TSM.withModuleDo([this, &R](Module &M) {
66     auto &MContext = M.getContext();
67     auto SpeculatorVTy = StructType::create(MContext, "Class.Speculator");
68     auto RuntimeCallTy = FunctionType::get(
69         Type::getVoidTy(MContext),
70         {SpeculatorVTy->getPointerTo(), Type::getInt64Ty(MContext)}, false);
71     auto RuntimeCall =
72         Function::Create(RuntimeCallTy, Function::LinkageTypes::ExternalLinkage,
73                          "__orc_speculate_for", &M);
74     auto SpeclAddr = new GlobalVariable(
75         M, SpeculatorVTy, false, GlobalValue::LinkageTypes::ExternalLinkage,
76         nullptr, "__orc_speculator");
77 
78     IRBuilder<> Mutator(MContext);
79 
80     // QueryAnalysis allowed to transform the IR source, one such example is
81     // Simplify CFG helps the static branch prediction heuristics!
82     for (auto &Fn : M.getFunctionList()) {
83       if (!Fn.isDeclaration()) {
84 
85         auto IRNames = QueryAnalysis(Fn);
86         // Instrument and register if Query has result
87         if (IRNames) {
88 
89           // Emit globals for each function.
90           auto LoadValueTy = Type::getInt8Ty(MContext);
91           auto SpeculatorGuard = new GlobalVariable(
92               M, LoadValueTy, false, GlobalValue::LinkageTypes::InternalLinkage,
93               ConstantInt::get(LoadValueTy, 0),
94               "__orc_speculate.guard.for." + Fn.getName());
95           SpeculatorGuard->setAlignment(Align(1));
96           SpeculatorGuard->setUnnamedAddr(GlobalValue::UnnamedAddr::Local);
97 
98           BasicBlock &ProgramEntry = Fn.getEntryBlock();
99           // Create BasicBlocks before the program's entry basicblock
100           BasicBlock *SpeculateBlock = BasicBlock::Create(
101               MContext, "__orc_speculate.block", &Fn, &ProgramEntry);
102           BasicBlock *SpeculateDecisionBlock = BasicBlock::Create(
103               MContext, "__orc_speculate.decision.block", &Fn, SpeculateBlock);
104 
105           assert(SpeculateDecisionBlock == &Fn.getEntryBlock() &&
106                  "SpeculateDecisionBlock not updated?");
107           Mutator.SetInsertPoint(SpeculateDecisionBlock);
108 
109           auto LoadGuard =
110               Mutator.CreateLoad(LoadValueTy, SpeculatorGuard, "guard.value");
111           // if just loaded value equal to 0,return true.
112           auto CanSpeculate =
113               Mutator.CreateICmpEQ(LoadGuard, ConstantInt::get(LoadValueTy, 0),
114                                    "compare.to.speculate");
115           Mutator.CreateCondBr(CanSpeculate, SpeculateBlock, &ProgramEntry);
116 
117           Mutator.SetInsertPoint(SpeculateBlock);
118           auto ImplAddrToUint =
119               Mutator.CreatePtrToInt(&Fn, Type::getInt64Ty(MContext));
120           Mutator.CreateCall(RuntimeCallTy, RuntimeCall,
121                              {SpeclAddr, ImplAddrToUint});
122           Mutator.CreateStore(ConstantInt::get(LoadValueTy, 1),
123                               SpeculatorGuard);
124           Mutator.CreateBr(&ProgramEntry);
125 
126           assert(Mutator.GetInsertBlock()->getParent() == &Fn &&
127                  "IR builder association mismatch?");
128           S.registerSymbols(internToJITSymbols(*IRNames),
129                             &R->getTargetJITDylib());
130         }
131       }
132     }
133   });
134 
135   assert(!TSM.withModuleDo([](const Module &M) { return verifyModule(M); }) &&
136          "Speculation Instrumentation breaks IR?");
137 
138   NextLayer.emit(std::move(R), std::move(TSM));
139 }
140 
141 } // namespace orc
142 } // namespace llvm
143