77#define DEBUG_TYPE "speculative-execution"
83 cl::desc(
"Speculative execution is not applied to basic blocks where "
84 "the cost of the instructions to speculatively execute "
85 "exceeds this limit."));
93 cl::desc(
"Speculative execution is not applied to basic blocks where the "
94 "number of instructions that would not be speculatively executed "
95 "exceeds this limit."));
99 cl::desc(
"Speculative execution is applied only to targets with divergent "
100 "branches, even if the pass was configured to apply only to all "
105class SpeculativeExecutionLegacyPass :
public FunctionPass {
108 explicit SpeculativeExecutionLegacyPass(
bool OnlyIfDivergentTarget =
false)
109 :
FunctionPass(
ID), OnlyIfDivergentTarget(OnlyIfDivergentTarget ||
111 Impl(OnlyIfDivergentTarget) {}
117 if (OnlyIfDivergentTarget)
118 return "Speculatively execute instructions if target has divergent "
120 return "Speculatively execute instructions";
125 const bool OnlyIfDivergentTarget;
131char SpeculativeExecutionLegacyPass::ID = 0;
133 "Speculatively execute instructions",
false,
false)
138void SpeculativeExecutionLegacyPass::getAnalysisUsage(
AnalysisUsage &AU)
const {
141 AU.setPreservesCFG();
144bool SpeculativeExecutionLegacyPass::runOnFunction(
Function &
F) {
148 auto *
TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
F);
149 return Impl.runImpl(
F,
TTI);
157 "TTI->hasBranchDivergence() is false.\n");
162 bool Changed =
false;
164 Changed |= runOnBasicBlock(
B);
169bool SpeculativeExecutionPass::runOnBasicBlock(
BasicBlock &
B) {
170 BranchInst *BI = dyn_cast<BranchInst>(
B.getTerminator());
179 if (&
B == &Succ0 || &
B == &Succ1 || &Succ0 == &Succ1) {
186 return considerHoistingFromTo(Succ0,
B);
192 return considerHoistingFromTo(Succ1,
B);
204 if (Succ1.
size() == 1)
205 return considerHoistingFromTo(Succ0,
B);
206 if (Succ0.
size() == 1)
207 return considerHoistingFromTo(Succ1,
B);
216 case Instruction::GetElementPtr:
217 case Instruction::Add:
218 case Instruction::Mul:
219 case Instruction::And:
220 case Instruction::Or:
221 case Instruction::Select:
222 case Instruction::Shl:
223 case Instruction::Sub:
224 case Instruction::LShr:
225 case Instruction::AShr:
226 case Instruction::Xor:
227 case Instruction::ZExt:
228 case Instruction::SExt:
229 case Instruction::Call:
230 case Instruction::BitCast:
231 case Instruction::PtrToInt:
232 case Instruction::IntToPtr:
233 case Instruction::AddrSpaceCast:
234 case Instruction::FPToUI:
235 case Instruction::FPToSI:
236 case Instruction::UIToFP:
237 case Instruction::SIToFP:
238 case Instruction::FPExt:
239 case Instruction::FPTrunc:
240 case Instruction::FAdd:
241 case Instruction::FSub:
242 case Instruction::FMul:
243 case Instruction::FDiv:
244 case Instruction::FRem:
245 case Instruction::FNeg:
246 case Instruction::ICmp:
247 case Instruction::FCmp:
248 case Instruction::Trunc:
249 case Instruction::Freeze:
250 case Instruction::ExtractElement:
251 case Instruction::InsertElement:
252 case Instruction::ShuffleVector:
253 case Instruction::ExtractValue:
254 case Instruction::InsertValue:
263bool SpeculativeExecutionPass::considerHoistingFromTo(
267 DbgVariableRecordsToHoist;
268 auto HasNoUnhoistedInstr = [&NotHoisted](
auto Values) {
269 for (
const Value *V : Values) {
270 if (
const auto *
I = dyn_cast_or_null<Instruction>(V))
276 auto AllPrecedingUsesFromBlockHoisted =
277 [&HasNoUnhoistedInstr](
const User *
U) {
279 if (
const auto *DVI = dyn_cast<DbgVariableIntrinsic>(U))
280 return HasNoUnhoistedInstr(DVI->location_ops());
286 if (isa<DbgLabelInst>(U))
289 return HasNoUnhoistedInstr(
U->operand_values());
293 unsigned NotHoistedInstCount = 0;
294 for (
const auto &
I : FromBlock) {
298 if (HasNoUnhoistedInstr(DVR.location_ops()))
299 DbgVariableRecordsToHoist[DVR.getInstruction()].push_back(&DVR);
303 AllPrecedingUsesFromBlockHoisted(&
I)) {
304 TotalSpeculationCost +=
Cost;
309 if (!isa<DbgInfoIntrinsic>(
I))
310 NotHoistedInstCount++;
317 for (
auto I = FromBlock.begin();
I != FromBlock.end();) {
321 if (DbgVariableRecordsToHoist.
contains(&*
I)) {
322 for (
auto *DVR : DbgVariableRecordsToHoist[&*
I]) {
323 DVR->removeFromParent();
332 if (!NotHoisted.
count(&*Current)) {
340 return new SpeculativeExecutionLegacyPass();
344 return new SpeculativeExecutionLegacyPass(
true);
348 : OnlyIfDivergentTarget(OnlyIfDivergentTarget ||
367 OS, MapClassName2PassName);
369 if (OnlyIfDivergentTarget)
370 OS <<
"only-if-divergent-target";
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This is the interface for a simple mod/ref and alias analysis over globals.
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
This file defines the SmallPtrSet class.
static cl::opt< unsigned > SpecExecMaxNotHoisted("spec-exec-max-not-hoisted", cl::init(5), cl::Hidden, cl::desc("Speculative execution is not applied to basic blocks where the " "number of instructions that would not be speculatively executed " "exceeds this limit."))
speculative Speculatively execute instructions
static cl::opt< unsigned > SpecExecMaxSpeculationCost("spec-exec-max-speculation-cost", cl::init(7), cl::Hidden, cl::desc("Speculative execution is not applied to basic blocks where " "the cost of the instructions to speculatively execute " "exceeds this limit."))
static cl::opt< bool > SpecExecOnlyIfDivergentTarget("spec-exec-only-if-divergent-target", cl::init(false), cl::Hidden, cl::desc("Speculative execution is applied only to targets with divergent " "branches, even if the pass was configured to apply only to all " "targets."))
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
LLVM Basic Block Representation.
void insertDbgRecordBefore(DbgRecord *DR, InstListType::iterator Here)
Insert a DbgRecord into a block at the position given by Here.
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Conditional or Unconditional Branch instruction.
unsigned getNumSuccessors() const
BasicBlock * getSuccessor(unsigned i) const
Represents analyses that only rely on functions' control flow.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
FunctionPass class - This class is used to implement most global optimizations.
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
Legacy wrapper pass to provide the GlobalsAAResult object.
static InstructionCost getInvalid(CostType Val=0)
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void preserveSet()
Mark an analysis set as preserved.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SpeculativeExecutionPass(bool OnlyIfDivergentTarget=false)
bool runImpl(Function &F, TargetTransformInfo *TTI)
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
StringRef - Represent a constant reference to a string, i.e.
Analysis pass providing the TargetTransformInfo.
LLVM Value Representation.
An efficient, type-erasing, non-owning reference to a callable.
self_iterator getIterator()
This class implements an extremely fast bulk output stream that can only output to a stream.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
FunctionPass * createSpeculativeExecutionIfHasBranchDivergencePass()
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
FunctionPass * createSpeculativeExecutionPass()
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
static InstructionCost ComputeSpeculationCost(const Instruction *I, const TargetTransformInfo &TTI)
A CRTP mix-in to automatically provide informational APIs needed for passes.