Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/Transforms/Scalar/MakeGuardsExplicit.cpp
Line
Count
Source (jump to first uncovered line)
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/IntrinsicInst.h"
38
#include "llvm/IR/Intrinsics.h"
39
#include "llvm/IR/IRBuilder.h"
40
#include "llvm/Pass.h"
41
#include "llvm/Transforms/Scalar.h"
42
#include "llvm/Transforms/Utils/GuardUtils.h"
43
44
using namespace llvm;
45
46
namespace {
47
struct MakeGuardsExplicitLegacyPass : public FunctionPass {
48
  static char ID;
49
2
  MakeGuardsExplicitLegacyPass() : FunctionPass(ID) {
50
2
    initializeMakeGuardsExplicitLegacyPassPass(*PassRegistry::getPassRegistry());
51
2
  }
52
53
  bool runOnFunction(Function &F) override;
54
};
55
}
56
57
20
static void turnToExplicitForm(CallInst *Guard, Function *DeoptIntrinsic) {
58
20
  // Replace the guard with an explicit branch (just like in GuardWidening).
59
20
  BasicBlock *BB = Guard->getParent();
60
20
  makeGuardControlFlowExplicit(DeoptIntrinsic, Guard);
61
20
  BranchInst *ExplicitGuard = cast<BranchInst>(BB->getTerminator());
62
20
  assert(ExplicitGuard->isConditional() && "Must be!");
63
20
64
20
  // We want the guard to be expressed as explicit control flow, but still be
65
20
  // widenable. For that, we add Widenable Condition intrinsic call to the
66
20
  // guard's condition.
67
20
  IRBuilder<> B(ExplicitGuard);
68
20
  auto *WidenableCondition =
69
20
      B.CreateIntrinsic(Intrinsic::experimental_widenable_condition,
70
20
                        {}, {}, nullptr, "widenable_cond");
71
20
  WidenableCondition->setCallingConv(Guard->getCallingConv());
72
20
  auto *NewCond =
73
20
      B.CreateAnd(ExplicitGuard->getCondition(), WidenableCondition);
74
20
  NewCond->setName("exiplicit_guard_cond");
75
20
  ExplicitGuard->setCondition(NewCond);
76
20
  Guard->eraseFromParent();
77
20
}
78
79
12
static bool explicifyGuards(Function &F) {
80
12
  // Check if we can cheaply rule out the possibility of not having any work to
81
12
  // do.
82
12
  auto *GuardDecl = F.getParent()->getFunction(
83
12
      Intrinsic::getName(Intrinsic::experimental_guard));
84
12
  if (!GuardDecl || GuardDecl->use_empty())
85
0
    return false;
86
12
87
12
  SmallVector<CallInst *, 8> GuardIntrinsics;
88
12
  for (auto &I : instructions(F))
89
78
    if (isGuard(&I))
90
20
      GuardIntrinsics.push_back(cast<CallInst>(&I));
91
12
92
12
  if (GuardIntrinsics.empty())
93
0
    return false;
94
12
95
12
  auto *DeoptIntrinsic = Intrinsic::getDeclaration(
96
12
      F.getParent(), Intrinsic::experimental_deoptimize, {F.getReturnType()});
97
12
  DeoptIntrinsic->setCallingConv(GuardDecl->getCallingConv());
98
12
99
12
  for (auto *Guard : GuardIntrinsics)
100
20
    turnToExplicitForm(Guard, DeoptIntrinsic);
101
12
102
12
  return true;
103
12
}
104
105
6
bool MakeGuardsExplicitLegacyPass::runOnFunction(Function &F) {
106
6
  return explicifyGuards(F);
107
6
}
108
109
char MakeGuardsExplicitLegacyPass::ID = 0;
110
INITIALIZE_PASS(MakeGuardsExplicitLegacyPass, "make-guards-explicit",
111
                "Lower the guard intrinsic to explicit control flow form",
112
                false, false)
113
114
PreservedAnalyses MakeGuardsExplicitPass::run(Function &F,
115
6
                                           FunctionAnalysisManager &) {
116
6
  if (explicifyGuards(F))
117
6
    return PreservedAnalyses::none();
118
0
  return PreservedAnalyses::all();
119
0
}