llvm/lib/Transforms/Scalar/MakeGuardsExplicit.cpp

   1 //===- MakeGuardsExplicit.cpp - Turn guard intrinsics into guard branches -===//
   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 // 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:
  13 //
  14 //   call void(i1, ...) @llvm.experimental.guard(i1 %old_cond) [ "deopt"() ]
  15 //
  16 // transforms to a guard represented as widenable explicit branch:
  17 //
  18 //   %widenable_cond = call i1 @llvm.experimental.widenable.condition()
  19 //   br i1 (%old_cond & %widenable_cond), label %guarded, label %deopt
  20 //
  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.
  29 //
  30 // Therefore, this branch preserves the property of widenability.
  31 //
  32 //===----------------------------------------------------------------------===//
  33
  34 #include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
  35 #include "llvm/Analysis/GuardUtils.h"
  36 #include "llvm/IR/InstIterator.h"
  37 #include "llvm/IR/Instructions.h"
  38 #include "llvm/IR/Intrinsics.h"
  39 #include "llvm/InitializePasses.h"
  40 #include "llvm/Pass.h"
  41 #include "llvm/Transforms/Utils/GuardUtils.h"
  42
  43 using namespace llvm;
  44
  45 namespace {
  46 struct MakeGuardsExplicitLegacyPass : public FunctionPass {
  47   static char ID;
  48   MakeGuardsExplicitLegacyPass() : FunctionPass(ID) {
  49     initializeMakeGuardsExplicitLegacyPassPass(*PassRegistry::getPassRegistry());
  50   }
  51
  52   bool runOnFunction(Function &F) override;
  53 };
  54 }
  55
  56 static 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");
  62
  63   Guard->eraseFromParent();
  64 }
  65
  66 static 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;
  73
  74   SmallVector<CallInst *, 8> GuardIntrinsics;
  75   for (auto &I : instructions(F))
  76     if (isGuard(&I))
  77       GuardIntrinsics.push_back(cast<CallInst>(&I));
  78
  79   if (GuardIntrinsics.empty())
  80     return false;
  81
  82   auto *DeoptIntrinsic = Intrinsic::getDeclaration(
  83       F.getParent(), Intrinsic::experimental_deoptimize, {F.getReturnType()});
  84   DeoptIntrinsic->setCallingConv(GuardDecl->getCallingConv());
  85
  86   for (auto *Guard : GuardIntrinsics)
  87     turnToExplicitForm(Guard, DeoptIntrinsic);
  88
  89   return true;
  90 }
  91
  92 bool MakeGuardsExplicitLegacyPass::runOnFunction(Function &F) {
  93   return explicifyGuards(F);
  94 }
  95
  96 char MakeGuardsExplicitLegacyPass::ID = 0;
  97 INITIALIZE_PASS(MakeGuardsExplicitLegacyPass, "make-guards-explicit",
  98                 "Lower the guard intrinsic to explicit control flow form",
  99                 false, false)
 100
 101 PreservedAnalyses MakeGuardsExplicitPass::run(Function &F,
 102                                            FunctionAnalysisManager &) {
 103   if (explicifyGuards(F))
 104     return PreservedAnalyses::none();
 105   return PreservedAnalyses::all();
 106 }