llvm/lib/Transforms/Utils/GuardUtils.cpp

   1 //===-- GuardUtils.cpp - Utils for work with guards -------------*- C++ -*-===//
   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 // Utils that are used to perform transformations related to guards and their
   9 // conditions.
  10 //===----------------------------------------------------------------------===//
  11
  12 #include "llvm/Transforms/Utils/GuardUtils.h"
  13 #include "llvm/Analysis/GuardUtils.h"
  14 #include "llvm/IR/Function.h"
  15 #include "llvm/IR/IRBuilder.h"
  16 #include "llvm/IR/Instructions.h"
  17 #include "llvm/IR/MDBuilder.h"
  18 #include "llvm/IR/PatternMatch.h"
  19 #include "llvm/Support/CommandLine.h"
  20 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
  21
  22 using namespace llvm;
  23 using namespace llvm::PatternMatch;
  24
  25 static cl::opt<uint32_t> PredicatePassBranchWeight(
  26     "guards-predicate-pass-branch-weight", cl::Hidden, cl::init(1 << 20),
  27     cl::desc("The probability of a guard failing is assumed to be the "
  28              "reciprocal of this value (default = 1 << 20)"));
  29
  30 void llvm::makeGuardControlFlowExplicit(Function *DeoptIntrinsic,
  31                                         CallInst *Guard, bool UseWC) {
  32   OperandBundleDef DeoptOB(*Guard->getOperandBundle(LLVMContext::OB_deopt));
  33   SmallVector<Value *, 4> Args(drop_begin(Guard->args()));
  34
  35   auto *CheckBB = Guard->getParent();
  36   auto *DeoptBlockTerm =
  37       SplitBlockAndInsertIfThen(Guard->getArgOperand(0), Guard, true);
  38
  39   auto *CheckBI = cast<BranchInst>(CheckBB->getTerminator());
  40
  41   // SplitBlockAndInsertIfThen inserts control flow that branches to
  42   // DeoptBlockTerm if the condition is true.  We want the opposite.
  43   CheckBI->swapSuccessors();
  44
  45   CheckBI->getSuccessor(0)->setName("guarded");
  46   CheckBI->getSuccessor(1)->setName("deopt");
  47
  48   if (auto *MD = Guard->getMetadata(LLVMContext::MD_make_implicit))
  49     CheckBI->setMetadata(LLVMContext::MD_make_implicit, MD);
  50
  51   MDBuilder MDB(Guard->getContext());
  52   CheckBI->setMetadata(LLVMContext::MD_prof,
  53                        MDB.createBranchWeights(PredicatePassBranchWeight, 1));
  54
  55   IRBuilder<> B(DeoptBlockTerm);
  56   auto *DeoptCall = B.CreateCall(DeoptIntrinsic, Args, {DeoptOB}, "");
  57
  58   if (DeoptIntrinsic->getReturnType()->isVoidTy()) {
  59     B.CreateRetVoid();
  60   } else {
  61     DeoptCall->setName("deoptcall");
  62     B.CreateRet(DeoptCall);
  63   }
  64
  65   DeoptCall->setCallingConv(Guard->getCallingConv());
  66   DeoptBlockTerm->eraseFromParent();
  67
  68   if (UseWC) {
  69     // We want the guard to be expressed as explicit control flow, but still be
  70     // widenable. For that, we add Widenable Condition intrinsic call to the
  71     // guard's condition.
  72     IRBuilder<> B(CheckBI);
  73     auto *WC = B.CreateIntrinsic(Intrinsic::experimental_widenable_condition,
  74                                  {}, {}, nullptr, "widenable_cond");
  75     CheckBI->setCondition(B.CreateAnd(CheckBI->getCondition(), WC,
  76                                       "exiplicit_guard_cond"));
  77     assert(isWidenableBranch(CheckBI) && "Branch must be widenable.");
  78   }
  79 }
  80
  81
  82 void llvm::widenWidenableBranch(BranchInst *WidenableBR, Value *NewCond) {
  83   assert(isWidenableBranch(WidenableBR) && "precondition");
  84
  85   // The tempting trivially option is to produce something like this:
  86   // br (and oldcond, newcond) where oldcond is assumed to contain a widenable
  87   // condition, but that doesn't match the pattern parseWidenableBranch expects
  88   // so we have to be more sophisticated.
  89
  90   Use *C, *WC;
  91   BasicBlock *IfTrueBB, *IfFalseBB;
  92   parseWidenableBranch(WidenableBR, C, WC, IfTrueBB, IfFalseBB);
  93   if (!C) {
  94     // br (wc()), ... form
  95     IRBuilder<> B(WidenableBR);
  96     WidenableBR->setCondition(B.CreateAnd(NewCond, WC->get()));
  97   } else {
  98     // br (wc & C), ... form
  99     IRBuilder<> B(WidenableBR);
 100     C->set(B.CreateAnd(NewCond, C->get()));
 101     Instruction *WCAnd = cast<Instruction>(WidenableBR->getCondition());
 102     // Condition is only guaranteed to dominate branch
 103     WCAnd->moveBefore(WidenableBR);
 104   }
 105   assert(isWidenableBranch(WidenableBR) && "preserve widenabiliy");
 106 }
 107
 108 void llvm::setWidenableBranchCond(BranchInst *WidenableBR, Value *NewCond) {
 109   assert(isWidenableBranch(WidenableBR) && "precondition");
 110
 111   Use *C, *WC;
 112   BasicBlock *IfTrueBB, *IfFalseBB;
 113   parseWidenableBranch(WidenableBR, C, WC, IfTrueBB, IfFalseBB);
 114   if (!C) {
 115     // br (wc()), ... form
 116     IRBuilder<> B(WidenableBR);
 117     WidenableBR->setCondition(B.CreateAnd(NewCond, WC->get()));
 118   } else {
 119     // br (wc & C), ... form
 120     Instruction *WCAnd = cast<Instruction>(WidenableBR->getCondition());
 121     // Condition is only guaranteed to dominate branch
 122     WCAnd->moveBefore(WidenableBR);
 123     C->set(NewCond);
 124   }
 125   assert(isWidenableBranch(WidenableBR) && "preserve widenabiliy");
 126 }