1 //===- LowerConstantIntrinsics.cpp - Lower constant intrinsic calls -------===//
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
7 //===----------------------------------------------------------------------===//
9 // This pass lowers all remaining 'objectsize' 'is.constant' intrinsic calls
10 // and provides constant propagation and basic CFG cleanup on the result.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
15 #include "llvm/ADT/PostOrderIterator.h"
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/Analysis/InstructionSimplify.h"
18 #include "llvm/Analysis/MemoryBuiltins.h"
19 #include "llvm/Analysis/TargetLibraryInfo.h"
20 #include "llvm/IR/BasicBlock.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/Function.h"
23 #include "llvm/IR/Instructions.h"
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/PatternMatch.h"
27 #include "llvm/InitializePasses.h"
28 #include "llvm/Pass.h"
29 #include "llvm/Support/Debug.h"
30 #include "llvm/Transforms/Scalar.h"
31 #include "llvm/Transforms/Utils/Local.h"
34 using namespace llvm::PatternMatch;
36 #define DEBUG_TYPE "lower-is-constant-intrinsic"
38 STATISTIC(IsConstantIntrinsicsHandled,
39 "Number of 'is.constant' intrinsic calls handled");
40 STATISTIC(ObjectSizeIntrinsicsHandled,
41 "Number of 'objectsize' intrinsic calls handled");
43 static Value *lowerIsConstantIntrinsic(IntrinsicInst *II) {
44 Value *Op = II->getOperand(0);
46 return isa<Constant>(Op) ? ConstantInt::getTrue(II->getType())
47 : ConstantInt::getFalse(II->getType());
50 static bool replaceConditionalBranchesOnConstant(Instruction *II,
52 bool HasDeadBlocks = false;
53 SmallSetVector<Instruction *, 8> Worklist;
54 replaceAndRecursivelySimplify(II, NewValue, nullptr, nullptr, nullptr,
56 for (auto I : Worklist) {
57 BranchInst *BI = dyn_cast<BranchInst>(I);
60 if (BI->isUnconditional())
63 BasicBlock *Target, *Other;
64 if (match(BI->getOperand(0), m_Zero())) {
65 Target = BI->getSuccessor(1);
66 Other = BI->getSuccessor(0);
67 } else if (match(BI->getOperand(0), m_One())) {
68 Target = BI->getSuccessor(0);
69 Other = BI->getSuccessor(1);
74 if (Target && Target != Other) {
75 BasicBlock *Source = BI->getParent();
76 Other->removePredecessor(Source);
77 BI->eraseFromParent();
78 BranchInst::Create(Target, Source);
79 if (pred_begin(Other) == pred_end(Other))
86 static bool lowerConstantIntrinsics(Function &F, const TargetLibraryInfo *TLI) {
87 bool HasDeadBlocks = false;
88 const auto &DL = F.getParent()->getDataLayout();
89 SmallVector<WeakTrackingVH, 8> Worklist;
91 ReversePostOrderTraversal<Function *> RPOT(&F);
92 for (BasicBlock *BB : RPOT) {
93 for (Instruction &I: *BB) {
94 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I);
97 switch (II->getIntrinsicID()) {
100 case Intrinsic::is_constant:
101 case Intrinsic::objectsize:
102 Worklist.push_back(WeakTrackingVH(&I));
107 for (WeakTrackingVH &VH: Worklist) {
108 // Items on the worklist can be mutated by earlier recursive replaces.
109 // This can remove the intrinsic as dead (VH == null), but also replace
110 // the intrinsic in place.
113 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&*VH);
117 switch (II->getIntrinsicID()) {
120 case Intrinsic::is_constant:
121 NewValue = lowerIsConstantIntrinsic(II);
122 IsConstantIntrinsicsHandled++;
124 case Intrinsic::objectsize:
125 NewValue = lowerObjectSizeCall(II, DL, TLI, true);
126 ObjectSizeIntrinsicsHandled++;
129 HasDeadBlocks |= replaceConditionalBranchesOnConstant(II, NewValue);
132 removeUnreachableBlocks(F);
133 return !Worklist.empty();
137 LowerConstantIntrinsicsPass::run(Function &F, FunctionAnalysisManager &AM) {
138 if (lowerConstantIntrinsics(F, AM.getCachedResult<TargetLibraryAnalysis>(F)))
139 return PreservedAnalyses::none();
141 return PreservedAnalyses::all();
145 /// Legacy pass for lowering is.constant intrinsics out of the IR.
147 /// When this pass is run over a function it converts is.constant intrinsics
148 /// into 'true' or 'false'. This is completements the normal constand folding
149 /// to 'true' as part of Instruction Simplify passes.
150 class LowerConstantIntrinsics : public FunctionPass {
153 LowerConstantIntrinsics() : FunctionPass(ID) {
154 initializeLowerConstantIntrinsicsPass(*PassRegistry::getPassRegistry());
157 bool runOnFunction(Function &F) override {
158 auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
159 const TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI(F) : nullptr;
160 return lowerConstantIntrinsics(F, TLI);
165 char LowerConstantIntrinsics::ID = 0;
166 INITIALIZE_PASS(LowerConstantIntrinsics, "lower-constant-intrinsics",
167 "Lower constant intrinsics", false, false)
169 FunctionPass *llvm::createLowerConstantIntrinsicsPass() {
170 return new LowerConstantIntrinsics();