143 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/ExecutionEngine/Orc/Speculation.h"10 11#include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h"12#include "llvm/IR/BasicBlock.h"13#include "llvm/IR/Function.h"14#include "llvm/IR/IRBuilder.h"15#include "llvm/IR/Instruction.h"16#include "llvm/IR/Instructions.h"17#include "llvm/IR/LLVMContext.h"18#include "llvm/IR/Module.h"19#include "llvm/IR/Type.h"20#include "llvm/IR/Verifier.h"21 22namespace llvm {23 24namespace orc {25 26// ImplSymbolMap methods27void ImplSymbolMap::trackImpls(SymbolAliasMap ImplMaps, JITDylib *SrcJD) {28 assert(SrcJD && "Tracking on Null Source .impl dylib");29 std::lock_guard<std::mutex> Lockit(ConcurrentAccess);30 for (auto &I : ImplMaps) {31 auto It = Maps.insert({I.first, {I.second.Aliasee, SrcJD}});32 // check rationale when independent dylibs have same symbol name?33 assert(It.second && "ImplSymbols are already tracked for this Symbol?");34 (void)(It);35 }36}37 38// Trigger Speculative Compiles.39void Speculator::speculateForEntryPoint(Speculator *Ptr, uint64_t StubId) {40 assert(Ptr && " Null Address Received in orc_speculate_for ");41 Ptr->speculateFor(ExecutorAddr(StubId));42}43 44Error Speculator::addSpeculationRuntime(JITDylib &JD,45 MangleAndInterner &Mangle) {46 ExecutorSymbolDef ThisPtr(ExecutorAddr::fromPtr(this),47 JITSymbolFlags::Exported);48 ExecutorSymbolDef SpeculateForEntryPtr(49 ExecutorAddr::fromPtr(&speculateForEntryPoint), JITSymbolFlags::Exported);50 return JD.define(absoluteSymbols({51 {Mangle("__orc_speculator"), ThisPtr}, // Data Symbol52 {Mangle("__orc_speculate_for"), SpeculateForEntryPtr} // Callable Symbol53 }));54}55 56// If two modules, share the same LLVMContext, different threads must57// not access them concurrently without locking the associated LLVMContext58// this implementation follows this contract.59void IRSpeculationLayer::emit(std::unique_ptr<MaterializationResponsibility> R,60 ThreadSafeModule TSM) {61 62 assert(TSM && "Speculation Layer received Null Module ?");63 64 // Instrumentation of runtime calls, lock the Module65 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 =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 is81 // 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 result87 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 basicblock100 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 orc142} // namespace llvm143