Bug Summary

File:llvm/lib/Transforms/IPO/IPConstantPropagation.cpp
Warning:line 90, column 16
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name IPConstantPropagation.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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Transforms/IPO -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Transforms/IPO -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Transforms/IPO -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-12-07-102640-14763-1 -x c++ /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Transforms/IPO/IPConstantPropagation.cpp

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Transforms/IPO/IPConstantPropagation.cpp

1//===-- IPConstantPropagation.cpp - Propagate constants through calls -----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This pass implements an _extremely_ simple interprocedural constant
10// propagation pass. It could certainly be improved in many different ways,
11// like using a worklist. This pass makes arguments dead, but does not remove
12// them. The existing dead argument elimination pass should be run after this
13// to clean up the mess.
14//
15//===----------------------------------------------------------------------===//
16
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/ADT/Statistic.h"
19#include "llvm/Analysis/ValueTracking.h"
20#include "llvm/IR/CallSite.h"
21#include "llvm/IR/Constants.h"
22#include "llvm/IR/Instructions.h"
23#include "llvm/IR/Module.h"
24#include "llvm/Pass.h"
25#include "llvm/Transforms/IPO.h"
26using namespace llvm;
27
28#define DEBUG_TYPE"ipconstprop" "ipconstprop"
29
30STATISTIC(NumArgumentsProped, "Number of args turned into constants")static llvm::Statistic NumArgumentsProped = {"ipconstprop", "NumArgumentsProped"
, "Number of args turned into constants"}
;
31STATISTIC(NumReturnValProped, "Number of return values turned into constants")static llvm::Statistic NumReturnValProped = {"ipconstprop", "NumReturnValProped"
, "Number of return values turned into constants"}
;
32
33namespace {
34 /// IPCP - The interprocedural constant propagation pass
35 ///
36 struct IPCP : public ModulePass {
37 static char ID; // Pass identification, replacement for typeid
38 IPCP() : ModulePass(ID) {
39 initializeIPCPPass(*PassRegistry::getPassRegistry());
40 }
41
42 bool runOnModule(Module &M) override;
43 };
44}
45
46/// PropagateConstantsIntoArguments - Look at all uses of the specified
47/// function. If all uses are direct call sites, and all pass a particular
48/// constant in for an argument, propagate that constant in as the argument.
49///
50static bool PropagateConstantsIntoArguments(Function &F) {
51 if (F.arg_empty() || F.use_empty()) return false; // No arguments? Early exit.
8
Assuming the condition is false
9
Calling 'Value::use_empty'
12
Returning from 'Value::use_empty'
13
Taking false branch
52
53 // For each argument, keep track of its constant value and whether it is a
54 // constant or not. The bool is driven to true when found to be non-constant.
55 SmallVector<std::pair<Constant*, bool>, 16> ArgumentConstants;
56 ArgumentConstants.resize(F.arg_size());
57
58 unsigned NumNonconstant = 0;
59 for (Use &U : F.uses()) {
60 User *UR = U.getUser();
61 // Ignore blockaddress uses.
62 if (isa<BlockAddress>(UR)) continue;
14
Assuming 'UR' is not a 'BlockAddress'
15
Taking false branch
63
64 // If no abstract call site was created we did not understand the use, bail.
65 AbstractCallSite ACS(&U);
66 if (!ACS)
16
Assuming the condition is false
17
Taking false branch
67 return false;
68
69 // Mismatched argument count is undefined behavior. Simply bail out to avoid
70 // handling of such situations below (avoiding asserts/crashes).
71 unsigned NumActualArgs = ACS.getNumArgOperands();
72 if (F.isVarArg() ? ArgumentConstants.size() > NumActualArgs
18
Assuming the condition is false
19
'?' condition is false
21
Taking false branch
73 : ArgumentConstants.size() != NumActualArgs)
20
Assuming the condition is false
74 return false;
75
76 // Check out all of the potentially constant arguments. Note that we don't
77 // inspect varargs here.
78 Function::arg_iterator Arg = F.arg_begin();
79 for (unsigned i = 0, e = ArgumentConstants.size(); i != e; ++i, ++Arg) {
22
Assuming 'i' is not equal to 'e'
23
Loop condition is true. Entering loop body
29
Null pointer value stored to 'Arg'
30
Assuming 'i' is not equal to 'e'
31
Loop condition is true. Entering loop body
80
81 // If this argument is known non-constant, ignore it.
82 if (ArgumentConstants[i].second)
24
Assuming field 'second' is false
25
Taking false branch
32
Assuming field 'second' is false
33
Taking false branch
83 continue;
84
85 Value *V = ACS.getCallArgOperand(i);
86 Constant *C = dyn_cast_or_null<Constant>(V);
26
Assuming null pointer is passed into cast
34
Assuming 'V' is a 'Constant'
87
88 // Mismatched argument type is undefined behavior. Simply bail out to avoid
89 // handling of such situations below (avoiding asserts/crashes).
90 if (C
26.1
'C' is null
34.1
'C' is non-null
26.1
'C' is null
34.1
'C' is non-null
&& Arg->getType() != C->getType())
35
Called C++ object pointer is null
91 return false;
92
93 // We can only propagate thread independent values through callbacks.
94 // This is different to direct/indirect call sites because for them we
95 // know the thread executing the caller and callee is the same. For
96 // callbacks this is not guaranteed, thus a thread dependent value could
97 // be different for the caller and callee, making it invalid to propagate.
98 if (C
26.2
'C' is null
26.2
'C' is null
&& ACS.isCallbackCall() && C->isThreadDependent()) {
99 // Argument became non-constant. If all arguments are non-constant now,
100 // give up on this function.
101 if (++NumNonconstant == ArgumentConstants.size())
102 return false;
103
104 ArgumentConstants[i].second = true;
105 continue;
106 }
107
108 if (C
26.3
'C' is null
26.3
'C' is null
&& ArgumentConstants[i].first == nullptr) {
109 ArgumentConstants[i].first = C; // First constant seen.
110 } else if (C
26.4
'C' is null
26.4
'C' is null
&& ArgumentConstants[i].first == C) {
111 // Still the constant value we think it is.
112 } else if (V == &*Arg) {
27
Assuming the condition is true
28
Taking true branch
113 // Ignore recursive calls passing argument down.
114 } else {
115 // Argument became non-constant. If all arguments are non-constant now,
116 // give up on this function.
117 if (++NumNonconstant == ArgumentConstants.size())
118 return false;
119 ArgumentConstants[i].second = true;
120 }
121 }
122 }
123
124 // If we got to this point, there is a constant argument!
125 assert(NumNonconstant != ArgumentConstants.size())((NumNonconstant != ArgumentConstants.size()) ? static_cast<
void> (0) : __assert_fail ("NumNonconstant != ArgumentConstants.size()"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Transforms/IPO/IPConstantPropagation.cpp"
, 125, __PRETTY_FUNCTION__))
;
126 bool MadeChange = false;
127 Function::arg_iterator AI = F.arg_begin();
128 for (unsigned i = 0, e = ArgumentConstants.size(); i != e; ++i, ++AI) {
129 // Do we have a constant argument?
130 if (ArgumentConstants[i].second || AI->use_empty() ||
131 AI->hasInAllocaAttr() || (AI->hasByValAttr() && !F.onlyReadsMemory()))
132 continue;
133
134 Value *V = ArgumentConstants[i].first;
135 if (!V) V = UndefValue::get(AI->getType());
136 AI->replaceAllUsesWith(V);
137 ++NumArgumentsProped;
138 MadeChange = true;
139 }
140 return MadeChange;
141}
142
143
144// Check to see if this function returns one or more constants. If so, replace
145// all callers that use those return values with the constant value. This will
146// leave in the actual return values and instructions, but deadargelim will
147// clean that up.
148//
149// Additionally if a function always returns one of its arguments directly,
150// callers will be updated to use the value they pass in directly instead of
151// using the return value.
152static bool PropagateConstantReturn(Function &F) {
153 if (F.getReturnType()->isVoidTy())
154 return false; // No return value.
155
156 // We can infer and propagate the return value only when we know that the
157 // definition we'll get at link time is *exactly* the definition we see now.
158 // For more details, see GlobalValue::mayBeDerefined.
159 if (!F.isDefinitionExact())
160 return false;
161
162 // Don't touch naked functions. The may contain asm returning
163 // value we don't see, so we may end up interprocedurally propagating
164 // the return value incorrectly.
165 if (F.hasFnAttribute(Attribute::Naked))
166 return false;
167
168 // Check to see if this function returns a constant.
169 SmallVector<Value *,4> RetVals;
170 StructType *STy = dyn_cast<StructType>(F.getReturnType());
171 if (STy)
172 for (unsigned i = 0, e = STy->getNumElements(); i < e; ++i)
173 RetVals.push_back(UndefValue::get(STy->getElementType(i)));
174 else
175 RetVals.push_back(UndefValue::get(F.getReturnType()));
176
177 unsigned NumNonConstant = 0;
178 for (BasicBlock &BB : F)
179 if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
180 for (unsigned i = 0, e = RetVals.size(); i != e; ++i) {
181 // Already found conflicting return values?
182 Value *RV = RetVals[i];
183 if (!RV)
184 continue;
185
186 // Find the returned value
187 Value *V;
188 if (!STy)
189 V = RI->getOperand(0);
190 else
191 V = FindInsertedValue(RI->getOperand(0), i);
192
193 if (V) {
194 // Ignore undefs, we can change them into anything
195 if (isa<UndefValue>(V))
196 continue;
197
198 // Try to see if all the rets return the same constant or argument.
199 if (isa<Constant>(V) || isa<Argument>(V)) {
200 if (isa<UndefValue>(RV)) {
201 // No value found yet? Try the current one.
202 RetVals[i] = V;
203 continue;
204 }
205 // Returning the same value? Good.
206 if (RV == V)
207 continue;
208 }
209 }
210 // Different or no known return value? Don't propagate this return
211 // value.
212 RetVals[i] = nullptr;
213 // All values non-constant? Stop looking.
214 if (++NumNonConstant == RetVals.size())
215 return false;
216 }
217 }
218
219 // If we got here, the function returns at least one constant value. Loop
220 // over all users, replacing any uses of the return value with the returned
221 // constant.
222 bool MadeChange = false;
223 for (Use &U : F.uses()) {
224 CallSite CS(U.getUser());
225 Instruction* Call = CS.getInstruction();
226
227 // Not a call instruction or a call instruction that's not calling F
228 // directly?
229 if (!Call || !CS.isCallee(&U))
230 continue;
231
232 // Call result not used?
233 if (Call->use_empty())
234 continue;
235
236 MadeChange = true;
237
238 if (!STy) {
239 Value* New = RetVals[0];
240 if (Argument *A = dyn_cast<Argument>(New))
241 // Was an argument returned? Then find the corresponding argument in
242 // the call instruction and use that.
243 New = CS.getArgument(A->getArgNo());
244 Call->replaceAllUsesWith(New);
245 continue;
246 }
247
248 for (auto I = Call->user_begin(), E = Call->user_end(); I != E;) {
249 Instruction *Ins = cast<Instruction>(*I);
250
251 // Increment now, so we can remove the use
252 ++I;
253
254 // Find the index of the retval to replace with
255 int index = -1;
256 if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Ins))
257 if (EV->getNumIndices() == 1)
258 index = *EV->idx_begin();
259
260 // If this use uses a specific return value, and we have a replacement,
261 // replace it.
262 if (index != -1) {
263 Value *New = RetVals[index];
264 if (New) {
265 if (Argument *A = dyn_cast<Argument>(New))
266 // Was an argument returned? Then find the corresponding argument in
267 // the call instruction and use that.
268 New = CS.getArgument(A->getArgNo());
269 Ins->replaceAllUsesWith(New);
270 Ins->eraseFromParent();
271 }
272 }
273 }
274 }
275
276 if (MadeChange) ++NumReturnValProped;
277 return MadeChange;
278}
279
280char IPCP::ID = 0;
281INITIALIZE_PASS(IPCP, "ipconstprop",static void *initializeIPCPPassOnce(PassRegistry &Registry
) { PassInfo *PI = new PassInfo( "Interprocedural constant propagation"
, "ipconstprop", &IPCP::ID, PassInfo::NormalCtor_t(callDefaultCtor
<IPCP>), false, false); Registry.registerPass(*PI, true
); return PI; } static llvm::once_flag InitializeIPCPPassFlag
; void llvm::initializeIPCPPass(PassRegistry &Registry) {
llvm::call_once(InitializeIPCPPassFlag, initializeIPCPPassOnce
, std::ref(Registry)); }
282 "Interprocedural constant propagation", false, false)static void *initializeIPCPPassOnce(PassRegistry &Registry
) { PassInfo *PI = new PassInfo( "Interprocedural constant propagation"
, "ipconstprop", &IPCP::ID, PassInfo::NormalCtor_t(callDefaultCtor
<IPCP>), false, false); Registry.registerPass(*PI, true
); return PI; } static llvm::once_flag InitializeIPCPPassFlag
; void llvm::initializeIPCPPass(PassRegistry &Registry) {
llvm::call_once(InitializeIPCPPassFlag, initializeIPCPPassOnce
, std::ref(Registry)); }
283
284ModulePass *llvm::createIPConstantPropagationPass() { return new IPCP(); }
285
286bool IPCP::runOnModule(Module &M) {
287 if (skipModule(M))
1
Assuming the condition is false
2
Taking false branch
288 return false;
289
290 bool Changed = false;
291 bool LocalChange = true;
292
293 // FIXME: instead of using smart algorithms, we just iterate until we stop
294 // making changes.
295 while (LocalChange) {
3
Loop condition is true. Entering loop body
296 LocalChange = false;
297 for (Function &F : M)
298 if (!F.isDeclaration()) {
4
Assuming the condition is true
5
Taking true branch
299 // Delete any klingons.
300 F.removeDeadConstantUsers();
301 if (F.hasLocalLinkage())
6
Taking true branch
302 LocalChange |= PropagateConstantsIntoArguments(F);
7
Calling 'PropagateConstantsIntoArguments'
303 Changed |= PropagateConstantReturn(F);
304 }
305 Changed |= LocalChange;
306 }
307 return Changed;
308}

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h

