LLVM 19.0.0git
Speculation.cpp
Go to the documentation of this file.
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
10#include "llvm/IR/BasicBlock.h"
11#include "llvm/IR/Function.h"
12#include "llvm/IR/IRBuilder.h"
13#include "llvm/IR/Instruction.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
20namespace llvm {
21
22namespace orc {
23
24// ImplSymbolMap methods
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.
37void Speculator::speculateForEntryPoint(Speculator *Ptr, uint64_t StubId) {
38 assert(Ptr && " Null Address Received in orc_speculate_for ");
39 Ptr->speculateFor(ExecutorAddr(StubId));
40}
41
43 MangleAndInterner &Mangle) {
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.
57void 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 {PointerType::getUnqual(MContext), Type::getInt64Ty(MContext)}, false);
71 auto RuntimeCall =
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
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:199
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:206
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:163
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:59
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:52
BasicBlock * GetInsertBlock() const
Definition: IRBuilder.h:174
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2231
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:1120
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Definition: IRBuilder.h:1790
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1803
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2107
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
Definition: IRBuilder.h:1114
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Definition: IRBuilder.h:180
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2402
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2656
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:662
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
Definition: Type.cpp:513
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
Represents an address in the executor process.
static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())
Create an ExecutorAddr from the given pointer.
Represents a defining location for a JIT symbol.
virtual void emit(std::unique_ptr< MaterializationResponsibility > R, ThreadSafeModule TSM)=0
Emit should materialize the given IR.
void emit(std::unique_ptr< MaterializationResponsibility > R, ThreadSafeModule TSM) override
Emit should materialize the given IR.
Definition: Speculation.cpp:57
void trackImpls(SymbolAliasMap ImplMaps, JITDylib *SrcJD)
Definition: Speculation.cpp:25
Represents a JIT'd dynamic library.
Definition: Core.h:989
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
Definition: Core.h:1922
Mangles symbol names then uniques them in the context of an ExecutionSession.
Definition: Mangling.h:26
Error addSpeculationRuntime(JITDylib &JD, MangleAndInterner &Mangle)
Define symbols for this Speculator object (__orc_speculator) and the speculation runtime entry point ...
Definition: Speculation.cpp:42
void registerSymbols(FunctionCandidatesMap Candidates, JITDylib *JD)
Definition: Speculation.h:139
LLVMContext * getContext()
Returns a pointer to the LLVMContext that was used to construct this instance, or null if the instanc...
An LLVM Module together with a shared ThreadSafeContext.
ThreadSafeContext getContext() const
Returns the context for this ThreadSafeModule.
decltype(auto) withModuleDo(Func &&F)
Locks the associated ThreadSafeContext and calls the given function on the contained Module.
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
Definition: Core.h:791
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39