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
20namespace llvm {
21
22namespace orc {
23
24// ImplSymbolMap methods
25void 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.
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
42Error 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.
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 =
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