LLVM 19.0.0git
AssumeBundleQueries.h
Go to the documentation of this file.
1//===- AssumeBundleQueries.h - utilis to query assume bundles ---*- 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// This file contain tools to query into assume bundles. assume bundles can be
10// built using utilities from Transform/Utils/AssumeBundleBuilder.h
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ANALYSIS_ASSUMEBUNDLEQUERIES_H
15#define LLVM_ANALYSIS_ASSUMEBUNDLEQUERIES_H
16
17#include "llvm/ADT/DenseMap.h"
19
20namespace llvm {
21class AssumptionCache;
22class DominatorTree;
23class Instruction;
24class Value;
25
26/// Index of elements in the operand bundle.
27/// If the element exist it is guaranteed to be what is specified in this enum
28/// but it may not exist.
32};
33
34/// Query the operand bundle of an llvm.assume to find a single attribute of
35/// the specified kind applied on a specified Value.
36///
37/// This has a non-constant complexity. It should only be used when a single
38/// attribute is going to be queried.
39///
40/// Return true iff the queried attribute was found.
41/// If ArgVal is set. the argument will be stored to ArgVal.
42bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn, StringRef AttrName,
43 uint64_t *ArgVal = nullptr);
44inline bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn,
46 uint64_t *ArgVal = nullptr) {
47 return hasAttributeInAssume(Assume, IsOn,
48 Attribute::getNameFromAttrKind(Kind), ArgVal);
49}
50
51template<> struct DenseMapInfo<Attribute::AttrKind> {
54 }
57 }
58 static unsigned getHashValue(Attribute::AttrKind AK) {
59 return hash_combine(AK);
60 }
62 return LHS == RHS;
63 }
64};
65
66/// The map Key contains the Value on for which the attribute is valid and
67/// the Attribute that is valid for that value.
68/// If the Attribute is not on any value, the Value is nullptr.
69using RetainedKnowledgeKey = std::pair<Value *, Attribute::AttrKind>;
70
71struct MinMax {
74};
75
76/// A mapping from intrinsics (=`llvm.assume` calls) to a value range
77/// (=knowledge) that is encoded in them. How the value range is interpreted
78/// depends on the RetainedKnowledgeKey that was used to get this out of the
79/// RetainedKnowledgeMap.
81
84
85/// Insert into the map all the informations contained in the operand bundles of
86/// the llvm.assume. This should be used instead of hasAttributeInAssume when
87/// many queries are going to be made on the same llvm.assume.
88/// String attributes are not inserted in the map.
89/// If the IR changes the map will be outdated.
91
92/// Represent one information held inside an operand bundle of an llvm.assume.
93/// AttrKind is the property that holds.
94/// WasOn if not null is that Value for which AttrKind holds.
95/// ArgValue is optionally an argument of the attribute.
96/// For example if we know that %P has an alignment of at least four:
97/// - AttrKind will be Attribute::Alignment.
98/// - WasOn will be %P.
99/// - ArgValue will be 4.
103 Value *WasOn = nullptr;
105 return AttrKind == Other.AttrKind && WasOn == Other.WasOn &&
106 ArgValue == Other.ArgValue;
107 }
108 bool operator!=(RetainedKnowledge Other) const { return !(*this == Other); }
109 /// This is only intended for use in std::min/std::max between attribute that
110 /// only differ in ArgValue.
112 assert(((AttrKind == Other.AttrKind && WasOn == Other.WasOn) ||
113 AttrKind == Attribute::None || Other.AttrKind == Attribute::None) &&
114 "This is only intend for use in min/max to select the best for "
115 "RetainedKnowledge that is otherwise equal");
116 return ArgValue < Other.ArgValue;
117 }
118 operator bool() const { return AttrKind != Attribute::None; }
120};
121
122/// Retreive the information help by Assume on the operand at index Idx.
123/// Assume should be an llvm.assume and Idx should be in the operand bundle.
124RetainedKnowledge getKnowledgeFromOperandInAssume(AssumeInst &Assume,
125 unsigned Idx);
126
127/// Retreive the information help by the Use U of an llvm.assume. the use should
128/// be in the operand bundle.
130 return getKnowledgeFromOperandInAssume(*cast<AssumeInst>(U->getUser()),
131 U->getOperandNo());
132}
133
134/// Tag in operand bundle indicating that this bundle should be ignored.
135constexpr StringRef IgnoreBundleTag = "ignore";
136
137/// Return true iff the operand bundles of the provided llvm.assume doesn't
138/// contain any valuable information. This is true when:
139/// - The operand bundle is empty
140/// - The operand bundle only contains information about dropped values or
141/// constant folded values.
142///
143/// the argument to the call of llvm.assume may still be useful even if the
144/// function returned true.
145bool isAssumeWithEmptyBundle(const AssumeInst &Assume);
146
147/// Return a valid Knowledge associated to the Use U if its Attribute kind is
148/// in AttrKinds.
151
152/// Return a valid Knowledge associated to the Value V if its Attribute kind is
153/// in AttrKinds and it matches the Filter.
155 const Value *V, ArrayRef<Attribute::AttrKind> AttrKinds,
156 AssumptionCache *AC = nullptr,
158 const CallBase::BundleOpInfo *)>
159 Filter = [](auto...) { return true; });
160
161/// Return a valid Knowledge associated to the Value V if its Attribute kind is
162/// in AttrKinds and the knowledge is suitable to be used in the context of
163/// CtxI.
164RetainedKnowledge getKnowledgeValidInContext(
165 const Value *V, ArrayRef<Attribute::AttrKind> AttrKinds,
166 const Instruction *CtxI, const DominatorTree *DT = nullptr,
167 AssumptionCache *AC = nullptr);
168
169/// This extracts the Knowledge from an element of an operand bundle.
170/// This is mostly for use in the assume builder.
171RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume,
172 const CallBase::BundleOpInfo &BOI);
173
174} // namespace llvm
175
176#endif
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This represents the llvm.assume intrinsic.
A cache of @llvm.assume calls within a function.
static StringRef getNameFromAttrKind(Attribute::AttrKind AttrKind)
Definition: Attributes.cpp:274
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:85
@ TombstoneKey
Use as Tombstone key for DenseMap of AttrKind.
Definition: Attributes.h:92
@ None
No attributes have been set.
Definition: Attributes.h:87
@ EmptyKey
Use as Empty key for DenseMap of AttrKind.
Definition: Attributes.h:91
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
An efficient, type-erasing, non-owning reference to a callable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
RetainedKnowledge getKnowledgeFromOperandInAssume(AssumeInst &Assume, unsigned Idx)
Retreive the information help by Assume on the operand at index Idx.
constexpr StringRef IgnoreBundleTag
Tag in operand bundle indicating that this bundle should be ignored.
bool isAssumeWithEmptyBundle(const AssumeInst &Assume)
Return true iff the operand bundles of the provided llvm.assume doesn't contain any valuable informat...
RetainedKnowledge getKnowledgeValidInContext(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, const Instruction *CtxI, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the know...
RetainedKnowledge getKnowledgeForValue(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, AssumptionCache *AC=nullptr, function_ref< bool(RetainedKnowledge, Instruction *, const CallBase::BundleOpInfo *)> Filter=[](auto...) { return true;})
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and it match...
RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
RetainedKnowledge getKnowledgeFromUse(const Use *U, ArrayRef< Attribute::AttrKind > AttrKinds)
Return a valid Knowledge associated to the Use U if its Attribute kind is in AttrKinds.
@ Other
Any other memory.
std::pair< Value *, Attribute::AttrKind > RetainedKnowledgeKey
The map Key contains the Value on for which the attribute is valid and the Attribute that is valid fo...
bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn, StringRef AttrName, uint64_t *ArgVal=nullptr)
Query the operand bundle of an llvm.assume to find a single attribute of the specified kind applied o...
void fillMapFromAssume(AssumeInst &Assume, RetainedKnowledgeMap &Result)
Insert into the map all the informations contained in the operand bundles of the llvm....
RetainedKnowledge getKnowledgeFromUseInAssume(const Use *U)
Retreive the information help by the Use U of an llvm.assume.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:613
AssumeBundleArg
Index of elements in the operand bundle.
Used to keep track of an operand bundle.
Definition: InstrTypes.h:2458
static Attribute::AttrKind getEmptyKey()
static unsigned getHashValue(Attribute::AttrKind AK)
static bool isEqual(Attribute::AttrKind LHS, Attribute::AttrKind RHS)
static Attribute::AttrKind getTombstoneKey()
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: DenseMapInfo.h:50
Represent one information held inside an operand bundle of an llvm.assume.
Attribute::AttrKind AttrKind
static RetainedKnowledge none()
bool operator!=(RetainedKnowledge Other) const
bool operator==(RetainedKnowledge Other) const
bool operator<(RetainedKnowledge Other) const
This is only intended for use in std::min/stdmax between attribute that only differ in ArgValue.