Bug Summary

File:src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis/ValueTracking.h
Warning:line 282, column 49
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name AttributorAttributes.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Transforms/IPO/AttributorAttributes.cpp

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Transforms/IPO/AttributorAttributes.cpp

1//===- AttributorAttributes.cpp - Attributes for Attributor deduction -----===//
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// See the Attributor.h file comment and the class descriptions in that file for
10// more information.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Transforms/IPO/Attributor.h"
15
16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/SCCIterator.h"
18#include "llvm/ADT/SmallPtrSet.h"
19#include "llvm/ADT/Statistic.h"
20#include "llvm/Analysis/AliasAnalysis.h"
21#include "llvm/Analysis/AssumeBundleQueries.h"
22#include "llvm/Analysis/AssumptionCache.h"
23#include "llvm/Analysis/CaptureTracking.h"
24#include "llvm/Analysis/InstructionSimplify.h"
25#include "llvm/Analysis/LazyValueInfo.h"
26#include "llvm/Analysis/MemoryBuiltins.h"
27#include "llvm/Analysis/OptimizationRemarkEmitter.h"
28#include "llvm/Analysis/ScalarEvolution.h"
29#include "llvm/Analysis/TargetTransformInfo.h"
30#include "llvm/Analysis/ValueTracking.h"
31#include "llvm/IR/Constants.h"
32#include "llvm/IR/IRBuilder.h"
33#include "llvm/IR/Instruction.h"
34#include "llvm/IR/Instructions.h"
35#include "llvm/IR/IntrinsicInst.h"
36#include "llvm/IR/NoFolder.h"
37#include "llvm/Support/Alignment.h"
38#include "llvm/Support/Casting.h"
39#include "llvm/Support/CommandLine.h"
40#include "llvm/Support/ErrorHandling.h"
41#include "llvm/Support/FileSystem.h"
42#include "llvm/Support/raw_ostream.h"
43#include "llvm/Transforms/IPO/ArgumentPromotion.h"
44#include "llvm/Transforms/Utils/Local.h"
45#include <cassert>
46
47using namespace llvm;
48
49#define DEBUG_TYPE"attributor" "attributor"
50
51static cl::opt<bool> ManifestInternal(
52 "attributor-manifest-internal", cl::Hidden,
53 cl::desc("Manifest Attributor internal string attributes."),
54 cl::init(false));
55
56static cl::opt<int> MaxHeapToStackSize("max-heap-to-stack-size", cl::init(128),
57 cl::Hidden);
58
59template <>
60unsigned llvm::PotentialConstantIntValuesState::MaxPotentialValues = 0;
61
62static cl::opt<unsigned, true> MaxPotentialValues(
63 "attributor-max-potential-values", cl::Hidden,
64 cl::desc("Maximum number of potential values to be "
65 "tracked for each position."),
66 cl::location(llvm::PotentialConstantIntValuesState::MaxPotentialValues),
67 cl::init(7));
68
69STATISTIC(NumAAs, "Number of abstract attributes created")static llvm::Statistic NumAAs = {"attributor", "NumAAs", "Number of abstract attributes created"
}
;
70
71// Some helper macros to deal with statistics tracking.
72//
73// Usage:
74// For simple IR attribute tracking overload trackStatistics in the abstract
75// attribute and choose the right STATS_DECLTRACK_********* macro,
76// e.g.,:
77// void trackStatistics() const override {
78// STATS_DECLTRACK_ARG_ATTR(returned)
79// }
80// If there is a single "increment" side one can use the macro
81// STATS_DECLTRACK with a custom message. If there are multiple increment
82// sides, STATS_DECL and STATS_TRACK can also be used separately.
83//
84#define BUILD_STAT_MSG_IR_ATTR(TYPE, NAME)("Number of " "TYPE" " marked '" "NAME" "'") \
85 ("Number of " #TYPE " marked '" #NAME "'")
86#define BUILD_STAT_NAME(NAME, TYPE)NumIRTYPE_NAME NumIR##TYPE##_##NAME
87#define STATS_DECL_(NAME, MSG)static llvm::Statistic NAME = {"attributor", "NAME", MSG}; STATISTIC(NAME, MSG)static llvm::Statistic NAME = {"attributor", "NAME", MSG};
88#define STATS_DECL(NAME, TYPE, MSG)static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};;
\
89 STATS_DECL_(BUILD_STAT_NAME(NAME, TYPE), MSG)static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};
;
90#define STATS_TRACK(NAME, TYPE)++(NumIRTYPE_NAME); ++(BUILD_STAT_NAME(NAME, TYPE)NumIRTYPE_NAME);
91#define STATS_DECLTRACK(NAME, TYPE, MSG){ static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};; ++(NumIRTYPE_NAME); }
\
92 { \
93 STATS_DECL(NAME, TYPE, MSG)static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};;
\
94 STATS_TRACK(NAME, TYPE)++(NumIRTYPE_NAME); \
95 }
96#define STATS_DECLTRACK_ARG_ATTR(NAME){ static llvm::Statistic NumIRArguments_NAME = {"attributor",
"NumIRArguments_NAME", ("Number of " "arguments" " marked '"
"NAME" "'")};; ++(NumIRArguments_NAME); }
\
97 STATS_DECLTRACK(NAME, Arguments, BUILD_STAT_MSG_IR_ATTR(arguments, NAME)){ static llvm::Statistic NumIRArguments_NAME = {"attributor",
"NumIRArguments_NAME", ("Number of " "arguments" " marked '"
"NAME" "'")};; ++(NumIRArguments_NAME); }
98#define STATS_DECLTRACK_CSARG_ATTR(NAME){ static llvm::Statistic NumIRCSArguments_NAME = {"attributor"
, "NumIRCSArguments_NAME", ("Number of " "call site arguments"
" marked '" "NAME" "'")};; ++(NumIRCSArguments_NAME); }
\
99 STATS_DECLTRACK(NAME, CSArguments, \{ static llvm::Statistic NumIRCSArguments_NAME = {"attributor"
, "NumIRCSArguments_NAME", ("Number of " "call site arguments"
" marked '" "NAME" "'")};; ++(NumIRCSArguments_NAME); }
100 BUILD_STAT_MSG_IR_ATTR(call site arguments, NAME)){ static llvm::Statistic NumIRCSArguments_NAME = {"attributor"
, "NumIRCSArguments_NAME", ("Number of " "call site arguments"
" marked '" "NAME" "'")};; ++(NumIRCSArguments_NAME); }
101#define STATS_DECLTRACK_FN_ATTR(NAME){ static llvm::Statistic NumIRFunction_NAME = {"attributor", "NumIRFunction_NAME"
, ("Number of " "functions" " marked '" "NAME" "'")};; ++(NumIRFunction_NAME
); }
\
102 STATS_DECLTRACK(NAME, Function, BUILD_STAT_MSG_IR_ATTR(functions, NAME)){ static llvm::Statistic NumIRFunction_NAME = {"attributor", "NumIRFunction_NAME"
, ("Number of " "functions" " marked '" "NAME" "'")};; ++(NumIRFunction_NAME
); }
103#define STATS_DECLTRACK_CS_ATTR(NAME){ static llvm::Statistic NumIRCS_NAME = {"attributor", "NumIRCS_NAME"
, ("Number of " "call site" " marked '" "NAME" "'")};; ++(NumIRCS_NAME
); }
\
104 STATS_DECLTRACK(NAME, CS, BUILD_STAT_MSG_IR_ATTR(call site, NAME)){ static llvm::Statistic NumIRCS_NAME = {"attributor", "NumIRCS_NAME"
, ("Number of " "call site" " marked '" "NAME" "'")};; ++(NumIRCS_NAME
); }
105#define STATS_DECLTRACK_FNRET_ATTR(NAME){ static llvm::Statistic NumIRFunctionReturn_NAME = {"attributor"
, "NumIRFunctionReturn_NAME", ("Number of " "function returns"
" marked '" "NAME" "'")};; ++(NumIRFunctionReturn_NAME); }
\
106 STATS_DECLTRACK(NAME, FunctionReturn, \{ static llvm::Statistic NumIRFunctionReturn_NAME = {"attributor"
, "NumIRFunctionReturn_NAME", ("Number of " "function returns"
" marked '" "NAME" "'")};; ++(NumIRFunctionReturn_NAME); }
107 BUILD_STAT_MSG_IR_ATTR(function returns, NAME)){ static llvm::Statistic NumIRFunctionReturn_NAME = {"attributor"
, "NumIRFunctionReturn_NAME", ("Number of " "function returns"
" marked '" "NAME" "'")};; ++(NumIRFunctionReturn_NAME); }
108#define STATS_DECLTRACK_CSRET_ATTR(NAME){ static llvm::Statistic NumIRCSReturn_NAME = {"attributor", "NumIRCSReturn_NAME"
, ("Number of " "call site returns" " marked '" "NAME" "'")};
; ++(NumIRCSReturn_NAME); }
\
109 STATS_DECLTRACK(NAME, CSReturn, \{ static llvm::Statistic NumIRCSReturn_NAME = {"attributor", "NumIRCSReturn_NAME"
, ("Number of " "call site returns" " marked '" "NAME" "'")};
; ++(NumIRCSReturn_NAME); }
110 BUILD_STAT_MSG_IR_ATTR(call site returns, NAME)){ static llvm::Statistic NumIRCSReturn_NAME = {"attributor", "NumIRCSReturn_NAME"
, ("Number of " "call site returns" " marked '" "NAME" "'")};
; ++(NumIRCSReturn_NAME); }
111#define STATS_DECLTRACK_FLOATING_ATTR(NAME){ static llvm::Statistic NumIRFloating_NAME = {"attributor", "NumIRFloating_NAME"
, ("Number of floating values known to be '" "NAME" "'")};; ++
(NumIRFloating_NAME); }
\
112 STATS_DECLTRACK(NAME, Floating, \{ static llvm::Statistic NumIRFloating_NAME = {"attributor", "NumIRFloating_NAME"
, ("Number of floating values known to be '" #NAME "'")};; ++
(NumIRFloating_NAME); }
113 ("Number of floating values known to be '" #NAME "'")){ static llvm::Statistic NumIRFloating_NAME = {"attributor", "NumIRFloating_NAME"
, ("Number of floating values known to be '" #NAME "'")};; ++
(NumIRFloating_NAME); }
114
115// Specialization of the operator<< for abstract attributes subclasses. This
116// disambiguates situations where multiple operators are applicable.
117namespace llvm {
118#define PIPE_OPERATOR(CLASS) \
119 raw_ostream &operator<<(raw_ostream &OS, const CLASS &AA) { \
120 return OS << static_cast<const AbstractAttribute &>(AA); \
121 }
122
123PIPE_OPERATOR(AAIsDead)
124PIPE_OPERATOR(AANoUnwind)
125PIPE_OPERATOR(AANoSync)
126PIPE_OPERATOR(AANoRecurse)
127PIPE_OPERATOR(AAWillReturn)
128PIPE_OPERATOR(AANoReturn)
129PIPE_OPERATOR(AAReturnedValues)
130PIPE_OPERATOR(AANonNull)
131PIPE_OPERATOR(AANoAlias)
132PIPE_OPERATOR(AADereferenceable)
133PIPE_OPERATOR(AAAlign)
134PIPE_OPERATOR(AANoCapture)
135PIPE_OPERATOR(AAValueSimplify)
136PIPE_OPERATOR(AANoFree)
137PIPE_OPERATOR(AAHeapToStack)
138PIPE_OPERATOR(AAReachability)
139PIPE_OPERATOR(AAMemoryBehavior)
140PIPE_OPERATOR(AAMemoryLocation)
141PIPE_OPERATOR(AAValueConstantRange)
142PIPE_OPERATOR(AAPrivatizablePtr)
143PIPE_OPERATOR(AAUndefinedBehavior)
144PIPE_OPERATOR(AAPotentialValues)
145PIPE_OPERATOR(AANoUndef)
146PIPE_OPERATOR(AACallEdges)
147PIPE_OPERATOR(AAFunctionReachability)
148PIPE_OPERATOR(AAPointerInfo)
149
150#undef PIPE_OPERATOR
151
152template <>
153ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
154 const DerefState &R) {
155 ChangeStatus CS0 =
156 clampStateAndIndicateChange(S.DerefBytesState, R.DerefBytesState);
157 ChangeStatus CS1 = clampStateAndIndicateChange(S.GlobalState, R.GlobalState);
158 return CS0 | CS1;
159}
160
161} // namespace llvm
162
163/// Get pointer operand of memory accessing instruction. If \p I is
164/// not a memory accessing instruction, return nullptr. If \p AllowVolatile,
165/// is set to false and the instruction is volatile, return nullptr.
166static const Value *getPointerOperand(const Instruction *I,
167 bool AllowVolatile) {
168 if (!AllowVolatile && I->isVolatile())
169 return nullptr;
170
171 if (auto *LI = dyn_cast<LoadInst>(I)) {
172 return LI->getPointerOperand();
173 }
174
175 if (auto *SI = dyn_cast<StoreInst>(I)) {
176 return SI->getPointerOperand();
177 }
178
179 if (auto *CXI = dyn_cast<AtomicCmpXchgInst>(I)) {
180 return CXI->getPointerOperand();
181 }
182
183 if (auto *RMWI = dyn_cast<AtomicRMWInst>(I)) {
184 return RMWI->getPointerOperand();
185 }
186
187 return nullptr;
188}
189
190/// Helper function to create a pointer of type \p ResTy, based on \p Ptr, and
191/// advanced by \p Offset bytes. To aid later analysis the method tries to build
192/// getelement pointer instructions that traverse the natural type of \p Ptr if
193/// possible. If that fails, the remaining offset is adjusted byte-wise, hence
194/// through a cast to i8*.
195///
196/// TODO: This could probably live somewhere more prominantly if it doesn't
197/// already exist.
198static Value *constructPointer(Type *ResTy, Type *PtrElemTy, Value *Ptr,
199 int64_t Offset, IRBuilder<NoFolder> &IRB,
200 const DataLayout &DL) {
201 assert(Offset >= 0 && "Negative offset not supported yet!")((void)0);
202 LLVM_DEBUG(dbgs() << "Construct pointer: " << *Ptr << " + " << Offsetdo { } while (false)
203 << "-bytes as " << *ResTy << "\n")do { } while (false);
204
205 if (Offset) {
206 SmallVector<Value *, 4> Indices;
207 std::string GEPName = Ptr->getName().str() + ".0";
208
209 // Add 0 index to look through the pointer.
210 assert((uint64_t)Offset < DL.getTypeAllocSize(PtrElemTy) &&((void)0)
211 "Offset out of bounds")((void)0);
212 Indices.push_back(Constant::getNullValue(IRB.getInt32Ty()));
213
214 Type *Ty = PtrElemTy;
215 do {
216 auto *STy = dyn_cast<StructType>(Ty);
217 if (!STy)
218 // Non-aggregate type, we cast and make byte-wise progress now.
219 break;
220
221 const StructLayout *SL = DL.getStructLayout(STy);
222 if (int64_t(SL->getSizeInBytes()) < Offset)
223 break;
224
225 uint64_t Idx = SL->getElementContainingOffset(Offset);
226 assert(Idx < STy->getNumElements() && "Offset calculation error!")((void)0);
227 uint64_t Rem = Offset - SL->getElementOffset(Idx);
228 Ty = STy->getElementType(Idx);
229
230 LLVM_DEBUG(errs() << "Ty: " << *Ty << " Offset: " << Offsetdo { } while (false)
231 << " Idx: " << Idx << " Rem: " << Rem << "\n")do { } while (false);
232
233 GEPName += "." + std::to_string(Idx);
234 Indices.push_back(ConstantInt::get(IRB.getInt32Ty(), Idx));
235 Offset = Rem;
236 } while (Offset);
237
238 // Create a GEP for the indices collected above.
239 Ptr = IRB.CreateGEP(PtrElemTy, Ptr, Indices, GEPName);
240
241 // If an offset is left we use byte-wise adjustment.
242 if (Offset) {
243 Ptr = IRB.CreateBitCast(Ptr, IRB.getInt8PtrTy());
244 Ptr = IRB.CreateGEP(IRB.getInt8Ty(), Ptr, IRB.getInt32(Offset),
245 GEPName + ".b" + Twine(Offset));
246 }
247 }
248
249 // Ensure the result has the requested type.
250 Ptr = IRB.CreateBitOrPointerCast(Ptr, ResTy, Ptr->getName() + ".cast");
251
252 LLVM_DEBUG(dbgs() << "Constructed pointer: " << *Ptr << "\n")do { } while (false);
253 return Ptr;
254}
255
256/// Recursively visit all values that might become \p IRP at some point. This
257/// will be done by looking through cast instructions, selects, phis, and calls
258/// with the "returned" attribute. Once we cannot look through the value any
259/// further, the callback \p VisitValueCB is invoked and passed the current
260/// value, the \p State, and a flag to indicate if we stripped anything.
261/// Stripped means that we unpacked the value associated with \p IRP at least
262/// once. Note that the value used for the callback may still be the value
263/// associated with \p IRP (due to PHIs). To limit how much effort is invested,
264/// we will never visit more values than specified by \p MaxValues.
265template <typename StateTy>
266static bool genericValueTraversal(
267 Attributor &A, IRPosition IRP, const AbstractAttribute &QueryingAA,
268 StateTy &State,
269 function_ref<bool(Value &, const Instruction *, StateTy &, bool)>
270 VisitValueCB,
271 const Instruction *CtxI, bool UseValueSimplify = true, int MaxValues = 16,
272 function_ref<Value *(Value *)> StripCB = nullptr) {
273
274 const AAIsDead *LivenessAA = nullptr;
275 if (IRP.getAnchorScope())
276 LivenessAA = &A.getAAFor<AAIsDead>(
277 QueryingAA,
278 IRPosition::function(*IRP.getAnchorScope(), IRP.getCallBaseContext()),
279 DepClassTy::NONE);
280 bool AnyDead = false;
281
282 Value *InitialV = &IRP.getAssociatedValue();
283 using Item = std::pair<Value *, const Instruction *>;
284 SmallSet<Item, 16> Visited;
285 SmallVector<Item, 16> Worklist;
286 Worklist.push_back({InitialV, CtxI});
287
288 int Iteration = 0;
289 do {
290 Item I = Worklist.pop_back_val();
291 Value *V = I.first;
292 CtxI = I.second;
293 if (StripCB)
294 V = StripCB(V);
295
296 // Check if we should process the current value. To prevent endless
297 // recursion keep a record of the values we followed!
298 if (!Visited.insert(I).second)
299 continue;
300
301 // Make sure we limit the compile time for complex expressions.
302 if (Iteration++ >= MaxValues)
303 return false;
304
305 // Explicitly look through calls with a "returned" attribute if we do
306 // not have a pointer as stripPointerCasts only works on them.
307 Value *NewV = nullptr;
308 if (V->getType()->isPointerTy()) {
309 NewV = V->stripPointerCasts();
310 } else {
311 auto *CB = dyn_cast<CallBase>(V);
312 if (CB && CB->getCalledFunction()) {
313 for (Argument &Arg : CB->getCalledFunction()->args())
314 if (Arg.hasReturnedAttr()) {
315 NewV = CB->getArgOperand(Arg.getArgNo());
316 break;
317 }
318 }
319 }
320 if (NewV && NewV != V) {
321 Worklist.push_back({NewV, CtxI});
322 continue;
323 }
324
325 // Look through select instructions, visit assumed potential values.
326 if (auto *SI = dyn_cast<SelectInst>(V)) {
327 bool UsedAssumedInformation = false;
328 Optional<Constant *> C = A.getAssumedConstant(
329 *SI->getCondition(), QueryingAA, UsedAssumedInformation);
330 bool NoValueYet = !C.hasValue();
331 if (NoValueYet || isa_and_nonnull<UndefValue>(*C))
332 continue;
333 if (auto *CI = dyn_cast_or_null<ConstantInt>(*C)) {
334 if (CI->isZero())
335 Worklist.push_back({SI->getFalseValue(), CtxI});
336 else
337 Worklist.push_back({SI->getTrueValue(), CtxI});
338 continue;
339 }
340 // We could not simplify the condition, assume both values.(
341 Worklist.push_back({SI->getTrueValue(), CtxI});
342 Worklist.push_back({SI->getFalseValue(), CtxI});
343 continue;
344 }
345
346 // Look through phi nodes, visit all live operands.
347 if (auto *PHI = dyn_cast<PHINode>(V)) {
348 assert(LivenessAA &&((void)0)
349 "Expected liveness in the presence of instructions!")((void)0);
350 for (unsigned u = 0, e = PHI->getNumIncomingValues(); u < e; u++) {
351 BasicBlock *IncomingBB = PHI->getIncomingBlock(u);
352 bool UsedAssumedInformation = false;
353 if (A.isAssumedDead(*IncomingBB->getTerminator(), &QueryingAA,
354 LivenessAA, UsedAssumedInformation,
355 /* CheckBBLivenessOnly */ true)) {
356 AnyDead = true;
357 continue;
358 }
359 Worklist.push_back(
360 {PHI->getIncomingValue(u), IncomingBB->getTerminator()});
361 }
362 continue;
363 }
364
365 if (UseValueSimplify && !isa<Constant>(V)) {
366 bool UsedAssumedInformation = false;
367 Optional<Value *> SimpleV =
368 A.getAssumedSimplified(*V, QueryingAA, UsedAssumedInformation);
369 if (!SimpleV.hasValue())
370 continue;
371 if (!SimpleV.getValue())
372 return false;
373 Value *NewV = SimpleV.getValue();
374 if (NewV != V) {
375 Worklist.push_back({NewV, CtxI});
376 continue;
377 }
378 }
379
380 // Once a leaf is reached we inform the user through the callback.
381 if (!VisitValueCB(*V, CtxI, State, Iteration > 1))
382 return false;
383 } while (!Worklist.empty());
384
385 // If we actually used liveness information so we have to record a dependence.
386 if (AnyDead)
387 A.recordDependence(*LivenessAA, QueryingAA, DepClassTy::OPTIONAL);
388
389 // All values have been visited.
390 return true;
391}
392
393bool AA::getAssumedUnderlyingObjects(Attributor &A, const Value &Ptr,
394 SmallVectorImpl<Value *> &Objects,
395 const AbstractAttribute &QueryingAA,
396 const Instruction *CtxI) {
397 auto StripCB = [&](Value *V) { return getUnderlyingObject(V); };
398 SmallPtrSet<Value *, 8> SeenObjects;
399 auto VisitValueCB = [&SeenObjects](Value &Val, const Instruction *,
400 SmallVectorImpl<Value *> &Objects,
401 bool) -> bool {
402 if (SeenObjects.insert(&Val).second)
403 Objects.push_back(&Val);
404 return true;
405 };
406 if (!genericValueTraversal<decltype(Objects)>(
407 A, IRPosition::value(Ptr), QueryingAA, Objects, VisitValueCB, CtxI,
408 true, 32, StripCB))
409 return false;
410 return true;
411}
412
413const Value *stripAndAccumulateMinimalOffsets(
414 Attributor &A, const AbstractAttribute &QueryingAA, const Value *Val,
415 const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
416 bool UseAssumed = false) {
417
418 auto AttributorAnalysis = [&](Value &V, APInt &ROffset) -> bool {
419 const IRPosition &Pos = IRPosition::value(V);
420 // Only track dependence if we are going to use the assumed info.
421 const AAValueConstantRange &ValueConstantRangeAA =
422 A.getAAFor<AAValueConstantRange>(QueryingAA, Pos,
423 UseAssumed ? DepClassTy::OPTIONAL
424 : DepClassTy::NONE);
425 ConstantRange Range = UseAssumed ? ValueConstantRangeAA.getAssumed()
426 : ValueConstantRangeAA.getKnown();
427 // We can only use the lower part of the range because the upper part can
428 // be higher than what the value can really be.
429 ROffset = Range.getSignedMin();
430 return true;
431 };
432
433 return Val->stripAndAccumulateConstantOffsets(DL, Offset, AllowNonInbounds,
434 AttributorAnalysis);
435}
436
437static const Value *getMinimalBaseOfAccsesPointerOperand(
438 Attributor &A, const AbstractAttribute &QueryingAA, const Instruction *I,
439 int64_t &BytesOffset, const DataLayout &DL, bool AllowNonInbounds = false) {
440 const Value *Ptr = getPointerOperand(I, /* AllowVolatile */ false);
441 if (!Ptr)
442 return nullptr;
443 APInt OffsetAPInt(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
444 const Value *Base = stripAndAccumulateMinimalOffsets(
445 A, QueryingAA, Ptr, DL, OffsetAPInt, AllowNonInbounds);
446
447 BytesOffset = OffsetAPInt.getSExtValue();
448 return Base;
449}
450
451static const Value *
452getBasePointerOfAccessPointerOperand(const Instruction *I, int64_t &BytesOffset,
453 const DataLayout &DL,
454 bool AllowNonInbounds = false) {
455 const Value *Ptr = getPointerOperand(I, /* AllowVolatile */ false);
456 if (!Ptr)
457 return nullptr;
458
459 return GetPointerBaseWithConstantOffset(Ptr, BytesOffset, DL,
460 AllowNonInbounds);
461}
462
463/// Clamp the information known for all returned values of a function
464/// (identified by \p QueryingAA) into \p S.
465template <typename AAType, typename StateType = typename AAType::StateType>
466static void clampReturnedValueStates(
467 Attributor &A, const AAType &QueryingAA, StateType &S,
468 const IRPosition::CallBaseContext *CBContext = nullptr) {
469 LLVM_DEBUG(dbgs() << "[Attributor] Clamp return value states for "do { } while (false)
470 << QueryingAA << " into " << S << "\n")do { } while (false);
471
472 assert((QueryingAA.getIRPosition().getPositionKind() ==((void)0)
473 IRPosition::IRP_RETURNED ||((void)0)
474 QueryingAA.getIRPosition().getPositionKind() ==((void)0)
475 IRPosition::IRP_CALL_SITE_RETURNED) &&((void)0)
476 "Can only clamp returned value states for a function returned or call "((void)0)
477 "site returned position!")((void)0);
478
479 // Use an optional state as there might not be any return values and we want
480 // to join (IntegerState::operator&) the state of all there are.
481 Optional<StateType> T;
482
483 // Callback for each possibly returned value.
484 auto CheckReturnValue = [&](Value &RV) -> bool {
485 const IRPosition &RVPos = IRPosition::value(RV, CBContext);
486 const AAType &AA =
487 A.getAAFor<AAType>(QueryingAA, RVPos, DepClassTy::REQUIRED);
488 LLVM_DEBUG(dbgs() << "[Attributor] RV: " << RV << " AA: " << AA.getAsStr()do { } while (false)
489 << " @ " << RVPos << "\n")do { } while (false);
490 const StateType &AAS = AA.getState();
491 if (T.hasValue())
492 *T &= AAS;
493 else
494 T = AAS;
495 LLVM_DEBUG(dbgs() << "[Attributor] AA State: " << AAS << " RV State: " << Tdo { } while (false)
496 << "\n")do { } while (false);
497 return T->isValidState();
498 };
499
500 if (!A.checkForAllReturnedValues(CheckReturnValue, QueryingAA))
501 S.indicatePessimisticFixpoint();
502 else if (T.hasValue())
503 S ^= *T;
504}
505
506/// Helper class for generic deduction: return value -> returned position.
507template <typename AAType, typename BaseType,
508 typename StateType = typename BaseType::StateType,
509 bool PropagateCallBaseContext = false>
510struct AAReturnedFromReturnedValues : public BaseType {
511 AAReturnedFromReturnedValues(const IRPosition &IRP, Attributor &A)
512 : BaseType(IRP, A) {}
513
514 /// See AbstractAttribute::updateImpl(...).
515 ChangeStatus updateImpl(Attributor &A) override {
516 StateType S(StateType::getBestState(this->getState()));
517 clampReturnedValueStates<AAType, StateType>(
518 A, *this, S,
519 PropagateCallBaseContext ? this->getCallBaseContext() : nullptr);
520 // TODO: If we know we visited all returned values, thus no are assumed
521 // dead, we can take the known information from the state T.
522 return clampStateAndIndicateChange<StateType>(this->getState(), S);
523 }
524};
525
526/// Clamp the information known at all call sites for a given argument
527/// (identified by \p QueryingAA) into \p S.
528template <typename AAType, typename StateType = typename AAType::StateType>
529static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
530 StateType &S) {
531 LLVM_DEBUG(dbgs() << "[Attributor] Clamp call site argument states for "do { } while (false)
532 << QueryingAA << " into " << S << "\n")do { } while (false);
533
534 assert(QueryingAA.getIRPosition().getPositionKind() ==((void)0)
535 IRPosition::IRP_ARGUMENT &&((void)0)
536 "Can only clamp call site argument states for an argument position!")((void)0);
537
538 // Use an optional state as there might not be any return values and we want
539 // to join (IntegerState::operator&) the state of all there are.
540 Optional<StateType> T;
541
542 // The argument number which is also the call site argument number.
543 unsigned ArgNo = QueryingAA.getIRPosition().getCallSiteArgNo();
544
545 auto CallSiteCheck = [&](AbstractCallSite ACS) {
546 const IRPosition &ACSArgPos = IRPosition::callsite_argument(ACS, ArgNo);
547 // Check if a coresponding argument was found or if it is on not associated
548 // (which can happen for callback calls).
549 if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
550 return false;
551
552 const AAType &AA =
553 A.getAAFor<AAType>(QueryingAA, ACSArgPos, DepClassTy::REQUIRED);
554 LLVM_DEBUG(dbgs() << "[Attributor] ACS: " << *ACS.getInstruction()do { } while (false)
555 << " AA: " << AA.getAsStr() << " @" << ACSArgPos << "\n")do { } while (false);
556 const StateType &AAS = AA.getState();
557 if (T.hasValue())
558 *T &= AAS;
559 else
560 T = AAS;
561 LLVM_DEBUG(dbgs() << "[Attributor] AA State: " << AAS << " CSA State: " << Tdo { } while (false)
562 << "\n")do { } while (false);
563 return T->isValidState();
564 };
565
566 bool AllCallSitesKnown;
567 if (!A.checkForAllCallSites(CallSiteCheck, QueryingAA, true,
568 AllCallSitesKnown))
569 S.indicatePessimisticFixpoint();
570 else if (T.hasValue())
571 S ^= *T;
572}
573
574/// This function is the bridge between argument position and the call base
575/// context.
576template <typename AAType, typename BaseType,
577 typename StateType = typename AAType::StateType>
578bool getArgumentStateFromCallBaseContext(Attributor &A,
579 BaseType &QueryingAttribute,
580 IRPosition &Pos, StateType &State) {
581 assert((Pos.getPositionKind() == IRPosition::IRP_ARGUMENT) &&((void)0)
582 "Expected an 'argument' position !")((void)0);
583 const CallBase *CBContext = Pos.getCallBaseContext();
584 if (!CBContext)
585 return false;
586
587 int ArgNo = Pos.getCallSiteArgNo();
588 assert(ArgNo >= 0 && "Invalid Arg No!")((void)0);
589
590 const auto &AA = A.getAAFor<AAType>(
591 QueryingAttribute, IRPosition::callsite_argument(*CBContext, ArgNo),
592 DepClassTy::REQUIRED);
593 const StateType &CBArgumentState =
594 static_cast<const StateType &>(AA.getState());
595
596 LLVM_DEBUG(dbgs() << "[Attributor] Briding Call site context to argument"do { } while (false)
597 << "Position:" << Pos << "CB Arg state:" << CBArgumentStatedo { } while (false)
598 << "\n")do { } while (false);
599
600 // NOTE: If we want to do call site grouping it should happen here.
601 State ^= CBArgumentState;
602 return true;
603}
604
605/// Helper class for generic deduction: call site argument -> argument position.
606template <typename AAType, typename BaseType,
607 typename StateType = typename AAType::StateType,
608 bool BridgeCallBaseContext = false>
609struct AAArgumentFromCallSiteArguments : public BaseType {
610 AAArgumentFromCallSiteArguments(const IRPosition &IRP, Attributor &A)
611 : BaseType(IRP, A) {}
612
613 /// See AbstractAttribute::updateImpl(...).
614 ChangeStatus updateImpl(Attributor &A) override {
615 StateType S = StateType::getBestState(this->getState());
616
617 if (BridgeCallBaseContext) {
618 bool Success =
619 getArgumentStateFromCallBaseContext<AAType, BaseType, StateType>(
620 A, *this, this->getIRPosition(), S);
621 if (Success)
622 return clampStateAndIndicateChange<StateType>(this->getState(), S);
623 }
624 clampCallSiteArgumentStates<AAType, StateType>(A, *this, S);
625
626 // TODO: If we know we visited all incoming values, thus no are assumed
627 // dead, we can take the known information from the state T.
628 return clampStateAndIndicateChange<StateType>(this->getState(), S);
629 }
630};
631
632/// Helper class for generic replication: function returned -> cs returned.
633template <typename AAType, typename BaseType,
634 typename StateType = typename BaseType::StateType,
635 bool IntroduceCallBaseContext = false>
636struct AACallSiteReturnedFromReturned : public BaseType {
637 AACallSiteReturnedFromReturned(const IRPosition &IRP, Attributor &A)
638 : BaseType(IRP, A) {}
639
640 /// See AbstractAttribute::updateImpl(...).
641 ChangeStatus updateImpl(Attributor &A) override {
642 assert(this->getIRPosition().getPositionKind() ==((void)0)
643 IRPosition::IRP_CALL_SITE_RETURNED &&((void)0)
644 "Can only wrap function returned positions for call site returned "((void)0)
645 "positions!")((void)0);
646 auto &S = this->getState();
647
648 const Function *AssociatedFunction =
649 this->getIRPosition().getAssociatedFunction();
650 if (!AssociatedFunction)
651 return S.indicatePessimisticFixpoint();
652
653 CallBase &CBContext = static_cast<CallBase &>(this->getAnchorValue());
654 if (IntroduceCallBaseContext)
655 LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:"do { } while (false)
656 << CBContext << "\n")do { } while (false);
657
658 IRPosition FnPos = IRPosition::returned(
659 *AssociatedFunction, IntroduceCallBaseContext ? &CBContext : nullptr);
660 const AAType &AA = A.getAAFor<AAType>(*this, FnPos, DepClassTy::REQUIRED);
661 return clampStateAndIndicateChange(S, AA.getState());
662 }
663};
664
665/// Helper function to accumulate uses.
666template <class AAType, typename StateType = typename AAType::StateType>
667static void followUsesInContext(AAType &AA, Attributor &A,
668 MustBeExecutedContextExplorer &Explorer,
669 const Instruction *CtxI,
670 SetVector<const Use *> &Uses,
671 StateType &State) {
672 auto EIt = Explorer.begin(CtxI), EEnd = Explorer.end(CtxI);
673 for (unsigned u = 0; u < Uses.size(); ++u) {
674 const Use *U = Uses[u];
675 if (const Instruction *UserI = dyn_cast<Instruction>(U->getUser())) {
676 bool Found = Explorer.findInContextOf(UserI, EIt, EEnd);
677 if (Found && AA.followUseInMBEC(A, U, UserI, State))
678 for (const Use &Us : UserI->uses())
679 Uses.insert(&Us);
680 }
681 }
682}
683
684/// Use the must-be-executed-context around \p I to add information into \p S.
685/// The AAType class is required to have `followUseInMBEC` method with the
686/// following signature and behaviour:
687///
688/// bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I)
689/// U - Underlying use.
690/// I - The user of the \p U.
691/// Returns true if the value should be tracked transitively.
692///
693template <class AAType, typename StateType = typename AAType::StateType>
694static void followUsesInMBEC(AAType &AA, Attributor &A, StateType &S,
695 Instruction &CtxI) {
696
697 // Container for (transitive) uses of the associated value.
698 SetVector<const Use *> Uses;
699 for (const Use &U : AA.getIRPosition().getAssociatedValue().uses())
700 Uses.insert(&U);
701
702 MustBeExecutedContextExplorer &Explorer =
703 A.getInfoCache().getMustBeExecutedContextExplorer();
704
705 followUsesInContext<AAType>(AA, A, Explorer, &CtxI, Uses, S);
706
707 if (S.isAtFixpoint())
708 return;
709
710 SmallVector<const BranchInst *, 4> BrInsts;
711 auto Pred = [&](const Instruction *I) {
712 if (const BranchInst *Br = dyn_cast<BranchInst>(I))
713 if (Br->isConditional())
714 BrInsts.push_back(Br);
715 return true;
716 };
717
718 // Here, accumulate conditional branch instructions in the context. We
719 // explore the child paths and collect the known states. The disjunction of
720 // those states can be merged to its own state. Let ParentState_i be a state
721 // to indicate the known information for an i-th branch instruction in the
722 // context. ChildStates are created for its successors respectively.
723 //
724 // ParentS_1 = ChildS_{1, 1} /\ ChildS_{1, 2} /\ ... /\ ChildS_{1, n_1}
725 // ParentS_2 = ChildS_{2, 1} /\ ChildS_{2, 2} /\ ... /\ ChildS_{2, n_2}
726 // ...
727 // ParentS_m = ChildS_{m, 1} /\ ChildS_{m, 2} /\ ... /\ ChildS_{m, n_m}
728 //
729 // Known State |= ParentS_1 \/ ParentS_2 \/... \/ ParentS_m
730 //
731 // FIXME: Currently, recursive branches are not handled. For example, we
732 // can't deduce that ptr must be dereferenced in below function.
733 //
734 // void f(int a, int c, int *ptr) {
735 // if(a)
736 // if (b) {
737 // *ptr = 0;
738 // } else {
739 // *ptr = 1;
740 // }
741 // else {
742 // if (b) {
743 // *ptr = 0;
744 // } else {
745 // *ptr = 1;
746 // }
747 // }
748 // }
749
750 Explorer.checkForAllContext(&CtxI, Pred);
751 for (const BranchInst *Br : BrInsts) {
752 StateType ParentState;
753
754 // The known state of the parent state is a conjunction of children's
755 // known states so it is initialized with a best state.
756 ParentState.indicateOptimisticFixpoint();
757
758 for (const BasicBlock *BB : Br->successors()) {
759 StateType ChildState;
760
761 size_t BeforeSize = Uses.size();
762 followUsesInContext(AA, A, Explorer, &BB->front(), Uses, ChildState);
763
764 // Erase uses which only appear in the child.
765 for (auto It = Uses.begin() + BeforeSize; It != Uses.end();)
766 It = Uses.erase(It);
767
768 ParentState &= ChildState;
769 }
770
771 // Use only known state.
772 S += ParentState;
773 }
774}
775
776/// ------------------------ PointerInfo ---------------------------------------
777
778namespace llvm {
779namespace AA {
780namespace PointerInfo {
781
782/// An access kind description as used by AAPointerInfo.
783struct OffsetAndSize;
784
785struct State;
786
787} // namespace PointerInfo
788} // namespace AA
789
790/// Helper for AA::PointerInfo::Acccess DenseMap/Set usage.
791template <>
792struct DenseMapInfo<AAPointerInfo::Access> : DenseMapInfo<Instruction *> {
793 using Access = AAPointerInfo::Access;
794 static inline Access getEmptyKey();
795 static inline Access getTombstoneKey();
796 static unsigned getHashValue(const Access &A);
797 static bool isEqual(const Access &LHS, const Access &RHS);
798};
799
800/// Helper that allows OffsetAndSize as a key in a DenseMap.
801template <>
802struct DenseMapInfo<AA::PointerInfo ::OffsetAndSize>
803 : DenseMapInfo<std::pair<int64_t, int64_t>> {};
804
805/// Helper for AA::PointerInfo::Acccess DenseMap/Set usage ignoring everythign
806/// but the instruction
807struct AccessAsInstructionInfo : DenseMapInfo<Instruction *> {
808 using Base = DenseMapInfo<Instruction *>;
809 using Access = AAPointerInfo::Access;
810 static inline Access getEmptyKey();
811 static inline Access getTombstoneKey();
812 static unsigned getHashValue(const Access &A);
813 static bool isEqual(const Access &LHS, const Access &RHS);
814};
815
816} // namespace llvm
817
818/// Helper to represent an access offset and size, with logic to deal with
819/// uncertainty and check for overlapping accesses.
820struct AA::PointerInfo::OffsetAndSize : public std::pair<int64_t, int64_t> {
821 using BaseTy = std::pair<int64_t, int64_t>;
822 OffsetAndSize(int64_t Offset, int64_t Size) : BaseTy(Offset, Size) {}
823 OffsetAndSize(const BaseTy &P) : BaseTy(P) {}
824 int64_t getOffset() const { return first; }
825 int64_t getSize() const { return second; }
826 static OffsetAndSize getUnknown() { return OffsetAndSize(Unknown, Unknown); }
827
828 /// Return true if this offset and size pair might describe an address that
829 /// overlaps with \p OAS.
830 bool mayOverlap(const OffsetAndSize &OAS) const {
831 // Any unknown value and we are giving up -> overlap.
832 if (OAS.getOffset() == OffsetAndSize::Unknown ||
833 OAS.getSize() == OffsetAndSize::Unknown ||
834 getOffset() == OffsetAndSize::Unknown ||
835 getSize() == OffsetAndSize::Unknown)
836 return true;
837
838 // Check if one offset point is in the other interval [offset, offset+size].
839 return OAS.getOffset() + OAS.getSize() > getOffset() &&
840 OAS.getOffset() < getOffset() + getSize();
841 }
842
843 /// Constant used to represent unknown offset or sizes.
844 static constexpr int64_t Unknown = 1 << 31;
845};
846
847/// Implementation of the DenseMapInfo.
848///
849///{
850inline llvm::AccessAsInstructionInfo::Access
851llvm::AccessAsInstructionInfo::getEmptyKey() {
852 return Access(Base::getEmptyKey(), nullptr, AAPointerInfo::AK_READ, nullptr);
853}
854inline llvm::AccessAsInstructionInfo::Access
855llvm::AccessAsInstructionInfo::getTombstoneKey() {
856 return Access(Base::getTombstoneKey(), nullptr, AAPointerInfo::AK_READ,
857 nullptr);
858}
859unsigned llvm::AccessAsInstructionInfo::getHashValue(
860 const llvm::AccessAsInstructionInfo::Access &A) {
861 return Base::getHashValue(A.getRemoteInst());
862}
863bool llvm::AccessAsInstructionInfo::isEqual(
864 const llvm::AccessAsInstructionInfo::Access &LHS,
865 const llvm::AccessAsInstructionInfo::Access &RHS) {
866 return LHS.getRemoteInst() == RHS.getRemoteInst();
867}
868inline llvm::DenseMapInfo<AAPointerInfo::Access>::Access
869llvm::DenseMapInfo<AAPointerInfo::Access>::getEmptyKey() {
870 return AAPointerInfo::Access(nullptr, nullptr, AAPointerInfo::AK_READ,
871 nullptr);
872}
873inline llvm::DenseMapInfo<AAPointerInfo::Access>::Access
874llvm::DenseMapInfo<AAPointerInfo::Access>::getTombstoneKey() {
875 return AAPointerInfo::Access(nullptr, nullptr, AAPointerInfo::AK_WRITE,
876 nullptr);
877}
878
879unsigned llvm::DenseMapInfo<AAPointerInfo::Access>::getHashValue(
880 const llvm::DenseMapInfo<AAPointerInfo::Access>::Access &A) {
881 return detail::combineHashValue(
882 DenseMapInfo<Instruction *>::getHashValue(A.getRemoteInst()),
883 (A.isWrittenValueYetUndetermined()
884 ? ~0
885 : DenseMapInfo<Value *>::getHashValue(A.getWrittenValue()))) +
886 A.getKind();
887}
888
889bool llvm::DenseMapInfo<AAPointerInfo::Access>::isEqual(
890 const llvm::DenseMapInfo<AAPointerInfo::Access>::Access &LHS,
891 const llvm::DenseMapInfo<AAPointerInfo::Access>::Access &RHS) {
892 return LHS == RHS;
893}
894///}
895
896/// A type to track pointer/struct usage and accesses for AAPointerInfo.
897struct AA::PointerInfo::State : public AbstractState {
898
899 /// Return the best possible representable state.
900 static State getBestState(const State &SIS) { return State(); }
901
902 /// Return the worst possible representable state.
903 static State getWorstState(const State &SIS) {
904 State R;
905 R.indicatePessimisticFixpoint();
906 return R;
907 }
908
909 State() {}
910 State(const State &SIS) : AccessBins(SIS.AccessBins) {}
911 State(State &&SIS) : AccessBins(std::move(SIS.AccessBins)) {}
912
913 const State &getAssumed() const { return *this; }
914
915 /// See AbstractState::isValidState().
916 bool isValidState() const override { return BS.isValidState(); }
917
918 /// See AbstractState::isAtFixpoint().
919 bool isAtFixpoint() const override { return BS.isAtFixpoint(); }
920
921 /// See AbstractState::indicateOptimisticFixpoint().
922 ChangeStatus indicateOptimisticFixpoint() override {
923 BS.indicateOptimisticFixpoint();
924 return ChangeStatus::UNCHANGED;
925 }
926
927 /// See AbstractState::indicatePessimisticFixpoint().
928 ChangeStatus indicatePessimisticFixpoint() override {
929 BS.indicatePessimisticFixpoint();
930 return ChangeStatus::CHANGED;
931 }
932
933 State &operator=(const State &R) {
934 if (this == &R)
935 return *this;
936 BS = R.BS;
937 AccessBins = R.AccessBins;
938 return *this;
939 }
940
941 State &operator=(State &&R) {
942 if (this == &R)
943 return *this;
944 std::swap(BS, R.BS);
945 std::swap(AccessBins, R.AccessBins);
946 return *this;
947 }
948
949 bool operator==(const State &R) const {
950 if (BS != R.BS)
951 return false;
952 if (AccessBins.size() != R.AccessBins.size())
953 return false;
954 auto It = begin(), RIt = R.begin(), E = end();
955 while (It != E) {
956 if (It->getFirst() != RIt->getFirst())
957 return false;
958 auto &Accs = It->getSecond();
959 auto &RAccs = RIt->getSecond();
960 if (Accs.size() != RAccs.size())
961 return false;
962 auto AccIt = Accs.begin(), RAccIt = RAccs.begin(), AccE = Accs.end();
963 while (AccIt != AccE) {
964 if (*AccIt != *RAccIt)
965 return false;
966 ++AccIt;
967 ++RAccIt;
968 }
969 ++It;
970 ++RIt;
971 }
972 return true;
973 }
974 bool operator!=(const State &R) const { return !(*this == R); }
975
976 /// We store accesses in a set with the instruction as key.
977 using Accesses = DenseSet<AAPointerInfo::Access, AccessAsInstructionInfo>;
978
979 /// We store all accesses in bins denoted by their offset and size.
980 using AccessBinsTy = DenseMap<OffsetAndSize, Accesses>;
981
982 AccessBinsTy::const_iterator begin() const { return AccessBins.begin(); }
983 AccessBinsTy::const_iterator end() const { return AccessBins.end(); }
984
985protected:
986 /// The bins with all the accesses for the associated pointer.
987 DenseMap<OffsetAndSize, Accesses> AccessBins;
988
989 /// Add a new access to the state at offset \p Offset and with size \p Size.
990 /// The access is associated with \p I, writes \p Content (if anything), and
991 /// is of kind \p Kind.
992 /// \Returns CHANGED, if the state changed, UNCHANGED otherwise.
993 ChangeStatus addAccess(int64_t Offset, int64_t Size, Instruction &I,
994 Optional<Value *> Content,
995 AAPointerInfo::AccessKind Kind, Type *Ty,
996 Instruction *RemoteI = nullptr,
997 Accesses *BinPtr = nullptr) {
998 OffsetAndSize Key{Offset, Size};
999 Accesses &Bin = BinPtr ? *BinPtr : AccessBins[Key];
1000 AAPointerInfo::Access Acc(&I, RemoteI ? RemoteI : &I, Content, Kind, Ty);
1001 // Check if we have an access for this instruction in this bin, if not,
1002 // simply add it.
1003 auto It = Bin.find(Acc);
1004 if (It == Bin.end()) {
1005 Bin.insert(Acc);
1006 return ChangeStatus::CHANGED;
1007 }
1008 // If the existing access is the same as then new one, nothing changed.
1009 AAPointerInfo::Access Before = *It;
1010 // The new one will be combined with the existing one.
1011 *It &= Acc;
1012 return *It == Before ? ChangeStatus::UNCHANGED : ChangeStatus::CHANGED;
1013 }
1014
1015 /// See AAPointerInfo::forallInterferingAccesses.
1016 bool forallInterferingAccesses(
1017 Instruction &I,
1018 function_ref<bool(const AAPointerInfo::Access &, bool)> CB) const {
1019 if (!isValidState())
1020 return false;
1021 // First find the offset and size of I.
1022 OffsetAndSize OAS(-1, -1);
1023 for (auto &It : AccessBins) {
1024 for (auto &Access : It.getSecond()) {
1025 if (Access.getRemoteInst() == &I) {
1026 OAS = It.getFirst();
1027 break;
1028 }
1029 }
1030 if (OAS.getSize() != -1)
1031 break;
1032 }
1033 if (OAS.getSize() == -1)
1034 return true;
1035
1036 // Now that we have an offset and size, find all overlapping ones and use
1037 // the callback on the accesses.
1038 for (auto &It : AccessBins) {
1039 OffsetAndSize ItOAS = It.getFirst();
1040 if (!OAS.mayOverlap(ItOAS))
1041 continue;
1042 for (auto &Access : It.getSecond())
1043 if (!CB(Access, OAS == ItOAS))
1044 return false;
1045 }
1046 return true;
1047 }
1048
1049private:
1050 /// State to track fixpoint and validity.
1051 BooleanState BS;
1052};
1053
1054struct AAPointerInfoImpl
1055 : public StateWrapper<AA::PointerInfo::State, AAPointerInfo> {
1056 using BaseTy = StateWrapper<AA::PointerInfo::State, AAPointerInfo>;
1057 AAPointerInfoImpl(const IRPosition &IRP, Attributor &A) : BaseTy(IRP) {}
1058
1059 /// See AbstractAttribute::initialize(...).
1060 void initialize(Attributor &A) override { AAPointerInfo::initialize(A); }
1061
1062 /// See AbstractAttribute::getAsStr().
1063 const std::string getAsStr() const override {
1064 return std::string("PointerInfo ") +
1065 (isValidState() ? (std::string("#") +
1066 std::to_string(AccessBins.size()) + " bins")
1067 : "<invalid>");
1068 }
1069
1070 /// See AbstractAttribute::manifest(...).
1071 ChangeStatus manifest(Attributor &A) override {
1072 return AAPointerInfo::manifest(A);
1073 }
1074
1075 bool forallInterferingAccesses(
1076 LoadInst &LI, function_ref<bool(const AAPointerInfo::Access &, bool)> CB)
1077 const override {
1078 return State::forallInterferingAccesses(LI, CB);
1079 }
1080 bool forallInterferingAccesses(
1081 StoreInst &SI, function_ref<bool(const AAPointerInfo::Access &, bool)> CB)
1082 const override {
1083 return State::forallInterferingAccesses(SI, CB);
1084 }
1085
1086 ChangeStatus translateAndAddCalleeState(Attributor &A,
1087 const AAPointerInfo &CalleeAA,
1088 int64_t CallArgOffset, CallBase &CB) {
1089 using namespace AA::PointerInfo;
1090 if (!CalleeAA.getState().isValidState() || !isValidState())
1091 return indicatePessimisticFixpoint();
1092
1093 const auto &CalleeImplAA = static_cast<const AAPointerInfoImpl &>(CalleeAA);
1094 bool IsByval = CalleeImplAA.getAssociatedArgument()->hasByValAttr();
1095
1096 // Combine the accesses bin by bin.
1097 ChangeStatus Changed = ChangeStatus::UNCHANGED;
1098 for (auto &It : CalleeImplAA.getState()) {
1099 OffsetAndSize OAS = OffsetAndSize::getUnknown();
1100 if (CallArgOffset != OffsetAndSize::Unknown)
1101 OAS = OffsetAndSize(It.first.getOffset() + CallArgOffset,
1102 It.first.getSize());
1103 Accesses &Bin = AccessBins[OAS];
1104 for (const AAPointerInfo::Access &RAcc : It.second) {
1105 if (IsByval && !RAcc.isRead())
1106 continue;
1107 bool UsedAssumedInformation = false;
1108 Optional<Value *> Content = A.translateArgumentToCallSiteContent(
1109 RAcc.getContent(), CB, *this, UsedAssumedInformation);
1110 AccessKind AK =
1111 AccessKind(RAcc.getKind() & (IsByval ? AccessKind::AK_READ
1112 : AccessKind::AK_READ_WRITE));
1113 Changed =
1114 Changed | addAccess(OAS.getOffset(), OAS.getSize(), CB, Content, AK,
1115 RAcc.getType(), RAcc.getRemoteInst(), &Bin);
1116 }
1117 }
1118 return Changed;
1119 }
1120
1121 /// Statistic tracking for all AAPointerInfo implementations.
1122 /// See AbstractAttribute::trackStatistics().
1123 void trackPointerInfoStatistics(const IRPosition &IRP) const {}
1124};
1125
1126struct AAPointerInfoFloating : public AAPointerInfoImpl {
1127 using AccessKind = AAPointerInfo::AccessKind;
1128 AAPointerInfoFloating(const IRPosition &IRP, Attributor &A)
1129 : AAPointerInfoImpl(IRP, A) {}
1130
1131 /// See AbstractAttribute::initialize(...).
1132 void initialize(Attributor &A) override { AAPointerInfoImpl::initialize(A); }
1133
1134 /// Deal with an access and signal if it was handled successfully.
1135 bool handleAccess(Attributor &A, Instruction &I, Value &Ptr,
1136 Optional<Value *> Content, AccessKind Kind, int64_t Offset,
1137 ChangeStatus &Changed, Type *Ty,
1138 int64_t Size = AA::PointerInfo::OffsetAndSize::Unknown) {
1139 using namespace AA::PointerInfo;
1140 // No need to find a size if one is given or the offset is unknown.
1141 if (Offset != OffsetAndSize::Unknown && Size == OffsetAndSize::Unknown &&
1142 Ty) {
1143 const DataLayout &DL = A.getDataLayout();
1144 TypeSize AccessSize = DL.getTypeStoreSize(Ty);
1145 if (!AccessSize.isScalable())
1146 Size = AccessSize.getFixedSize();
1147 }
1148 Changed = Changed | addAccess(Offset, Size, I, Content, Kind, Ty);
1149 return true;
1150 };
1151
1152 /// Helper struct, will support ranges eventually.
1153 struct OffsetInfo {
1154 int64_t Offset = AA::PointerInfo::OffsetAndSize::Unknown;
1155
1156 bool operator==(const OffsetInfo &OI) const { return Offset == OI.Offset; }
1157 };
1158
1159 /// See AbstractAttribute::updateImpl(...).
1160 ChangeStatus updateImpl(Attributor &A) override {
1161 using namespace AA::PointerInfo;
1162 State S = getState();
1163 ChangeStatus Changed = ChangeStatus::UNCHANGED;
1164 Value &AssociatedValue = getAssociatedValue();
1165
1166 const DataLayout &DL = A.getDataLayout();
1167 DenseMap<Value *, OffsetInfo> OffsetInfoMap;
1168 OffsetInfoMap[&AssociatedValue] = OffsetInfo{0};
1169
1170 auto HandlePassthroughUser = [&](Value *Usr, OffsetInfo &PtrOI,
1171 bool &Follow) {
1172 OffsetInfo &UsrOI = OffsetInfoMap[Usr];
1173 UsrOI = PtrOI;
1174 Follow = true;
1175 return true;
1176 };
1177
1178 auto UsePred = [&](const Use &U, bool &Follow) -> bool {
1179 Value *CurPtr = U.get();
1180 User *Usr = U.getUser();
1181 LLVM_DEBUG(dbgs() << "[AAPointerInfo] Analyze " << *CurPtr << " in "do { } while (false)
1182 << *Usr << "\n")do { } while (false);
1183
1184 OffsetInfo &PtrOI = OffsetInfoMap[CurPtr];
1185
1186 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Usr)) {
1187 if (CE->isCast())
1188 return HandlePassthroughUser(Usr, PtrOI, Follow);
1189 if (CE->isCompare())
1190 return true;
1191 if (!CE->isGEPWithNoNotionalOverIndexing()) {
1192 LLVM_DEBUG(dbgs() << "[AAPointerInfo] Unhandled constant user " << *CEdo { } while (false)
1193 << "\n")do { } while (false);
1194 return false;
1195 }
1196 }
1197 if (auto *GEP = dyn_cast<GEPOperator>(Usr)) {
1198 OffsetInfo &UsrOI = OffsetInfoMap[Usr];
1199 UsrOI = PtrOI;
1200
1201 // TODO: Use range information.
1202 if (PtrOI.Offset == OffsetAndSize::Unknown ||
1203 !GEP->hasAllConstantIndices()) {
1204 UsrOI.Offset = OffsetAndSize::Unknown;
1205 Follow = true;
1206 return true;
1207 }
1208
1209 SmallVector<Value *, 8> Indices;
1210 for (Use &Idx : llvm::make_range(GEP->idx_begin(), GEP->idx_end())) {
1211 if (auto *CIdx = dyn_cast<ConstantInt>(Idx)) {
1212 Indices.push_back(CIdx);
1213 continue;
1214 }
1215
1216 LLVM_DEBUG(dbgs() << "[AAPointerInfo] Non constant GEP index " << *GEPdo { } while (false)
1217 << " : " << *Idx << "\n")do { } while (false);
1218 return false;
1219 }
1220 UsrOI.Offset = PtrOI.Offset +
1221 DL.getIndexedOffsetInType(
1222 CurPtr->getType()->getPointerElementType(), Indices);
1223 Follow = true;
1224 return true;
1225 }
1226 if (isa<CastInst>(Usr) || isa<SelectInst>(Usr))
1227 return HandlePassthroughUser(Usr, PtrOI, Follow);
1228
1229 // For PHIs we need to take care of the recurrence explicitly as the value
1230 // might change while we iterate through a loop. For now, we give up if
1231 // the PHI is not invariant.
1232 if (isa<PHINode>(Usr)) {
1233 // Check if the PHI is invariant (so far).
1234 OffsetInfo &UsrOI = OffsetInfoMap[Usr];
1235 if (UsrOI == PtrOI)
1236 return true;
1237
1238 // Check if the PHI operand has already an unknown offset as we can't
1239 // improve on that anymore.
1240 if (PtrOI.Offset == OffsetAndSize::Unknown) {
1241 UsrOI = PtrOI;
1242 Follow = true;
1243 return true;
1244 }
1245
1246 // Check if the PHI operand is not dependent on the PHI itself.
1247 APInt Offset(DL.getIndexTypeSizeInBits(AssociatedValue.getType()), 0);
1248 if (&AssociatedValue == CurPtr->stripAndAccumulateConstantOffsets(
1249 DL, Offset, /* AllowNonInbounds */ true)) {
1250 if (Offset != PtrOI.Offset) {
1251 LLVM_DEBUG(dbgs()do { } while (false)
1252 << "[AAPointerInfo] PHI operand pointer offset mismatch "do { } while (false)
1253 << *CurPtr << " in " << *Usr << "\n")do { } while (false);
1254 return false;
1255 }
1256 return HandlePassthroughUser(Usr, PtrOI, Follow);
1257 }
1258
1259 // TODO: Approximate in case we know the direction of the recurrence.
1260 LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI operand is too complex "do { } while (false)
1261 << *CurPtr << " in " << *Usr << "\n")do { } while (false);
1262 UsrOI = PtrOI;
1263 UsrOI.Offset = OffsetAndSize::Unknown;
1264 Follow = true;
1265 return true;
1266 }
1267
1268 if (auto *LoadI = dyn_cast<LoadInst>(Usr))
1269 return handleAccess(A, *LoadI, *CurPtr, /* Content */ nullptr,
1270 AccessKind::AK_READ, PtrOI.Offset, Changed,
1271 LoadI->getType());
1272 if (auto *StoreI = dyn_cast<StoreInst>(Usr)) {
1273 if (StoreI->getValueOperand() == CurPtr) {
1274 LLVM_DEBUG(dbgs() << "[AAPointerInfo] Escaping use in store "do { } while (false)
1275 << *StoreI << "\n")do { } while (false);
1276 return false;
1277 }
1278 bool UsedAssumedInformation = false;
1279 Optional<Value *> Content = A.getAssumedSimplified(
1280 *StoreI->getValueOperand(), *this, UsedAssumedInformation);
1281 return handleAccess(A, *StoreI, *CurPtr, Content, AccessKind::AK_WRITE,
1282 PtrOI.Offset, Changed,
1283 StoreI->getValueOperand()->getType());
1284 }
1285 if (auto *CB = dyn_cast<CallBase>(Usr)) {
1286 if (CB->isLifetimeStartOrEnd())
1287 return true;
1288 if (CB->isArgOperand(&U)) {
1289 unsigned ArgNo = CB->getArgOperandNo(&U);
1290 const auto &CSArgPI = A.getAAFor<AAPointerInfo>(
1291 *this, IRPosition::callsite_argument(*CB, ArgNo),
1292 DepClassTy::REQUIRED);
1293 Changed = translateAndAddCalleeState(A, CSArgPI, PtrOI.Offset, *CB) |
1294 Changed;
1295 return true;
1296 }
1297 LLVM_DEBUG(dbgs() << "[AAPointerInfo] Call user not handled " << *CBdo { } while (false)
1298 << "\n")do { } while (false);
1299 // TODO: Allow some call uses
1300 return false;
1301 }
1302
1303 LLVM_DEBUG(dbgs() << "[AAPointerInfo] User not handled " << *Usr << "\n")do { } while (false);
1304 return false;
1305 };
1306 if (!A.checkForAllUses(UsePred, *this, AssociatedValue,
1307 /* CheckBBLivenessOnly */ true))
1308 return indicatePessimisticFixpoint();
1309
1310 LLVM_DEBUG({do { } while (false)
1311 dbgs() << "Accesses by bin after update:\n";do { } while (false)
1312 for (auto &It : AccessBins) {do { } while (false)
1313 dbgs() << "[" << It.first.getOffset() << "-"do { } while (false)
1314 << It.first.getOffset() + It.first.getSize()do { } while (false)
1315 << "] : " << It.getSecond().size() << "\n";do { } while (false)
1316 for (auto &Acc : It.getSecond()) {do { } while (false)
1317 dbgs() << " - " << Acc.getKind() << " - " << *Acc.getLocalInst()do { } while (false)
1318 << "\n";do { } while (false)
1319 if (Acc.getLocalInst() != Acc.getRemoteInst())do { } while (false)
1320 dbgs() << " --> "do { } while (false)
1321 << *Acc.getRemoteInst() << "\n";do { } while (false)
1322 if (!Acc.isWrittenValueYetUndetermined())do { } while (false)
1323 dbgs() << " - " << Acc.getWrittenValue() << "\n";do { } while (false)
1324 }do { } while (false)
1325 }do { } while (false)
1326 })do { } while (false);
1327
1328 return Changed;
1329 }
1330
1331 /// See AbstractAttribute::trackStatistics()
1332 void trackStatistics() const override {
1333 AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
1334 }
1335};
1336
1337struct AAPointerInfoReturned final : AAPointerInfoImpl {
1338 AAPointerInfoReturned(const IRPosition &IRP, Attributor &A)
1339 : AAPointerInfoImpl(IRP, A) {}
1340
1341 /// See AbstractAttribute::updateImpl(...).
1342 ChangeStatus updateImpl(Attributor &A) override {
1343 return indicatePessimisticFixpoint();
1344 }
1345
1346 /// See AbstractAttribute::trackStatistics()
1347 void trackStatistics() const override {
1348 AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
1349 }
1350};
1351
1352struct AAPointerInfoArgument final : AAPointerInfoFloating {
1353 AAPointerInfoArgument(const IRPosition &IRP, Attributor &A)
1354 : AAPointerInfoFloating(IRP, A) {}
1355
1356 /// See AbstractAttribute::initialize(...).
1357 void initialize(Attributor &A) override {
1358 AAPointerInfoFloating::initialize(A);
1359 if (getAnchorScope()->isDeclaration())
1360 indicatePessimisticFixpoint();
1361 }
1362
1363 /// See AbstractAttribute::trackStatistics()
1364 void trackStatistics() const override {
1365 AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
1366 }
1367};
1368
1369struct AAPointerInfoCallSiteArgument final : AAPointerInfoFloating {
1370 AAPointerInfoCallSiteArgument(const IRPosition &IRP, Attributor &A)
1371 : AAPointerInfoFloating(IRP, A) {}
1372
1373 /// See AbstractAttribute::updateImpl(...).
1374 ChangeStatus updateImpl(Attributor &A) override {
1375 using namespace AA::PointerInfo;
1376 // We handle memory intrinsics explicitly, at least the first (=
1377 // destination) and second (=source) arguments as we know how they are
1378 // accessed.
1379 if (auto *MI = dyn_cast_or_null<MemIntrinsic>(getCtxI())) {
1380 ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
1381 int64_t LengthVal = OffsetAndSize::Unknown;
1382 if (Length)
1383 LengthVal = Length->getSExtValue();
1384 Value &Ptr = getAssociatedValue();
1385 unsigned ArgNo = getIRPosition().getCallSiteArgNo();
1386 ChangeStatus Changed;
1387 if (ArgNo == 0) {
1388 handleAccess(A, *MI, Ptr, nullptr, AccessKind::AK_WRITE, 0, Changed,
1389 nullptr, LengthVal);
1390 } else if (ArgNo == 1) {
1391 handleAccess(A, *MI, Ptr, nullptr, AccessKind::AK_READ, 0, Changed,
1392 nullptr, LengthVal);
1393 } else {
1394 LLVM_DEBUG(dbgs() << "[AAPointerInfo] Unhandled memory intrinsic "do { } while (false)
1395 << *MI << "\n")do { } while (false);
1396 return indicatePessimisticFixpoint();
1397 }
1398 return Changed;
1399 }
1400
1401 // TODO: Once we have call site specific value information we can provide
1402 // call site specific liveness information and then it makes
1403 // sense to specialize attributes for call sites arguments instead of
1404 // redirecting requests to the callee argument.
1405 Argument *Arg = getAssociatedArgument();
1406 if (!Arg)
1407 return indicatePessimisticFixpoint();
1408 const IRPosition &ArgPos = IRPosition::argument(*Arg);
1409 auto &ArgAA =
1410 A.getAAFor<AAPointerInfo>(*this, ArgPos, DepClassTy::REQUIRED);
1411 return translateAndAddCalleeState(A, ArgAA, 0, *cast<CallBase>(getCtxI()));
1412 }
1413
1414 /// See AbstractAttribute::trackStatistics()
1415 void trackStatistics() const override {
1416 AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
1417 }
1418};
1419
1420struct AAPointerInfoCallSiteReturned final : AAPointerInfoFloating {
1421 AAPointerInfoCallSiteReturned(const IRPosition &IRP, Attributor &A)
1422 : AAPointerInfoFloating(IRP, A) {}
1423
1424 /// See AbstractAttribute::trackStatistics()
1425 void trackStatistics() const override {
1426 AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
1427 }
1428};
1429
1430/// -----------------------NoUnwind Function Attribute--------------------------
1431
1432struct AANoUnwindImpl : AANoUnwind {
1433 AANoUnwindImpl(const IRPosition &IRP, Attributor &A) : AANoUnwind(IRP, A) {}
1434
1435 const std::string getAsStr() const override {
1436 return getAssumed() ? "nounwind" : "may-unwind";
1437 }
1438
1439 /// See AbstractAttribute::updateImpl(...).
1440 ChangeStatus updateImpl(Attributor &A) override {
1441 auto Opcodes = {
1442 (unsigned)Instruction::Invoke, (unsigned)Instruction::CallBr,
1443 (unsigned)Instruction::Call, (unsigned)Instruction::CleanupRet,
1444 (unsigned)Instruction::CatchSwitch, (unsigned)Instruction::Resume};
1445
1446 auto CheckForNoUnwind = [&](Instruction &I) {
1447 if (!I.mayThrow())
1448 return true;
1449
1450 if (const auto *CB = dyn_cast<CallBase>(&I)) {
1451 const auto &NoUnwindAA = A.getAAFor<AANoUnwind>(
1452 *this, IRPosition::callsite_function(*CB), DepClassTy::REQUIRED);
1453 return NoUnwindAA.isAssumedNoUnwind();
1454 }
1455 return false;
1456 };
1457
1458 bool UsedAssumedInformation = false;
1459 if (!A.checkForAllInstructions(CheckForNoUnwind, *this, Opcodes,
1460 UsedAssumedInformation))
1461 return indicatePessimisticFixpoint();
1462
1463 return ChangeStatus::UNCHANGED;
1464 }
1465};
1466
1467struct AANoUnwindFunction final : public AANoUnwindImpl {
1468 AANoUnwindFunction(const IRPosition &IRP, Attributor &A)
1469 : AANoUnwindImpl(IRP, A) {}
1470
1471 /// See AbstractAttribute::trackStatistics()
1472 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nounwind){ static llvm::Statistic NumIRFunction_nounwind = {"attributor"
, "NumIRFunction_nounwind", ("Number of " "functions" " marked '"
"nounwind" "'")};; ++(NumIRFunction_nounwind); }
}
1473};
1474
1475/// NoUnwind attribute deduction for a call sites.
1476struct AANoUnwindCallSite final : AANoUnwindImpl {
1477 AANoUnwindCallSite(const IRPosition &IRP, Attributor &A)
1478 : AANoUnwindImpl(IRP, A) {}
1479
1480 /// See AbstractAttribute::initialize(...).
1481 void initialize(Attributor &A) override {
1482 AANoUnwindImpl::initialize(A);
1483 Function *F = getAssociatedFunction();
1484 if (!F || F->isDeclaration())
1485 indicatePessimisticFixpoint();
1486 }
1487
1488 /// See AbstractAttribute::updateImpl(...).
1489 ChangeStatus updateImpl(Attributor &A) override {
1490 // TODO: Once we have call site specific value information we can provide
1491 // call site specific liveness information and then it makes
1492 // sense to specialize attributes for call sites arguments instead of
1493 // redirecting requests to the callee argument.
1494 Function *F = getAssociatedFunction();
1495 const IRPosition &FnPos = IRPosition::function(*F);
1496 auto &FnAA = A.getAAFor<AANoUnwind>(*this, FnPos, DepClassTy::REQUIRED);
1497 return clampStateAndIndicateChange(getState(), FnAA.getState());
1498 }
1499
1500 /// See AbstractAttribute::trackStatistics()
1501 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nounwind){ static llvm::Statistic NumIRCS_nounwind = {"attributor", "NumIRCS_nounwind"
, ("Number of " "call site" " marked '" "nounwind" "'")};; ++
(NumIRCS_nounwind); }
; }
1502};
1503
1504/// --------------------- Function Return Values -------------------------------
1505
1506/// "Attribute" that collects all potential returned values and the return
1507/// instructions that they arise from.
1508///
1509/// If there is a unique returned value R, the manifest method will:
1510/// - mark R with the "returned" attribute, if R is an argument.
1511class AAReturnedValuesImpl : public AAReturnedValues, public AbstractState {
1512
1513 /// Mapping of values potentially returned by the associated function to the
1514 /// return instructions that might return them.
1515 MapVector<Value *, SmallSetVector<ReturnInst *, 4>> ReturnedValues;
1516
1517 /// State flags
1518 ///
1519 ///{
1520 bool IsFixed = false;
1521 bool IsValidState = true;
1522 ///}
1523
1524public:
1525 AAReturnedValuesImpl(const IRPosition &IRP, Attributor &A)
1526 : AAReturnedValues(IRP, A) {}
1527
1528 /// See AbstractAttribute::initialize(...).
1529 void initialize(Attributor &A) override {
1530 // Reset the state.
1531 IsFixed = false;
1532 IsValidState = true;
1533 ReturnedValues.clear();
1534
1535 Function *F = getAssociatedFunction();
1536 if (!F || F->isDeclaration()) {
1537 indicatePessimisticFixpoint();
1538 return;
1539 }
1540 assert(!F->getReturnType()->isVoidTy() &&((void)0)
1541 "Did not expect a void return type!")((void)0);
1542
1543 // The map from instruction opcodes to those instructions in the function.
1544 auto &OpcodeInstMap = A.getInfoCache().getOpcodeInstMapForFunction(*F);
1545
1546 // Look through all arguments, if one is marked as returned we are done.
1547 for (Argument &Arg : F->args()) {
1548 if (Arg.hasReturnedAttr()) {
1549 auto &ReturnInstSet = ReturnedValues[&Arg];
1550 if (auto *Insts = OpcodeInstMap.lookup(Instruction::Ret))
1551 for (Instruction *RI : *Insts)
1552 ReturnInstSet.insert(cast<ReturnInst>(RI));
1553
1554 indicateOptimisticFixpoint();
1555 return;
1556 }
1557 }
1558
1559 if (!A.isFunctionIPOAmendable(*F))
1560 indicatePessimisticFixpoint();
1561 }
1562
1563 /// See AbstractAttribute::manifest(...).
1564 ChangeStatus manifest(Attributor &A) override;
1565
1566 /// See AbstractAttribute::getState(...).
1567 AbstractState &getState() override { return *this; }
1568
1569 /// See AbstractAttribute::getState(...).
1570 const AbstractState &getState() const override { return *this; }
1571
1572 /// See AbstractAttribute::updateImpl(Attributor &A).
1573 ChangeStatus updateImpl(Attributor &A) override;
1574
1575 llvm::iterator_range<iterator> returned_values() override {
1576 return llvm::make_range(ReturnedValues.begin(), ReturnedValues.end());
1577 }
1578
1579 llvm::iterator_range<const_iterator> returned_values() const override {
1580 return llvm::make_range(ReturnedValues.begin(), ReturnedValues.end());
1581 }
1582
1583 /// Return the number of potential return values, -1 if unknown.
1584 size_t getNumReturnValues() const override {
1585 return isValidState() ? ReturnedValues.size() : -1;
1586 }
1587
1588 /// Return an assumed unique return value if a single candidate is found. If
1589 /// there cannot be one, return a nullptr. If it is not clear yet, return the
1590 /// Optional::NoneType.
1591 Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
1592
1593 /// See AbstractState::checkForAllReturnedValues(...).
1594 bool checkForAllReturnedValuesAndReturnInsts(
1595 function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
1596 const override;
1597
1598 /// Pretty print the attribute similar to the IR representation.
1599 const std::string getAsStr() const override;
1600
1601 /// See AbstractState::isAtFixpoint().
1602 bool isAtFixpoint() const override { return IsFixed; }
1603
1604 /// See AbstractState::isValidState().
1605 bool isValidState() const override { return IsValidState; }
1606
1607 /// See AbstractState::indicateOptimisticFixpoint(...).
1608 ChangeStatus indicateOptimisticFixpoint() override {
1609 IsFixed = true;
1610 return ChangeStatus::UNCHANGED;
1611 }
1612
1613 ChangeStatus indicatePessimisticFixpoint() override {
1614 IsFixed = true;
1615 IsValidState = false;
1616 return ChangeStatus::CHANGED;
1617 }
1618};
1619
1620ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
1621 ChangeStatus Changed = ChangeStatus::UNCHANGED;
1622
1623 // Bookkeeping.
1624 assert(isValidState())((void)0);
1625 STATS_DECLTRACK(KnownReturnValues, FunctionReturn,{ static llvm::Statistic NumIRFunctionReturn_KnownReturnValues
= {"attributor", "NumIRFunctionReturn_KnownReturnValues", "Number of function with known return values"
};; ++(NumIRFunctionReturn_KnownReturnValues); }
1626 "Number of function with known return values"){ static llvm::Statistic NumIRFunctionReturn_KnownReturnValues
= {"attributor", "NumIRFunctionReturn_KnownReturnValues", "Number of function with known return values"
};; ++(NumIRFunctionReturn_KnownReturnValues); }
;
1627
1628 // Check if we have an assumed unique return value that we could manifest.
1629 Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A);
1630
1631 if (!UniqueRV.hasValue() || !UniqueRV.getValue())
1632 return Changed;
1633
1634 // Bookkeeping.
1635 STATS_DECLTRACK(UniqueReturnValue, FunctionReturn,{ static llvm::Statistic NumIRFunctionReturn_UniqueReturnValue
= {"attributor", "NumIRFunctionReturn_UniqueReturnValue", "Number of function with unique return"
};; ++(NumIRFunctionReturn_UniqueReturnValue); }
1636 "Number of function with unique return"){ static llvm::Statistic NumIRFunctionReturn_UniqueReturnValue
= {"attributor", "NumIRFunctionReturn_UniqueReturnValue", "Number of function with unique return"
};; ++(NumIRFunctionReturn_UniqueReturnValue); }
;
1637 // If the assumed unique return value is an argument, annotate it.
1638 if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
1639 if (UniqueRVArg->getType()->canLosslesslyBitCastTo(
1640 getAssociatedFunction()->getReturnType())) {
1641 getIRPosition() = IRPosition::argument(*UniqueRVArg);
1642 Changed = IRAttribute::manifest(A);
1643 }
1644 }
1645 return Changed;
1646}
1647
1648const std::string AAReturnedValuesImpl::getAsStr() const {
1649 return (isAtFixpoint() ? "returns(#" : "may-return(#") +
1650 (isValidState() ? std::to_string(getNumReturnValues()) : "?") + ")";
1651}
1652
1653Optional<Value *>
1654AAReturnedValuesImpl::getAssumedUniqueReturnValue(Attributor &A) const {
1655 // If checkForAllReturnedValues provides a unique value, ignoring potential
1656 // undef values that can also be present, it is assumed to be the actual
1657 // return value and forwarded to the caller of this method. If there are
1658 // multiple, a nullptr is returned indicating there cannot be a unique
1659 // returned value.
1660 Optional<Value *> UniqueRV;
1661 Type *Ty = getAssociatedFunction()->getReturnType();
1662
1663 auto Pred = [&](Value &RV) -> bool {
1664 UniqueRV = AA::combineOptionalValuesInAAValueLatice(UniqueRV, &RV, Ty);
1665 return UniqueRV != Optional<Value *>(nullptr);
1666 };
1667
1668 if (!A.checkForAllReturnedValues(Pred, *this))
1669 UniqueRV = nullptr;
1670
1671 return UniqueRV;
1672}
1673
1674bool AAReturnedValuesImpl::checkForAllReturnedValuesAndReturnInsts(
1675 function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
1676 const {
1677 if (!isValidState())
1678 return false;
1679
1680 // Check all returned values but ignore call sites as long as we have not
1681 // encountered an overdefined one during an update.
1682 for (auto &It : ReturnedValues) {
1683 Value *RV = It.first;
1684 if (!Pred(*RV, It.second))
1685 return false;
1686 }
1687
1688 return true;
1689}
1690
1691ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A) {
1692 ChangeStatus Changed = ChangeStatus::UNCHANGED;
1693
1694 auto ReturnValueCB = [&](Value &V, const Instruction *CtxI, ReturnInst &Ret,
1695 bool) -> bool {
1696 bool UsedAssumedInformation = false;
1697 Optional<Value *> SimpleRetVal =
1698 A.getAssumedSimplified(V, *this, UsedAssumedInformation);
1699 if (!SimpleRetVal.hasValue())
1700 return true;
1701 if (!SimpleRetVal.getValue())
1702 return false;
1703 Value *RetVal = *SimpleRetVal;
1704 assert(AA::isValidInScope(*RetVal, Ret.getFunction()) &&((void)0)
1705 "Assumed returned value should be valid in function scope!")((void)0);
1706 if (ReturnedValues[RetVal].insert(&Ret))
1707 Changed = ChangeStatus::CHANGED;
1708 return true;
1709 };
1710
1711 auto ReturnInstCB = [&](Instruction &I) {
1712 ReturnInst &Ret = cast<ReturnInst>(I);
1713 return genericValueTraversal<ReturnInst>(
1714 A, IRPosition::value(*Ret.getReturnValue()), *this, Ret, ReturnValueCB,
1715 &I);
1716 };
1717
1718 // Discover returned values from all live returned instructions in the
1719 // associated function.
1720 bool UsedAssumedInformation = false;
1721 if (!A.checkForAllInstructions(ReturnInstCB, *this, {Instruction::Ret},
1722 UsedAssumedInformation))
1723 return indicatePessimisticFixpoint();
1724 return Changed;
1725}
1726
1727struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
1728 AAReturnedValuesFunction(const IRPosition &IRP, Attributor &A)
1729 : AAReturnedValuesImpl(IRP, A) {}
1730
1731 /// See AbstractAttribute::trackStatistics()
1732 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(returned){ static llvm::Statistic NumIRArguments_returned = {"attributor"
, "NumIRArguments_returned", ("Number of " "arguments" " marked '"
"returned" "'")};; ++(NumIRArguments_returned); }
}
1733};
1734
1735/// Returned values information for a call sites.
1736struct AAReturnedValuesCallSite final : AAReturnedValuesImpl {
1737 AAReturnedValuesCallSite(const IRPosition &IRP, Attributor &A)
1738 : AAReturnedValuesImpl(IRP, A) {}
1739
1740 /// See AbstractAttribute::initialize(...).
1741 void initialize(Attributor &A) override {
1742 // TODO: Once we have call site specific value information we can provide
1743 // call site specific liveness information and then it makes
1744 // sense to specialize attributes for call sites instead of
1745 // redirecting requests to the callee.
1746 llvm_unreachable("Abstract attributes for returned values are not "__builtin_unreachable()
1747 "supported for call sites yet!")__builtin_unreachable();
1748 }
1749
1750 /// See AbstractAttribute::updateImpl(...).
1751 ChangeStatus updateImpl(Attributor &A) override {
1752 return indicatePessimisticFixpoint();
1753 }
1754
1755 /// See AbstractAttribute::trackStatistics()
1756 void trackStatistics() const override {}
1757};
1758
1759/// ------------------------ NoSync Function Attribute -------------------------
1760
1761struct AANoSyncImpl : AANoSync {
1762 AANoSyncImpl(const IRPosition &IRP, Attributor &A) : AANoSync(IRP, A) {}
1763
1764 const std::string getAsStr() const override {
1765 return getAssumed() ? "nosync" : "may-sync";
1766 }
1767
1768 /// See AbstractAttribute::updateImpl(...).
1769 ChangeStatus updateImpl(Attributor &A) override;
1770
1771 /// Helper function used to determine whether an instruction is non-relaxed
1772 /// atomic. In other words, if an atomic instruction does not have unordered
1773 /// or monotonic ordering
1774 static bool isNonRelaxedAtomic(Instruction *I);
1775
1776 /// Helper function specific for intrinsics which are potentially volatile
1777 static bool isNoSyncIntrinsic(Instruction *I);
1778};
1779
1780bool AANoSyncImpl::isNonRelaxedAtomic(Instruction *I) {
1781 if (!I->isAtomic())
1782 return false;
1783
1784 if (auto *FI = dyn_cast<FenceInst>(I))
1785 // All legal orderings for fence are stronger than monotonic.
1786 return FI->getSyncScopeID() != SyncScope::SingleThread;
1787 else if (auto *AI = dyn_cast<AtomicCmpXchgInst>(I)) {
1788 // Unordered is not a legal ordering for cmpxchg.
1789 return (AI->getSuccessOrdering() != AtomicOrdering::Monotonic ||
1790 AI->getFailureOrdering() != AtomicOrdering::Monotonic);
1791 }
1792
1793 AtomicOrdering Ordering;
1794 switch (I->getOpcode()) {
1795 case Instruction::AtomicRMW:
1796 Ordering = cast<AtomicRMWInst>(I)->getOrdering();
1797 break;
1798 case Instruction::Store:
1799 Ordering = cast<StoreInst>(I)->getOrdering();
1800 break;
1801 case Instruction::Load:
1802 Ordering = cast<LoadInst>(I)->getOrdering();
1803 break;
1804 default:
1805 llvm_unreachable(__builtin_unreachable()
1806 "New atomic operations need to be known in the attributor.")__builtin_unreachable();
1807 }
1808
1809 return (Ordering != AtomicOrdering::Unordered &&
1810 Ordering != AtomicOrdering::Monotonic);
1811}
1812
1813/// Return true if this intrinsic is nosync. This is only used for intrinsics
1814/// which would be nosync except that they have a volatile flag. All other
1815/// intrinsics are simply annotated with the nosync attribute in Intrinsics.td.
1816bool AANoSyncImpl::isNoSyncIntrinsic(Instruction *I) {
1817 if (auto *MI = dyn_cast<MemIntrinsic>(I))
1818 return !MI->isVolatile();
1819 return false;
1820}
1821
1822ChangeStatus AANoSyncImpl::updateImpl(Attributor &A) {
1823
1824 auto CheckRWInstForNoSync = [&](Instruction &I) {
1825 /// We are looking for volatile instructions or Non-Relaxed atomics.
1826
1827 if (const auto *CB = dyn_cast<CallBase>(&I)) {
1828 if (CB->hasFnAttr(Attribute::NoSync))
1829 return true;
1830
1831 if (isNoSyncIntrinsic(&I))
1832 return true;
1833
1834 const auto &NoSyncAA = A.getAAFor<AANoSync>(
1835 *this, IRPosition::callsite_function(*CB), DepClassTy::REQUIRED);
1836 return NoSyncAA.isAssumedNoSync();
1837 }
1838
1839 if (!I.isVolatile() && !isNonRelaxedAtomic(&I))
1840 return true;
1841
1842 return false;
1843 };
1844
1845 auto CheckForNoSync = [&](Instruction &I) {
1846 // At this point we handled all read/write effects and they are all
1847 // nosync, so they can be skipped.
1848 if (I.mayReadOrWriteMemory())
1849 return true;
1850
1851 // non-convergent and readnone imply nosync.
1852 return !cast<CallBase>(I).isConvergent();
1853 };
1854
1855 bool UsedAssumedInformation = false;
1856 if (!A.checkForAllReadWriteInstructions(CheckRWInstForNoSync, *this,
1857 UsedAssumedInformation) ||
1858 !A.checkForAllCallLikeInstructions(CheckForNoSync, *this,
1859 UsedAssumedInformation))
1860 return indicatePessimisticFixpoint();
1861
1862 return ChangeStatus::UNCHANGED;
1863}
1864
1865struct AANoSyncFunction final : public AANoSyncImpl {
1866 AANoSyncFunction(const IRPosition &IRP, Attributor &A)
1867 : AANoSyncImpl(IRP, A) {}
1868
1869 /// See AbstractAttribute::trackStatistics()
1870 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nosync){ static llvm::Statistic NumIRFunction_nosync = {"attributor"
, "NumIRFunction_nosync", ("Number of " "functions" " marked '"
"nosync" "'")};; ++(NumIRFunction_nosync); }
}
1871};
1872
1873/// NoSync attribute deduction for a call sites.
1874struct AANoSyncCallSite final : AANoSyncImpl {
1875 AANoSyncCallSite(const IRPosition &IRP, Attributor &A)
1876 : AANoSyncImpl(IRP, A) {}
1877
1878 /// See AbstractAttribute::initialize(...).
1879 void initialize(Attributor &A) override {
1880 AANoSyncImpl::initialize(A);
1881 Function *F = getAssociatedFunction();
1882 if (!F || F->isDeclaration())
1883 indicatePessimisticFixpoint();
1884 }
1885
1886 /// See AbstractAttribute::updateImpl(...).
1887 ChangeStatus updateImpl(Attributor &A) override {
1888 // TODO: Once we have call site specific value information we can provide
1889 // call site specific liveness information and then it makes
1890 // sense to specialize attributes for call sites arguments instead of
1891 // redirecting requests to the callee argument.
1892 Function *F = getAssociatedFunction();
1893 const IRPosition &FnPos = IRPosition::function(*F);
1894 auto &FnAA = A.getAAFor<AANoSync>(*this, FnPos, DepClassTy::REQUIRED);
1895 return clampStateAndIndicateChange(getState(), FnAA.getState());
1896 }
1897
1898 /// See AbstractAttribute::trackStatistics()
1899 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nosync){ static llvm::Statistic NumIRCS_nosync = {"attributor", "NumIRCS_nosync"
, ("Number of " "call site" " marked '" "nosync" "'")};; ++(NumIRCS_nosync
); }
; }
1900};
1901
1902/// ------------------------ No-Free Attributes ----------------------------
1903
1904struct AANoFreeImpl : public AANoFree {
1905 AANoFreeImpl(const IRPosition &IRP, Attributor &A) : AANoFree(IRP, A) {}
1906
1907 /// See AbstractAttribute::updateImpl(...).
1908 ChangeStatus updateImpl(Attributor &A) override {
1909 auto CheckForNoFree = [&](Instruction &I) {
1910 const auto &CB = cast<CallBase>(I);
1911 if (CB.hasFnAttr(Attribute::NoFree))
1912 return true;
1913
1914 const auto &NoFreeAA = A.getAAFor<AANoFree>(
1915 *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);
1916 return NoFreeAA.isAssumedNoFree();
1917 };
1918
1919 bool UsedAssumedInformation = false;
1920 if (!A.checkForAllCallLikeInstructions(CheckForNoFree, *this,
1921 UsedAssumedInformation))
1922 return indicatePessimisticFixpoint();
1923 return ChangeStatus::UNCHANGED;
1924 }
1925
1926 /// See AbstractAttribute::getAsStr().
1927 const std::string getAsStr() const override {
1928 return getAssumed() ? "nofree" : "may-free";
1929 }
1930};
1931
1932struct AANoFreeFunction final : public AANoFreeImpl {
1933 AANoFreeFunction(const IRPosition &IRP, Attributor &A)
1934 : AANoFreeImpl(IRP, A) {}
1935
1936 /// See AbstractAttribute::trackStatistics()
1937 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nofree){ static llvm::Statistic NumIRFunction_nofree = {"attributor"
, "NumIRFunction_nofree", ("Number of " "functions" " marked '"
"nofree" "'")};; ++(NumIRFunction_nofree); }
}
1938};
1939
1940/// NoFree attribute deduction for a call sites.
1941struct AANoFreeCallSite final : AANoFreeImpl {
1942 AANoFreeCallSite(const IRPosition &IRP, Attributor &A)
1943 : AANoFreeImpl(IRP, A) {}
1944
1945 /// See AbstractAttribute::initialize(...).
1946 void initialize(Attributor &A) override {
1947 AANoFreeImpl::initialize(A);
1948 Function *F = getAssociatedFunction();
1949 if (!F || F->isDeclaration())
1950 indicatePessimisticFixpoint();
1951 }
1952
1953 /// See AbstractAttribute::updateImpl(...).
1954 ChangeStatus updateImpl(Attributor &A) override {
1955 // TODO: Once we have call site specific value information we can provide
1956 // call site specific liveness information and then it makes
1957 // sense to specialize attributes for call sites arguments instead of
1958 // redirecting requests to the callee argument.
1959 Function *F = getAssociatedFunction();
1960 const IRPosition &FnPos = IRPosition::function(*F);
1961 auto &FnAA = A.getAAFor<AANoFree>(*this, FnPos, DepClassTy::REQUIRED);
1962 return clampStateAndIndicateChange(getState(), FnAA.getState());
1963 }
1964
1965 /// See AbstractAttribute::trackStatistics()
1966 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nofree){ static llvm::Statistic NumIRCS_nofree = {"attributor", "NumIRCS_nofree"
, ("Number of " "call site" " marked '" "nofree" "'")};; ++(NumIRCS_nofree
); }
; }
1967};
1968
1969/// NoFree attribute for floating values.
1970struct AANoFreeFloating : AANoFreeImpl {
1971 AANoFreeFloating(const IRPosition &IRP, Attributor &A)
1972 : AANoFreeImpl(IRP, A) {}
1973
1974 /// See AbstractAttribute::trackStatistics()
1975 void trackStatistics() const override{STATS_DECLTRACK_FLOATING_ATTR(nofree){ static llvm::Statistic NumIRFloating_nofree = {"attributor"
, "NumIRFloating_nofree", ("Number of floating values known to be '"
"nofree" "'")};; ++(NumIRFloating_nofree); }
}
1976
1977 /// See Abstract Attribute::updateImpl(...).
1978 ChangeStatus updateImpl(Attributor &A) override {
1979 const IRPosition &IRP = getIRPosition();
1980
1981 const auto &NoFreeAA = A.getAAFor<AANoFree>(
1982 *this, IRPosition::function_scope(IRP), DepClassTy::OPTIONAL);
1983 if (NoFreeAA.isAssumedNoFree())
1984 return ChangeStatus::UNCHANGED;
1985
1986 Value &AssociatedValue = getIRPosition().getAssociatedValue();
1987 auto Pred = [&](const Use &U, bool &Follow) -> bool {
1988 Instruction *UserI = cast<Instruction>(U.getUser());
1989 if (auto *CB = dyn_cast<CallBase>(UserI)) {
1990 if (CB->isBundleOperand(&U))
1991 return false;
1992 if (!CB->isArgOperand(&U))
1993 return true;
1994 unsigned ArgNo = CB->getArgOperandNo(&U);
1995
1996 const auto &NoFreeArg = A.getAAFor<AANoFree>(
1997 *this, IRPosition::callsite_argument(*CB, ArgNo),
1998 DepClassTy::REQUIRED);
1999 return NoFreeArg.isAssumedNoFree();
2000 }
2001
2002 if (isa<GetElementPtrInst>(UserI) || isa<BitCastInst>(UserI) ||
2003 isa<PHINode>(UserI) || isa<SelectInst>(UserI)) {
2004 Follow = true;
2005 return true;
2006 }
2007 if (isa<StoreInst>(UserI) || isa<LoadInst>(UserI) ||
2008 isa<ReturnInst>(UserI))
2009 return true;
2010
2011 // Unknown user.
2012 return false;
2013 };
2014 if (!A.checkForAllUses(Pred, *this, AssociatedValue))
2015 return indicatePessimisticFixpoint();
2016
2017 return ChangeStatus::UNCHANGED;
2018 }
2019};
2020
2021/// NoFree attribute for a call site argument.
2022struct AANoFreeArgument final : AANoFreeFloating {
2023 AANoFreeArgument(const IRPosition &IRP, Attributor &A)
2024 : AANoFreeFloating(IRP, A) {}
2025
2026 /// See AbstractAttribute::trackStatistics()
2027 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nofree){ static llvm::Statistic NumIRArguments_nofree = {"attributor"
, "NumIRArguments_nofree", ("Number of " "arguments" " marked '"
"nofree" "'")};; ++(NumIRArguments_nofree); }
}
2028};
2029
2030/// NoFree attribute for call site arguments.
2031struct AANoFreeCallSiteArgument final : AANoFreeFloating {
2032 AANoFreeCallSiteArgument(const IRPosition &IRP, Attributor &A)
2033 : AANoFreeFloating(IRP, A) {}
2034
2035 /// See AbstractAttribute::updateImpl(...).
2036 ChangeStatus updateImpl(Attributor &A) override {
2037 // TODO: Once we have call site specific value information we can provide
2038 // call site specific liveness information and then it makes
2039 // sense to specialize attributes for call sites arguments instead of
2040 // redirecting requests to the callee argument.
2041 Argument *Arg = getAssociatedArgument();
2042 if (!Arg)
2043 return indicatePessimisticFixpoint();
2044 const IRPosition &ArgPos = IRPosition::argument(*Arg);
2045 auto &ArgAA = A.getAAFor<AANoFree>(*this, ArgPos, DepClassTy::REQUIRED);
2046 return clampStateAndIndicateChange(getState(), ArgAA.getState());
2047 }
2048
2049 /// See AbstractAttribute::trackStatistics()
2050 void trackStatistics() const override{STATS_DECLTRACK_CSARG_ATTR(nofree){ static llvm::Statistic NumIRCSArguments_nofree = {"attributor"
, "NumIRCSArguments_nofree", ("Number of " "call site arguments"
" marked '" "nofree" "'")};; ++(NumIRCSArguments_nofree); }
};
2051};
2052
2053/// NoFree attribute for function return value.
2054struct AANoFreeReturned final : AANoFreeFloating {
2055 AANoFreeReturned(const IRPosition &IRP, Attributor &A)
2056 : AANoFreeFloating(IRP, A) {
2057 llvm_unreachable("NoFree is not applicable to function returns!")__builtin_unreachable();
2058 }
2059
2060 /// See AbstractAttribute::initialize(...).
2061 void initialize(Attributor &A) override {
2062 llvm_unreachable("NoFree is not applicable to function returns!")__builtin_unreachable();
2063 }
2064
2065 /// See AbstractAttribute::updateImpl(...).
2066 ChangeStatus updateImpl(Attributor &A) override {
2067 llvm_unreachable("NoFree is not applicable to function returns!")__builtin_unreachable();
2068 }
2069
2070 /// See AbstractAttribute::trackStatistics()
2071 void trackStatistics() const override {}
2072};
2073
2074/// NoFree attribute deduction for a call site return value.
2075struct AANoFreeCallSiteReturned final : AANoFreeFloating {
2076 AANoFreeCallSiteReturned(const IRPosition &IRP, Attributor &A)
2077 : AANoFreeFloating(IRP, A) {}
2078
2079 ChangeStatus manifest(Attributor &A) override {
2080 return ChangeStatus::UNCHANGED;
2081 }
2082 /// See AbstractAttribute::trackStatistics()
2083 void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nofree){ static llvm::Statistic NumIRCSReturn_nofree = {"attributor"
, "NumIRCSReturn_nofree", ("Number of " "call site returns" " marked '"
"nofree" "'")};; ++(NumIRCSReturn_nofree); }
}
2084};
2085
2086/// ------------------------ NonNull Argument Attribute ------------------------
2087static int64_t getKnownNonNullAndDerefBytesForUse(
2088 Attributor &A, const AbstractAttribute &QueryingAA, Value &AssociatedValue,
2089 const Use *U, const Instruction *I, bool &IsNonNull, bool &TrackUse) {
2090 TrackUse = false;
2091
2092 const Value *UseV = U->get();
2093 if (!UseV->getType()->isPointerTy())
2094 return 0;
2095
2096 // We need to follow common pointer manipulation uses to the accesses they
2097 // feed into. We can try to be smart to avoid looking through things we do not
2098 // like for now, e.g., non-inbounds GEPs.
2099 if (isa<CastInst>(I)) {
2100 TrackUse = true;
2101 return 0;
2102 }
2103
2104 if (isa<GetElementPtrInst>(I)) {
2105 TrackUse = true;
2106 return 0;
2107 }
2108
2109 Type *PtrTy = UseV->getType();
2110 const Function *F = I->getFunction();
2111 bool NullPointerIsDefined =
2112 F ? llvm::NullPointerIsDefined(F, PtrTy->getPointerAddressSpace()) : true;
2113 const DataLayout &DL = A.getInfoCache().getDL();
2114 if (const auto *CB = dyn_cast<CallBase>(I)) {
2115 if (CB->isBundleOperand(U)) {
2116 if (RetainedKnowledge RK = getKnowledgeFromUse(
2117 U, {Attribute::NonNull, Attribute::Dereferenceable})) {
2118 IsNonNull |=
2119 (RK.AttrKind == Attribute::NonNull || !NullPointerIsDefined);
2120 return RK.ArgValue;
2121 }
2122 return 0;
2123 }
2124
2125 if (CB->isCallee(U)) {
2126 IsNonNull |= !NullPointerIsDefined;
2127 return 0;
2128 }
2129
2130 unsigned ArgNo = CB->getArgOperandNo(U);
2131 IRPosition IRP = IRPosition::callsite_argument(*CB, ArgNo);
2132 // As long as we only use known information there is no need to track
2133 // dependences here.
2134 auto &DerefAA =
2135 A.getAAFor<AADereferenceable>(QueryingAA, IRP, DepClassTy::NONE);
2136 IsNonNull |= DerefAA.isKnownNonNull();
2137 return DerefAA.getKnownDereferenceableBytes();
2138 }
2139
2140 int64_t Offset;
2141 const Value *Base =
2142 getMinimalBaseOfAccsesPointerOperand(A, QueryingAA, I, Offset, DL);
2143 if (Base) {
2144 if (Base == &AssociatedValue &&
2145 getPointerOperand(I, /* AllowVolatile */ false) == UseV) {
2146 int64_t DerefBytes =
2147 (int64_t)DL.getTypeStoreSize(PtrTy->getPointerElementType()) + Offset;
2148
2149 IsNonNull |= !NullPointerIsDefined;
2150 return std::max(int64_t(0), DerefBytes);
2151 }
2152 }
2153
2154 /// Corner case when an offset is 0.
2155 Base = getBasePointerOfAccessPointerOperand(I, Offset, DL,
2156 /*AllowNonInbounds*/ true);
2157 if (Base) {
2158 if (Offset == 0 && Base == &AssociatedValue &&
2159 getPointerOperand(I, /* AllowVolatile */ false) == UseV) {
2160 int64_t DerefBytes =
2161 (int64_t)DL.getTypeStoreSize(PtrTy->getPointerElementType());
2162 IsNonNull |= !NullPointerIsDefined;
2163 return std::max(int64_t(0), DerefBytes);
2164 }
2165 }
2166
2167 return 0;
2168}
2169
2170struct AANonNullImpl : AANonNull {
2171 AANonNullImpl(const IRPosition &IRP, Attributor &A)
2172 : AANonNull(IRP, A),
2173 NullIsDefined(NullPointerIsDefined(
2174 getAnchorScope(),
2175 getAssociatedValue().getType()->getPointerAddressSpace())) {}
2176
2177 /// See AbstractAttribute::initialize(...).
2178 void initialize(Attributor &A) override {
2179 Value &V = getAssociatedValue();
2180 if (!NullIsDefined &&
2181 hasAttr({Attribute::NonNull, Attribute::Dereferenceable},
2182 /* IgnoreSubsumingPositions */ false, &A)) {
2183 indicateOptimisticFixpoint();
2184 return;
2185 }
2186
2187 if (isa<ConstantPointerNull>(V)) {
2188 indicatePessimisticFixpoint();
2189 return;
2190 }
2191
2192 AANonNull::initialize(A);
2193
2194 bool CanBeNull, CanBeFreed;
2195 if (V.getPointerDereferenceableBytes(A.getDataLayout(), CanBeNull,
2196 CanBeFreed)) {
2197 if (!CanBeNull) {
2198 indicateOptimisticFixpoint();
2199 return;
2200 }
2201 }
2202
2203 if (isa<GlobalValue>(&getAssociatedValue())) {
2204 indicatePessimisticFixpoint();
2205 return;
2206 }
2207
2208 if (Instruction *CtxI = getCtxI())
2209 followUsesInMBEC(*this, A, getState(), *CtxI);
2210 }
2211
2212 /// See followUsesInMBEC
2213 bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
2214 AANonNull::StateType &State) {
2215 bool IsNonNull = false;
2216 bool TrackUse = false;
2217 getKnownNonNullAndDerefBytesForUse(A, *this, getAssociatedValue(), U, I,
2218 IsNonNull, TrackUse);
2219 State.setKnown(IsNonNull);
2220 return TrackUse;
2221 }
2222
2223 /// See AbstractAttribute::getAsStr().
2224 const std::string getAsStr() const override {
2225 return getAssumed() ? "nonnull" : "may-null";
2226 }
2227
2228 /// Flag to determine if the underlying value can be null and still allow
2229 /// valid accesses.
2230 const bool NullIsDefined;
2231};
2232
2233/// NonNull attribute for a floating value.
2234struct AANonNullFloating : public AANonNullImpl {
2235 AANonNullFloating(const IRPosition &IRP, Attributor &A)
2236 : AANonNullImpl(IRP, A) {}
2237
2238 /// See AbstractAttribute::updateImpl(...).
2239 ChangeStatus updateImpl(Attributor &A) override {
2240 const DataLayout &DL = A.getDataLayout();
2241
2242 DominatorTree *DT = nullptr;
2243 AssumptionCache *AC = nullptr;
2244 InformationCache &InfoCache = A.getInfoCache();
2245 if (const Function *Fn = getAnchorScope()) {
2246 DT = InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(*Fn);
2247 AC = InfoCache.getAnalysisResultForFunction<AssumptionAnalysis>(*Fn);
2248 }
2249
2250 auto VisitValueCB = [&](Value &V, const Instruction *CtxI,
2251 AANonNull::StateType &T, bool Stripped) -> bool {
2252 const auto &AA = A.getAAFor<AANonNull>(*this, IRPosition::value(V),
2253 DepClassTy::REQUIRED);
2254 if (!Stripped && this == &AA) {
2255 if (!isKnownNonZero(&V, DL, 0, AC, CtxI, DT))
2256 T.indicatePessimisticFixpoint();
2257 } else {
2258 // Use abstract attribute information.
2259 const AANonNull::StateType &NS = AA.getState();
2260 T ^= NS;
2261 }
2262 return T.isValidState();
2263 };
2264
2265 StateType T;
2266 if (!genericValueTraversal<StateType>(A, getIRPosition(), *this, T,
2267 VisitValueCB, getCtxI()))
2268 return indicatePessimisticFixpoint();
2269
2270 return clampStateAndIndicateChange(getState(), T);
2271 }
2272
2273 /// See AbstractAttribute::trackStatistics()
2274 void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull){ static llvm::Statistic NumIRFunctionReturn_nonnull = {"attributor"
, "NumIRFunctionReturn_nonnull", ("Number of " "function returns"
" marked '" "nonnull" "'")};; ++(NumIRFunctionReturn_nonnull
); }
}
2275};
2276
2277/// NonNull attribute for function return value.
2278struct AANonNullReturned final
2279 : AAReturnedFromReturnedValues<AANonNull, AANonNull> {
2280 AANonNullReturned(const IRPosition &IRP, Attributor &A)
2281 : AAReturnedFromReturnedValues<AANonNull, AANonNull>(IRP, A) {}
2282
2283 /// See AbstractAttribute::getAsStr().
2284 const std::string getAsStr() const override {
2285 return getAssumed() ? "nonnull" : "may-null";
2286 }
2287
2288 /// See AbstractAttribute::trackStatistics()
2289 void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull){ static llvm::Statistic NumIRFunctionReturn_nonnull = {"attributor"
, "NumIRFunctionReturn_nonnull", ("Number of " "function returns"
" marked '" "nonnull" "'")};; ++(NumIRFunctionReturn_nonnull
); }
}
2290};
2291
2292/// NonNull attribute for function argument.
2293struct AANonNullArgument final
2294 : AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl> {
2295 AANonNullArgument(const IRPosition &IRP, Attributor &A)
2296 : AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl>(IRP, A) {}
2297
2298 /// See AbstractAttribute::trackStatistics()
2299 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nonnull){ static llvm::Statistic NumIRArguments_nonnull = {"attributor"
, "NumIRArguments_nonnull", ("Number of " "arguments" " marked '"
"nonnull" "'")};; ++(NumIRArguments_nonnull); }
}
2300};
2301
2302struct AANonNullCallSiteArgument final : AANonNullFloating {
2303 AANonNullCallSiteArgument(const IRPosition &IRP, Attributor &A)
2304 : AANonNullFloating(IRP, A) {}
2305
2306 /// See AbstractAttribute::trackStatistics()
2307 void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(nonnull){ static llvm::Statistic NumIRCSArguments_nonnull = {"attributor"
, "NumIRCSArguments_nonnull", ("Number of " "call site arguments"
" marked '" "nonnull" "'")};; ++(NumIRCSArguments_nonnull); }
}
2308};
2309
2310/// NonNull attribute for a call site return position.
2311struct AANonNullCallSiteReturned final
2312 : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl> {
2313 AANonNullCallSiteReturned(const IRPosition &IRP, Attributor &A)
2314 : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl>(IRP, A) {}
2315
2316 /// See AbstractAttribute::trackStatistics()
2317 void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nonnull){ static llvm::Statistic NumIRCSReturn_nonnull = {"attributor"
, "NumIRCSReturn_nonnull", ("Number of " "call site returns" " marked '"
"nonnull" "'")};; ++(NumIRCSReturn_nonnull); }
}
2318};
2319
2320/// ------------------------ No-Recurse Attributes ----------------------------
2321
2322struct AANoRecurseImpl : public AANoRecurse {
2323 AANoRecurseImpl(const IRPosition &IRP, Attributor &A) : AANoRecurse(IRP, A) {}
2324
2325 /// See AbstractAttribute::getAsStr()
2326 const std::string getAsStr() const override {
2327 return getAssumed() ? "norecurse" : "may-recurse";
2328 }
2329};
2330
2331struct AANoRecurseFunction final : AANoRecurseImpl {
2332 AANoRecurseFunction(const IRPosition &IRP, Attributor &A)
2333 : AANoRecurseImpl(IRP, A) {}
2334
2335 /// See AbstractAttribute::initialize(...).
2336 void initialize(Attributor &A) override {
2337 AANoRecurseImpl::initialize(A);
2338 if (const Function *F = getAnchorScope())
2339 if (A.getInfoCache().getSccSize(*F) != 1)
2340 indicatePessimisticFixpoint();
2341 }
2342
2343 /// See AbstractAttribute::updateImpl(...).
2344 ChangeStatus updateImpl(Attributor &A) override {
2345
2346 // If all live call sites are known to be no-recurse, we are as well.
2347 auto CallSitePred = [&](AbstractCallSite ACS) {
2348 const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
2349 *this, IRPosition::function(*ACS.getInstruction()->getFunction()),
2350 DepClassTy::NONE);
2351 return NoRecurseAA.isKnownNoRecurse();
2352 };
2353 bool AllCallSitesKnown;
2354 if (A.checkForAllCallSites(CallSitePred, *this, true, AllCallSitesKnown)) {
2355 // If we know all call sites and all are known no-recurse, we are done.
2356 // If all known call sites, which might not be all that exist, are known
2357 // to be no-recurse, we are not done but we can continue to assume
2358 // no-recurse. If one of the call sites we have not visited will become
2359 // live, another update is triggered.
2360 if (AllCallSitesKnown)
2361 indicateOptimisticFixpoint();
2362 return ChangeStatus::UNCHANGED;
2363 }
2364
2365 // If the above check does not hold anymore we look at the calls.
2366 auto CheckForNoRecurse = [&](Instruction &I) {
2367 const auto &CB = cast<CallBase>(I);
2368 if (CB.hasFnAttr(Attribute::NoRecurse))
2369 return true;
2370
2371 const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
2372 *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);
2373 if (!NoRecurseAA.isAssumedNoRecurse())
2374 return false;
2375
2376 // Recursion to the same function
2377 if (CB.getCalledFunction() == getAnchorScope())
2378 return false;
2379
2380 return true;
2381 };
2382
2383 bool UsedAssumedInformation = false;
2384 if (!A.checkForAllCallLikeInstructions(CheckForNoRecurse, *this,
2385 UsedAssumedInformation))
2386 return indicatePessimisticFixpoint();
2387 return ChangeStatus::UNCHANGED;
2388 }
2389
2390 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse){ static llvm::Statistic NumIRFunction_norecurse = {"attributor"
, "NumIRFunction_norecurse", ("Number of " "functions" " marked '"
"norecurse" "'")};; ++(NumIRFunction_norecurse); }
}
2391};
2392
2393/// NoRecurse attribute deduction for a call sites.
2394struct AANoRecurseCallSite final : AANoRecurseImpl {
2395 AANoRecurseCallSite(const IRPosition &IRP, Attributor &A)
2396 : AANoRecurseImpl(IRP, A) {}
2397
2398 /// See AbstractAttribute::initialize(...).
2399 void initialize(Attributor &A) override {
2400 AANoRecurseImpl::initialize(A);
2401 Function *F = getAssociatedFunction();
2402 if (!F || F->isDeclaration())
2403 indicatePessimisticFixpoint();
2404 }
2405
2406 /// See AbstractAttribute::updateImpl(...).
2407 ChangeStatus updateImpl(Attributor &A) override {
2408 // TODO: Once we have call site specific value information we can provide
2409 // call site specific liveness information and then it makes
2410 // sense to specialize attributes for call sites arguments instead of
2411 // redirecting requests to the callee argument.
2412 Function *F = getAssociatedFunction();
2413 const IRPosition &FnPos = IRPosition::function(*F);
2414 auto &FnAA = A.getAAFor<AANoRecurse>(*this, FnPos, DepClassTy::REQUIRED);
2415 return clampStateAndIndicateChange(getState(), FnAA.getState());
2416 }
2417
2418 /// See AbstractAttribute::trackStatistics()
2419 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(norecurse){ static llvm::Statistic NumIRCS_norecurse = {"attributor", "NumIRCS_norecurse"
, ("Number of " "call site" " marked '" "norecurse" "'")};; ++
(NumIRCS_norecurse); }
; }
2420};
2421
2422/// -------------------- Undefined-Behavior Attributes ------------------------
2423
2424struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
2425 AAUndefinedBehaviorImpl(const IRPosition &IRP, Attributor &A)
2426 : AAUndefinedBehavior(IRP, A) {}
2427
2428 /// See AbstractAttribute::updateImpl(...).
2429 // through a pointer (i.e. also branches etc.)
2430 ChangeStatus updateImpl(Attributor &A) override {
2431 const size_t UBPrevSize = KnownUBInsts.size();
2432 const size_t NoUBPrevSize = AssumedNoUBInsts.size();
2433
2434 auto InspectMemAccessInstForUB = [&](Instruction &I) {
2435 // Skip instructions that are already saved.
2436 if (AssumedNoUBInsts.count(&I) || KnownUBInsts.count(&I))
2437 return true;
2438
2439 // If we reach here, we know we have an instruction
2440 // that accesses memory through a pointer operand,
2441 // for which getPointerOperand() should give it to us.
2442 Value *PtrOp =
2443 const_cast<Value *>(getPointerOperand(&I, /* AllowVolatile */ true));
2444 assert(PtrOp &&((void)0)
2445 "Expected pointer operand of memory accessing instruction")((void)0);
2446
2447 // Either we stopped and the appropriate action was taken,
2448 // or we got back a simplified value to continue.
2449 Optional<Value *> SimplifiedPtrOp = stopOnUndefOrAssumed(A, PtrOp, &I);
2450 if (!SimplifiedPtrOp.hasValue() || !SimplifiedPtrOp.getValue())
2451 return true;
2452 const Value *PtrOpVal = SimplifiedPtrOp.getValue();
2453
2454 // A memory access through a pointer is considered UB
2455 // only if the pointer has constant null value.
2456 // TODO: Expand it to not only check constant values.
2457 if (!isa<ConstantPointerNull>(PtrOpVal)) {
2458 AssumedNoUBInsts.insert(&I);
2459 return true;
2460 }
2461 const Type *PtrTy = PtrOpVal->getType();
2462
2463 // Because we only consider instructions inside functions,
2464 // assume that a parent function exists.
2465 const Function *F = I.getFunction();
2466
2467 // A memory access using constant null pointer is only considered UB
2468 // if null pointer is _not_ defined for the target platform.
2469 if (llvm::NullPointerIsDefined(F, PtrTy->getPointerAddressSpace()))
2470 AssumedNoUBInsts.insert(&I);
2471 else
2472 KnownUBInsts.insert(&I);
2473 return true;
2474 };
2475
2476 auto InspectBrInstForUB = [&](Instruction &I) {
2477 // A conditional branch instruction is considered UB if it has `undef`
2478 // condition.
2479
2480 // Skip instructions that are already saved.
2481 if (AssumedNoUBInsts.count(&I) || KnownUBInsts.count(&I))
2482 return true;
2483
2484 // We know we have a branch instruction.
2485 auto *BrInst = cast<BranchInst>(&I);
2486
2487 // Unconditional branches are never considered UB.
2488 if (BrInst->isUnconditional())
2489 return true;
2490
2491 // Either we stopped and the appropriate action was taken,
2492 // or we got back a simplified value to continue.
2493 Optional<Value *> SimplifiedCond =
2494 stopOnUndefOrAssumed(A, BrInst->getCondition(), BrInst);
2495 if (!SimplifiedCond.hasValue() || !SimplifiedCond.getValue())
2496 return true;
2497 AssumedNoUBInsts.insert(&I);
2498 return true;
2499 };
2500
2501 auto InspectCallSiteForUB = [&](Instruction &I) {
2502 // Check whether a callsite always cause UB or not
2503
2504 // Skip instructions that are already saved.
2505 if (AssumedNoUBInsts.count(&I) || KnownUBInsts.count(&I))
2506 return true;
2507
2508 // Check nonnull and noundef argument attribute violation for each
2509 // callsite.
2510 CallBase &CB = cast<CallBase>(I);
2511 Function *Callee = CB.getCalledFunction();
2512 if (!Callee)
2513 return true;
2514 for (unsigned idx = 0; idx < CB.getNumArgOperands(); idx++) {
2515 // If current argument is known to be simplified to null pointer and the
2516 // corresponding argument position is known to have nonnull attribute,
2517 // the argument is poison. Furthermore, if the argument is poison and
2518 // the position is known to have noundef attriubte, this callsite is
2519 // considered UB.
2520 if (idx >= Callee->arg_size())
2521 break;
2522 Value *ArgVal = CB.getArgOperand(idx);
2523 if (!ArgVal)
2524 continue;
2525 // Here, we handle three cases.
2526 // (1) Not having a value means it is dead. (we can replace the value
2527 // with undef)
2528 // (2) Simplified to undef. The argument violate noundef attriubte.
2529 // (3) Simplified to null pointer where known to be nonnull.
2530 // The argument is a poison value and violate noundef attribute.
2531 IRPosition CalleeArgumentIRP = IRPosition::callsite_argument(CB, idx);
2532 auto &NoUndefAA =
2533 A.getAAFor<AANoUndef>(*this, CalleeArgumentIRP, DepClassTy::NONE);
2534 if (!NoUndefAA.isKnownNoUndef())
2535 continue;
2536 bool UsedAssumedInformation = false;
2537 Optional<Value *> SimplifiedVal = A.getAssumedSimplified(
2538 IRPosition::value(*ArgVal), *this, UsedAssumedInformation);
2539 if (UsedAssumedInformation)
2540 continue;
2541 if (SimplifiedVal.hasValue() && !SimplifiedVal.getValue())
2542 return true;
2543 if (!SimplifiedVal.hasValue() ||
2544 isa<UndefValue>(*SimplifiedVal.getValue())) {
2545 KnownUBInsts.insert(&I);
2546 continue;
2547 }
2548 if (!ArgVal->getType()->isPointerTy() ||
2549 !isa<ConstantPointerNull>(*SimplifiedVal.getValue()))
2550 continue;
2551 auto &NonNullAA =
2552 A.getAAFor<AANonNull>(*this, CalleeArgumentIRP, DepClassTy::NONE);
2553 if (NonNullAA.isKnownNonNull())
2554 KnownUBInsts.insert(&I);
2555 }
2556 return true;
2557 };
2558
2559 auto InspectReturnInstForUB =
2560 [&](Value &V, const SmallSetVector<ReturnInst *, 4> RetInsts) {
2561 // Check if a return instruction always cause UB or not
2562 // Note: It is guaranteed that the returned position of the anchor
2563 // scope has noundef attribute when this is called.
2564 // We also ensure the return position is not "assumed dead"
2565 // because the returned value was then potentially simplified to
2566 // `undef` in AAReturnedValues without removing the `noundef`
2567 // attribute yet.
2568
2569 // When the returned position has noundef attriubte, UB occur in the
2570 // following cases.
2571 // (1) Returned value is known to be undef.
2572 // (2) The value is known to be a null pointer and the returned
2573 // position has nonnull attribute (because the returned value is
2574 // poison).
2575 bool FoundUB = false;
2576 if (isa<UndefValue>(V)) {
2577 FoundUB = true;
2578 } else {
2579 if (isa<ConstantPointerNull>(V)) {
2580 auto &NonNullAA = A.getAAFor<AANonNull>(
2581 *this, IRPosition::returned(*getAnchorScope()),
2582 DepClassTy::NONE);
2583 if (NonNullAA.isKnownNonNull())
2584 FoundUB = true;
2585 }
2586 }
2587
2588 if (FoundUB)
2589 for (ReturnInst *RI : RetInsts)
2590 KnownUBInsts.insert(RI);
2591 return true;
2592 };
2593
2594 bool UsedAssumedInformation = false;
2595 A.checkForAllInstructions(InspectMemAccessInstForUB, *this,
2596 {Instruction::Load, Instruction::Store,
2597 Instruction::AtomicCmpXchg,
2598 Instruction::AtomicRMW},
2599 UsedAssumedInformation,
2600 /* CheckBBLivenessOnly */ true);
2601 A.checkForAllInstructions(InspectBrInstForUB, *this, {Instruction::Br},
2602 UsedAssumedInformation,
2603 /* CheckBBLivenessOnly */ true);
2604 A.checkForAllCallLikeInstructions(InspectCallSiteForUB, *this,
2605 UsedAssumedInformation);
2606
2607 // If the returned position of the anchor scope has noundef attriubte, check
2608 // all returned instructions.
2609 if (!getAnchorScope()->getReturnType()->isVoidTy()) {
2610 const IRPosition &ReturnIRP = IRPosition::returned(*getAnchorScope());
2611 if (!A.isAssumedDead(ReturnIRP, this, nullptr, UsedAssumedInformation)) {
2612 auto &RetPosNoUndefAA =
2613 A.getAAFor<AANoUndef>(*this, ReturnIRP, DepClassTy::NONE);
2614 if (RetPosNoUndefAA.isKnownNoUndef())
2615 A.checkForAllReturnedValuesAndReturnInsts(InspectReturnInstForUB,
2616 *this);
2617 }
2618 }
2619
2620 if (NoUBPrevSize != AssumedNoUBInsts.size() ||
2621 UBPrevSize != KnownUBInsts.size())
2622 return ChangeStatus::CHANGED;
2623 return ChangeStatus::UNCHANGED;
2624 }
2625
2626 bool isKnownToCauseUB(Instruction *I) const override {
2627 return KnownUBInsts.count(I);
2628 }
2629
2630 bool isAssumedToCauseUB(Instruction *I) const override {
2631 // In simple words, if an instruction is not in the assumed to _not_
2632 // cause UB, then it is assumed UB (that includes those
2633 // in the KnownUBInsts set). The rest is boilerplate
2634 // is to ensure that it is one of the instructions we test
2635 // for UB.
2636
2637 switch (I->getOpcode()) {
2638 case Instruction::Load:
2639 case Instruction::Store:
2640 case Instruction::AtomicCmpXchg:
2641 case Instruction::AtomicRMW:
2642 return !AssumedNoUBInsts.count(I);
2643 case Instruction::Br: {
2644 auto BrInst = cast<BranchInst>(I);
2645 if (BrInst->isUnconditional())
2646 return false;
2647 return !AssumedNoUBInsts.count(I);
2648 } break;
2649 default:
2650 return false;
2651 }
2652 return false;
2653 }
2654
2655 ChangeStatus manifest(Attributor &A) override {
2656 if (KnownUBInsts.empty())
2657 return ChangeStatus::UNCHANGED;
2658 for (Instruction *I : KnownUBInsts)
2659 A.changeToUnreachableAfterManifest(I);
2660 return ChangeStatus::CHANGED;
2661 }
2662
2663 /// See AbstractAttribute::getAsStr()
2664 const std::string getAsStr() const override {
2665 return getAssumed() ? "undefined-behavior" : "no-ub";
2666 }
2667
2668 /// Note: The correctness of this analysis depends on the fact that the
2669 /// following 2 sets will stop changing after some point.
2670 /// "Change" here means that their size changes.
2671 /// The size of each set is monotonically increasing
2672 /// (we only add items to them) and it is upper bounded by the number of
2673 /// instructions in the processed function (we can never save more
2674 /// elements in either set than this number). Hence, at some point,
2675 /// they will stop increasing.
2676 /// Consequently, at some point, both sets will have stopped
2677 /// changing, effectively making the analysis reach a fixpoint.
2678
2679 /// Note: These 2 sets are disjoint and an instruction can be considered
2680 /// one of 3 things:
2681 /// 1) Known to cause UB (AAUndefinedBehavior could prove it) and put it in
2682 /// the KnownUBInsts set.
2683 /// 2) Assumed to cause UB (in every updateImpl, AAUndefinedBehavior
2684 /// has a reason to assume it).
2685 /// 3) Assumed to not cause UB. very other instruction - AAUndefinedBehavior
2686 /// could not find a reason to assume or prove that it can cause UB,
2687 /// hence it assumes it doesn't. We have a set for these instructions
2688 /// so that we don't reprocess them in every update.
2689 /// Note however that instructions in this set may cause UB.
2690
2691protected:
2692 /// A set of all live instructions _known_ to cause UB.
2693 SmallPtrSet<Instruction *, 8> KnownUBInsts;
2694
2695private:
2696 /// A set of all the (live) instructions that are assumed to _not_ cause UB.
2697 SmallPtrSet<Instruction *, 8> AssumedNoUBInsts;
2698
2699 // Should be called on updates in which if we're processing an instruction
2700 // \p I that depends on a value \p V, one of the following has to happen:
2701 // - If the value is assumed, then stop.
2702 // - If the value is known but undef, then consider it UB.
2703 // - Otherwise, do specific processing with the simplified value.
2704 // We return None in the first 2 cases to signify that an appropriate
2705 // action was taken and the caller should stop.
2706 // Otherwise, we return the simplified value that the caller should
2707 // use for specific processing.
2708 Optional<Value *> stopOnUndefOrAssumed(Attributor &A, Value *V,
2709 Instruction *I) {
2710 bool UsedAssumedInformation = false;
2711 Optional<Value *> SimplifiedV = A.getAssumedSimplified(
2712 IRPosition::value(*V), *this, UsedAssumedInformation);
2713 if (!UsedAssumedInformation) {
2714 // Don't depend on assumed values.
2715 if (!SimplifiedV.hasValue()) {
2716 // If it is known (which we tested above) but it doesn't have a value,
2717 // then we can assume `undef` and hence the instruction is UB.
2718 KnownUBInsts.insert(I);
2719 return llvm::None;
2720 }
2721 if (!SimplifiedV.getValue())
2722 return nullptr;
2723 V = *SimplifiedV;
2724 }
2725 if (isa<UndefValue>(V)) {
2726 KnownUBInsts.insert(I);
2727 return llvm::None;
2728 }
2729 return V;
2730 }
2731};
2732
2733struct AAUndefinedBehaviorFunction final : AAUndefinedBehaviorImpl {
2734 AAUndefinedBehaviorFunction(const IRPosition &IRP, Attributor &A)
2735 : AAUndefinedBehaviorImpl(IRP, A) {}
2736
2737 /// See AbstractAttribute::trackStatistics()
2738 void trackStatistics() const override {
2739 STATS_DECL(UndefinedBehaviorInstruction, Instruction,static llvm::Statistic NumIRInstruction_UndefinedBehaviorInstruction
= {"attributor", "NumIRInstruction_UndefinedBehaviorInstruction"
, "Number of instructions known to have UB"};;
2740 "Number of instructions known to have UB")static llvm::Statistic NumIRInstruction_UndefinedBehaviorInstruction
= {"attributor", "NumIRInstruction_UndefinedBehaviorInstruction"
, "Number of instructions known to have UB"};;
;
2741 BUILD_STAT_NAME(UndefinedBehaviorInstruction, Instruction)NumIRInstruction_UndefinedBehaviorInstruction +=
2742 KnownUBInsts.size();
2743 }
2744};
2745
2746/// ------------------------ Will-Return Attributes ----------------------------
2747
2748// Helper function that checks whether a function has any cycle which we don't
2749// know if it is bounded or not.
2750// Loops with maximum trip count are considered bounded, any other cycle not.
2751static bool mayContainUnboundedCycle(Function &F, Attributor &A) {
2752 ScalarEvolution *SE =
2753 A.getInfoCache().getAnalysisResultForFunction<ScalarEvolutionAnalysis>(F);
2754 LoopInfo *LI = A.getInfoCache().getAnalysisResultForFunction<LoopAnalysis>(F);
2755 // If either SCEV or LoopInfo is not available for the function then we assume
2756 // any cycle to be unbounded cycle.
2757 // We use scc_iterator which uses Tarjan algorithm to find all the maximal
2758 // SCCs.To detect if there's a cycle, we only need to find the maximal ones.
2759 if (!SE || !LI) {
2760 for (scc_iterator<Function *> SCCI = scc_begin(&F); !SCCI.isAtEnd(); ++SCCI)
2761 if (SCCI.hasCycle())
2762 return true;
2763 return false;
2764 }
2765
2766 // If there's irreducible control, the function may contain non-loop cycles.
2767 if (mayContainIrreducibleControl(F, LI))
2768 return true;
2769
2770 // Any loop that does not have a max trip count is considered unbounded cycle.
2771 for (auto *L : LI->getLoopsInPreorder()) {
2772 if (!SE->getSmallConstantMaxTripCount(L))
2773 return true;
2774 }
2775 return false;
2776}
2777
2778struct AAWillReturnImpl : public AAWillReturn {
2779 AAWillReturnImpl(const IRPosition &IRP, Attributor &A)
2780 : AAWillReturn(IRP, A) {}
2781
2782 /// See AbstractAttribute::initialize(...).
2783 void initialize(Attributor &A) override {
2784 AAWillReturn::initialize(A);
2785
2786 if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ true)) {
2787 indicateOptimisticFixpoint();
2788 return;
2789 }
2790 }
2791
2792 /// Check for `mustprogress` and `readonly` as they imply `willreturn`.
2793 bool isImpliedByMustprogressAndReadonly(Attributor &A, bool KnownOnly) {
2794 // Check for `mustprogress` in the scope and the associated function which
2795 // might be different if this is a call site.
2796 if ((!getAnchorScope() || !getAnchorScope()->mustProgress()) &&
2797 (!getAssociatedFunction() || !getAssociatedFunction()->mustProgress()))
2798 return false;
2799
2800 const auto &MemAA =
2801 A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(), DepClassTy::NONE);
2802 if (!MemAA.isAssumedReadOnly())
2803 return false;
2804 if (KnownOnly && !MemAA.isKnownReadOnly())
2805 return false;
2806 if (!MemAA.isKnownReadOnly())
2807 A.recordDependence(MemAA, *this, DepClassTy::OPTIONAL);
2808
2809 return true;
2810 }
2811
2812 /// See AbstractAttribute::updateImpl(...).
2813 ChangeStatus updateImpl(Attributor &A) override {
2814 if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
2815 return ChangeStatus::UNCHANGED;
2816
2817 auto CheckForWillReturn = [&](Instruction &I) {
2818 IRPosition IPos = IRPosition::callsite_function(cast<CallBase>(I));
2819 const auto &WillReturnAA =
2820 A.getAAFor<AAWillReturn>(*this, IPos, DepClassTy::REQUIRED);
2821 if (WillReturnAA.isKnownWillReturn())
2822 return true;
2823 if (!WillReturnAA.isAssumedWillReturn())
2824 return false;
2825 const auto &NoRecurseAA =
2826 A.getAAFor<AANoRecurse>(*this, IPos, DepClassTy::REQUIRED);
2827 return NoRecurseAA.isAssumedNoRecurse();
2828 };
2829
2830 bool UsedAssumedInformation = false;
2831 if (!A.checkForAllCallLikeInstructions(CheckForWillReturn, *this,
2832 UsedAssumedInformation))
2833 return indicatePessimisticFixpoint();
2834
2835 return ChangeStatus::UNCHANGED;
2836 }
2837
2838 /// See AbstractAttribute::getAsStr()
2839 const std::string getAsStr() const override {
2840 return getAssumed() ? "willreturn" : "may-noreturn";
2841 }
2842};
2843
2844struct AAWillReturnFunction final : AAWillReturnImpl {
2845 AAWillReturnFunction(const IRPosition &IRP, Attributor &A)
2846 : AAWillReturnImpl(IRP, A) {}
2847
2848 /// See AbstractAttribute::initialize(...).
2849 void initialize(Attributor &A) override {
2850 AAWillReturnImpl::initialize(A);
2851
2852 Function *F = getAnchorScope();
2853 if (!F || F->isDeclaration() || mayContainUnboundedCycle(*F, A))
2854 indicatePessimisticFixpoint();
2855 }
2856
2857 /// See AbstractAttribute::trackStatistics()
2858 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(willreturn){ static llvm::Statistic NumIRFunction_willreturn = {"attributor"
, "NumIRFunction_willreturn", ("Number of " "functions" " marked '"
"willreturn" "'")};; ++(NumIRFunction_willreturn); }
}
2859};
2860
2861/// WillReturn attribute deduction for a call sites.
2862struct AAWillReturnCallSite final : AAWillReturnImpl {
2863 AAWillReturnCallSite(const IRPosition &IRP, Attributor &A)
2864 : AAWillReturnImpl(IRP, A) {}
2865
2866 /// See AbstractAttribute::initialize(...).
2867 void initialize(Attributor &A) override {
2868 AAWillReturnImpl::initialize(A);
2869 Function *F = getAssociatedFunction();
2870 if (!F || !A.isFunctionIPOAmendable(*F))
2871 indicatePessimisticFixpoint();
2872 }
2873
2874 /// See AbstractAttribute::updateImpl(...).
2875 ChangeStatus updateImpl(Attributor &A) override {
2876 if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
2877 return ChangeStatus::UNCHANGED;
2878
2879 // TODO: Once we have call site specific value information we can provide
2880 // call site specific liveness information and then it makes
2881 // sense to specialize attributes for call sites arguments instead of
2882 // redirecting requests to the callee argument.
2883 Function *F = getAssociatedFunction();
2884 const IRPosition &FnPos = IRPosition::function(*F);
2885 auto &FnAA = A.getAAFor<AAWillReturn>(*this, FnPos, DepClassTy::REQUIRED);
2886 return clampStateAndIndicateChange(getState(), FnAA.getState());
2887 }
2888
2889 /// See AbstractAttribute::trackStatistics()
2890 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(willreturn){ static llvm::Statistic NumIRCS_willreturn = {"attributor", "NumIRCS_willreturn"
, ("Number of " "call site" " marked '" "willreturn" "'")};; ++
(NumIRCS_willreturn); }
; }
2891};
2892
2893/// -------------------AAReachability Attribute--------------------------
2894
2895struct AAReachabilityImpl : AAReachability {
2896 AAReachabilityImpl(const IRPosition &IRP, Attributor &A)
2897 : AAReachability(IRP, A) {}
2898
2899 const std::string getAsStr() const override {
2900 // TODO: Return the number of reachable queries.
2901 return "reachable";
2902 }
2903
2904 /// See AbstractAttribute::updateImpl(...).
2905 ChangeStatus updateImpl(Attributor &A) override {
2906 return ChangeStatus::UNCHANGED;
2907 }
2908};
2909
2910struct AAReachabilityFunction final : public AAReachabilityImpl {
2911 AAReachabilityFunction(const IRPosition &IRP, Attributor &A)
2912 : AAReachabilityImpl(IRP, A) {}
2913
2914 /// See AbstractAttribute::trackStatistics()
2915 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(reachable){ static llvm::Statistic NumIRFunction_reachable = {"attributor"
, "NumIRFunction_reachable", ("Number of " "functions" " marked '"
"reachable" "'")};; ++(NumIRFunction_reachable); }
; }
2916};
2917
2918/// ------------------------ NoAlias Argument Attribute ------------------------
2919
2920struct AANoAliasImpl : AANoAlias {
2921 AANoAliasImpl(const IRPosition &IRP, Attributor &A) : AANoAlias(IRP, A) {
2922 assert(getAssociatedType()->isPointerTy() &&((void)0)
2923 "Noalias is a pointer attribute")((void)0);
2924 }
2925
2926 const std::string getAsStr() const override {
2927 return getAssumed() ? "noalias" : "may-alias";
2928 }
2929};
2930
2931/// NoAlias attribute for a floating value.
2932struct AANoAliasFloating final : AANoAliasImpl {
2933 AANoAliasFloating(const IRPosition &IRP, Attributor &A)
2934 : AANoAliasImpl(IRP, A) {}
2935
2936 /// See AbstractAttribute::initialize(...).
2937 void initialize(Attributor &A) override {
2938 AANoAliasImpl::initialize(A);
2939 Value *Val = &getAssociatedValue();
2940 do {
2941 CastInst *CI = dyn_cast<CastInst>(Val);
2942 if (!CI)
2943 break;
2944 Value *Base = CI->getOperand(0);
2945 if (!Base->hasOneUse())
2946 break;
2947 Val = Base;
2948 } while (true);
2949
2950 if (!Val->getType()->isPointerTy()) {
2951 indicatePessimisticFixpoint();
2952 return;
2953 }
2954
2955 if (isa<AllocaInst>(Val))
2956 indicateOptimisticFixpoint();
2957 else if (isa<ConstantPointerNull>(Val) &&
2958 !NullPointerIsDefined(getAnchorScope(),
2959 Val->getType()->getPointerAddressSpace()))
2960 indicateOptimisticFixpoint();
2961 else if (Val != &getAssociatedValue()) {
2962 const auto &ValNoAliasAA = A.getAAFor<AANoAlias>(
2963 *this, IRPosition::value(*Val), DepClassTy::OPTIONAL);
2964 if (ValNoAliasAA.isKnownNoAlias())
2965 indicateOptimisticFixpoint();
2966 }
2967 }
2968
2969 /// See AbstractAttribute::updateImpl(...).
2970 ChangeStatus updateImpl(Attributor &A) override {
2971 // TODO: Implement this.
2972 return indicatePessimisticFixpoint();
2973 }
2974
2975 /// See AbstractAttribute::trackStatistics()
2976 void trackStatistics() const override {
2977 STATS_DECLTRACK_FLOATING_ATTR(noalias){ static llvm::Statistic NumIRFloating_noalias = {"attributor"
, "NumIRFloating_noalias", ("Number of floating values known to be '"
"noalias" "'")};; ++(NumIRFloating_noalias); }
2978 }
2979};
2980
2981/// NoAlias attribute for an argument.
2982struct AANoAliasArgument final
2983 : AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl> {
2984 using Base = AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl>;
2985 AANoAliasArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}
2986
2987 /// See AbstractAttribute::initialize(...).
2988 void initialize(Attributor &A) override {
2989 Base::initialize(A);
2990 // See callsite argument attribute and callee argument attribute.
2991 if (hasAttr({Attribute::ByVal}))
2992 indicateOptimisticFixpoint();
2993 }
2994
2995 /// See AbstractAttribute::update(...).
2996 ChangeStatus updateImpl(Attributor &A) override {
2997 // We have to make sure no-alias on the argument does not break
2998 // synchronization when this is a callback argument, see also [1] below.
2999 // If synchronization cannot be affected, we delegate to the base updateImpl
3000 // function, otherwise we give up for now.
3001
3002 // If the function is no-sync, no-alias cannot break synchronization.
3003 const auto &NoSyncAA =
3004 A.getAAFor<AANoSync>(*this, IRPosition::function_scope(getIRPosition()),
3005 DepClassTy::OPTIONAL);
3006 if (NoSyncAA.isAssumedNoSync())
3007 return Base::updateImpl(A);
3008
3009 // If the argument is read-only, no-alias cannot break synchronization.
3010 const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
3011 *this, getIRPosition(), DepClassTy::OPTIONAL);
3012 if (MemBehaviorAA.isAssumedReadOnly())
3013 return Base::updateImpl(A);
3014
3015 // If the argument is never passed through callbacks, no-alias cannot break
3016 // synchronization.
3017 bool AllCallSitesKnown;
3018 if (A.checkForAllCallSites(
3019 [](AbstractCallSite ACS) { return !ACS.isCallbackCall(); }, *this,
3020 true, AllCallSitesKnown))
3021 return Base::updateImpl(A);
3022
3023 // TODO: add no-alias but make sure it doesn't break synchronization by
3024 // introducing fake uses. See:
3025 // [1] Compiler Optimizations for OpenMP, J. Doerfert and H. Finkel,
3026 // International Workshop on OpenMP 2018,
3027 // http://compilers.cs.uni-saarland.de/people/doerfert/par_opt18.pdf
3028
3029 return indicatePessimisticFixpoint();
3030 }
3031
3032 /// See AbstractAttribute::trackStatistics()
3033 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noalias){ static llvm::Statistic NumIRArguments_noalias = {"attributor"
, "NumIRArguments_noalias", ("Number of " "arguments" " marked '"
"noalias" "'")};; ++(NumIRArguments_noalias); }
}
3034};
3035
3036struct AANoAliasCallSiteArgument final : AANoAliasImpl {
3037 AANoAliasCallSiteArgument(const IRPosition &IRP, Attributor &A)
3038 : AANoAliasImpl(IRP, A) {}
3039
3040 /// See AbstractAttribute::initialize(...).
3041 void initialize(Attributor &A) override {
3042 // See callsite argument attribute and callee argument attribute.
3043 const auto &CB = cast<CallBase>(getAnchorValue());
3044 if (CB.paramHasAttr(getCallSiteArgNo(), Attribute::NoAlias))
3045 indicateOptimisticFixpoint();
3046 Value &Val = getAssociatedValue();
3047 if (isa<ConstantPointerNull>(Val) &&
3048 !NullPointerIsDefined(getAnchorScope(),
3049 Val.getType()->getPointerAddressSpace()))
3050 indicateOptimisticFixpoint();
3051 }
3052
3053 /// Determine if the underlying value may alias with the call site argument
3054 /// \p OtherArgNo of \p ICS (= the underlying call site).
3055 bool mayAliasWithArgument(Attributor &A, AAResults *&AAR,
3056 const AAMemoryBehavior &MemBehaviorAA,
3057 const CallBase &CB, unsigned OtherArgNo) {
3058 // We do not need to worry about aliasing with the underlying IRP.
3059 if (this->getCalleeArgNo() == (int)OtherArgNo)
3060 return false;
3061
3062 // If it is not a pointer or pointer vector we do not alias.
3063 const Value *ArgOp = CB.getArgOperand(OtherArgNo);
3064 if (!ArgOp->getType()->isPtrOrPtrVectorTy())
3065 return false;
3066
3067 auto &CBArgMemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
3068 *this, IRPosition::callsite_argument(CB, OtherArgNo), DepClassTy::NONE);
3069
3070 // If the argument is readnone, there is no read-write aliasing.
3071 if (CBArgMemBehaviorAA.isAssumedReadNone()) {
3072 A.recordDependence(CBArgMemBehaviorAA, *this, DepClassTy::OPTIONAL);
3073 return false;
3074 }
3075
3076 // If the argument is readonly and the underlying value is readonly, there
3077 // is no read-write aliasing.
3078 bool IsReadOnly = MemBehaviorAA.isAssumedReadOnly();
3079 if (CBArgMemBehaviorAA.isAssumedReadOnly() && IsReadOnly) {
3080 A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
3081 A.recordDependence(CBArgMemBehaviorAA, *this, DepClassTy::OPTIONAL);
3082 return false;
3083 }
3084
3085 // We have to utilize actual alias analysis queries so we need the object.
3086 if (!AAR)
3087 AAR = A.getInfoCache().getAAResultsForFunction(*getAnchorScope());
3088
3089 // Try to rule it out at the call site.
3090 bool IsAliasing = !AAR || !AAR->isNoAlias(&getAssociatedValue(), ArgOp);
3091 LLVM_DEBUG(dbgs() << "[NoAliasCSArg] Check alias between "do { } while (false)
3092 "callsite arguments: "do { } while (false)
3093 << getAssociatedValue() << " " << *ArgOp << " => "do { } while (false)
3094 << (IsAliasing ? "" : "no-") << "alias \n")do { } while (false);
3095
3096 return IsAliasing;
3097 }
3098
3099 bool
3100 isKnownNoAliasDueToNoAliasPreservation(Attributor &A, AAResults *&AAR,
3101 const AAMemoryBehavior &MemBehaviorAA,
3102 const AANoAlias &NoAliasAA) {
3103 // We can deduce "noalias" if the following conditions hold.
3104 // (i) Associated value is assumed to be noalias in the definition.
3105 // (ii) Associated value is assumed to be no-capture in all the uses
3106 // possibly executed before this callsite.
3107 // (iii) There is no other pointer argument which could alias with the
3108 // value.
3109
3110 bool AssociatedValueIsNoAliasAtDef = NoAliasAA.isAssumedNoAlias();
3111 if (!AssociatedValueIsNoAliasAtDef) {
3112 LLVM_DEBUG(dbgs() << "[AANoAlias] " << getAssociatedValue()do { } while (false)
3113 << " is not no-alias at the definition\n")do { } while (false);
3114 return false;
3115 }
3116
3117 A.recordDependence(NoAliasAA, *this, DepClassTy::OPTIONAL);
3118
3119 const IRPosition &VIRP = IRPosition::value(getAssociatedValue());
3120 const Function *ScopeFn = VIRP.getAnchorScope();
3121 auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, VIRP, DepClassTy::NONE);
3122 // Check whether the value is captured in the scope using AANoCapture.
3123 // Look at CFG and check only uses possibly executed before this
3124 // callsite.
3125 auto UsePred = [&](const Use &U, bool &Follow) -> bool {
3126 Instruction *UserI = cast<Instruction>(U.getUser());
3127
3128 // If UserI is the curr instruction and there is a single potential use of
3129 // the value in UserI we allow the use.
3130 // TODO: We should inspect the operands and allow those that cannot alias
3131 // with the value.
3132 if (UserI == getCtxI() && UserI->getNumOperands() == 1)
3133 return true;
3134
3135 if (ScopeFn) {
3136 const auto &ReachabilityAA = A.getAAFor<AAReachability>(
3137 *this, IRPosition::function(*ScopeFn), DepClassTy::OPTIONAL);
3138
3139 if (!ReachabilityAA.isAssumedReachable(A, *UserI, *getCtxI()))
3140 return true;
3141
3142 if (auto *CB = dyn_cast<CallBase>(UserI)) {
3143 if (CB->isArgOperand(&U)) {
3144
3145 unsigned ArgNo = CB->getArgOperandNo(&U);
3146
3147 const auto &NoCaptureAA = A.getAAFor<AANoCapture>(
3148 *this, IRPosition::callsite_argument(*CB, ArgNo),
3149 DepClassTy::OPTIONAL);
3150
3151 if (NoCaptureAA.isAssumedNoCapture())
3152 return true;
3153 }
3154 }
3155 }
3156
3157 // For cases which can potentially have more users
3158 if (isa<GetElementPtrInst>(U) || isa<BitCastInst>(U) || isa<PHINode>(U) ||
3159 isa<SelectInst>(U)) {
3160 Follow = true;
3161 return true;
3162 }
3163
3164 LLVM_DEBUG(dbgs() << "[AANoAliasCSArg] Unknown user: " << *U << "\n")do { } while (false);
3165 return false;
3166 };
3167
3168 if (!NoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
3169 if (!A.checkForAllUses(UsePred, *this, getAssociatedValue())) {
3170 LLVM_DEBUG(do { } while (false)
3171 dbgs() << "[AANoAliasCSArg] " << getAssociatedValue()do { } while (false)
3172 << " cannot be noalias as it is potentially captured\n")do { } while (false);
3173 return false;
3174 }
3175 }
3176 A.recordDependence(NoCaptureAA, *this, DepClassTy::OPTIONAL);
3177
3178 // Check there is no other pointer argument which could alias with the
3179 // value passed at this call site.
3180 // TODO: AbstractCallSite
3181 const auto &CB = cast<CallBase>(getAnchorValue());
3182 for (unsigned OtherArgNo = 0; OtherArgNo < CB.getNumArgOperands();
3183 OtherArgNo++)
3184 if (mayAliasWithArgument(A, AAR, MemBehaviorAA, CB, OtherArgNo))
3185 return false;
3186
3187 return true;
3188 }
3189
3190 /// See AbstractAttribute::updateImpl(...).
3191 ChangeStatus updateImpl(Attributor &A) override {
3192 // If the argument is readnone we are done as there are no accesses via the
3193 // argument.
3194 auto &MemBehaviorAA =
3195 A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(), DepClassTy::NONE);
3196 if (MemBehaviorAA.isAssumedReadNone()) {
3197 A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
3198 return ChangeStatus::UNCHANGED;
3199 }
3200
3201 const IRPosition &VIRP = IRPosition::value(getAssociatedValue());
3202 const auto &NoAliasAA =
3203 A.getAAFor<AANoAlias>(*this, VIRP, DepClassTy::NONE);
3204
3205 AAResults *AAR = nullptr;
3206 if (isKnownNoAliasDueToNoAliasPreservation(A, AAR, MemBehaviorAA,
3207 NoAliasAA)) {
3208 LLVM_DEBUG(do { } while (false)
3209 dbgs() << "[AANoAlias] No-Alias deduced via no-alias preservation\n")do { } while (false);
3210 return ChangeStatus::UNCHANGED;
3211 }
3212
3213 return indicatePessimisticFixpoint();
3214 }
3215
3216 /// See AbstractAttribute::trackStatistics()
3217 void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(noalias){ static llvm::Statistic NumIRCSArguments_noalias = {"attributor"
, "NumIRCSArguments_noalias", ("Number of " "call site arguments"
" marked '" "noalias" "'")};; ++(NumIRCSArguments_noalias); }
}
3218};
3219
3220/// NoAlias attribute for function return value.
3221struct AANoAliasReturned final : AANoAliasImpl {
3222 AANoAliasReturned(const IRPosition &IRP, Attributor &A)
3223 : AANoAliasImpl(IRP, A) {}
3224
3225 /// See AbstractAttribute::initialize(...).
3226 void initialize(Attributor &A) override {
3227 AANoAliasImpl::initialize(A);
3228 Function *F = getAssociatedFunction();
3229 if (!F || F->isDeclaration())
3230 indicatePessimisticFixpoint();
3231 }
3232
3233 /// See AbstractAttribute::updateImpl(...).
3234 virtual ChangeStatus updateImpl(Attributor &A) override {
3235
3236 auto CheckReturnValue = [&](Value &RV) -> bool {
3237 if (Constant *C = dyn_cast<Constant>(&RV))
3238 if (C->isNullValue() || isa<UndefValue>(C))
3239 return true;
3240
3241 /// For now, we can only deduce noalias if we have call sites.
3242 /// FIXME: add more support.
3243 if (!isa<CallBase>(&RV))
3244 return false;
3245
3246 const IRPosition &RVPos = IRPosition::value(RV);
3247 const auto &NoAliasAA =
3248 A.getAAFor<AANoAlias>(*this, RVPos, DepClassTy::REQUIRED);
3249 if (!NoAliasAA.isAssumedNoAlias())
3250 return false;
3251
3252 const auto &NoCaptureAA =
3253 A.getAAFor<AANoCapture>(*this, RVPos, DepClassTy::REQUIRED);
3254 return NoCaptureAA.isAssumedNoCaptureMaybeReturned();
3255 };
3256
3257 if (!A.checkForAllReturnedValues(CheckReturnValue, *this))
3258 return indicatePessimisticFixpoint();
3259
3260 return ChangeStatus::UNCHANGED;
3261 }
3262
3263 /// See AbstractAttribute::trackStatistics()
3264 void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noalias){ static llvm::Statistic NumIRFunctionReturn_noalias = {"attributor"
, "NumIRFunctionReturn_noalias", ("Number of " "function returns"
" marked '" "noalias" "'")};; ++(NumIRFunctionReturn_noalias
); }
}
3265};
3266
3267/// NoAlias attribute deduction for a call site return value.
3268struct AANoAliasCallSiteReturned final : AANoAliasImpl {
3269 AANoAliasCallSiteReturned(const IRPosition &IRP, Attributor &A)
3270 : AANoAliasImpl(IRP, A) {}
3271
3272 /// See AbstractAttribute::initialize(...).
3273 void initialize(Attributor &A) override {
3274 AANoAliasImpl::initialize(A);
3275 Function *F = getAssociatedFunction();
3276 if (!F || F->isDeclaration())
3277 indicatePessimisticFixpoint();
3278 }
3279
3280 /// See AbstractAttribute::updateImpl(...).
3281 ChangeStatus updateImpl(Attributor &A) override {
3282 // TODO: Once we have call site specific value information we can provide
3283 // call site specific liveness information and then it makes
3284 // sense to specialize attributes for call sites arguments instead of
3285 // redirecting requests to the callee argument.
3286 Function *F = getAssociatedFunction();
3287 const IRPosition &FnPos = IRPosition::returned(*F);
3288 auto &FnAA = A.getAAFor<AANoAlias>(*this, FnPos, DepClassTy::REQUIRED);
3289 return clampStateAndIndicateChange(getState(), FnAA.getState());
3290 }
3291
3292 /// See AbstractAttribute::trackStatistics()
3293 void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(noalias){ static llvm::Statistic NumIRCSReturn_noalias = {"attributor"
, "NumIRCSReturn_noalias", ("Number of " "call site returns" " marked '"
"noalias" "'")};; ++(NumIRCSReturn_noalias); }
; }
3294};
3295
3296/// -------------------AAIsDead Function Attribute-----------------------
3297
3298struct AAIsDeadValueImpl : public AAIsDead {
3299 AAIsDeadValueImpl(const IRPosition &IRP, Attributor &A) : AAIsDead(IRP, A) {}
3300
3301 /// See AAIsDead::isAssumedDead().
3302 bool isAssumedDead() const override { return isAssumed(IS_DEAD); }
3303
3304 /// See AAIsDead::isKnownDead().
3305 bool isKnownDead() const override { return isKnown(IS_DEAD); }
3306
3307 /// See AAIsDead::isAssumedDead(BasicBlock *).
3308 bool isAssumedDead(const BasicBlock *BB) const override { return false; }
3309
3310 /// See AAIsDead::isKnownDead(BasicBlock *).
3311 bool isKnownDead(const BasicBlock *BB) const override { return false; }
3312
3313 /// See AAIsDead::isAssumedDead(Instruction *I).
3314 bool isAssumedDead(const Instruction *I) const override {
3315 return I == getCtxI() && isAssumedDead();
3316 }
3317
3318 /// See AAIsDead::isKnownDead(Instruction *I).
3319 bool isKnownDead(const Instruction *I) const override {
3320 return isAssumedDead(I) && isKnownDead();
3321 }
3322
3323 /// See AbstractAttribute::getAsStr().
3324 const std::string getAsStr() const override {
3325 return isAssumedDead() ? "assumed-dead" : "assumed-live";
3326 }
3327
3328 /// Check if all uses are assumed dead.
3329 bool areAllUsesAssumedDead(Attributor &A, Value &V) {
3330 // Callers might not check the type, void has no uses.
3331 if (V.getType()->isVoidTy())
3332 return true;
3333
3334 // If we replace a value with a constant there are no uses left afterwards.
3335 if (!isa<Constant>(V)) {
3336 bool UsedAssumedInformation = false;
3337 Optional<Constant *> C =
3338 A.getAssumedConstant(V, *this, UsedAssumedInformation);
3339 if (!C.hasValue() || *C)
3340 return true;
3341 }
3342
3343 auto UsePred = [&](const Use &U, bool &Follow) { return false; };
3344 // Explicitly set the dependence class to required because we want a long
3345 // chain of N dependent instructions to be considered live as soon as one is
3346 // without going through N update cycles. This is not required for
3347 // correctness.
3348 return A.checkForAllUses(UsePred, *this, V, /* CheckBBLivenessOnly */ false,
3349 DepClassTy::REQUIRED);
3350 }
3351
3352 /// Determine if \p I is assumed to be side-effect free.
3353 bool isAssumedSideEffectFree(Attributor &A, Instruction *I) {
3354 if (!I || wouldInstructionBeTriviallyDead(I))
3355 return true;
3356
3357 auto *CB = dyn_cast<CallBase>(I);
3358 if (!CB || isa<IntrinsicInst>(CB))
3359 return false;
3360
3361 const IRPosition &CallIRP = IRPosition::callsite_function(*CB);
3362 const auto &NoUnwindAA =
3363 A.getAndUpdateAAFor<AANoUnwind>(*this, CallIRP, DepClassTy::NONE);
3364 if (!NoUnwindAA.isAssumedNoUnwind())
3365 return false;
3366 if (!NoUnwindAA.isKnownNoUnwind())
3367 A.recordDependence(NoUnwindAA, *this, DepClassTy::OPTIONAL);
3368
3369 const auto &MemBehaviorAA =
3370 A.getAndUpdateAAFor<AAMemoryBehavior>(*this, CallIRP, DepClassTy::NONE);
3371 if (MemBehaviorAA.isAssumedReadOnly()) {
3372 if (!MemBehaviorAA.isKnownReadOnly())
3373 A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
3374 return true;
3375 }
3376 return false;
3377 }
3378};
3379
3380struct AAIsDeadFloating : public AAIsDeadValueImpl {
3381 AAIsDeadFloating(const IRPosition &IRP, Attributor &A)
3382 : AAIsDeadValueImpl(IRP, A) {}
3383
3384 /// See AbstractAttribute::initialize(...).
3385 void initialize(Attributor &A) override {
3386 if (isa<UndefValue>(getAssociatedValue())) {
3387 indicatePessimisticFixpoint();
3388 return;
3389 }
3390
3391 Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
3392 if (!isAssumedSideEffectFree(A, I)) {
3393 if (!isa_and_nonnull<StoreInst>(I))
3394 indicatePessimisticFixpoint();
3395 else
3396 removeAssumedBits(HAS_NO_EFFECT);
3397 }
3398 }
3399
3400 bool isDeadStore(Attributor &A, StoreInst &SI) {
3401 bool UsedAssumedInformation = false;
3402 SmallSetVector<Value *, 4> PotentialCopies;
3403 if (!AA::getPotentialCopiesOfStoredValue(A, SI, PotentialCopies, *this,
3404 UsedAssumedInformation))
3405 return false;
3406 return llvm::all_of(PotentialCopies, [&](Value *V) {
3407 return A.isAssumedDead(IRPosition::value(*V), this, nullptr,
3408 UsedAssumedInformation);
3409 });
3410 }
3411
3412 /// See AbstractAttribute::updateImpl(...).
3413 ChangeStatus updateImpl(Attributor &A) override {
3414 Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
3415 if (auto *SI = dyn_cast_or_null<StoreInst>(I)) {
3416 if (!isDeadStore(A, *SI))
3417 return indicatePessimisticFixpoint();
3418 } else {
3419 if (!isAssumedSideEffectFree(A, I))
3420 return indicatePessimisticFixpoint();
3421 if (!areAllUsesAssumedDead(A, getAssociatedValue()))
3422 return indicatePessimisticFixpoint();
3423 }
3424 return ChangeStatus::UNCHANGED;
3425 }
3426
3427 /// See AbstractAttribute::manifest(...).
3428 ChangeStatus manifest(Attributor &A) override {
3429 Value &V = getAssociatedValue();
3430 if (auto *I = dyn_cast<Instruction>(&V)) {
3431 // If we get here we basically know the users are all dead. We check if
3432 // isAssumedSideEffectFree returns true here again because it might not be
3433 // the case and only the users are dead but the instruction (=call) is
3434 // still needed.
3435 if (isa<StoreInst>(I) ||
3436 (isAssumedSideEffectFree(A, I) && !isa<InvokeInst>(I))) {
3437 A.deleteAfterManifest(*I);
3438 return ChangeStatus::CHANGED;
3439 }
3440 }
3441 if (V.use_empty())
3442 return ChangeStatus::UNCHANGED;
3443
3444 bool UsedAssumedInformation = false;
3445 Optional<Constant *> C =
3446 A.getAssumedConstant(V, *this, UsedAssumedInformation);
3447 if (C.hasValue() && C.getValue())
3448 return ChangeStatus::UNCHANGED;
3449
3450 // Replace the value with undef as it is dead but keep droppable uses around
3451 // as they provide information we don't want to give up on just yet.
3452 UndefValue &UV = *UndefValue::get(V.getType());
3453 bool AnyChange =
3454 A.changeValueAfterManifest(V, UV, /* ChangeDropppable */ false);
3455 return AnyChange ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
3456 }
3457
3458 /// See AbstractAttribute::trackStatistics()
3459 void trackStatistics() const override {
3460 STATS_DECLTRACK_FLOATING_ATTR(IsDead){ static llvm::Statistic NumIRFloating_IsDead = {"attributor"
, "NumIRFloating_IsDead", ("Number of floating values known to be '"
"IsDead" "'")};; ++(NumIRFloating_IsDead); }
3461 }
3462};
3463
3464struct AAIsDeadArgument : public AAIsDeadFloating {
3465 AAIsDeadArgument(const IRPosition &IRP, Attributor &A)
3466 : AAIsDeadFloating(IRP, A) {}
3467
3468 /// See AbstractAttribute::initialize(...).
3469 void initialize(Attributor &A) override {
3470 if (!A.isFunctionIPOAmendable(*getAnchorScope()))
3471 indicatePessimisticFixpoint();
3472 }
3473
3474 /// See AbstractAttribute::manifest(...).
3475 ChangeStatus manifest(Attributor &A) override {
3476 ChangeStatus Changed = AAIsDeadFloating::manifest(A);
3477 Argument &Arg = *getAssociatedArgument();
3478 if (A.isValidFunctionSignatureRewrite(Arg, /* ReplacementTypes */ {}))
3479 if (A.registerFunctionSignatureRewrite(
3480 Arg, /* ReplacementTypes */ {},
3481 Attributor::ArgumentReplacementInfo::CalleeRepairCBTy{},
3482 Attributor::ArgumentReplacementInfo::ACSRepairCBTy{})) {
3483 Arg.dropDroppableUses();
3484 return ChangeStatus::CHANGED;
3485 }
3486 return Changed;
3487 }
3488
3489 /// See AbstractAttribute::trackStatistics()
3490 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(IsDead){ static llvm::Statistic NumIRArguments_IsDead = {"attributor"
, "NumIRArguments_IsDead", ("Number of " "arguments" " marked '"
"IsDead" "'")};; ++(NumIRArguments_IsDead); }
}
3491};
3492
3493struct AAIsDeadCallSiteArgument : public AAIsDeadValueImpl {
3494 AAIsDeadCallSiteArgument(const IRPosition &IRP, Attributor &A)
3495 : AAIsDeadValueImpl(IRP, A) {}
3496
3497 /// See AbstractAttribute::initialize(...).
3498 void initialize(Attributor &A) override {
3499 if (isa<UndefValue>(getAssociatedValue()))
3500 indicatePessimisticFixpoint();
3501 }
3502
3503 /// See AbstractAttribute::updateImpl(...).
3504 ChangeStatus updateImpl(Attributor &A) override {
3505 // TODO: Once we have call site specific value information we can provide
3506 // call site specific liveness information and then it makes
3507 // sense to specialize attributes for call sites arguments instead of
3508 // redirecting requests to the callee argument.
3509 Argument *Arg = getAssociatedArgument();
3510 if (!Arg)
3511 return indicatePessimisticFixpoint();
3512 const IRPosition &ArgPos = IRPosition::argument(*Arg);
3513 auto &ArgAA = A.getAAFor<AAIsDead>(*this, ArgPos, DepClassTy::REQUIRED);
3514 return clampStateAndIndicateChange(getState(), ArgAA.getState());
3515 }
3516
3517 /// See AbstractAttribute::manifest(...).
3518 ChangeStatus manifest(Attributor &A) override {
3519 CallBase &CB = cast<CallBase>(getAnchorValue());
3520 Use &U = CB.getArgOperandUse(getCallSiteArgNo());
3521 assert(!isa<UndefValue>(U.get()) &&((void)0)
3522 "Expected undef values to be filtered out!")((void)0);
3523 UndefValue &UV = *UndefValue::get(U->getType());
3524 if (A.changeUseAfterManifest(U, UV))
3525 return ChangeStatus::CHANGED;
3526 return ChangeStatus::UNCHANGED;
3527 }
3528
3529 /// See AbstractAttribute::trackStatistics()
3530 void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(IsDead){ static llvm::Statistic NumIRCSArguments_IsDead = {"attributor"
, "NumIRCSArguments_IsDead", ("Number of " "call site arguments"
" marked '" "IsDead" "'")};; ++(NumIRCSArguments_IsDead); }
}
3531};
3532
3533struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
3534 AAIsDeadCallSiteReturned(const IRPosition &IRP, Attributor &A)
3535 : AAIsDeadFloating(IRP, A), IsAssumedSideEffectFree(true) {}
3536
3537 /// See AAIsDead::isAssumedDead().
3538 bool isAssumedDead() const override {
3539 return AAIsDeadFloating::isAssumedDead() && IsAssumedSideEffectFree;
3540 }
3541
3542 /// See AbstractAttribute::initialize(...).
3543 void initialize(Attributor &A) override {
3544 if (isa<UndefValue>(getAssociatedValue())) {
3545 indicatePessimisticFixpoint();
3546 return;
3547 }
3548
3549 // We track this separately as a secondary state.
3550 IsAssumedSideEffectFree = isAssumedSideEffectFree(A, getCtxI());
3551 }
3552
3553 /// See AbstractAttribute::updateImpl(...).
3554 ChangeStatus updateImpl(Attributor &A) override {
3555 ChangeStatus Changed = ChangeStatus::UNCHANGED;
3556 if (IsAssumedSideEffectFree && !isAssumedSideEffectFree(A, getCtxI())) {
3557 IsAssumedSideEffectFree = false;
3558 Changed = ChangeStatus::CHANGED;
3559 }
3560 if (!areAllUsesAssumedDead(A, getAssociatedValue()))
3561 return indicatePessimisticFixpoint();
3562 return Changed;
3563 }
3564
3565 /// See AbstractAttribute::trackStatistics()
3566 void trackStatistics() const override {
3567 if (IsAssumedSideEffectFree)
3568 STATS_DECLTRACK_CSRET_ATTR(IsDead){ static llvm::Statistic NumIRCSReturn_IsDead = {"attributor"
, "NumIRCSReturn_IsDead", ("Number of " "call site returns" " marked '"
"IsDead" "'")};; ++(NumIRCSReturn_IsDead); }
3569 else
3570 STATS_DECLTRACK_CSRET_ATTR(UnusedResult){ static llvm::Statistic NumIRCSReturn_UnusedResult = {"attributor"
, "NumIRCSReturn_UnusedResult", ("Number of " "call site returns"
" marked '" "UnusedResult" "'")};; ++(NumIRCSReturn_UnusedResult
); }
3571 }
3572
3573 /// See AbstractAttribute::getAsStr().
3574 const std::string getAsStr() const override {
3575 return isAssumedDead()
3576 ? "assumed-dead"
3577 : (getAssumed() ? "assumed-dead-users" : "assumed-live");
3578 }
3579
3580private:
3581 bool IsAssumedSideEffectFree;
3582};
3583
3584struct AAIsDeadReturned : public AAIsDeadValueImpl {
3585 AAIsDeadReturned(const IRPosition &IRP, Attributor &A)
3586 : AAIsDeadValueImpl(IRP, A) {}
3587
3588 /// See AbstractAttribute::updateImpl(...).
3589 ChangeStatus updateImpl(Attributor &A) override {
3590
3591 bool UsedAssumedInformation = false;
3592 A.checkForAllInstructions([](Instruction &) { return true; }, *this,
3593 {Instruction::Ret}, UsedAssumedInformation);
3594
3595 auto PredForCallSite = [&](AbstractCallSite ACS) {
3596 if (ACS.isCallbackCall() || !ACS.getInstruction())
3597 return false;
3598 return areAllUsesAssumedDead(A, *ACS.getInstruction());
3599 };
3600
3601 bool AllCallSitesKnown;
3602 if (!A.checkForAllCallSites(PredForCallSite, *this, true,
3603 AllCallSitesKnown))
3604 return indicatePessimisticFixpoint();
3605
3606 return ChangeStatus::UNCHANGED;
3607 }
3608
3609 /// See AbstractAttribute::manifest(...).
3610 ChangeStatus manifest(Attributor &A) override {
3611 // TODO: Rewrite the signature to return void?
3612 bool AnyChange = false;
3613 UndefValue &UV = *UndefValue::get(getAssociatedFunction()->getReturnType());
3614 auto RetInstPred = [&](Instruction &I) {
3615 ReturnInst &RI = cast<ReturnInst>(I);
3616 if (!isa<UndefValue>(RI.getReturnValue()))
3617 AnyChange |= A.changeUseAfterManifest(RI.getOperandUse(0), UV);
3618 return true;
3619 };
3620 bool UsedAssumedInformation = false;
3621 A.checkForAllInstructions(RetInstPred, *this, {Instruction::Ret},
3622 UsedAssumedInformation);
3623 return AnyChange ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
3624 }
3625
3626 /// See AbstractAttribute::trackStatistics()
3627 void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(IsDead){ static llvm::Statistic NumIRFunctionReturn_IsDead = {"attributor"
, "NumIRFunctionReturn_IsDead", ("Number of " "function returns"
" marked '" "IsDead" "'")};; ++(NumIRFunctionReturn_IsDead);
}
}
3628};
3629
3630struct AAIsDeadFunction : public AAIsDead {
3631 AAIsDeadFunction(const IRPosition &IRP, Attributor &A) : AAIsDead(IRP, A) {}
3632
3633 /// See AbstractAttribute::initialize(...).
3634 void initialize(Attributor &A) override {
3635 const Function *F = getAnchorScope();
3636 if (F && !F->isDeclaration()) {
3637 // We only want to compute liveness once. If the function is not part of
3638 // the SCC, skip it.
3639 if (A.isRunOn(*const_cast<Function *>(F))) {
3640 ToBeExploredFrom.insert(&F->getEntryBlock().front());
3641 assumeLive(A, F->getEntryBlock());
3642 } else {
3643 indicatePessimisticFixpoint();
3644 }
3645 }
3646 }
3647
3648 /// See AbstractAttribute::getAsStr().
3649 const std::string getAsStr() const override {
3650 return "Live[#BB " + std::to_string(AssumedLiveBlocks.size()) + "/" +
3651 std::to_string(getAnchorScope()->size()) + "][#TBEP " +
3652 std::to_string(ToBeExploredFrom.size()) + "][#KDE " +
3653 std::to_string(KnownDeadEnds.size()) + "]";
3654 }
3655
3656 /// See AbstractAttribute::manifest(...).
3657 ChangeStatus manifest(Attributor &A) override {
3658 assert(getState().isValidState() &&((void)0)
3659 "Attempted to manifest an invalid state!")((void)0);
3660
3661 ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
3662 Function &F = *getAnchorScope();
3663
3664 if (AssumedLiveBlocks.empty()) {
3665 A.deleteAfterManifest(F);
3666 return ChangeStatus::CHANGED;
3667 }
3668
3669 // Flag to determine if we can change an invoke to a call assuming the
3670 // callee is nounwind. This is not possible if the personality of the
3671 // function allows to catch asynchronous exceptions.
3672 bool Invoke2CallAllowed = !mayCatchAsynchronousExceptions(F);
3673
3674 KnownDeadEnds.set_union(ToBeExploredFrom);
3675 for (const Instruction *DeadEndI : KnownDeadEnds) {
3676 auto *CB = dyn_cast<CallBase>(DeadEndI);
3677 if (!CB)
3678 continue;
3679 const auto &NoReturnAA = A.getAndUpdateAAFor<AANoReturn>(
3680 *this, IRPosition::callsite_function(*CB), DepClassTy::OPTIONAL);
3681 bool MayReturn = !NoReturnAA.isAssumedNoReturn();
3682 if (MayReturn && (!Invoke2CallAllowed || !isa<InvokeInst>(CB)))
3683 continue;
3684
3685 if (auto *II = dyn_cast<InvokeInst>(DeadEndI))
3686 A.registerInvokeWithDeadSuccessor(const_cast<InvokeInst &>(*II));
3687 else
3688 A.changeToUnreachableAfterManifest(
3689 const_cast<Instruction *>(DeadEndI->getNextNode()));
3690 HasChanged = ChangeStatus::CHANGED;
3691 }
3692
3693 STATS_DECL(AAIsDead, BasicBlock, "Number of dead basic blocks deleted.")static llvm::Statistic NumIRBasicBlock_AAIsDead = {"attributor"
, "NumIRBasicBlock_AAIsDead", "Number of dead basic blocks deleted."
};;
;
3694 for (BasicBlock &BB : F)
3695 if (!AssumedLiveBlocks.count(&BB)) {
3696 A.deleteAfterManifest(BB);
3697 ++BUILD_STAT_NAME(AAIsDead, BasicBlock)NumIRBasicBlock_AAIsDead;
3698 }
3699
3700 return HasChanged;
3701 }
3702
3703 /// See AbstractAttribute::updateImpl(...).
3704 ChangeStatus updateImpl(Attributor &A) override;
3705
3706 bool isEdgeDead(const BasicBlock *From, const BasicBlock *To) const override {
3707 return !AssumedLiveEdges.count(std::make_pair(From, To));
3708 }
3709
3710 /// See AbstractAttribute::trackStatistics()
3711 void trackStatistics() const override {}
3712
3713 /// Returns true if the function is assumed dead.
3714 bool isAssumedDead() const override { return false; }
3715
3716 /// See AAIsDead::isKnownDead().
3717 bool isKnownDead() const override { return false; }
3718
3719 /// See AAIsDead::isAssumedDead(BasicBlock *).
3720 bool isAssumedDead(const BasicBlock *BB) const override {
3721 assert(BB->getParent() == getAnchorScope() &&((void)0)
3722 "BB must be in the same anchor scope function.")((void)0);
3723
3724 if (!getAssumed())
3725 return false;
3726 return !AssumedLiveBlocks.count(BB);
3727 }
3728
3729 /// See AAIsDead::isKnownDead(BasicBlock *).
3730 bool isKnownDead(const BasicBlock *BB) const override {
3731 return getKnown() && isAssumedDead(BB);
3732 }
3733
3734 /// See AAIsDead::isAssumed(Instruction *I).
3735 bool isAssumedDead(const Instruction *I) const override {
3736 assert(I->getParent()->getParent() == getAnchorScope() &&((void)0)
3737 "Instruction must be in the same anchor scope function.")((void)0);
3738
3739 if (!getAssumed())
3740 return false;
3741
3742 // If it is not in AssumedLiveBlocks then it for sure dead.
3743 // Otherwise, it can still be after noreturn call in a live block.
3744 if (!AssumedLiveBlocks.count(I->getParent()))
3745 return true;
3746
3747 // If it is not after a liveness barrier it is live.
3748 const Instruction *PrevI = I->getPrevNode();
3749 while (PrevI) {
3750 if (KnownDeadEnds.count(PrevI) || ToBeExploredFrom.count(PrevI))
3751 return true;
3752 PrevI = PrevI->getPrevNode();
3753 }
3754 return false;
3755 }
3756
3757 /// See AAIsDead::isKnownDead(Instruction *I).
3758 bool isKnownDead(const Instruction *I) const override {
3759 return getKnown() && isAssumedDead(I);
3760 }
3761
3762 /// Assume \p BB is (partially) live now and indicate to the Attributor \p A
3763 /// that internal function called from \p BB should now be looked at.
3764 bool assumeLive(Attributor &A, const BasicBlock &BB) {
3765 if (!AssumedLiveBlocks.insert(&BB).second)
3766 return false;
3767
3768 // We assume that all of BB is (probably) live now and if there are calls to
3769 // internal functions we will assume that those are now live as well. This
3770 // is a performance optimization for blocks with calls to a lot of internal
3771 // functions. It can however cause dead functions to be treated as live.
3772 for (const Instruction &I : BB)
3773 if (const auto *CB = dyn_cast<CallBase>(&I))
3774 if (const Function *F = CB->getCalledFunction())
3775 if (F->hasLocalLinkage())
3776 A.markLiveInternalFunction(*F);
3777 return true;
3778 }
3779
3780 /// Collection of instructions that need to be explored again, e.g., we
3781 /// did assume they do not transfer control to (one of their) successors.
3782 SmallSetVector<const Instruction *, 8> ToBeExploredFrom;
3783
3784 /// Collection of instructions that are known to not transfer control.
3785 SmallSetVector<const Instruction *, 8> KnownDeadEnds;
3786
3787 /// Collection of all assumed live edges
3788 DenseSet<std::pair<const BasicBlock *, const BasicBlock *>> AssumedLiveEdges;
3789
3790 /// Collection of all assumed live BasicBlocks.
3791 DenseSet<const BasicBlock *> AssumedLiveBlocks;
3792};
3793
3794static bool
3795identifyAliveSuccessors(Attributor &A, const CallBase &CB,
3796 AbstractAttribute &AA,
3797 SmallVectorImpl<const Instruction *> &AliveSuccessors) {
3798 const IRPosition &IPos = IRPosition::callsite_function(CB);
3799
3800 const auto &NoReturnAA =
3801 A.getAndUpdateAAFor<AANoReturn>(AA, IPos, DepClassTy::OPTIONAL);
3802 if (NoReturnAA.isAssumedNoReturn())
3803 return !NoReturnAA.isKnownNoReturn();
3804 if (CB.isTerminator())
3805 AliveSuccessors.push_back(&CB.getSuccessor(0)->front());
3806 else
3807 AliveSuccessors.push_back(CB.getNextNode());
3808 return false;
3809}
3810
3811static bool
3812identifyAliveSuccessors(Attributor &A, const InvokeInst &II,
3813 AbstractAttribute &AA,
3814 SmallVectorImpl<const Instruction *> &AliveSuccessors) {
3815 bool UsedAssumedInformation =
3816 identifyAliveSuccessors(A, cast<CallBase>(II), AA, AliveSuccessors);
3817
3818 // First, determine if we can change an invoke to a call assuming the
3819 // callee is nounwind. This is not possible if the personality of the
3820 // function allows to catch asynchronous exceptions.
3821 if (AAIsDeadFunction::mayCatchAsynchronousExceptions(*II.getFunction())) {
3822 AliveSuccessors.push_back(&II.getUnwindDest()->front());
3823 } else {
3824 const IRPosition &IPos = IRPosition::callsite_function(II);
3825 const auto &AANoUnw =
3826 A.getAndUpdateAAFor<AANoUnwind>(AA, IPos, DepClassTy::OPTIONAL);
3827 if (AANoUnw.isAssumedNoUnwind()) {
3828 UsedAssumedInformation |= !AANoUnw.isKnownNoUnwind();
3829 } else {
3830 AliveSuccessors.push_back(&II.getUnwindDest()->front());
3831 }
3832 }
3833 return UsedAssumedInformation;
3834}
3835
3836static bool
3837identifyAliveSuccessors(Attributor &A, const BranchInst &BI,
3838 AbstractAttribute &AA,
3839 SmallVectorImpl<const Instruction *> &AliveSuccessors) {
3840 bool UsedAssumedInformation = false;
3841 if (BI.getNumSuccessors() == 1) {
3842 AliveSuccessors.push_back(&BI.getSuccessor(0)->front());
3843 } else {
3844 Optional<Constant *> C =
3845 A.getAssumedConstant(*BI.getCondition(), AA, UsedAssumedInformation);
3846 if (!C.hasValue() || isa_and_nonnull<UndefValue>(C.getValue())) {
3847 // No value yet, assume both edges are dead.
3848 } else if (isa_and_nonnull<ConstantInt>(*C)) {
3849 const BasicBlock *SuccBB =
3850 BI.getSuccessor(1 - cast<ConstantInt>(*C)->getValue().getZExtValue());
3851 AliveSuccessors.push_back(&SuccBB->front());
3852 } else {
3853 AliveSuccessors.push_back(&BI.getSuccessor(0)->front());
3854 AliveSuccessors.push_back(&BI.getSuccessor(1)->front());
3855 UsedAssumedInformation = false;
3856 }
3857 }
3858 return UsedAssumedInformation;
3859}
3860
3861static bool
3862identifyAliveSuccessors(Attributor &A, const SwitchInst &SI,
3863 AbstractAttribute &AA,
3864 SmallVectorImpl<const Instruction *> &AliveSuccessors) {
3865 bool UsedAssumedInformation = false;
3866 Optional<Constant *> C =
3867 A.getAssumedConstant(*SI.getCondition(), AA, UsedAssumedInformation);
3868 if (!C.hasValue() || isa_and_nonnull<UndefValue>(C.getValue())) {
3869 // No value yet, assume all edges are dead.
3870 } else if (isa_and_nonnull<ConstantInt>(C.getValue())) {
3871 for (auto &CaseIt : SI.cases()) {
3872 if (CaseIt.getCaseValue() == C.getValue()) {
3873 AliveSuccessors.push_back(&CaseIt.getCaseSuccessor()->front());
3874 return UsedAssumedInformation;
3875 }
3876 }
3877 AliveSuccessors.push_back(&SI.getDefaultDest()->front());
3878 return UsedAssumedInformation;
3879 } else {
3880 for (const BasicBlock *SuccBB : successors(SI.getParent()))
3881 AliveSuccessors.push_back(&SuccBB->front());
3882 }
3883 return UsedAssumedInformation;
3884}
3885
3886ChangeStatus AAIsDeadFunction::updateImpl(Attributor &A) {
3887 ChangeStatus Change = ChangeStatus::UNCHANGED;
3888
3889 LLVM_DEBUG(dbgs() << "[AAIsDead] Live [" << AssumedLiveBlocks.size() << "/"do { } while (false)
3890 << getAnchorScope()->size() << "] BBs and "do { } while (false)
3891 << ToBeExploredFrom.size() << " exploration points and "do { } while (false)
3892 << KnownDeadEnds.size() << " known dead ends\n")do { } while (false);
3893
3894 // Copy and clear the list of instructions we need to explore from. It is
3895 // refilled with instructions the next update has to look at.
3896 SmallVector<const Instruction *, 8> Worklist(ToBeExploredFrom.begin(),
3897 ToBeExploredFrom.end());
3898 decltype(ToBeExploredFrom) NewToBeExploredFrom;
3899
3900 SmallVector<const Instruction *, 8> AliveSuccessors;
3901 while (!Worklist.empty()) {
3902 const Instruction *I = Worklist.pop_back_val();
3903 LLVM_DEBUG(dbgs() << "[AAIsDead] Exploration inst: " << *I << "\n")do { } while (false);
3904
3905 // Fast forward for uninteresting instructions. We could look for UB here
3906 // though.
3907 while (!I->isTerminator() && !isa<CallBase>(I))
3908 I = I->getNextNode();
3909
3910 AliveSuccessors.clear();
3911
3912 bool UsedAssumedInformation = false;
3913 switch (I->getOpcode()) {
3914 // TODO: look for (assumed) UB to backwards propagate "deadness".
3915 default:
3916 assert(I->isTerminator() &&((void)0)
3917 "Expected non-terminators to be handled already!")((void)0);
3918 for (const BasicBlock *SuccBB : successors(I->getParent()))
3919 AliveSuccessors.push_back(&SuccBB->front());
3920 break;
3921 case Instruction::Call:
3922 UsedAssumedInformation = identifyAliveSuccessors(A, cast<CallInst>(*I),
3923 *this, AliveSuccessors);
3924 break;
3925 case Instruction::Invoke:
3926 UsedAssumedInformation = identifyAliveSuccessors(A, cast<InvokeInst>(*I),
3927 *this, AliveSuccessors);
3928 break;
3929 case Instruction::Br:
3930 UsedAssumedInformation = identifyAliveSuccessors(A, cast<BranchInst>(*I),
3931 *this, AliveSuccessors);
3932 break;
3933 case Instruction::Switch:
3934 UsedAssumedInformation = identifyAliveSuccessors(A, cast<SwitchInst>(*I),
3935 *this, AliveSuccessors);
3936 break;
3937 }
3938
3939 if (UsedAssumedInformation) {
3940 NewToBeExploredFrom.insert(I);
3941 } else if (AliveSuccessors.empty() ||
3942 (I->isTerminator() &&
3943 AliveSuccessors.size() < I->getNumSuccessors())) {
3944 if (KnownDeadEnds.insert(I))
3945 Change = ChangeStatus::CHANGED;
3946 }
3947
3948 LLVM_DEBUG(dbgs() << "[AAIsDead] #AliveSuccessors: "do { } while (false)
3949 << AliveSuccessors.size() << " UsedAssumedInformation: "do { } while (false)
3950 << UsedAssumedInformation << "\n")do { } while (false);
3951
3952 for (const Instruction *AliveSuccessor : AliveSuccessors) {
3953 if (!I->isTerminator()) {
3954 assert(AliveSuccessors.size() == 1 &&((void)0)
3955 "Non-terminator expected to have a single successor!")((void)0);
3956 Worklist.push_back(AliveSuccessor);
3957 } else {
3958 // record the assumed live edge
3959 auto Edge = std::make_pair(I->getParent(), AliveSuccessor->getParent());
3960 if (AssumedLiveEdges.insert(Edge).second)
3961 Change = ChangeStatus::CHANGED;
3962 if (assumeLive(A, *AliveSuccessor->getParent()))
3963 Worklist.push_back(AliveSuccessor);
3964 }
3965 }
3966 }
3967
3968 // Check if the content of ToBeExploredFrom changed, ignore the order.
3969 if (NewToBeExploredFrom.size() != ToBeExploredFrom.size() ||
3970 llvm::any_of(NewToBeExploredFrom, [&](const Instruction *I) {
3971 return !ToBeExploredFrom.count(I);
3972 })) {
3973 Change = ChangeStatus::CHANGED;
3974 ToBeExploredFrom = std::move(NewToBeExploredFrom);
3975 }
3976
3977 // If we know everything is live there is no need to query for liveness.
3978 // Instead, indicating a pessimistic fixpoint will cause the state to be
3979 // "invalid" and all queries to be answered conservatively without lookups.
3980 // To be in this state we have to (1) finished the exploration and (3) not
3981 // discovered any non-trivial dead end and (2) not ruled unreachable code
3982 // dead.
3983 if (ToBeExploredFrom.empty() &&
3984 getAnchorScope()->size() == AssumedLiveBlocks.size() &&
3985 llvm::all_of(KnownDeadEnds, [](const Instruction *DeadEndI) {
3986 return DeadEndI->isTerminator() && DeadEndI->getNumSuccessors() == 0;
3987 }))
3988 return indicatePessimisticFixpoint();
3989 return Change;
3990}
3991
3992/// Liveness information for a call sites.
3993struct AAIsDeadCallSite final : AAIsDeadFunction {
3994 AAIsDeadCallSite(const IRPosition &IRP, Attributor &A)
3995 : AAIsDeadFunction(IRP, A) {}
3996
3997 /// See AbstractAttribute::initialize(...).
3998 void initialize(Attributor &A) override {
3999 // TODO: Once we have call site specific value information we can provide
4000 // call site specific liveness information and then it makes
4001 // sense to specialize attributes for call sites instead of
4002 // redirecting requests to the callee.
4003 llvm_unreachable("Abstract attributes for liveness are not "__builtin_unreachable()
4004 "supported for call sites yet!")__builtin_unreachable();
4005 }
4006
4007 /// See AbstractAttribute::updateImpl(...).
4008 ChangeStatus updateImpl(Attributor &A) override {
4009 return indicatePessimisticFixpoint();
4010 }
4011
4012 /// See AbstractAttribute::trackStatistics()
4013 void trackStatistics() const override {}
4014};
4015
4016/// -------------------- Dereferenceable Argument Attribute --------------------
4017
4018struct AADereferenceableImpl : AADereferenceable {
4019 AADereferenceableImpl(const IRPosition &IRP, Attributor &A)
4020 : AADereferenceable(IRP, A) {}
4021 using StateType = DerefState;
4022
4023 /// See AbstractAttribute::initialize(...).
4024 void initialize(Attributor &A) override {
4025 SmallVector<Attribute, 4> Attrs;
4026 getAttrs({Attribute::Dereferenceable, Attribute::DereferenceableOrNull},
4027 Attrs, /* IgnoreSubsumingPositions */ false, &A);
4028 for (const Attribute &Attr : Attrs)
4029 takeKnownDerefBytesMaximum(Attr.getValueAsInt());
4030
4031 const IRPosition &IRP = this->getIRPosition();
4032 NonNullAA = &A.getAAFor<AANonNull>(*this, IRP, DepClassTy::NONE);
4033
4034 bool CanBeNull, CanBeFreed;
4035 takeKnownDerefBytesMaximum(
4036 IRP.getAssociatedValue().getPointerDereferenceableBytes(
4037 A.getDataLayout(), CanBeNull, CanBeFreed));
4038
4039 bool IsFnInterface = IRP.isFnInterfaceKind();
4040 Function *FnScope = IRP.getAnchorScope();
4041 if (IsFnInterface && (!FnScope || !A.isFunctionIPOAmendable(*FnScope))) {
4042 indicatePessimisticFixpoint();
4043 return;
4044 }
4045
4046 if (Instruction *CtxI = getCtxI())
4047 followUsesInMBEC(*this, A, getState(), *CtxI);
4048 }
4049
4050 /// See AbstractAttribute::getState()
4051 /// {
4052 StateType &getState() override { return *this; }
4053 const StateType &getState() const override { return *this; }
4054 /// }
4055
4056 /// Helper function for collecting accessed bytes in must-be-executed-context
4057 void addAccessedBytesForUse(Attributor &A, const Use *U, const Instruction *I,
4058 DerefState &State) {
4059 const Value *UseV = U->get();
4060 if (!UseV->getType()->isPointerTy())
4061 return;
4062
4063 Type *PtrTy = UseV->getType();
4064 const DataLayout &DL = A.getDataLayout();
4065 int64_t Offset;
4066 if (const Value *Base = getBasePointerOfAccessPointerOperand(
4067 I, Offset, DL, /*AllowNonInbounds*/ true)) {
4068 if (Base == &getAssociatedValue() &&
4069 getPointerOperand(I, /* AllowVolatile */ false) == UseV) {
4070 uint64_t Size = DL.getTypeStoreSize(PtrTy->getPointerElementType());
4071 State.addAccessedBytes(Offset, Size);
4072 }
4073 }
4074 }
4075
4076 /// See followUsesInMBEC
4077 bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
4078 AADereferenceable::StateType &State) {
4079 bool IsNonNull = false;
4080 bool TrackUse = false;
4081 int64_t DerefBytes = getKnownNonNullAndDerefBytesForUse(
4082 A, *this, getAssociatedValue(), U, I, IsNonNull, TrackUse);
4083 LLVM_DEBUG(dbgs() << "[AADereferenceable] Deref bytes: " << DerefBytesdo { } while (false)
4084 << " for instruction " << *I << "\n")do { } while (false);
4085
4086 addAccessedBytesForUse(A, U, I, State);
4087 State.takeKnownDerefBytesMaximum(DerefBytes);
4088 return TrackUse;
4089 }
4090
4091 /// See AbstractAttribute::manifest(...).
4092 ChangeStatus manifest(Attributor &A) override {
4093 ChangeStatus Change = AADereferenceable::manifest(A);
4094 if (isAssumedNonNull() && hasAttr(Attribute::DereferenceableOrNull)) {
4095 removeAttrs({Attribute::DereferenceableOrNull});
4096 return ChangeStatus::CHANGED;
4097 }
4098 return Change;
4099 }
4100
4101 void getDeducedAttributes(LLVMContext &Ctx,
4102 SmallVectorImpl<Attribute> &Attrs) const override {
4103 // TODO: Add *_globally support
4104 if (isAssumedNonNull())
4105 Attrs.emplace_back(Attribute::getWithDereferenceableBytes(
4106 Ctx, getAssumedDereferenceableBytes()));
4107 else
4108 Attrs.emplace_back(Attribute::getWithDereferenceableOrNullBytes(
4109 Ctx, getAssumedDereferenceableBytes()));
4110 }
4111
4112 /// See AbstractAttribute::getAsStr().
4113 const std::string getAsStr() const override {
4114 if (!getAssumedDereferenceableBytes())
4115 return "unknown-dereferenceable";
4116 return std::string("dereferenceable") +
4117 (isAssumedNonNull() ? "" : "_or_null") +
4118 (isAssumedGlobal() ? "_globally" : "") + "<" +
4119 std::to_string(getKnownDereferenceableBytes()) + "-" +
4120 std::to_string(getAssumedDereferenceableBytes()) + ">";
4121 }
4122};
4123
4124/// Dereferenceable attribute for a floating value.
4125struct AADereferenceableFloating : AADereferenceableImpl {
4126 AADereferenceableFloating(const IRPosition &IRP, Attributor &A)
4127 : AADereferenceableImpl(IRP, A) {}
4128
4129 /// See AbstractAttribute::updateImpl(...).
4130 ChangeStatus updateImpl(Attributor &A) override {
4131 const DataLayout &DL = A.getDataLayout();
4132
4133 auto VisitValueCB = [&](const Value &V, const Instruction *, DerefState &T,
4134 bool Stripped) -> bool {
4135 unsigned IdxWidth =
4136 DL.getIndexSizeInBits(V.getType()->getPointerAddressSpace());
4137 APInt Offset(IdxWidth, 0);
4138 const Value *Base =
4139 stripAndAccumulateMinimalOffsets(A, *this, &V, DL, Offset, false);
4140
4141 const auto &AA = A.getAAFor<AADereferenceable>(
4142 *this, IRPosition::value(*Base), DepClassTy::REQUIRED);
4143 int64_t DerefBytes = 0;
4144 if (!Stripped && this == &AA) {
4145 // Use IR information if we did not strip anything.
4146 // TODO: track globally.
4147 bool CanBeNull, CanBeFreed;
4148 DerefBytes =
4149 Base->getPointerDereferenceableBytes(DL, CanBeNull, CanBeFreed);
4150 T.GlobalState.indicatePessimisticFixpoint();
4151 } else {
4152 const DerefState &DS = AA.getState();
4153 DerefBytes = DS.DerefBytesState.getAssumed();
4154 T.GlobalState &= DS.GlobalState;
4155 }
4156
4157 // For now we do not try to "increase" dereferenceability due to negative
4158 // indices as we first have to come up with code to deal with loops and
4159 // for overflows of the dereferenceable bytes.
4160 int64_t OffsetSExt = Offset.getSExtValue();
4161 if (OffsetSExt < 0)
4162 OffsetSExt = 0;
4163
4164 T.takeAssumedDerefBytesMinimum(
4165 std::max(int64_t(0), DerefBytes - OffsetSExt));
4166
4167 if (this == &AA) {
4168 if (!Stripped) {
4169 // If nothing was stripped IR information is all we got.
4170 T.takeKnownDerefBytesMaximum(
4171 std::max(int64_t(0), DerefBytes - OffsetSExt));
4172 T.indicatePessimisticFixpoint();
4173 } else if (OffsetSExt > 0) {
4174 // If something was stripped but there is circular reasoning we look
4175 // for the offset. If it is positive we basically decrease the
4176 // dereferenceable bytes in a circluar loop now, which will simply
4177 // drive them down to the known value in a very slow way which we
4178 // can accelerate.
4179 T.indicatePessimisticFixpoint();
4180 }
4181 }
4182
4183 return T.isValidState();
4184 };
4185
4186 DerefState T;
4187 if (!genericValueTraversal<DerefState>(A, getIRPosition(), *this, T,
4188 VisitValueCB, getCtxI()))
4189 return indicatePessimisticFixpoint();
4190
4191 return clampStateAndIndicateChange(getState(), T);
4192 }
4193
4194 /// See AbstractAttribute::trackStatistics()
4195 void trackStatistics() const override {
4196 STATS_DECLTRACK_FLOATING_ATTR(dereferenceable){ static llvm::Statistic NumIRFloating_dereferenceable = {"attributor"
, "NumIRFloating_dereferenceable", ("Number of floating values known to be '"
"dereferenceable" "'")};; ++(NumIRFloating_dereferenceable);
}
4197 }
4198};
4199
4200/// Dereferenceable attribute for a return value.
4201struct AADereferenceableReturned final
4202 : AAReturnedFromReturnedValues<AADereferenceable, AADereferenceableImpl> {
4203 AADereferenceableReturned(const IRPosition &IRP, Attributor &A)
4204 : AAReturnedFromReturnedValues<AADereferenceable, AADereferenceableImpl>(
4205 IRP, A) {}
4206
4207 /// See AbstractAttribute::trackStatistics()
4208 void trackStatistics() const override {
4209 STATS_DECLTRACK_FNRET_ATTR(dereferenceable){ static llvm::Statistic NumIRFunctionReturn_dereferenceable =
{"attributor", "NumIRFunctionReturn_dereferenceable", ("Number of "
"function returns" " marked '" "dereferenceable" "'")};; ++(
NumIRFunctionReturn_dereferenceable); }
4210 }
4211};
4212
4213/// Dereferenceable attribute for an argument
4214struct AADereferenceableArgument final
4215 : AAArgumentFromCallSiteArguments<AADereferenceable,
4216 AADereferenceableImpl> {
4217 using Base =
4218 AAArgumentFromCallSiteArguments<AADereferenceable, AADereferenceableImpl>;
4219 AADereferenceableArgument(const IRPosition &IRP, Attributor &A)
4220 : Base(IRP, A) {}
4221
4222 /// See AbstractAttribute::trackStatistics()
4223 void trackStatistics() const override {
4224 STATS_DECLTRACK_ARG_ATTR(dereferenceable){ static llvm::Statistic NumIRArguments_dereferenceable = {"attributor"
, "NumIRArguments_dereferenceable", ("Number of " "arguments"
" marked '" "dereferenceable" "'")};; ++(NumIRArguments_dereferenceable
); }
4225 }
4226};
4227
4228/// Dereferenceable attribute for a call site argument.
4229struct AADereferenceableCallSiteArgument final : AADereferenceableFloating {
4230 AADereferenceableCallSiteArgument(const IRPosition &IRP, Attributor &A)
4231 : AADereferenceableFloating(IRP, A) {}
4232
4233 /// See AbstractAttribute::trackStatistics()
4234 void trackStatistics() const override {
4235 STATS_DECLTRACK_CSARG_ATTR(dereferenceable){ static llvm::Statistic NumIRCSArguments_dereferenceable = {
"attributor", "NumIRCSArguments_dereferenceable", ("Number of "
"call site arguments" " marked '" "dereferenceable" "'")};; ++
(NumIRCSArguments_dereferenceable); }
4236 }
4237};
4238
4239/// Dereferenceable attribute deduction for a call site return value.
4240struct AADereferenceableCallSiteReturned final
4241 : AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl> {
4242 using Base =
4243 AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl>;
4244 AADereferenceableCallSiteReturned(const IRPosition &IRP, Attributor &A)
4245 : Base(IRP, A) {}
4246
4247 /// See AbstractAttribute::trackStatistics()
4248 void trackStatistics() const override {
4249 STATS_DECLTRACK_CS_ATTR(dereferenceable){ static llvm::Statistic NumIRCS_dereferenceable = {"attributor"
, "NumIRCS_dereferenceable", ("Number of " "call site" " marked '"
"dereferenceable" "'")};; ++(NumIRCS_dereferenceable); }
;
4250 }
4251};
4252
4253// ------------------------ Align Argument Attribute ------------------------
4254
4255static unsigned getKnownAlignForUse(Attributor &A, AAAlign &QueryingAA,
4256 Value &AssociatedValue, const Use *U,
4257 const Instruction *I, bool &TrackUse) {
4258 // We need to follow common pointer manipulation uses to the accesses they
4259 // feed into.
4260 if (isa<CastInst>(I)) {
1
Assuming 'I' is not a 'CastInst'
2
Taking false branch
4261 // Follow all but ptr2int casts.
4262 TrackUse = !isa<PtrToIntInst>(I);
4263 return 0;
4264 }
4265 if (auto *GEP
3.1
'GEP' is null
3.1
'GEP' is null
3.1
'GEP' is null
3.1
'GEP' is null
= dyn_cast<GetElementPtrInst>(I)) {
3
Assuming 'I' is not a 'GetElementPtrInst'
4
Taking false branch
4266 if (GEP->hasAllConstantIndices())
4267 TrackUse = true;
4268 return 0;
4269 }
4270
4271 MaybeAlign MA;
4272 if (const auto *CB
5.1
'CB' is null
5.1
'CB' is null
5.1
'CB' is null
5.1
'CB' is null
= dyn_cast<CallBase>(I)) {
5
Assuming 'I' is not a 'CallBase'
6
Taking false branch
4273 if (CB->isBundleOperand(U) || CB->isCallee(U))
4274 return 0;
4275
4276 unsigned ArgNo = CB->getArgOperandNo(U);
4277 IRPosition IRP = IRPosition::callsite_argument(*CB, ArgNo);
4278 // As long as we only use known information there is no need to track
4279 // dependences here.
4280 auto &AlignAA = A.getAAFor<AAAlign>(QueryingAA, IRP, DepClassTy::NONE);
4281 MA = MaybeAlign(AlignAA.getKnownAlign());
4282 }
4283
4284 const DataLayout &DL = A.getDataLayout();
4285 const Value *UseV = U->get();
7
'UseV' initialized here
4286 if (auto *SI
8.1
'SI' is non-null
8.1
'SI' is non-null
8.1
'SI' is non-null
8.1
'SI' is non-null
= dyn_cast<StoreInst>(I)) {
8
Assuming 'I' is a 'StoreInst'
9
Taking true branch
4287 if (SI->getPointerOperand() == UseV)
10
Assuming pointer value is null
11
Taking true branch
4288 MA = SI->getAlign();
4289 } else if (auto *LI = dyn_cast<LoadInst>(I)) {
4290 if (LI->getPointerOperand() == UseV)
4291 MA = LI->getAlign();
4292 }
4293
4294 if (!MA || *MA <= QueryingAA.getKnownAlign())
12
Calling 'Optional::operator bool'
20
Returning from 'Optional::operator bool'
21
Calling 'operator<='
24
Returning from 'operator<='
25
Taking false branch
4295 return 0;
4296
4297 unsigned Alignment = MA->value();
4298 int64_t Offset;
4299
4300 if (const Value *Base = GetPointerBaseWithConstantOffset(UseV, Offset, DL)) {
26
Passing null pointer value via 1st parameter 'Ptr'
27
Calling 'GetPointerBaseWithConstantOffset'
4301 if (Base == &AssociatedValue) {
4302 // BasePointerAddr + Offset = Alignment * Q for some integer Q.
4303 // So we can say that the maximum power of two which is a divisor of
4304 // gcd(Offset, Alignment) is an alignment.
4305
4306 uint32_t gcd =
4307 greatestCommonDivisor(uint32_t(abs((int32_t)Offset)), Alignment);
4308 Alignment = llvm::PowerOf2Floor(gcd);
4309 }
4310 }
4311
4312 return Alignment;
4313}
4314
4315struct AAAlignImpl : AAAlign {
4316 AAAlignImpl(const IRPosition &IRP, Attributor &A) : AAAlign(IRP, A) {}
4317
4318 /// See AbstractAttribute::initialize(...).
4319 void initialize(Attributor &A) override {
4320 SmallVector<Attribute, 4> Attrs;
4321 getAttrs({Attribute::Alignment}, Attrs);
4322 for (const Attribute &Attr : Attrs)
4323 takeKnownMaximum(Attr.getValueAsInt());
4324
4325 Value &V = getAssociatedValue();
4326 // TODO: This is a HACK to avoid getPointerAlignment to introduce a ptr2int
4327 // use of the function pointer. This was caused by D73131. We want to
4328 // avoid this for function pointers especially because we iterate
4329 // their uses and int2ptr is not handled. It is not a correctness
4330 // problem though!
4331 if (!V.getType()->getPointerElementType()->isFunctionTy())
4332 takeKnownMaximum(V.getPointerAlignment(A.getDataLayout()).value());
4333
4334 if (getIRPosition().isFnInterfaceKind() &&
4335 (!getAnchorScope() ||
4336 !A.isFunctionIPOAmendable(*getAssociatedFunction()))) {
4337 indicatePessimisticFixpoint();
4338 return;
4339 }
4340
4341 if (Instruction *CtxI = getCtxI())
4342 followUsesInMBEC(*this, A, getState(), *CtxI);
4343 }
4344
4345 /// See AbstractAttribute::manifest(...).
4346 ChangeStatus manifest(Attributor &A) override {
4347 ChangeStatus LoadStoreChanged = ChangeStatus::UNCHANGED;
4348
4349 // Check for users that allow alignment annotations.
4350 Value &AssociatedValue = getAssociatedValue();
4351 for (const Use &U : AssociatedValue.uses()) {
4352 if (auto *SI = dyn_cast<StoreInst>(U.getUser())) {
4353 if (SI->getPointerOperand() == &AssociatedValue)
4354 if (SI->getAlignment() < getAssumedAlign()) {
4355 STATS_DECLTRACK(AAAlign, Store,{ static llvm::Statistic NumIRStore_AAAlign = {"attributor", "NumIRStore_AAAlign"
, "Number of times alignment added to a store"};; ++(NumIRStore_AAAlign
); }
4356 "Number of times alignment added to a store"){ static llvm::Statistic NumIRStore_AAAlign = {"attributor", "NumIRStore_AAAlign"
, "Number of times alignment added to a store"};; ++(NumIRStore_AAAlign
); }
;
4357 SI->setAlignment(Align(getAssumedAlign()));
4358 LoadStoreChanged = ChangeStatus::CHANGED;
4359 }
4360 } else if (auto *LI = dyn_cast<LoadInst>(U.getUser())) {
4361 if (LI->getPointerOperand() == &AssociatedValue)
4362 if (LI->getAlignment() < getAssumedAlign()) {
4363 LI->setAlignment(Align(getAssumedAlign()));
4364 STATS_DECLTRACK(AAAlign, Load,{ static llvm::Statistic NumIRLoad_AAAlign = {"attributor", "NumIRLoad_AAAlign"
, "Number of times alignment added to a load"};; ++(NumIRLoad_AAAlign
); }
4365 "Number of times alignment added to a load"){ static llvm::Statistic NumIRLoad_AAAlign = {"attributor", "NumIRLoad_AAAlign"
, "Number of times alignment added to a load"};; ++(NumIRLoad_AAAlign
); }
;
4366 LoadStoreChanged = ChangeStatus::CHANGED;
4367 }
4368 }
4369 }
4370
4371 ChangeStatus Changed = AAAlign::manifest(A);
4372
4373 Align InheritAlign =
4374 getAssociatedValue().getPointerAlignment(A.getDataLayout());
4375 if (InheritAlign >= getAssumedAlign())
4376 return LoadStoreChanged;
4377 return Changed | LoadStoreChanged;
4378 }
4379
4380 // TODO: Provide a helper to determine the implied ABI alignment and check in
4381 // the existing manifest method and a new one for AAAlignImpl that value
4382 // to avoid making the alignment explicit if it did not improve.
4383
4384 /// See AbstractAttribute::getDeducedAttributes
4385 virtual void
4386 getDeducedAttributes(LLVMContext &Ctx,
4387 SmallVectorImpl<Attribute> &Attrs) const override {
4388 if (getAssumedAlign() > 1)
4389 Attrs.emplace_back(
4390 Attribute::getWithAlignment(Ctx, Align(getAssumedAlign())));
4391 }
4392
4393 /// See followUsesInMBEC
4394 bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
4395 AAAlign::StateType &State) {
4396 bool TrackUse = false;
4397
4398 unsigned int KnownAlign =
4399 getKnownAlignForUse(A, *this, getAssociatedValue(), U, I, TrackUse);
4400 State.takeKnownMaximum(KnownAlign);
4401
4402 return TrackUse;
4403 }
4404
4405 /// See AbstractAttribute::getAsStr().
4406 const std::string getAsStr() const override {
4407 return getAssumedAlign() ? ("align<" + std::to_string(getKnownAlign()) +
4408 "-" + std::to_string(getAssumedAlign()) + ">")
4409 : "unknown-align";
4410 }
4411};
4412
4413/// Align attribute for a floating value.
4414struct AAAlignFloating : AAAlignImpl {
4415 AAAlignFloating(const IRPosition &IRP, Attributor &A) : AAAlignImpl(IRP, A) {}
4416
4417 /// See AbstractAttribute::updateImpl(...).
4418 ChangeStatus updateImpl(Attributor &A) override {
4419 const DataLayout &DL = A.getDataLayout();
4420
4421 auto VisitValueCB = [&](Value &V, const Instruction *,
4422 AAAlign::StateType &T, bool Stripped) -> bool {
4423 const auto &AA = A.getAAFor<AAAlign>(*this, IRPosition::value(V),
4424 DepClassTy::REQUIRED);
4425 if (!Stripped && this == &AA) {
4426 int64_t Offset;
4427 unsigned Alignment = 1;
4428 if (const Value *Base =
4429 GetPointerBaseWithConstantOffset(&V, Offset, DL)) {
4430 Align PA = Base->getPointerAlignment(DL);
4431 // BasePointerAddr + Offset = Alignment * Q for some integer Q.
4432 // So we can say that the maximum power of two which is a divisor of
4433 // gcd(Offset, Alignment) is an alignment.
4434
4435 uint32_t gcd = greatestCommonDivisor(uint32_t(abs((int32_t)Offset)),
4436 uint32_t(PA.value()));
4437 Alignment = llvm::PowerOf2Floor(gcd);
4438 } else {
4439 Alignment = V.getPointerAlignment(DL).value();
4440 }
4441 // Use only IR information if we did not strip anything.
4442 T.takeKnownMaximum(Alignment);
4443 T.indicatePessimisticFixpoint();
4444 } else {
4445 // Use abstract attribute information.
4446 const AAAlign::StateType &DS = AA.getState();
4447 T ^= DS;
4448 }
4449 return T.isValidState();
4450 };
4451
4452 StateType T;
4453 if (!genericValueTraversal<StateType>(A, getIRPosition(), *this, T,
4454 VisitValueCB, getCtxI()))
4455 return indicatePessimisticFixpoint();
4456
4457 // TODO: If we know we visited all incoming values, thus no are assumed
4458 // dead, we can take the known information from the state T.
4459 return clampStateAndIndicateChange(getState(), T);
4460 }
4461
4462 /// See AbstractAttribute::trackStatistics()
4463 void trackStatistics() const override { STATS_DECLTRACK_FLOATING_ATTR(align){ static llvm::Statistic NumIRFloating_align = {"attributor",
"NumIRFloating_align", ("Number of floating values known to be '"
"align" "'")};; ++(NumIRFloating_align); }
}
4464};
4465
4466/// Align attribute for function return value.
4467struct AAAlignReturned final
4468 : AAReturnedFromReturnedValues<AAAlign, AAAlignImpl> {
4469 using Base = AAReturnedFromReturnedValues<AAAlign, AAAlignImpl>;
4470 AAAlignReturned(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}
4471
4472 /// See AbstractAttribute::initialize(...).
4473 void initialize(Attributor &A) override {
4474 Base::initialize(A);
4475 Function *F = getAssociatedFunction();
4476 if (!F || F->isDeclaration())
4477 indicatePessimisticFixpoint();
4478 }
4479
4480 /// See AbstractAttribute::trackStatistics()
4481 void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(aligned){ static llvm::Statistic NumIRFunctionReturn_aligned = {"attributor"
, "NumIRFunctionReturn_aligned", ("Number of " "function returns"
" marked '" "aligned" "'")};; ++(NumIRFunctionReturn_aligned
); }
}
4482};
4483
4484/// Align attribute for function argument.
4485struct AAAlignArgument final
4486 : AAArgumentFromCallSiteArguments<AAAlign, AAAlignImpl> {
4487 using Base = AAArgumentFromCallSiteArguments<AAAlign, AAAlignImpl>;
4488 AAAlignArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}
4489
4490 /// See AbstractAttribute::manifest(...).
4491 ChangeStatus manifest(Attributor &A) override {
4492 // If the associated argument is involved in a must-tail call we give up
4493 // because we would need to keep the argument alignments of caller and
4494 // callee in-sync. Just does not seem worth the trouble right now.
4495 if (A.getInfoCache().isInvolvedInMustTailCall(*getAssociatedArgument()))
4496 return ChangeStatus::UNCHANGED;
4497 return Base::manifest(A);
4498 }
4499
4500 /// See AbstractAttribute::trackStatistics()
4501 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(aligned){ static llvm::Statistic NumIRArguments_aligned = {"attributor"
, "NumIRArguments_aligned", ("Number of " "arguments" " marked '"
"aligned" "'")};; ++(NumIRArguments_aligned); }
}
4502};
4503
4504struct AAAlignCallSiteArgument final : AAAlignFloating {
4505 AAAlignCallSiteArgument(const IRPosition &IRP, Attributor &A)
4506 : AAAlignFloating(IRP, A) {}
4507
4508 /// See AbstractAttribute::manifest(...).
4509 ChangeStatus manifest(Attributor &A) override {
4510 // If the associated argument is involved in a must-tail call we give up
4511 // because we would need to keep the argument alignments of caller and
4512 // callee in-sync. Just does not seem worth the trouble right now.
4513 if (Argument *Arg = getAssociatedArgument())
4514 if (A.getInfoCache().isInvolvedInMustTailCall(*Arg))
4515 return ChangeStatus::UNCHANGED;
4516 ChangeStatus Changed = AAAlignImpl::manifest(A);
4517 Align InheritAlign =
4518 getAssociatedValue().getPointerAlignment(A.getDataLayout());
4519 if (InheritAlign >= getAssumedAlign())
4520 Changed = ChangeStatus::UNCHANGED;
4521 return Changed;
4522 }
4523
4524 /// See AbstractAttribute::updateImpl(Attributor &A).
4525 ChangeStatus updateImpl(Attributor &A) override {
4526 ChangeStatus Changed = AAAlignFloating::updateImpl(A);
4527 if (Argument *Arg = getAssociatedArgument()) {
4528 // We only take known information from the argument
4529 // so we do not need to track a dependence.
4530 const auto &ArgAlignAA = A.getAAFor<AAAlign>(
4531 *this, IRPosition::argument(*Arg), DepClassTy::NONE);
4532 takeKnownMaximum(ArgAlignAA.getKnownAlign());
4533 }
4534 return Changed;
4535 }
4536
4537 /// See AbstractAttribute::trackStatistics()
4538 void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(aligned){ static llvm::Statistic NumIRCSArguments_aligned = {"attributor"
, "NumIRCSArguments_aligned", ("Number of " "call site arguments"
" marked '" "aligned" "'")};; ++(NumIRCSArguments_aligned); }
}
4539};
4540
4541/// Align attribute deduction for a call site return value.
4542struct AAAlignCallSiteReturned final
4543 : AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl> {
4544 using Base = AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl>;
4545 AAAlignCallSiteReturned(const IRPosition &IRP, Attributor &A)
4546 : Base(IRP, A) {}
4547
4548 /// See AbstractAttribute::initialize(...).
4549 void initialize(Attributor &A) override {
4550 Base::initialize(A);
4551 Function *F = getAssociatedFunction();
4552 if (!F || F->isDeclaration())
4553 indicatePessimisticFixpoint();
4554 }
4555
4556 /// See AbstractAttribute::trackStatistics()
4557 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(align){ static llvm::Statistic NumIRCS_align = {"attributor", "NumIRCS_align"
, ("Number of " "call site" " marked '" "align" "'")};; ++(NumIRCS_align
); }
; }
4558};
4559
4560/// ------------------ Function No-Return Attribute ----------------------------
4561struct AANoReturnImpl : public AANoReturn {
4562 AANoReturnImpl(const IRPosition &IRP, Attributor &A) : AANoReturn(IRP, A) {}
4563
4564 /// See AbstractAttribute::initialize(...).
4565 void initialize(Attributor &A) override {
4566 AANoReturn::initialize(A);
4567 Function *F = getAssociatedFunction();
4568 if (!F || F->isDeclaration())
4569 indicatePessimisticFixpoint();
4570 }
4571
4572 /// See AbstractAttribute::getAsStr().
4573 const std::string getAsStr() const override {
4574 return getAssumed() ? "noreturn" : "may-return";
4575 }
4576
4577 /// See AbstractAttribute::updateImpl(Attributor &A).
4578 virtual ChangeStatus updateImpl(Attributor &A) override {
4579 auto CheckForNoReturn = [](Instruction &) { return false; };
4580 bool UsedAssumedInformation = false;
4581 if (!A.checkForAllInstructions(CheckForNoReturn, *this,
4582 {(unsigned)Instruction::Ret},
4583 UsedAssumedInformation))
4584 return indicatePessimisticFixpoint();
4585 return ChangeStatus::UNCHANGED;
4586 }
4587};
4588
4589struct AANoReturnFunction final : AANoReturnImpl {
4590 AANoReturnFunction(const IRPosition &IRP, Attributor &A)
4591 : AANoReturnImpl(IRP, A) {}
4592
4593 /// See AbstractAttribute::trackStatistics()
4594 void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(noreturn){ static llvm::Statistic NumIRFunction_noreturn = {"attributor"
, "NumIRFunction_noreturn", ("Number of " "functions" " marked '"
"noreturn" "'")};; ++(NumIRFunction_noreturn); }
}
4595};
4596
4597/// NoReturn attribute deduction for a call sites.
4598struct AANoReturnCallSite final : AANoReturnImpl {
4599 AANoReturnCallSite(const IRPosition &IRP, Attributor &A)
4600 : AANoReturnImpl(IRP, A) {}
4601
4602 /// See AbstractAttribute::initialize(...).
4603 void initialize(Attributor &A) override {
4604 AANoReturnImpl::initialize(A);
4605 if (Function *F = getAssociatedFunction()) {
4606 const IRPosition &FnPos = IRPosition::function(*F);
4607 auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos, DepClassTy::REQUIRED);
4608 if (!FnAA.isAssumedNoReturn())
4609 indicatePessimisticFixpoint();
4610 }
4611 }
4612
4613 /// See AbstractAttribute::updateImpl(...).
4614 ChangeStatus updateImpl(Attributor &A) override {
4615 // TODO: Once we have call site specific value information we can provide
4616 // call site specific liveness information and then it makes
4617 // sense to specialize attributes for call sites arguments instead of
4618 // redirecting requests to the callee argument.
4619 Function *F = getAssociatedFunction();
4620 const IRPosition &FnPos = IRPosition::function(*F);
4621 auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos, DepClassTy::REQUIRED);
4622 return clampStateAndIndicateChange(getState(), FnAA.getState());
4623 }
4624
4625 /// See AbstractAttribute::trackStatistics()
4626 void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(noreturn){ static llvm::Statistic NumIRCS_noreturn = {"attributor", "NumIRCS_noreturn"
, ("Number of " "call site" " marked '" "noreturn" "'")};; ++
(NumIRCS_noreturn); }
; }
4627};
4628
4629/// ----------------------- Variable Capturing ---------------------------------
4630
4631/// A class to hold the state of for no-capture attributes.
4632struct AANoCaptureImpl : public AANoCapture {
4633 AANoCaptureImpl(const IRPosition &IRP, Attributor &A) : AANoCapture(IRP, A) {}
4634
4635 /// See AbstractAttribute::initialize(...).
4636 void initialize(Attributor &A) override {
4637 if (hasAttr(getAttrKind(), /* IgnoreSubsumingPositions */ true)) {
4638 indicateOptimisticFixpoint();
4639 return;
4640 }
4641 Function *AnchorScope = getAnchorScope();
4642 if (isFnInterfaceKind() &&
4643 (!AnchorScope || !A.isFunctionIPOAmendable(*AnchorScope))) {
4644 indicatePessimisticFixpoint();
4645 return;
4646 }
4647
4648 // You cannot "capture" null in the default address space.
4649 if (isa<ConstantPointerNull>(getAssociatedValue()) &&
4650 getAssociatedValue().getType()->getPointerAddressSpace() == 0) {
4651 indicateOptimisticFixpoint();
4652 return;
4653 }
4654
4655 const Function *F =
4656 isArgumentPosition() ? getAssociatedFunction() : AnchorScope;
4657
4658 // Check what state the associated function can actually capture.
4659 if (F)
4660 determineFunctionCaptureCapabilities(getIRPosition(), *F, *this);
4661 else
4662 indicatePessimisticFixpoint();
4663 }
4664
4665 /// See AbstractAttribute::updateImpl(...).
4666 ChangeStatus updateImpl(Attributor &A) override;
4667
4668 /// see AbstractAttribute::isAssumedNoCaptureMaybeReturned(...).
4669 virtual void
4670 getDeducedAttributes(LLVMContext &Ctx,
4671 SmallVectorImpl<Attribute> &Attrs) const override {
4672 if (!isAssumedNoCaptureMaybeReturned())
4673 return;
4674
4675 if (isArgumentPosition()) {
4676 if (isAssumedNoCapture())
4677 Attrs.emplace_back(Attribute::get(Ctx, Attribute::NoCapture));
4678 else if (ManifestInternal)
4679 Attrs.emplace_back(Attribute::get(Ctx, "no-capture-maybe-returned"));
4680 }
4681 }
4682
4683 /// Set the NOT_CAPTURED_IN_MEM and NOT_CAPTURED_IN_RET bits in \p Known
4684 /// depending on the ability of the function associated with \p IRP to capture
4685 /// state in memory and through "returning/throwing", respectively.
4686 static void determineFunctionCaptureCapabilities(const IRPosition &IRP,
4687 const Function &F,
4688 BitIntegerState &State) {
4689 // TODO: Once we have memory behavior attributes we should use them here.
4690
4691 // If we know we cannot communicate or write to memory, we do not care about
4692 // ptr2int anymore.
4693 if (F.onlyReadsMemory() && F.doesNotThrow() &&
4694 F.getReturnType()->isVoidTy()) {
4695 State.addKnownBits(NO_CAPTURE);
4696 return;
4697 }
4698
4699 // A function cannot capture state in memory if it only reads memory, it can
4700 // however return/throw state and the state might be influenced by the
4701 // pointer value, e.g., loading from a returned pointer might reveal a bit.
4702 if (F.onlyReadsMemory())
4703 State.addKnownBits(NOT_CAPTURED_IN_MEM);
4704
4705 // A function cannot communicate state back if it does not through
4706 // exceptions and doesn not return values.
4707 if (F.doesNotThrow() && F.getReturnType()->isVoidTy())
4708 State.addKnownBits(NOT_CAPTURED_IN_RET);
4709
4710 // Check existing "returned" attributes.
4711 int ArgNo = IRP.getCalleeArgNo();
4712 if (F.doesNotThrow() && ArgNo >= 0) {
4713 for (unsigned u = 0, e = F.arg_size(); u < e; ++u)
4714 if (F.hasParamAttribute(u, Attribute::Returned)) {
4715 if (u == unsigned(ArgNo))
4716 State.removeAssumedBits(NOT_CAPTURED_IN_RET);
4717 else if (F.onlyReadsMemory())
4718 State.addKnownBits(NO_CAPTURE);
4719 else
4720 State.addKnownBits(NOT_CAPTURED_IN_RET);
4721 break;
4722 }
4723 }
4724 }
4725
4726 /// See AbstractState::getAsStr().
4727 const std::string getAsStr() const override {
4728 if (isKnownNoCapture())
4729 return "known not-captured";
4730 if (isAssumedNoCapture())
4731 return "assumed not-captured";
4732 if (isKnownNoCaptureMaybeReturned())
4733 return "known not-captured-maybe-returned";
4734 if (isAssumedNoCaptureMaybeReturned())
4735 return "assumed not-captured-maybe-returned";
4736 return "assumed-captured";
4737 }
4738};
4739
4740/// Attributor-aware capture tracker.
4741struct AACaptureUseTracker final : public CaptureTracker {
4742
4743 /// Create a capture tracker that can lookup in-flight abstract attributes
4744 /// through the Attributor \p A.
4745 ///
4746 /// If a use leads to a potential capture, \p CapturedInMemory is set and the
4747 /// search is stopped. If a use leads to a return instruction,
4748 /// \p CommunicatedBack is set to true and \p CapturedInMemory is not changed.
4749 /// If a use leads to a ptr2int which may capture the value,
4750 /// \p CapturedInInteger is set. If a use is found that is currently assumed
4751 /// "no-capture-maybe-returned", the user is added to the \p PotentialCopies
4752 /// set. All values in \p PotentialCopies are later tracked as well. For every
4753 /// explored use we decrement \p RemainingUsesToExplore. Once it reaches 0,
4754 /// the search is stopped with \p CapturedInMemory and \p CapturedInInteger
4755 /// conservatively set to true.
4756 AACaptureUseTracker(Attributor &A, AANoCapture &NoCaptureAA,
4757 const AAIsDead &IsDeadAA, AANoCapture::StateType &State,
4758 SmallSetVector<Value *, 4> &PotentialCopies,
4759 unsigned &RemainingUsesToExplore)
4760 : A(A), NoCaptureAA(NoCaptureAA), IsDeadAA(IsDeadAA), State(State),
4761 PotentialCopies(PotentialCopies),
4762 RemainingUsesToExplore(RemainingUsesToExplore) {}
4763
4764 /// Determine if \p V maybe captured. *Also updates the state!*
4765 bool valueMayBeCaptured(const Value *V) {
4766 if (V->getType()->isPointerTy()) {
4767 PointerMayBeCaptured(V, this);
4768 } else {
4769 State.indicatePessimisticFixpoint();
4770 }
4771 return State.isAssumed(AANoCapture::NO_CAPTURE_MAYBE_RETURNED);
4772 }
4773
4774 /// See CaptureTracker::tooManyUses().
4775 void tooManyUses() override {
4776 State.removeAssumedBits(AANoCapture::NO_CAPTURE);
4777 }
4778
4779 bool isDereferenceableOrNull(Value *O, const DataLayout &DL) override {
4780 if (CaptureTracker::isDereferenceableOrNull(O, DL))
4781 return true;
4782 const auto &DerefAA = A.getAAFor<AADereferenceable>(
4783 NoCaptureAA, IRPosition::value(*O), DepClassTy::OPTIONAL);
4784 return DerefAA.getAssumedDereferenceableBytes();
4785 }
4786
4787 /// See CaptureTracker::captured(...).
4788 bool captured(const Use *U) override {
4789 Instruction *UInst = cast<Instruction>(U->getUser());
4790 LLVM_DEBUG(dbgs() << "Check use: " << *U->get() << " in " << *UInstdo { } while (false)
4791 << "\n")do { } while (false);
4792
4793 // Because we may reuse the tracker multiple times we keep track of the
4794 // number of explored uses ourselves as well.
4795 if (RemainingUsesToExplore-- == 0) {
4796 LLVM_DEBUG(dbgs() << " - too many uses to explore!\n")do { } while (false);
4797 return isCapturedIn(/* Memory */ true, /* Integer */ true,
4798 /* Return */ true);
4799 }
4800
4801 // Deal with ptr2int by following uses.
4802 if (isa<PtrToIntInst>(UInst)) {
4803 LLVM_DEBUG(dbgs() << " - ptr2int assume the worst!\n")do { } while (false);
4804 return valueMayBeCaptured(UInst);
4805 }
4806
4807 // For stores we check if we can follow the value through memory or not.
4808 if (auto *SI = dyn_cast<StoreInst>(UInst)) {
4809 if (SI->isVolatile())
4810 return isCapturedIn(/* Memory */ true, /* Integer */ false,
4811 /* Return */ false);
4812 bool UsedAssumedInformation = false;
4813 if (!AA::getPotentialCopiesOfStoredValue(
4814 A, *SI, PotentialCopies, NoCaptureAA, UsedAssumedInformation))
4815 return isCapturedIn(/* Memory */ true, /* Integer */ false,
4816 /* Return */ false);
4817 // Not captured directly, potential copies will be checked.
4818 return isCapturedIn(/* Memory */ false, /* Integer */ false,
4819 /* Return */ false);
4820 }
4821
4822 // Explicitly catch return instructions.
4823 if (isa<ReturnInst>(UInst)) {
4824 if (UInst->getFunction() == NoCaptureAA.getAnchorScope())
4825 return isCapturedIn(/* Memory */ false, /* Integer */ false,
4826 /* Return */ true);
4827 return isCapturedIn(/* Memory */ true, /* Integer */ true,
4828 /* Return */ true);
4829 }
4830
4831 // For now we only use special logic for call sites. However, the tracker
4832 // itself knows about a lot of other non-capturing cases already.
4833 auto *CB = dyn_cast<CallBase>(UInst);
4834 if (!CB || !CB->isArgOperand(U))
4835 return isCapturedIn(/* Memory */ true, /* Integer */ true,
4836 /* Return */ true);
4837
4838 unsigned ArgNo = CB->getArgOperandNo(U);
4839 const IRPosition &CSArgPos = IRPosition::callsite_argument(*CB, ArgNo);
4840 // If we have a abstract no-capture attribute for the argument we can use
4841 // it to justify a non-capture attribute here. This allows recursion!
4842 auto &ArgNoCaptureAA =
4843 A.getAAFor<AANoCapture>(NoCaptureAA, CSArgPos, DepClassTy::REQUIRED);
4844 if (ArgNoCaptureAA.isAssumedNoCapture())
4845 return isCapturedIn(/* Memory */ false, /* Integer */ false,
4846 /* Return */ false);
4847 if (ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
4848 addPotentialCopy(*CB);
4849 return isCapturedIn(/* Memory */ false, /* Integer */ false,
4850 /* Return */ false);
4851 }
4852
4853 // Lastly, we could not find a reason no-capture can be assumed so we don't.
4854 return isCapturedIn(/* Memory */ true, /* Integer */ true,
4855 /* Return */ true);
4856 }
4857
4858 /// Register \p CS as potential copy of the value we are checking.
4859 void addPotentialCopy(CallBase &CB) { PotentialCopies.insert(&CB); }
4860
4861 /// See CaptureTracker::shouldExplore(...).
4862 bool shouldExplore(const Use *U) override {
4863 // Check liveness and ignore droppable users.
4864 bool UsedAssumedInformation = false;
4865 return !U->getUser()->isDroppable() &&
4866 !A.isAssumedDead(*U, &NoCaptureAA, &IsDeadAA,
4867 UsedAssumedInformation);
4868 }
4869
4870 /// Update the state according to \p CapturedInMem, \p CapturedInInt, and
4871 /// \p CapturedInRet, then return the appropriate value for use in the
4872 /// CaptureTracker::captured() interface.
4873 bool isCapturedIn(bool CapturedInMem, bool CapturedInInt,
4874 bool CapturedInRet) {
4875 LLVM_DEBUG(dbgs() << " - captures [Mem " << CapturedInMem << "|Int "do { } while (false)
4876 << CapturedInInt << "|Ret " << CapturedInRet << "]\n")do { } while (false);
4877 if (CapturedInMem)
4878 State.removeAssumedBits(AANoCapture::NOT_CAPTURED_IN_MEM);
4879 if (CapturedInInt)
4880 State.removeAssumedBits(AANoCapture::NOT_CAPTURED_IN_INT);
4881 if (CapturedInRet)
4882 State.removeAssumedBits(AANoCapture::NOT_CAPTURED_IN_RET);
4883 return !State.isAssumed(AANoCapture::NO_CAPTURE_MAYBE_RETURNED);
4884 }
4885
4886private:
4887 /// The attributor providing in-flight abstract attributes.
4888 Attributor &A;
4889
4890 /// The abstract attribute currently updated.
4891 AANoCapture &NoCaptureAA;
4892
4893 /// The abstract liveness state.
4894 const AAIsDead &IsDeadAA;
4895
4896 /// The state currently updated.
4897 AANoCapture::StateType &State;
4898
4899 /// Set of potential copies of the tracked value.
4900 SmallSetVector<Value *, 4> &PotentialCopies;
4901
4902 /// Global counter to limit the number of explored uses.
4903 unsigned &RemainingUsesToExplore;
4904};
4905
4906ChangeStatus AANoCaptureImpl::updateImpl(Attributor &A) {
4907 const IRPosition &IRP = getIRPosition();
4908 Value *V = isArgumentPosition() ? IRP.getAssociatedArgument()
4909 : &IRP.getAssociatedValue();
4910 if (!V)
4911 return indicatePessimisticFixpoint();
4912
4913 const Function *F =
4914 isArgumentPosition() ? IRP.getAssociatedFunction() : IRP.getAnchorScope();
4915 assert(F && "Expected a function!")((void)0);
4916 const IRPosition &FnPos = IRPosition::function(*F);
4917 const auto &IsDeadAA = A.getAAFor<AAIsDead>(*this, FnPos, DepClassTy::NONE);
4918
4919 AANoCapture::StateType T;
4920
4921 // Readonly means we cannot capture through memory.
4922 const auto &FnMemAA =
4923 A.getAAFor<AAMemoryBehavior>(*this, FnPos, DepClassTy::NONE);
4924 if (FnMemAA.isAssumedReadOnly()) {
4925 T.addKnownBits(NOT_CAPTURED_IN_MEM);
4926 if (FnMemAA.isKnownReadOnly())
4927 addKnownBits(NOT_CAPTURED_IN_MEM);
4928 else
4929 A.recordDependence(FnMemAA, *this, DepClassTy::OPTIONAL);
4930 }
4931
4932 // Make sure all returned values are different than the underlying value.
4933 // TODO: we could do this in a more sophisticated way inside
4934 // AAReturnedValues, e.g., track all values that escape through returns
4935 // directly somehow.
4936 auto CheckReturnedArgs = [&](const AAReturnedValues &RVAA) {
4937 bool SeenConstant = false;
4938 for (auto &It : RVAA.returned_values()) {
4939 if (isa<Constant>(It.first)) {
4940 if (SeenConstant)
4941 return false;
4942 SeenConstant = true;
4943 } else if (!isa<Argument>(It.first) ||
4944 It.first == getAssociatedArgument())
4945 return false;
4946 }
4947 return true;
4948 };
4949
4950 const auto &NoUnwindAA =
4951 A.getAAFor<AANoUnwind>(*this, FnPos, DepClassTy::OPTIONAL);
4952 if (NoUnwindAA.isAssumedNoUnwind()) {
4953 bool IsVoidTy = F->getReturnType()->isVoidTy();
4954 const AAReturnedValues *RVAA =
4955 IsVoidTy ? nullptr
4956 : &A.getAAFor<AAReturnedValues>(*this, FnPos,
4957
4958 DepClassTy::OPTIONAL);
4959 if (IsVoidTy || CheckReturnedArgs(*RVAA)) {
4960 T.addKnownBits(NOT_CAPTURED_IN_RET);
4961 if (T.isKnown(NOT_CAPTURED_IN_MEM))
4962 return ChangeStatus::UNCHANGED;
4963 if (NoUnwindAA.isKnownNoUnwind() &&
4964 (IsVoidTy || RVAA->getState().isAtFixpoint())) {
4965 addKnownBits(NOT_CAPTURED_IN_RET);
4966 if (isKnown(NOT_CAPTURED_IN_MEM))
4967 return indicateOptimisticFixpoint();
4968 }
4969 }
4970 }
4971
4972 // Use the CaptureTracker interface and logic with the specialized tracker,
4973 // defined in AACaptureUseTracker, that can look at in-flight abstract
4974 // attributes and directly updates the assumed state.
4975 SmallSetVector<Value *, 4> PotentialCopies;
4976 unsigned RemainingUsesToExplore =
4977 getDefaultMaxUsesToExploreForCaptureTracking();
4978 AACaptureUseTracker Tracker(A, *this, IsDeadAA, T, PotentialCopies,
4979 RemainingUsesToExplore);
4980
4981 // Check all potential copies of the associated value until we can assume
4982 // none will be captured or we have to assume at least one might be.
4983 unsigned Idx = 0;
4984 PotentialCopies.insert(V);
4985 while (T.isAssumed(NO_CAPTURE_MAYBE_RETURNED) && Idx < PotentialCopies.size())
4986 Tracker.valueMayBeCaptured(PotentialCopies[Idx++]);
4987
4988 AANoCapture::StateType &S = getState();
4989 auto Assumed = S.getAssumed();
4990 S.intersectAssumedBits(T.getAssumed());
4991 if (!isAssumedNoCaptureMaybeReturned())
4992 return indicatePessimisticFixpoint();
4993 return Assumed == S.getAssumed() ? ChangeStatus::UNCHANGED
4994 : ChangeStatus::CHANGED;
4995}
4996
4997/// NoCapture attribute for function arguments.
4998struct AANoCaptureArgument final : AANoCaptureImpl {
4999 AANoCaptureArgument(const IRPosition &IRP, Attributor &A)
5000 : AANoCaptureImpl(IRP, A) {}
5001
5002 /// See AbstractAttribute::trackStatistics()
5003 void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nocapture){ static llvm::Statistic NumIRArguments_nocapture = {"attributor"
, "NumIRArguments_nocapture", ("Number of " "arguments" " marked '"
"nocapture" "'")};; ++(NumIRArguments_nocapture); }
}
5004};
5005
5006/// NoCapture attribute for call site arguments.
5007struct AANoCaptureCallSiteArgument final : AANoCaptureImpl {
5008 AANoCaptureCallSiteArgument(const IRPosition &IRP, Attributor &A)
5009 : AANoCaptureImpl(IRP, A) {}
5010
5011 /// See AbstractAttribute::initialize(...).
5012 void initialize(Attributor &A) override {
5013 if (Argument *Arg = getAssociatedArgument())
5014 if (Arg->hasByValAttr())
5015 indicateOptimisticFixpoint();
5016 AANoCaptureImpl::initialize(A);
5017 }
5018
5019 /// See AbstractAttribute::updateImpl(...).
5020 ChangeStatus updateImpl(Attributor &A) override {
5021 // TODO: Once we have call site specific value information we can provide
5022 // call site specific liveness information and then it makes
5023 // sense to specialize attributes for call sites arguments instead of
5024 // redirecting requests to the callee argument.
5025 Argument *Arg = getAssociatedArgument();
5026 if (!Arg)
5027 return indicatePessimisticFixpoint();
5028 const IRPosition &ArgPos = IRPosition::argument(*Arg);
5029 auto &ArgAA = A.getAAFor<AANoCapture>(*this, ArgPos, DepClassTy::REQUIRED);
5030 return clampStateAndIndicateChange(getState(), ArgAA.getState());
5031 }
5032
5033 /// See AbstractAttribute::trackStatistics()
5034 void trackStatistics() const override{STATS_DECLTRACK_CSARG_ATTR(nocapture){ static llvm::Statistic NumIRCSArguments_nocapture = {"attributor"
, "NumIRCSArguments_nocapture", ("Number of " "call site arguments"
" marked '" "nocapture" "'")};; ++(NumIRCSArguments_nocapture
); }
};
5035};
5036
5037/// NoCapture attribute for floating values.
5038struct AANoCaptureFloating final : AANoCaptureImpl {
5039 AANoCaptureFloating(const IRPosition &IRP, Attributor &A)
5040 : AANoCaptureImpl(IRP, A) {}
5041
5042 /// See AbstractAttribute::trackStatistics()
5043 void trackStatistics() const override {
5044 STATS_DECLTRACK_FLOATING_ATTR(nocapture){ static llvm::Statistic NumIRFloating_nocapture = {"attributor"
, "NumIRFloating_nocapture", ("Number of floating values known to be '"
"nocapture" "'")};; ++(NumIRFloating_nocapture); }
5045 }
5046};
5047
5048/// NoCapture attribute for function return value.
5049struct AANoCaptureReturned final : AANoCaptureImpl {
5050 AANoCaptureReturned(const IRPosition &IRP, Attributor &A)
5051 : AANoCaptureImpl(IRP, A) {
5052 llvm_unreachable("NoCapture is not applicable to function returns!")__builtin_unreachable();
5053 }
5054
5055 /// See AbstractAttribute::initialize(...).
5056 void initialize(Attributor &A) override {
5057 llvm_unreachable("NoCapture is not applicable to function returns!")__builtin_unreachable();
5058 }
5059
5060 /// See AbstractAttribute::updateImpl(...).
5061 ChangeStatus updateImpl(Attributor &A) override {
5062 llvm_unreachable("NoCapture is not applicable to function returns!")__builtin_unreachable();
5063 }
5064
5065 /// See AbstractAttribute::trackStatistics()
5066 void trackStatistics() const override {}
5067};
5068
5069/// NoCapture attribute deduction for a call site return value.
5070struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
5071 AANoCaptureCallSiteReturned(const IRPosition &IRP, Attributor &A)
5072 : AANoCaptureImpl(IRP, A) {}
5073
5074 /// See AbstractAttribute::initialize(...).
5075 void initialize(Attributor &A) override {
5076 const Function *F = getAnchorScope();
5077 // Check what state the associated function can actually capture.
5078 determineFunctionCaptureCapabilities(getIRPosition(), *F, *this);
5079 }
5080
5081 /// See AbstractAttribute::trackStatistics()
5082 void trackStatistics() const override {
5083 STATS_DECLTRACK_CSRET_ATTR(nocapture){ static llvm::Statistic NumIRCSReturn_nocapture = {"attributor"
, "NumIRCSReturn_nocapture", ("Number of " "call site returns"
" marked '" "nocapture" "'")};; ++(NumIRCSReturn_nocapture);
}
5084 }
5085};
5086
5087/// ------------------ Value Simplify Attribute ----------------------------
5088
5089bool ValueSimplifyStateType::unionAssumed(Optional<Value *> Other) {
5090 // FIXME: Add a typecast support.
5091 SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
5092 SimplifiedAssociatedValue, Other, Ty);
5093 if (SimplifiedAssociatedValue == Optional<Value *>(nullptr))
5094 return false;
5095
5096 LLVM_DEBUG({do { } while (false)
5097 if (SimplifiedAssociatedValue.hasValue())do { } while (false)
5098 dbgs() << "[ValueSimplify] is assumed to be "do { } while (false)
5099 << **SimplifiedAssociatedValue << "\n";do { } while (false)
5100 elsedo { } while (false)
5101 dbgs() << "[ValueSimplify] is assumed to be <none>\n";do { } while (false)
5102 })do { } while (false);
5103 return true;
5104}
5105
5106struct AAValueSimplifyImpl : AAValueSimplify {
5107 AAValueSimplifyImpl(const IRPosition &IRP, Attributor &A)
5108 : AAValueSimplify(IRP, A) {}
5109
5110 /// See AbstractAttribute::initialize(...).
5111 void initialize(Attributor &A) override {
5112 if (getAssociatedValue().getType()->isVoidTy())
5113 indicatePessimisticFixpoint();
5114 if (A.hasSimplificationCallback(getIRPosition()))
5115 indicatePessimisticFixpoint();
5116 }
5117
5118 /// See AbstractAttribute::getAsStr().
5119 const std::string getAsStr() const override {
5120 LLVM_DEBUG({do { } while (false)
5121 errs() << "SAV: " << SimplifiedAssociatedValue << " ";do { } while (false)
5122 if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue)do { } while (false)
5123 errs() << "SAV: " << **SimplifiedAssociatedValue << " ";do { } while (false)
5124 })do { } while (false);
5125 return isValidState() ? (isAtFixpoint() ? "simplified" : "maybe-simple")
5126 : "not-simple";
5127 }
5128
5129 /// See AbstractAttribute::trackStatistics()
5130 void trackStatistics() const override {}
5131
5132 /// See AAValueSimplify::getAssumedSimplifiedValue()
5133 Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
5134 return SimplifiedAssociatedValue;
5135 }
5136
5137 /// Return a value we can use as replacement for the associated one, or
5138 /// nullptr if we don't have one that makes sense.
5139 Value *getReplacementValue(Attributor &A) const {
5140 Value *NewV;
5141 NewV = SimplifiedAssociatedValue.hasValue()
5142 ? SimplifiedAssociatedValue.getValue()
5143 : UndefValue::get(getAssociatedType());
5144 if (!NewV)
5145 return nullptr;
5146 NewV = AA::getWithType(*NewV, *getAssociatedType());
5147 if (!NewV || NewV == &getAssociatedValue())
5148 return nullptr;
5149 const Instruction *CtxI = getCtxI();
5150 if (CtxI && !AA::isValidAtPosition(*NewV, *CtxI, A.getInfoCache()))
5151 return nullptr;
5152 if (!CtxI && !AA::isValidInScope(*NewV, getAnchorScope()))
5153 return nullptr;
5154 return NewV;
5155 }
5156
5157 /// Helper function for querying AAValueSimplify and updating candicate.
5158 /// \param IRP The value position we are trying to unify with SimplifiedValue
5159 bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
5160 const IRPosition &IRP, bool Simplify = true) {
5161 bool UsedAssumedInformation = false;
5162 Optional<Value *> QueryingValueSimplified = &IRP.getAssociatedValue();
5163 if (Simplify)
5164 QueryingValueSimplified =
5165 A.getAssumedSimplified(IRP, QueryingAA, UsedAssumedInformation);
5166 return unionAssumed(QueryingValueSimplified);
5167 }
5168
5169 /// Returns a candidate is found or not
5170 template <typename AAType> bool askSimplifiedValueFor(Attributor &A) {
5171 if (!getAssociatedValue().getType()->isIntegerTy())
5172 return false;
5173
5174 // This will also pass the call base context.
5175 const auto &AA =
5176 A.getAAFor<AAType>(*this, getIRPosition(), DepClassTy::NONE);
5177
5178 Optional<ConstantInt *> COpt = AA.getAssumedConstantInt(A);
5179
5180 if (!COpt.hasValue()) {
5181 SimplifiedAssociatedValue = llvm::None;
5182 A.recordDependence(AA, *this, DepClassTy::OPTIONAL);
5183 return true;
5184 }
5185 if (auto *C = COpt.getValue()) {
5186 SimplifiedAssociatedValue = C;
5187 A.recordDependence(AA, *this, DepClassTy::OPTIONAL);
5188 return true;
5189 }
5190 return false;
5191 }
5192
5193 bool askSimplifiedValueForOtherAAs(Attributor &A) {
5194 if (askSimplifiedValueFor<AAValueConstantRange>(A))
5195 return true;
5196 if (askSimplifiedValueFor<AAPotentialValues>(A))
5197 return true;
5198 return false;
5199 }
5200
5201 /// See AbstractAttribute::manifest(...).
5202 ChangeStatus manifest(Attributor &A) override {
5203 ChangeStatus Changed = ChangeStatus::UNCHANGED;
5204 if (getAssociatedValue().user_empty())
5205 return Changed;
5206
5207 if (auto *NewV = getReplacementValue(A)) {
5208 LLVM_DEBUG(dbgs() << "[ValueSimplify] " << getAssociatedValue() << " -> "do { } while (false)
5209 << *NewV << " :: " << *this << "\n")do { } while (false);
5210 if (A.changeValueAfterManifest(getAssociatedValue(), *NewV))
5211 Changed = ChangeStatus::CHANGED;
5212 }
5213
5214 return Changed | AAValueSimplify::manifest(A);
5215 }
5216
5217 /// See AbstractState::indicatePessimisticFixpoint(...).
5218 ChangeStatus indicatePessimisticFixpoint() override {
5219 SimplifiedAssociatedValue = &getAssociatedValue();
5220 return AAValueSimplify::indicatePessimisticFixpoint();
5221 }
5222
5223 static bool handleLoad(Attributor &A, const AbstractAttribute &AA,
5224 LoadInst &L, function_ref<bool(Value &)> Union) {
5225 auto UnionWrapper = [&](Value &V, Value &Obj) {
5226 if (isa<AllocaInst>(Obj))
5227 return Union(V);
5228 if (!AA::isDynamicallyUnique(A, AA, V))
5229 return false;
5230 if (!AA::isValidAtPosition(V, L, A.getInfoCache()))
5231 return false;
5232 return Union(V);
5233 };
5234
5235 Value &Ptr = *L.getPointerOperand();
5236 SmallVector<Value *, 8> Objects;
5237 if (!AA::getAssumedUnderlyingObjects(A, Ptr, Objects, AA, &L))
5238 return false;
5239
5240 for (Value *Obj : Objects) {
5241 LLVM_DEBUG(dbgs() << "Visit underlying object " << *Obj << "\n")do { } while (false);
5242 if (isa<UndefValue>(Obj))
5243 continue;
5244 if (isa<ConstantPointerNull>(Obj)) {
5245 // A null pointer access can be undefined but any offset from null may
5246 // be OK. We do not try to optimize the latter.
5247 bool UsedAssumedInformation = false;
5248 if (!NullPointerIsDefined(L.getFunction(),
5249 Ptr.getType()->getPointerAddressSpace()) &&
5250 A.getAssumedSimplified(Ptr, AA, UsedAssumedInformation) == Obj)
5251 continue;
5252 return false;
5253 }
5254 if (!isa<AllocaInst>(Obj) && !isa<GlobalVariable>(Obj))
5255 return false;
5256 Constant *InitialVal = AA::getInitialValueForObj(*Obj, *L.getType());
5257 if (!InitialVal || !Union(*InitialVal))
5258 return false;
5259
5260 LLVM_DEBUG(dbgs() << "Underlying object amenable to load-store "do { } while (false)
5261 "propagation, checking accesses next.\n")do { } while (false);
5262
5263 auto CheckAccess = [&](const AAPointerInfo::Access &Acc, bool IsExact) {
5264 LLVM_DEBUG(dbgs() << " - visit access " << Acc << "\n")do { } while (false);
5265 if (!Acc.isWrite())
5266 return true;
5267 if (Acc.isWrittenValueYetUndetermined())
5268 return true;
5269 Value *Content = Acc.getWrittenValue();
5270 if (!Content)
5271 return false;
5272 Value *CastedContent =
5273 AA::getWithType(*Content, *AA.getAssociatedType());
5274 if (!CastedContent)
5275 return false;
5276 if (IsExact)
5277 return UnionWrapper(*CastedContent, *Obj);
5278 if (auto *C = dyn_cast<Constant>(CastedContent))
5279 if (C->isNullValue() || C->isAllOnesValue() || isa<UndefValue>(C))
5280 return UnionWrapper(*CastedContent, *Obj);
5281 return false;
5282 };
5283
5284 auto &PI = A.getAAFor<AAPointerInfo>(AA, IRPosition::value(*Obj),
5285 DepClassTy::REQUIRED);
5286 if (!PI.forallInterferingAccesses(L, CheckAccess))
5287 return false;
5288 }
5289 return true;
5290 }
5291};
5292
5293struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
5294 AAValueSimplifyArgument(const IRPosition &IRP, Attributor &A)
5295 : AAValueSimplifyImpl(IRP, A) {}
5296
5297 void initialize(Attributor &A) override {
5298 AAValueSimplifyImpl::initialize(A);
5299 if (!getAnchorScope() || getAnchorScope()->isDeclaration())
5300 indicatePessimisticFixpoint();
5301 if (hasAttr({Attribute::InAlloca, Attribute::Preallocated,
5302 Attribute::StructRet, Attribute::Nest, Attribute::ByVal},
5303 /* IgnoreSubsumingPositions */ true))
5304 indicatePessimisticFixpoint();
5305
5306 // FIXME: This is a hack to prevent us from propagating function poiner in
5307 // the new pass manager CGSCC pass as it creates call edges the
5308 // CallGraphUpdater cannot handle yet.
5309 Value &V = getAssociatedValue();
5310 if (V.getType()->isPointerTy() &&
5311 V.getType()->getPointerElementType()->isFunctionTy() &&
5312 !A.isModulePass())
5313 indicatePessimisticFixpoint();
5314 }
5315
5316 /// See AbstractAttribute::updateImpl(...).
5317 ChangeStatus updateImpl(Attributor &A) override {
5318 // Byval is only replacable if it is readonly otherwise we would write into
5319 // the replaced value and not the copy that byval creates implicitly.
5320 Argument *Arg = getAssociatedArgument();
5321 if (Arg->hasByValAttr()) {
5322 // TODO: We probably need to verify synchronization is not an issue, e.g.,
5323 // there is no race by not copying a constant byval.
5324 const auto &MemAA = A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(),
5325 DepClassTy::REQUIRED);
5326 if (!MemAA.isAssumedReadOnly())
5327 return indicatePessimisticFixpoint();
5328 }
5329
5330 auto Before = SimplifiedAssociatedValue;
5331
5332 auto PredForCallSite = [&](AbstractCallSite ACS) {
5333 const IRPosition &ACSArgPos =
5334 IRPosition::callsite_argument(ACS, getCallSiteArgNo());
5335 // Check if a coresponding argument was found or if it is on not
5336 // associated (which can happen for callback calls).
5337 if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
5338 return false;
5339
5340 // Simplify the argument operand explicitly and check if the result is
5341 // valid in the current scope. This avoids refering to simplified values
5342 // in other functions, e.g., we don't want to say a an argument in a
5343 // static function is actually an argument in a different function.
5344 bool UsedAssumedInformation = false;
5345 Optional<Constant *> SimpleArgOp =
5346 A.getAssumedConstant(ACSArgPos, *this, UsedAssumedInformation);
5347 if (!SimpleArgOp.hasValue())
5348 return true;
5349 if (!SimpleArgOp.getValue())
5350 return false;
5351 if (!AA::isDynamicallyUnique(A, *this, **SimpleArgOp))
5352 return false;
5353 return unionAssumed(*SimpleArgOp);
5354 };
5355
5356 // Generate a answer specific to a call site context.
5357 bool Success;
5358 bool AllCallSitesKnown;
5359 if (hasCallBaseContext() &&
5360 getCallBaseContext()->getCalledFunction() == Arg->getParent())
5361 Success = PredForCallSite(
5362 AbstractCallSite(&getCallBaseContext()->getCalledOperandUse()));
5363 else
5364 Success = A.checkForAllCallSites(PredForCallSite, *this, true,
5365 AllCallSitesKnown);
5366
5367 if (!Success)
5368 if (!askSimplifiedValueForOtherAAs(A))
5369 return indicatePessimisticFixpoint();
5370
5371 // If a candicate was found in this update, return CHANGED.
5372 return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
5373 : ChangeStatus ::CHANGED;
5374 }
5375
5376 /// See AbstractAttribute::trackStatistics()
5377 void trackStatistics() const override {
5378 STATS_DECLTRACK_ARG_ATTR(value_simplify){ static llvm::Statistic NumIRArguments_value_simplify = {"attributor"
, "NumIRArguments_value_simplify", ("Number of " "arguments" " marked '"
"value_simplify" "'")};; ++(NumIRArguments_value_simplify); }
5379 }
5380};
5381
5382struct AAValueSimplifyReturned : AAValueSimplifyImpl {
5383 AAValueSimplifyReturned(const IRPosition &IRP, Attributor &A)
5384 : AAValueSimplifyImpl(IRP, A) {}
5385
5386 /// See AAValueSimplify::getAssumedSimplifiedValue()
5387 Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
5388 if (!isValidState())
5389 return nullptr;
5390 return SimplifiedAssociatedValue;
5391 }
5392
5393 /// See AbstractAttribute::updateImpl(...).
5394 ChangeStatus updateImpl(Attributor &A) override {
5395 auto Before = SimplifiedAssociatedValue;
5396
5397 auto PredForReturned = [&](Value &V) {
5398 return checkAndUpdate(A, *this,
5399 IRPosition::value(V, getCallBaseContext()));
5400 };
5401
5402 if (!A.checkForAllReturnedValues(PredForReturned, *this))
5403 if (!askSimplifiedValueForOtherAAs(A))
5404 return indicatePessimisticFixpoint();
5405
5406 // If a candicate was found in this update, return CHANGED.
5407 return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
5408 : ChangeStatus ::CHANGED;
5409 }
5410
5411 ChangeStatus manifest(Attributor &A) override {
5412 ChangeStatus Changed = ChangeStatus::UNCHANGED;
5413
5414 if (auto *NewV = getReplacementValue(A)) {
5415 auto PredForReturned =
5416 [&](Value &, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
5417 for (ReturnInst *RI : RetInsts) {
5418 Value *ReturnedVal = RI->getReturnValue();
5419 if (ReturnedVal == NewV || isa<UndefValue>(ReturnedVal))
5420 return true;
5421 assert(RI->getFunction() == getAnchorScope() &&((void)0)
5422 "ReturnInst in wrong function!")((void)0);
5423 LLVM_DEBUG(dbgs()do { } while (false)
5424 << "[ValueSimplify] " << *ReturnedVal << " -> "do { } while (false)
5425 << *NewV << " in " << *RI << " :: " << *this << "\n")do { } while (false);
5426 if (A.changeUseAfterManifest(RI->getOperandUse(0), *NewV))
5427 Changed = ChangeStatus::CHANGED;
5428 }
5429 return true;
5430 };
5431 A.checkForAllReturnedValuesAndReturnInsts(PredForReturned, *this);
5432 }
5433
5434 return Changed | AAValueSimplify::manifest(A);
5435 }
5436
5437 /// See AbstractAttribute::trackStatistics()
5438 void trackStatistics() const override {
5439 STATS_DECLTRACK_FNRET_ATTR(value_simplify){ static llvm::Statistic NumIRFunctionReturn_value_simplify =
{"attributor", "NumIRFunctionReturn_value_simplify", ("Number of "
"function returns" " marked '" "value_simplify" "'")};; ++(NumIRFunctionReturn_value_simplify
); }
5440 }
5441};
5442
5443struct AAValueSimplifyFloating : AAValueSimplifyImpl {
5444 AAValueSimplifyFloating(const IRPosition &IRP, Attributor &A)
5445 : AAValueSimplifyImpl(IRP, A) {}
5446
5447 /// See AbstractAttribute::initialize(...).
5448 void initialize(Attributor &A) override {
5449 AAValueSimplifyImpl::initialize(A);
5450 Value &V = getAnchorValue();
5451
5452 // TODO: add other stuffs
5453 if (isa<Constant>(V))
5454 indicatePessimisticFixpoint();
5455 }
5456
5457 /// Check if \p Cmp is a comparison we can simplify.
5458 ///
5459 /// We handle multiple cases, one in which at least one operand is an
5460 /// (assumed) nullptr. If so, try to simplify it using AANonNull on the other
5461 /// operand. Return true if successful, in that case SimplifiedAssociatedValue
5462 /// will be updated.
5463 bool handleCmp(Attributor &A, CmpInst &Cmp) {
5464 auto Union = [&](Value &V) {
5465 SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
5466 SimplifiedAssociatedValue, &V, V.getType());
5467 return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
5468 };
5469
5470 Value *LHS = Cmp.getOperand(0);
5471 Value *RHS = Cmp.getOperand(1);
5472
5473 // Simplify the operands first.
5474 bool UsedAssumedInformation = false;
5475 const auto &SimplifiedLHS =
5476 A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
5477 *this, UsedAssumedInformation);
5478 if (!SimplifiedLHS.hasValue())
5479 return true;
5480 if (!SimplifiedLHS.getValue())
5481 return false;
5482 LHS = *SimplifiedLHS;
5483
5484 const auto &SimplifiedRHS =
5485 A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
5486 *this, UsedAssumedInformation);
5487 if (!SimplifiedRHS.hasValue())
5488 return true;
5489 if (!SimplifiedRHS.getValue())
5490 return false;
5491 RHS = *SimplifiedRHS;
5492
5493 LLVMContext &Ctx = Cmp.getContext();
5494 // Handle the trivial case first in which we don't even need to think about
5495 // null or non-null.
5496 if (LHS == RHS && (Cmp.isTrueWhenEqual() || Cmp.isFalseWhenEqual())) {
5497 Constant *NewVal =
5498 ConstantInt::get(Type::getInt1Ty(Ctx), Cmp.isTrueWhenEqual());
5499 if (!Union(*NewVal))
5500 return false;
5501 if (!UsedAssumedInformation)
5502 indicateOptimisticFixpoint();
5503 return true;
5504 }
5505
5506 // From now on we only handle equalities (==, !=).
5507 ICmpInst *ICmp = dyn_cast<ICmpInst>(&Cmp);
5508 if (!ICmp || !ICmp->isEquality())
5509 return false;
5510
5511 bool LHSIsNull = isa<ConstantPointerNull>(LHS);
5512 bool RHSIsNull = isa<ConstantPointerNull>(RHS);
5513 if (!LHSIsNull && !RHSIsNull)
5514 return false;
5515
5516 // Left is the nullptr ==/!= non-nullptr case. We'll use AANonNull on the
5517 // non-nullptr operand and if we assume it's non-null we can conclude the
5518 // result of the comparison.
5519 assert((LHSIsNull || RHSIsNull) &&((void)0)
5520 "Expected nullptr versus non-nullptr comparison at this point")((void)0);
5521
5522 // The index is the operand that we assume is not null.
5523 unsigned PtrIdx = LHSIsNull;
5524 auto &PtrNonNullAA = A.getAAFor<AANonNull>(
5525 *this, IRPosition::value(*ICmp->getOperand(PtrIdx)),
5526 DepClassTy::REQUIRED);
5527 if (!PtrNonNullAA.isAssumedNonNull())
5528 return false;
5529 UsedAssumedInformation |= !PtrNonNullAA.isKnownNonNull();
5530
5531 // The new value depends on the predicate, true for != and false for ==.
5532 Constant *NewVal = ConstantInt::get(
5533 Type::getInt1Ty(Ctx), ICmp->getPredicate() == CmpInst::ICMP_NE);
5534 if (!Union(*NewVal))
5535 return false;
5536
5537 if (!UsedAssumedInformation)
5538 indicateOptimisticFixpoint();
5539
5540 return true;
5541 }
5542
5543 bool updateWithLoad(Attributor &A, LoadInst &L) {
5544 auto Union = [&](Value &V) {
5545 SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
5546 SimplifiedAssociatedValue, &V, L.getType());
5547 return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
5548 };
5549 return handleLoad(A, *this, L, Union);
5550 }
5551
5552 /// Use the generic, non-optimistic InstSimplfy functionality if we managed to
5553 /// simplify any operand of the instruction \p I. Return true if successful,
5554 /// in that case SimplifiedAssociatedValue will be updated.
5555 bool handleGenericInst(Attributor &A, Instruction &I) {
5556 bool SomeSimplified = false;
5557 bool UsedAssumedInformation = false;
5558
5559 SmallVector<Value *, 8> NewOps(I.getNumOperands());
5560 int Idx = 0;
5561 for (Value *Op : I.operands()) {
5562 const auto &SimplifiedOp =
5563 A.getAssumedSimplified(IRPosition::value(*Op, getCallBaseContext()),
5564 *this, UsedAssumedInformation);
5565 // If we are not sure about any operand we are not sure about the entire
5566 // instruction, we'll wait.
5567 if (!SimplifiedOp.hasValue())
5568 return true;
5569
5570 if (SimplifiedOp.getValue())
5571 NewOps[Idx] = SimplifiedOp.getValue();
5572 else
5573 NewOps[Idx] = Op;
5574
5575 SomeSimplified |= (NewOps[Idx] != Op);
5576 ++Idx;
5577 }
5578
5579 // We won't bother with the InstSimplify interface if we didn't simplify any
5580 // operand ourselves.
5581 if (!SomeSimplified)
5582 return false;
5583
5584 InformationCache &InfoCache = A.getInfoCache();
5585 Function *F = I.getFunction();
5586 const auto *DT =
5587 InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(*F);
5588 const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);
5589 auto *AC = InfoCache.getAnalysisResultForFunction<AssumptionAnalysis>(*F);
5590 OptimizationRemarkEmitter *ORE = nullptr;
5591
5592 const DataLayout &DL = I.getModule()->getDataLayout();
5593 SimplifyQuery Q(DL, TLI, DT, AC, &I);
5594 if (Value *SimplifiedI =
5595 SimplifyInstructionWithOperands(&I, NewOps, Q, ORE)) {
5596 SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
5597 SimplifiedAssociatedValue, SimplifiedI, I.getType());
5598 return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
5599 }
5600 return false;
5601 }
5602
5603 /// See AbstractAttribute::updateImpl(...).
5604 ChangeStatus updateImpl(Attributor &A) override {
5605 auto Before = SimplifiedAssociatedValue;
5606
5607 auto VisitValueCB = [&](Value &V, const Instruction *CtxI, bool &,
5608 bool Stripped) -> bool {
5609 auto &AA = A.getAAFor<AAValueSimplify>(
5610 *this, IRPosition::value(V, getCallBaseContext()),
5611 DepClassTy::REQUIRED);
5612 if (!Stripped && this == &AA) {
5613
5614 if (auto *I = dyn_cast<Instruction>(&V)) {
5615 if (auto *LI = dyn_cast<LoadInst>(&V))
5616 if (updateWithLoad(A, *LI))
5617 return true;
5618 if (auto *Cmp = dyn_cast<CmpInst>(&V))
5619 if (handleCmp(A, *Cmp))
5620 return true;
5621 if (handleGenericInst(A, *I))
5622 return true;
5623 }
5624 // TODO: Look the instruction and check recursively.
5625
5626 LLVM_DEBUG(dbgs() << "[ValueSimplify] Can't be stripped more : " << Vdo { } while (false)
5627 << "\n")do { } while (false);
5628 return false;
5629 }
5630 return checkAndUpdate(A, *this,
5631 IRPosition::value(V, getCallBaseContext()));
5632 };
5633
5634 bool Dummy = false;
5635 if (!genericValueTraversal<bool>(A, getIRPosition(), *this, Dummy,
5636 VisitValueCB, getCtxI(),
5637 /* UseValueSimplify */ false))
5638 if (!askSimplifiedValueForOtherAAs(A))
5639 return indicatePessimisticFixpoint();
5640
5641 // If a candicate was found in this update, return CHANGED.
5642 return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
5643 : ChangeStatus ::CHANGED;
5644 }
5645
5646 /// See AbstractAttribute::trackStatistics()
5647 void trackStatistics() const override {
5648 STATS_DECLTRACK_FLOATING_ATTR(value_simplify){ static llvm::Statistic NumIRFloating_value_simplify = {"attributor"
, "NumIRFloating_value_simplify", ("Number of floating values known to be '"
"value_simplify" "'")};; ++(NumIRFloating_value_simplify); }
5649 }
5650};
5651
5652struct AAValueSimplifyFunction : AAValueSimplifyImpl {
5653 AAValueSimplifyFunction(const IRPosition &IRP, Attributor &A)
5654 : AAValueSimplifyImpl(IRP, A) {}
5655
5656 /// See AbstractAttribute::initialize(...).
5657 void initialize(Attributor &A) override {
5658 SimplifiedAssociatedValue = nullptr;
5659 indicateOptimisticFixpoint();
5660 }
5661 /// See AbstractAttribute::initialize(...).
5662 ChangeStatus updateImpl(Attributor &A) override {
5663 llvm_unreachable(__builtin_unreachable()
5664 "AAValueSimplify(Function|CallSite)::updateImpl will not be called")__builtin_unreachable();
5665 }
5666 /// See AbstractAttribute::trackStatistics()
5667 void trackStatistics() const override {
5668 STATS_DECLTRACK_FN_ATTR(value_simplify){ static llvm::Statistic NumIRFunction_value_simplify = {"attributor"
, "NumIRFunction_value_simplify", ("Number of " "functions" " marked '"
"value_simplify" "'")};; ++(NumIRFunction_value_simplify); }
5669 }
5670};
5671
5672struct AAValueSimplifyCallSite : AAValueSimplifyFunction {
5673 AAValueSimplifyCallSite(const IRPosition &IRP, Attributor &A)
5674 : AAValueSimplifyFunction(IRP, A) {}
5675 /// See AbstractAttribute::trackStatistics()
5676 void trackStatistics() const override {
5677 STATS_DECLTRACK_CS_ATTR(value_simplify){ static llvm::Statistic NumIRCS_value_simplify = {"attributor"
, "NumIRCS_value_simplify", ("Number of " "call site" " marked '"
"value_simplify" "'")};; ++(NumIRCS_value_simplify); }
5678 }
5679};
5680
5681struct AAValueSimplifyCallSiteReturned : AAValueSimplifyImpl {
5682 AAValueSimplifyCallSiteReturned(const IRPosition &IRP, Attributor &A)
5683 : AAValueSimplifyImpl(IRP, A) {}
5684
5685 void initialize(Attributor &A) override {
5686 AAValueSimplifyImpl::initialize(A);
5687 if (!getAssociatedFunction())
5688 indicatePessimisticFixpoint();
5689 }
5690
5691 /// See AbstractAttribute::updateImpl(...).
5692 ChangeStatus updateImpl(Attributor &A) override {
5693 auto Before = SimplifiedAssociatedValue;
5694 auto &RetAA = A.getAAFor<AAReturnedValues>(
5695 *this, IRPosition::function(*getAssociatedFunction()),
5696 DepClassTy::REQUIRED);
5697 auto PredForReturned =
5698 [&](Value &RetVal, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
5699 bool UsedAssumedInformation = false;
5700 Optional<Value *> CSRetVal = A.translateArgumentToCallSiteContent(
5701 &RetVal, *cast<CallBase>(getCtxI()), *this,
5702 UsedAssumedInformation);
5703 SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
5704 SimplifiedAssociatedValue, CSRetVal, getAssociatedType());
5705 return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
5706 };
5707 if (!RetAA.checkForAllReturnedValuesAndReturnInsts(PredForReturned))
5708 if (!askSimplifiedValueForOtherAAs(A))
5709 return indicatePessimisticFixpoint();
5710 return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
5711 : ChangeStatus ::CHANGED;
5712 }
5713
5714 void trackStatistics() const override {
5715 STATS_DECLTRACK_CSRET_ATTR(value_simplify){ static llvm::Statistic NumIRCSReturn_value_simplify = {"attributor"
, "NumIRCSReturn_value_simplify", ("Number of " "call site returns"
" marked '" "value_simplify" "'")};; ++(NumIRCSReturn_value_simplify
); }
5716 }
5717};
5718
5719struct AAValueSimplifyCallSiteArgument : AAValueSimplifyFloating {
5720 AAValueSimplifyCallSiteArgument(const IRPosition &IRP, Attributor &A)
5721 : AAValueSimplifyFloating(IRP, A) {}
5722
5723 /// See AbstractAttribute::manifest(...).
5724 ChangeStatus manifest(Attributor &A) override {
5725 ChangeStatus Changed = ChangeStatus::UNCHANGED;
5726
5727 if (auto *NewV = getReplacementValue(A)) {
5728 Use &U = cast<CallBase>(&getAnchorValue())
5729 ->getArgOperandUse(getCallSiteArgNo());
5730 if (A.changeUseAfterManifest(U, *NewV))
5731 Changed = ChangeStatus::CHANGED;
5732 }
5733
5734 return Changed | AAValueSimplify::manifest(A);
5735 }
5736
5737 void trackStatistics() const override {
5738 STATS_DECLTRACK_CSARG_ATTR(value_simplify){ static llvm::Statistic NumIRCSArguments_value_simplify = {"attributor"
, "NumIRCSArguments_value_simplify", ("Number of " "call site arguments"
" marked '" "value_simplify" "'")};; ++(NumIRCSArguments_value_simplify
); }
5739 }
5740};
5741
5742/// ----------------------- Heap-To-Stack Conversion ---------------------------
5743struct AAHeapToStackFunction final : public AAHeapToStack {
5744
5745 struct AllocationInfo {
5746 /// The call that allocates the memory.
5747 CallBase *const CB;
5748
5749 /// The kind of allocation.
5750 const enum class AllocationKind {
5751 MALLOC,
5752 CALLOC,
5753 ALIGNED_ALLOC,
5754 } Kind;
5755
5756 /// The library function id for the allocation.
5757 LibFunc LibraryFunctionId = NotLibFunc;
5758
5759 /// The status wrt. a rewrite.
5760 enum {
5761 STACK_DUE_TO_USE,
5762 STACK_DUE_TO_FREE,
5763 INVALID,
5764 } Status = STACK_DUE_TO_USE;
5765
5766 /// Flag to indicate if we encountered a use that might free this allocation
5767 /// but which is not in the deallocation infos.
5768 bool HasPotentiallyFreeingUnknownUses = false;
5769
5770 /// The set of free calls that use this allocation.
5771 SmallPtrSet<CallBase *, 1> PotentialFreeCalls{};
5772 };
5773
5774 struct DeallocationInfo {
5775 /// The call that deallocates the memory.
5776 CallBase *const CB;
5777
5778 /// Flag to indicate if we don't know all objects this deallocation might
5779 /// free.
5780 bool MightFreeUnknownObjects = false;
5781
5782 /// The set of allocation calls that are potentially freed.
5783 SmallPtrSet<CallBase *, 1> PotentialAllocationCalls{};
5784 };
5785
5786 AAHeapToStackFunction(const IRPosition &IRP, Attributor &A)
5787 : AAHeapToStack(IRP, A) {}
5788
5789 ~AAHeapToStackFunction() {
5790 // Ensure we call the destructor so we release any memory allocated in the
5791 // sets.
5792 for (auto &It : AllocationInfos)
5793 It.getSecond()->~AllocationInfo();
5794 for (auto &It : DeallocationInfos)
5795 It.getSecond()->~DeallocationInfo();
5796 }
5797
5798 void initialize(Attributor &A) override {
5799 AAHeapToStack::initialize(A);
5800
5801 const Function *F = getAnchorScope();
5802 const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);
5803
5804 auto AllocationIdentifierCB = [&](Instruction &I) {
5805 CallBase *CB = dyn_cast<CallBase>(&I);
5806 if (!CB)
5807 return true;
5808 if (isFreeCall(CB, TLI)) {
5809 DeallocationInfos[CB] = new (A.Allocator) DeallocationInfo{CB};
5810 return true;
5811 }
5812 bool IsMalloc = isMallocLikeFn(CB, TLI);