LLVM 17.0.0git
Go to the documentation of this file.
1//===- MakeGuardsExplicit.cpp - Turn guard intrinsics into guard branches -===//
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
9// This pass lowers the @llvm.experimental.guard intrinsic to the new form of
10// guard represented as widenable explicit branch to the deopt block. The
11// difference between this pass and LowerGuardIntrinsic is that after this pass
12// the guard represented as intrinsic:
14// call void(i1, ...) @llvm.experimental.guard(i1 %old_cond) [ "deopt"() ]
16// transforms to a guard represented as widenable explicit branch:
18// %widenable_cond = call i1 @llvm.experimental.widenable.condition()
19// br i1 (%old_cond & %widenable_cond), label %guarded, label %deopt
21// Here:
22// - The semantics of @llvm.experimental.widenable.condition allows to replace
23// %widenable_cond with the construction (%widenable_cond & %any_other_cond)
24// without loss of correctness;
25// - %guarded is the lower part of old guard intrinsic's parent block split by
26// the intrinsic call;
27// - %deopt is a block containing a sole call to @llvm.experimental.deoptimize
28// intrinsic.
30// Therefore, this branch preserves the property of widenability.
38#include "llvm/IR/Intrinsics.h"
40#include "llvm/Pass.h"
43using namespace llvm;
45namespace {
46struct MakeGuardsExplicitLegacyPass : public FunctionPass {
47 static char ID;
48 MakeGuardsExplicitLegacyPass() : FunctionPass(ID) {
50 }
52 bool runOnFunction(Function &F) override;
56static void turnToExplicitForm(CallInst *Guard, Function *DeoptIntrinsic) {
57 // Replace the guard with an explicit branch (just like in GuardWidening).
58 BasicBlock *OriginalBB = Guard->getParent();
59 (void)OriginalBB;
60 makeGuardControlFlowExplicit(DeoptIntrinsic, Guard, true);
61 assert(isWidenableBranch(OriginalBB->getTerminator()) && "should hold");
63 Guard->eraseFromParent();
66static bool explicifyGuards(Function &F) {
67 // Check if we can cheaply rule out the possibility of not having any work to
68 // do.
69 auto *GuardDecl = F.getParent()->getFunction(
70 Intrinsic::getName(Intrinsic::experimental_guard));
71 if (!GuardDecl || GuardDecl->use_empty())
72 return false;
74 SmallVector<CallInst *, 8> GuardIntrinsics;
75 for (auto &I : instructions(F))
76 if (isGuard(&I))
77 GuardIntrinsics.push_back(cast<CallInst>(&I));
79 if (GuardIntrinsics.empty())
80 return false;
82 auto *DeoptIntrinsic = Intrinsic::getDeclaration(
83 F.getParent(), Intrinsic::experimental_deoptimize, {F.getReturnType()});
84 DeoptIntrinsic->setCallingConv(GuardDecl->getCallingConv());
86 for (auto *Guard : GuardIntrinsics)
87 turnToExplicitForm(Guard, DeoptIntrinsic);
89 return true;
92bool MakeGuardsExplicitLegacyPass::runOnFunction(Function &F) {
93 return explicifyGuards(F);
96char MakeGuardsExplicitLegacyPass::ID = 0;
97INITIALIZE_PASS(MakeGuardsExplicitLegacyPass, "make-guards-explicit",
98 "Lower the guard intrinsic to explicit control flow form",
99 false, false)
103 if (explicifyGuards(F))
105 return PreservedAnalyses::all();
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
static void turnToExplicitForm(CallInst *Guard, Function *DeoptIntrinsic)
static bool explicifyGuards(Function &F)
print must be executed print the must be executed context for all instructions
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
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...
Definition: BasicBlock.h:127
This class represents a function call, abstracting a target machine's calling convention.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
const BasicBlock * getParent() const
Definition: Instruction.h:90
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:82
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:155
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
bool empty() const
Definition: SmallVector.h:94
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:992
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1465
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void makeGuardControlFlowExplicit(Function *DeoptIntrinsic, CallInst *Guard, bool UseWC)
Splits control flow at point of Guard, replacing it with explicit branch by the condition of guard's ...
Definition: GuardUtils.cpp:30
void initializeMakeGuardsExplicitLegacyPassPass(PassRegistry &)
bool isGuard(const User *U)
Returns true iff U has semantics of a guard expressed in a form of call of llvm.experimental....
Definition: GuardUtils.cpp:18
bool isWidenableBranch(const User *U)
Returns true iff U is a widenable branch (that is, parseWidenableBranch returns true).
Definition: GuardUtils.cpp:22