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