1//===- llvm/Value.h - Definition of the Value class -------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the Value class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_IR_VALUE_H
14#define LLVM_IR_VALUE_H
15
16#include "llvm-c/Types.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/iterator_range.h"
19#include "llvm/IR/Use.h"
20#include "llvm/Support/Alignment.h"
21#include "llvm/Support/CBindingWrapping.h"
22#include "llvm/Support/Casting.h"
23#include <cassert>
24#include <iterator>
25#include <memory>
26
27namespace llvm {
28
29class APInt;
30class Argument;
31class BasicBlock;
32class Constant;
33class ConstantData;
34class ConstantAggregate;
35class DataLayout;
36class Function;
37class GlobalAlias;
38class GlobalIFunc;
39class GlobalIndirectSymbol;
40class GlobalObject;
41class GlobalValue;
42class GlobalVariable;
43class InlineAsm;
44class Instruction;
45class LLVMContext;
46class Module;
47class ModuleSlotTracker;
48class raw_ostream;
49template<typename ValueTy> class StringMapEntry;
50class StringRef;
51class Twine;
52class Type;
53class User;
54
55using ValueName = StringMapEntry<Value *>;
56
57//===----------------------------------------------------------------------===//
58// Value Class
59//===----------------------------------------------------------------------===//
60
61/// LLVM Value Representation
62///
63/// This is a very important LLVM class. It is the base class of all values
64/// computed by a program that may be used as operands to other values. Value is
65/// the super class of other important classes such as Instruction and Function.
66/// All Values have a Type. Type is not a subclass of Value. Some values can
67/// have a name and they belong to some Module. Setting the name on the Value
68/// automatically updates the module's symbol table.
69///
70/// Every value has a "use list" that keeps track of which other Values are
71/// using this Value. A Value can also have an arbitrary number of ValueHandle
72/// objects that watch it and listen to RAUW and Destroy events. See
73/// llvm/IR/ValueHandle.h for details.
74class Value {
75 // The least-significant bit of the first word of Value *must* be zero:
76 // http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
77 Type *VTy;
78 Use *UseList;
79
80 friend class ValueAsMetadata; // Allow access to IsUsedByMD.
81 friend class ValueHandleBase;
82
83 const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast)
84 unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?
85
86protected:
87 /// Hold subclass data that can be dropped.
88 ///
89 /// This member is similar to SubclassData, however it is for holding
90 /// information which may be used to aid optimization, but which may be
91 /// cleared to zero without affecting conservative interpretation.
92 unsigned char SubclassOptionalData : 7;
93
94private:
95 /// Hold arbitrary subclass data.
96 ///
97 /// This member is defined by this class, but is not used for anything.
98 /// Subclasses can use it to hold whatever state they find useful. This
99 /// field is initialized to zero by the ctor.
100 unsigned short SubclassData;
101
102protected:
103 /// The number of operands in the subclass.
104 ///
105 /// This member is defined by this class, but not used for anything.
106 /// Subclasses can use it to store their number of operands, if they have
107 /// any.
108 ///
109 /// This is stored here to save space in User on 64-bit hosts. Since most
110 /// instances of Value have operands, 32-bit hosts aren't significantly
111 /// affected.
112 ///
113 /// Note, this should *NOT* be used directly by any class other than User.
114 /// User uses this value to find the Use list.
115 enum : unsigned { NumUserOperandsBits = 28 };
116 unsigned NumUserOperands : NumUserOperandsBits;
117
118 // Use the same type as the bitfield above so that MSVC will pack them.
119 unsigned IsUsedByMD : 1;
120 unsigned HasName : 1;
121 unsigned HasHungOffUses : 1;
122 unsigned HasDescriptor : 1;
123
124private:
125 template <typename UseT> // UseT == 'Use' or 'const Use'
126 class use_iterator_impl
127 : public std::iterator<std::forward_iterator_tag, UseT *> {
128 friend class Value;
129
130 UseT *U;
131
132 explicit use_iterator_impl(UseT *u) : U(u) {}
133
134 public:
135 use_iterator_impl() : U() {}
136
137 bool operator==(const use_iterator_impl &x) const { return U == x.U; }
138 bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }
139
140 use_iterator_impl &operator++() { // Preincrement
141 assert(U && "Cannot increment end iterator!")((U && "Cannot increment end iterator!") ? static_cast
<void> (0) : __assert_fail ("U && \"Cannot increment end iterator!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 141, __PRETTY_FUNCTION__))
;
142 U = U->getNext();
143 return *this;
144 }
145
146 use_iterator_impl operator++(int) { // Postincrement
147 auto tmp = *this;
148 ++*this;
149 return tmp;
150 }
151
152 UseT &operator*() const {
153 assert(U && "Cannot dereference end iterator!")((U && "Cannot dereference end iterator!") ? static_cast
<void> (0) : __assert_fail ("U && \"Cannot dereference end iterator!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 153, __PRETTY_FUNCTION__))
;
154 return *U;
155 }
156
157 UseT *operator->() const { return &operator*(); }
158
159 operator use_iterator_impl<const UseT>() const {
160 return use_iterator_impl<const UseT>(U);
161 }
162 };
163
164 template <typename UserTy> // UserTy == 'User' or 'const User'
165 class user_iterator_impl
166 : public std::iterator<std::forward_iterator_tag, UserTy *> {
167 use_iterator_impl<Use> UI;
168 explicit user_iterator_impl(Use *U) : UI(U) {}
169 friend class Value;
170
171 public:
172 user_iterator_impl() = default;
173
174 bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
175 bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
176
177 /// Returns true if this iterator is equal to user_end() on the value.
178 bool atEnd() const { return *this == user_iterator_impl(); }
179
180 user_iterator_impl &operator++() { // Preincrement
181 ++UI;
182 return *this;
183 }
184
185 user_iterator_impl operator++(int) { // Postincrement
186 auto tmp = *this;
187 ++*this;
188 return tmp;
189 }
190
191 // Retrieve a pointer to the current User.
192 UserTy *operator*() const {
193 return UI->getUser();
194 }
195
196 UserTy *operator->() const { return operator*(); }
197
198 operator user_iterator_impl<const UserTy>() const {
199 return user_iterator_impl<const UserTy>(*UI);
200 }
201
202 Use &getUse() const { return *UI; }
203 };
204
205protected:
206 Value(Type *Ty, unsigned scid);
207
208 /// Value's destructor should be virtual by design, but that would require
209 /// that Value and all of its subclasses have a vtable that effectively
210 /// duplicates the information in the value ID. As a size optimization, the
211 /// destructor has been protected, and the caller should manually call
212 /// deleteValue.
213 ~Value(); // Use deleteValue() to delete a generic Value.
214
215public:
216 Value(const Value &) = delete;
217 Value &operator=(const Value &) = delete;
218
219 /// Delete a pointer to a generic Value.
220 void deleteValue();
221
222 /// Support for debugging, callable in GDB: V->dump()
223 void dump() const;
224
225 /// Implement operator<< on Value.
226 /// @{
227 void print(raw_ostream &O, bool IsForDebug = false) const;
228 void print(raw_ostream &O, ModuleSlotTracker &MST,
229 bool IsForDebug = false) const;
230 /// @}
231
232 /// Print the name of this Value out to the specified raw_ostream.
233 ///
234 /// This is useful when you just want to print 'int %reg126', not the
235 /// instruction that generated it. If you specify a Module for context, then
236 /// even constanst get pretty-printed; for example, the type of a null
237 /// pointer is printed symbolically.
238 /// @{
239 void printAsOperand(raw_ostream &O, bool PrintType = true,
240 const Module *M = nullptr) const;
241 void printAsOperand(raw_ostream &O, bool PrintType,
242 ModuleSlotTracker &MST) const;
243 /// @}
244
245 /// All values are typed, get the type of this value.
246 Type *getType() const { return VTy; }
247
248 /// All values hold a context through their type.
249 LLVMContext &getContext() const;
250
251 // All values can potentially be named.
252 bool hasName() const { return HasName; }
253 ValueName *getValueName() const;
254 void setValueName(ValueName *VN);
255
256private:
257 void destroyValueName();
258 enum class ReplaceMetadataUses { No, Yes };
259 void doRAUW(Value *New, ReplaceMetadataUses);
260 void setNameImpl(const Twine &Name);
261
262public:
263 /// Return a constant reference to the value's name.
264 ///
265 /// This guaranteed to return the same reference as long as the value is not
266 /// modified. If the value has a name, this does a hashtable lookup, so it's
267 /// not free.
268 StringRef getName() const;
269
270 /// Change the name of the value.
271 ///
272 /// Choose a new unique name if the provided name is taken.
273 ///
274 /// \param Name The new name; or "" if the value's name should be removed.
275 void setName(const Twine &Name);
276
277 /// Transfer the name from V to this value.
278 ///
279 /// After taking V's name, sets V's name to empty.
280 ///
281 /// \note It is an error to call V->takeName(V).
282 void takeName(Value *V);
283
284 /// Change all uses of this to point to a new Value.
285 ///
286 /// Go through the uses list for this definition and make each use point to
287 /// "V" instead of "this". After this completes, 'this's use list is
288 /// guaranteed to be empty.
289 void replaceAllUsesWith(Value *V);
290
291 /// Change non-metadata uses of this to point to a new Value.
292 ///
293 /// Go through the uses list for this definition and make each use point to
294 /// "V" instead of "this". This function skips metadata entries in the list.
295 void replaceNonMetadataUsesWith(Value *V);
296
297 /// Go through the uses list for this definition and make each use point
298 /// to "V" if the callback ShouldReplace returns true for the given Use.
299 /// Unlike replaceAllUsesWith() this function does not support basic block
300 /// values or constant users.
301 void replaceUsesWithIf(Value *New,
302 llvm::function_ref<bool(Use &U)> ShouldReplace) {
303 assert(New && "Value::replaceUsesWithIf(<null>) is invalid!")((New && "Value::replaceUsesWithIf(<null>) is invalid!"
) ? static_cast<void> (0) : __assert_fail ("New && \"Value::replaceUsesWithIf(<null>) is invalid!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 303, __PRETTY_FUNCTION__))
;
304 assert(New->getType() == getType() &&((New->getType() == getType() && "replaceUses of value with new value of different type!"
) ? static_cast<void> (0) : __assert_fail ("New->getType() == getType() && \"replaceUses of value with new value of different type!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 305, __PRETTY_FUNCTION__))
305 "replaceUses of value with new value of different type!")((New->getType() == getType() && "replaceUses of value with new value of different type!"
) ? static_cast<void> (0) : __assert_fail ("New->getType() == getType() && \"replaceUses of value with new value of different type!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 305, __PRETTY_FUNCTION__))
;
306
307 for (use_iterator UI = use_begin(), E = use_end(); UI != E;) {
308 Use &U = *UI;
309 ++UI;
310 if (!ShouldReplace(U))
311 continue;
312 U.set(New);
313 }
314 }
315
316 /// replaceUsesOutsideBlock - Go through the uses list for this definition and
317 /// make each use point to "V" instead of "this" when the use is outside the
318 /// block. 'This's use list is expected to have at least one element.
319 /// Unlike replaceAllUsesWith() this function does not support basic block
320 /// values or constant users.
321 void replaceUsesOutsideBlock(Value *V, BasicBlock *BB);
322
323 //----------------------------------------------------------------------
324 // Methods for handling the chain of uses of this Value.
325 //
326 // Materializing a function can introduce new uses, so these methods come in
327 // two variants:
328 // The methods that start with materialized_ check the uses that are
329 // currently known given which functions are materialized. Be very careful
330 // when using them since you might not get all uses.
331 // The methods that don't start with materialized_ assert that modules is
332 // fully materialized.
333 void assertModuleIsMaterializedImpl() const;
334 // This indirection exists so we can keep assertModuleIsMaterializedImpl()
335 // around in release builds of Value.cpp to be linked with other code built
336 // in debug mode. But this avoids calling it in any of the release built code.
337 void assertModuleIsMaterialized() const {
338#ifndef NDEBUG
339 assertModuleIsMaterializedImpl();
340#endif
341 }
342
343 bool use_empty() const {
344 assertModuleIsMaterialized();
345 return UseList == nullptr;
10
Assuming the condition is false
11
Returning zero, which participates in a condition later
346 }
347
348 bool materialized_use_empty() const {
349 return UseList == nullptr;
350 }
351
352 using use_iterator = use_iterator_impl<Use>;
353 using const_use_iterator = use_iterator_impl<const Use>;
354
355 use_iterator materialized_use_begin() { return use_iterator(UseList); }
356 const_use_iterator materialized_use_begin() const {
357 return const_use_iterator(UseList);
358 }
359 use_iterator use_begin() {
360 assertModuleIsMaterialized();
361 return materialized_use_begin();
362 }
363 const_use_iterator use_begin() const {
364 assertModuleIsMaterialized();
365 return materialized_use_begin();
366 }
367 use_iterator use_end() { return use_iterator(); }
368 const_use_iterator use_end() const { return const_use_iterator(); }
369 iterator_range<use_iterator> materialized_uses() {
370 return make_range(materialized_use_begin(), use_end());
371 }
372 iterator_range<const_use_iterator> materialized_uses() const {
373 return make_range(materialized_use_begin(), use_end());
374 }
375 iterator_range<use_iterator> uses() {
376 assertModuleIsMaterialized();
377 return materialized_uses();
378 }
379 iterator_range<const_use_iterator> uses() const {
380 assertModuleIsMaterialized();
381 return materialized_uses();
382 }
383
384 bool user_empty() const {
385 assertModuleIsMaterialized();
386 return UseList == nullptr;
387 }
388
389 using user_iterator = user_iterator_impl<User>;
390 using const_user_iterator = user_iterator_impl<const User>;
391
392 user_iterator materialized_user_begin() { return user_iterator(UseList); }
393 const_user_iterator materialized_user_begin() const {
394 return const_user_iterator(UseList);
395 }
396 user_iterator user_begin() {
397 assertModuleIsMaterialized();
398 return materialized_user_begin();
399 }
400 const_user_iterator user_begin() const {
401 assertModuleIsMaterialized();
402 return materialized_user_begin();
403 }
404 user_iterator user_end() { return user_iterator(); }
405 const_user_iterator user_end() const { return const_user_iterator(); }
406 User *user_back() {
407 assertModuleIsMaterialized();
408 return *materialized_user_begin();
409 }
410 const User *user_back() const {
411 assertModuleIsMaterialized();
412 return *materialized_user_begin();
413 }
414 iterator_range<user_iterator> materialized_users() {
415 return make_range(materialized_user_begin(), user_end());
416 }
417 iterator_range<const_user_iterator> materialized_users() const {
418 return make_range(materialized_user_begin(), user_end());
419 }
420 iterator_range<user_iterator> users() {
421 assertModuleIsMaterialized();
422 return materialized_users();
423 }
424 iterator_range<const_user_iterator> users() const {
425 assertModuleIsMaterialized();
426 return materialized_users();
427 }
428
429 /// Return true if there is exactly one user of this value.
430 ///
431 /// This is specialized because it is a common request and does not require
432 /// traversing the whole use list.
433 bool hasOneUse() const {
434 const_use_iterator I = use_begin(), E = use_end();
435 if (I == E) return false;
436 return ++I == E;
437 }
438
439 /// Return true if this Value has exactly N users.
440 bool hasNUses(unsigned N) const;
441
442 /// Return true if this value has N users or more.
443 ///
444 /// This is logically equivalent to getNumUses() >= N.
445 bool hasNUsesOrMore(unsigned N) const;
446
447 /// Check if this value is used in the specified basic block.
448 bool isUsedInBasicBlock(const BasicBlock *BB) const;
449
450 /// This method computes the number of uses of this Value.
451 ///
452 /// This is a linear time operation. Use hasOneUse, hasNUses, or
453 /// hasNUsesOrMore to check for specific values.
454 unsigned getNumUses() const;
455
456 /// This method should only be used by the Use class.
457 void addUse(Use &U) { U.addToList(&UseList); }
458
459 /// Concrete subclass of this.
460 ///
461 /// An enumeration for keeping track of the concrete subclass of Value that
462 /// is actually instantiated. Values of this enumeration are kept in the
463 /// Value classes SubclassID field. They are used for concrete type
464 /// identification.
465 enum ValueTy {
466#define HANDLE_VALUE(Name) Name##Val,
467#include "llvm/IR/Value.def"
468
469 // Markers:
470#define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val,
471#include "llvm/IR/Value.def"
472 };
473
474 /// Return an ID for the concrete type of this object.
475 ///
476 /// This is used to implement the classof checks. This should not be used
477 /// for any other purpose, as the values may change as LLVM evolves. Also,
478 /// note that for instructions, the Instruction's opcode is added to
479 /// InstructionVal. So this means three things:
480 /// # there is no value with code InstructionVal (no opcode==0).
481 /// # there are more possible values for the value type than in ValueTy enum.
482 /// # the InstructionVal enumerator must be the highest valued enumerator in
483 /// the ValueTy enum.
484 unsigned getValueID() const {
485 return SubclassID;
486 }
487
488 /// Return the raw optional flags value contained in this value.
489 ///
490 /// This should only be used when testing two Values for equivalence.
491 unsigned getRawSubclassOptionalData() const {
492 return SubclassOptionalData;
493 }
494
495 /// Clear the optional flags contained in this value.
496 void clearSubclassOptionalData() {
497 SubclassOptionalData = 0;
498 }
499
500 /// Check the optional flags for equality.
501 bool hasSameSubclassOptionalData(const Value *V) const {
502 return SubclassOptionalData == V->SubclassOptionalData;
503 }
504
505 /// Return true if there is a value handle associated with this value.
506 bool hasValueHandle() const { return HasValueHandle; }
507
508 /// Return true if there is metadata referencing this value.
509 bool isUsedByMetadata() const { return IsUsedByMD; }
510
511 /// Return true if this value is a swifterror value.
512 ///
513 /// swifterror values can be either a function argument or an alloca with a
514 /// swifterror attribute.
515 bool isSwiftError() const;
516
517 /// Strip off pointer casts, all-zero GEPs and address space casts.
518 ///
519 /// Returns the original uncasted value. If this is called on a non-pointer
520 /// value, it returns 'this'.
521 const Value *stripPointerCasts() const;
522 Value *stripPointerCasts() {
523 return const_cast<Value *>(
524 static_cast<const Value *>(this)->stripPointerCasts());
525 }
526
527 /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
528 ///
529 /// Returns the original uncasted value. If this is called on a non-pointer
530 /// value, it returns 'this'.
531 const Value *stripPointerCastsAndAliases() const;
532 Value *stripPointerCastsAndAliases() {
533 return const_cast<Value *>(
534 static_cast<const Value *>(this)->stripPointerCastsAndAliases());
535 }
536
537 /// Strip off pointer casts, all-zero GEPs and address space casts
538 /// but ensures the representation of the result stays the same.
539 ///
540 /// Returns the original uncasted value with the same representation. If this
541 /// is called on a non-pointer value, it returns 'this'.
542 const Value *stripPointerCastsSameRepresentation() const;
543 Value *stripPointerCastsSameRepresentation() {
544 return const_cast<Value *>(static_cast<const Value *>(this)
545 ->stripPointerCastsSameRepresentation());
546 }
547
548 /// Strip off pointer casts, all-zero GEPs and invariant group info.
549 ///
550 /// Returns the original uncasted value. If this is called on a non-pointer
551 /// value, it returns 'this'. This function should be used only in
552 /// Alias analysis.
553 const Value *stripPointerCastsAndInvariantGroups() const;
554 Value *stripPointerCastsAndInvariantGroups() {
555 return const_cast<Value *>(static_cast<const Value *>(this)
556 ->stripPointerCastsAndInvariantGroups());
557 }
558
559 /// Strip off pointer casts and all-constant inbounds GEPs.
560 ///
561 /// Returns the original pointer value. If this is called on a non-pointer
562 /// value, it returns 'this'.
563 const Value *stripInBoundsConstantOffsets() const;
564 Value *stripInBoundsConstantOffsets() {
565 return const_cast<Value *>(
566 static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
567 }
568
569 /// Accumulate the constant offset this value has compared to a base pointer.
570 /// Only 'getelementptr' instructions (GEPs) with constant indices are
571 /// accumulated but other instructions, e.g., casts, are stripped away as
572 /// well. The accumulated constant offset is added to \p Offset and the base
573 /// pointer is returned.
574 ///
575 /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
576 /// the address space of 'this' pointer value, e.g., use
577 /// DataLayout::getIndexTypeSizeInBits(Ty).
578 ///
579 /// If \p AllowNonInbounds is true, constant offsets in GEPs are stripped and
580 /// accumulated even if the GEP is not "inbounds".
581 ///
582 /// If this is called on a non-pointer value, it returns 'this' and the
583 /// \p Offset is not modified.
584 ///
585 /// Note that this function will never return a nullptr. It will also never
586 /// manipulate the \p Offset in a way that would not match the difference
587 /// between the underlying value and the returned one. Thus, if no constant
588 /// offset was found, the returned value is the underlying one and \p Offset
589 /// is unchanged.
590 const Value *stripAndAccumulateConstantOffsets(const DataLayout &DL,
591 APInt &Offset,
592 bool AllowNonInbounds) const;
593 Value *stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
594 bool AllowNonInbounds) {
595 return const_cast<Value *>(
596 static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
597 DL, Offset, AllowNonInbounds));
598 }
599
600 /// This is a wrapper around stripAndAccumulateConstantOffsets with the
601 /// in-bounds requirement set to false.
602 const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
603 APInt &Offset) const {
604 return stripAndAccumulateConstantOffsets(DL, Offset,
605 /* AllowNonInbounds */ false);
606 }
607 Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
608 APInt &Offset) {
609 return stripAndAccumulateConstantOffsets(DL, Offset,
610 /* AllowNonInbounds */ false);
611 }
612
613 /// Strip off pointer casts and inbounds GEPs.
614 ///
615 /// Returns the original pointer value. If this is called on a non-pointer
616 /// value, it returns 'this'.
617 const Value *stripInBoundsOffsets() const;
618 Value *stripInBoundsOffsets() {
619 return const_cast<Value *>(
620 static_cast<const Value *>(this)->stripInBoundsOffsets());
621 }
622
623 /// Returns the number of bytes known to be dereferenceable for the
624 /// pointer value.
625 ///
626 /// If CanBeNull is set by this function the pointer can either be null or be
627 /// dereferenceable up to the returned number of bytes.
628 uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
629 bool &CanBeNull) const;
630
631 /// Returns an alignment of the pointer value.
632 ///
633 /// Returns an alignment which is either specified explicitly, e.g. via
634 /// align attribute of a function argument, or guaranteed by DataLayout.
635 MaybeAlign getPointerAlignment(const DataLayout &DL) const;
636
637 /// Translate PHI node to its predecessor from the given basic block.
638 ///
639 /// If this value is a PHI node with CurBB as its parent, return the value in
640 /// the PHI node corresponding to PredBB. If not, return ourself. This is
641 /// useful if you want to know the value something has in a predecessor
642 /// block.
643 const Value *DoPHITranslation(const BasicBlock *CurBB,
644 const BasicBlock *PredBB) const;
645 Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
646 return const_cast<Value *>(
647 static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
648 }
649
650 /// The maximum alignment for instructions.
651 ///
652 /// This is the greatest alignment value supported by load, store, and alloca
653 /// instructions, and global values.
654 static const unsigned MaxAlignmentExponent = 29;
655 static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
656
657 /// Mutate the type of this Value to be of the specified type.
658 ///
659 /// Note that this is an extremely dangerous operation which can create
660 /// completely invalid IR very easily. It is strongly recommended that you
661 /// recreate IR objects with the right types instead of mutating them in
662 /// place.
663 void mutateType(Type *Ty) {
664 VTy = Ty;
665 }
666
667 /// Sort the use-list.
668 ///
669 /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
670 /// expected to compare two \a Use references.
671 template <class Compare> void sortUseList(Compare Cmp);
672
673 /// Reverse the use-list.
674 void reverseUseList();
675
676private:
677 /// Merge two lists together.
678 ///
679 /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
680 /// "equal" items from L before items from R.
681 ///
682 /// \return the first element in the list.
683 ///
684 /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
685 template <class Compare>
686 static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
687 Use *Merged;
688 Use **Next = &Merged;
689
690 while (true) {
691 if (!L) {
692 *Next = R;
693 break;
694 }
695 if (!R) {
696 *Next = L;
697 break;
698 }
699 if (Cmp(*R, *L)) {
700 *Next = R;
701 Next = &R->Next;
702 R = R->Next;
703 } else {
704 *Next = L;
705 Next = &L->Next;
706 L = L->Next;
707 }
708 }
709
710 return Merged;
711 }
712
713protected:
714 unsigned short getSubclassDataFromValue() const { return SubclassData; }
715 void setValueSubclassData(unsigned short D) { SubclassData = D; }
716};
717
718struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
719
720/// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
721/// Those don't work because Value and Instruction's destructors are protected,
722/// aren't virtual, and won't destroy the complete object.
723using unique_value = std::unique_ptr<Value, ValueDeleter>;
724
725inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
726 V.print(OS);
727 return OS;
728}
729
730void Use::set(Value *V) {
731 if (Val) removeFromList();
732 Val = V;
733 if (V) V->addUse(*this);
734}
735
736Value *Use::operator=(Value *RHS) {
737 set(RHS);
738 return RHS;
739}
740
741const Use &Use::operator=(const Use &RHS) {
742 set(RHS.Val);
743 return *this;
744}
745
746template <class Compare> void Value::sortUseList(Compare Cmp) {
747 if (!UseList || !UseList->Next)
748 // No need to sort 0 or 1 uses.
749 return;
750
751 // Note: this function completely ignores Prev pointers until the end when
752 // they're fixed en masse.
753
754 // Create a binomial vector of sorted lists, visiting uses one at a time and
755 // merging lists as necessary.
756 const unsigned MaxSlots = 32;
757 Use *Slots[MaxSlots];
758
759 // Collect the first use, turning it into a single-item list.
760 Use *Next = UseList->Next;
761 UseList->Next = nullptr;
762 unsigned NumSlots = 1;
763 Slots[0] = UseList;
764
765 // Collect all but the last use.
766 while (Next->Next) {
767 Use *Current = Next;
768 Next = Current->Next;
769
770 // Turn Current into a single-item list.
771 Current->Next = nullptr;
772
773 // Save Current in the first available slot, merging on collisions.
774 unsigned I;
775 for (I = 0; I < NumSlots; ++I) {
776 if (!Slots[I])
777 break;
778
779 // Merge two lists, doubling the size of Current and emptying slot I.
780 //
781 // Since the uses in Slots[I] originally preceded those in Current, send
782 // Slots[I] in as the left parameter to maintain a stable sort.
783 Current = mergeUseLists(Slots[I], Current, Cmp);
784 Slots[I] = nullptr;
785 }
786 // Check if this is a new slot.
787 if (I == NumSlots) {
788 ++NumSlots;
789 assert(NumSlots <= MaxSlots && "Use list bigger than 2^32")((NumSlots <= MaxSlots && "Use list bigger than 2^32"
) ? static_cast<void> (0) : __assert_fail ("NumSlots <= MaxSlots && \"Use list bigger than 2^32\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 789, __PRETTY_FUNCTION__))
;
790 }
791
792 // Found an open slot.
793 Slots[I] = Current;
794 }
795
796 // Merge all the lists together.
797 assert(Next && "Expected one more Use")((Next && "Expected one more Use") ? static_cast<void
> (0) : __assert_fail ("Next && \"Expected one more Use\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 797, __PRETTY_FUNCTION__))
;
798 assert(!Next->Next && "Expected only one Use")((!Next->Next && "Expected only one Use") ? static_cast
<void> (0) : __assert_fail ("!Next->Next && \"Expected only one Use\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/Value.h"
, 798, __PRETTY_FUNCTION__))
;
799 UseList = Next;
800 for (unsigned I = 0; I < NumSlots; ++I)
801 if (Slots[I])
802 // Since the uses in Slots[I] originally preceded those in UseList, send
803 // Slots[I] in as the left parameter to maintain a stable sort.
804 UseList = mergeUseLists(Slots[I], UseList, Cmp);
805
806 // Fix the Prev pointers.
807 for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
808 I->setPrev(Prev);
809 Prev = &I->Next;
810 }
811}
812
813// isa - Provide some specializations of isa so that we don't have to include
814// the subtype header files to test to see if the value is a subclass...
815//
816template <> struct isa_impl<Constant, Value> {
817 static inline bool doit(const Value &Val) {
818 static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
819 return Val.getValueID() <= Value::ConstantLastVal;
820 }
821};
822
823template <> struct isa_impl<ConstantData, Value> {
824 static inline bool doit(const Value &Val) {
825 return Val.getValueID() >= Value::ConstantDataFirstVal &&
826 Val.getValueID() <= Value::ConstantDataLastVal;
827 }
828};
829
830template <> struct isa_impl<ConstantAggregate, Value> {
831 static inline bool doit(const Value &Val) {
832 return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
833 Val.getValueID() <= Value::ConstantAggregateLastVal;
834 }
835};
836
837template <> struct isa_impl<Argument, Value> {
838 static inline bool doit (const Value &Val) {
839 return Val.getValueID() == Value::ArgumentVal;
840 }
841};
842
843template <> struct isa_impl<InlineAsm, Value> {
844 static inline bool doit(const Value &Val) {
845 return Val.getValueID() == Value::InlineAsmVal;
846 }
847};
848
849template <> struct isa_impl<Instruction, Value> {
850 static inline bool doit(const Value &Val) {
851 return Val.getValueID() >= Value::InstructionVal;
852 }
853};
854
855template <> struct isa_impl<BasicBlock, Value> {
856 static inline bool doit(const Value &Val) {
857 return Val.getValueID() == Value::BasicBlockVal;
858 }
859};
860
861template <> struct isa_impl<Function, Value> {
862 static inline bool doit(const Value &Val) {
863 return Val.getValueID() == Value::FunctionVal;
864 }
865};
866
867template <> struct isa_impl<GlobalVariable, Value> {
868 static inline bool doit(const Value &Val) {
869 return Val.getValueID() == Value::GlobalVariableVal;
870 }
871};
872
873template <> struct isa_impl<GlobalAlias, Value> {
874 static inline bool doit(const Value &Val) {
875 return Val.getValueID() == Value::GlobalAliasVal;
876 }
877};
878
879template <> struct isa_impl<GlobalIFunc, Value> {
880 static inline bool doit(const Value &Val) {
881 return Val.getValueID() == Value::GlobalIFuncVal;
882 }
883};
884
885template <> struct isa_impl<GlobalIndirectSymbol, Value> {
886 static inline bool doit(const Value &Val) {
887 return isa<GlobalAlias>(Val) || isa<GlobalIFunc>(Val);
888 }
889};
890
891template <> struct isa_impl<GlobalValue, Value> {
892 static inline bool doit(const Value &Val) {
893 return isa<GlobalObject>(Val) || isa<GlobalIndirectSymbol>(Val);
894 }
895};
896
897template <> struct isa_impl<GlobalObject, Value> {
898 static inline bool doit(const Value &Val) {
899 return isa<GlobalVariable>(Val) || isa<Function>(Val);
900 }
901};
902
903// Create wrappers for C Binding types (see CBindingWrapping.h).
904DEFINE_ISA_CONVERSION_FUNCTIONS(Value, LLVMValueRef)inline Value *unwrap(LLVMValueRef P) { return reinterpret_cast
<Value*>(P); } inline LLVMValueRef wrap(const Value *P)
{ return reinterpret_cast<LLVMValueRef>(const_cast<
Value*>(P)); } template<typename T> inline T *unwrap
(LLVMValueRef P) { return cast<T>(unwrap(P)); }
905
906// Specialized opaque value conversions.
907inline Value **unwrap(LLVMValueRef *Vals) {
908 return reinterpret_cast<Value**>(Vals);
909}
910
911template<typename T>
912inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
913#ifndef NDEBUG
914 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
915 unwrap<T>(*I); // For side effect of calling assert on invalid usage.
916#endif
917 (void)Length;
918 return reinterpret_cast<T**>(Vals);
919}
920
921inline LLVMValueRef *wrap(const Value **Vals) {
922 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
923}
924
925} // end namespace llvm
926
927#endif // LLVM_IR_VALUE_H