1//===-- SimplifyQuery.h - Context for simplifications -----------*- 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
9#ifndef LLVM_ANALYSIS_SIMPLIFYQUERY_H
10#define LLVM_ANALYSIS_SIMPLIFYQUERY_H
11
12#include "llvm/IR/PatternMatch.h"
13
14namespace llvm {
15
16class AssumptionCache;
17class DomConditionCache;
18class DominatorTree;
19class TargetLibraryInfo;
20
21/// InstrInfoQuery provides an interface to query additional information for
22/// instructions like metadata or keywords like nsw, which provides conservative
23/// results if the users specified it is safe to use.
24struct InstrInfoQuery {
25 InstrInfoQuery(bool UMD) : UseInstrInfo(UMD) {}
26 InstrInfoQuery() = default;
27 bool UseInstrInfo = true;
28
29 MDNode *getMetadata(const Instruction *I, unsigned KindID) const {
30 if (UseInstrInfo)
31 return I->getMetadata(KindID);
32 return nullptr;
33 }
34
35 template <class InstT> bool hasNoUnsignedWrap(const InstT *Op) const {
36 if (UseInstrInfo)
37 return Op->hasNoUnsignedWrap();
38 return false;
39 }
40
41 template <class InstT> bool hasNoSignedWrap(const InstT *Op) const {
42 if (UseInstrInfo)
43 return Op->hasNoSignedWrap();
44 return false;
45 }
46
47 bool isExact(const BinaryOperator *Op) const {
48 if (UseInstrInfo && isa<PossiblyExactOperator>(Val: Op))
49 return cast<PossiblyExactOperator>(Val: Op)->isExact();
50 return false;
51 }
52
53 template <class InstT> bool hasNoSignedZeros(const InstT *Op) const {
54 if (UseInstrInfo)
55 return Op->hasNoSignedZeros();
56 return false;
57 }
58};
59
60struct SimplifyQuery {
61 const DataLayout &DL;
62 const TargetLibraryInfo *TLI = nullptr;
63 const DominatorTree *DT = nullptr;
64 AssumptionCache *AC = nullptr;
65 const Instruction *CxtI = nullptr;
66 const DomConditionCache *DC = nullptr;
67
68 // Wrapper to query additional information for instructions like metadata or
69 // keywords like nsw, which provides conservative results if those cannot
70 // be safely used.
71 const InstrInfoQuery IIQ;
72
73 /// Controls whether simplifications are allowed to constrain the range of
74 /// possible values for uses of undef. If it is false, simplifications are not
75 /// allowed to assume a particular value for a use of undef for example.
76 bool CanUseUndef = true;
77
78 SimplifyQuery(const DataLayout &DL, const Instruction *CXTI = nullptr)
79 : DL(DL), CxtI(CXTI) {}
80
81 SimplifyQuery(const DataLayout &DL, const TargetLibraryInfo *TLI,
82 const DominatorTree *DT = nullptr,
83 AssumptionCache *AC = nullptr,
84 const Instruction *CXTI = nullptr, bool UseInstrInfo = true,
85 bool CanUseUndef = true, const DomConditionCache *DC = nullptr)
86 : DL(DL), TLI(TLI), DT(DT), AC(AC), CxtI(CXTI), DC(DC), IIQ(UseInstrInfo),
87 CanUseUndef(CanUseUndef) {}
88
89 SimplifyQuery(const DataLayout &DL, const DominatorTree *DT,
90 AssumptionCache *AC = nullptr,
91 const Instruction *CXTI = nullptr, bool UseInstrInfo = true,
92 bool CanUseUndef = true)
93 : DL(DL), DT(DT), AC(AC), CxtI(CXTI), IIQ(UseInstrInfo),
94 CanUseUndef(CanUseUndef) {}
95
96 SimplifyQuery getWithInstruction(const Instruction *I) const {
97 SimplifyQuery Copy(*this);
98 Copy.CxtI = I;
99 return Copy;
100 }
101 SimplifyQuery getWithoutUndef() const {
102 SimplifyQuery Copy(*this);
103 Copy.CanUseUndef = false;
104 return Copy;
105 }
106
107 /// If CanUseUndef is true, returns whether \p V is undef.
108 /// Otherwise always return false.
109 bool isUndefValue(Value *V) const {
110 if (!CanUseUndef)
111 return false;
112
113 using namespace PatternMatch;
114 return match(V, P: m_Undef());
115 }
116};
117
118} // end namespace llvm
119
120#endif
121

source code of llvm/include/llvm/Analysis/SimplifyQuery.h