Bug Summary

File:llvm/lib/Analysis/LazyValueInfo.cpp
Warning:line 1322, column 34
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LazyValueInfo.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 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Analysis -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Analysis -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Analysis -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/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-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/Analysis -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Analysis/LazyValueInfo.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/Analysis/LazyValueInfo.cpp

1//===- LazyValueInfo.cpp - Value constraint analysis ------------*- 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 defines the interface for lazy computation of value constraint
10// information.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Analysis/LazyValueInfo.h"
15#include "llvm/ADT/DenseSet.h"
16#include "llvm/ADT/Optional.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/Analysis/AssumptionCache.h"
19#include "llvm/Analysis/ConstantFolding.h"
20#include "llvm/Analysis/InstructionSimplify.h"
21#include "llvm/Analysis/TargetLibraryInfo.h"
22#include "llvm/Analysis/ValueLattice.h"
23#include "llvm/Analysis/ValueTracking.h"
24#include "llvm/IR/AssemblyAnnotationWriter.h"
25#include "llvm/IR/CFG.h"
26#include "llvm/IR/ConstantRange.h"
27#include "llvm/IR/Constants.h"
28#include "llvm/IR/DataLayout.h"
29#include "llvm/IR/Dominators.h"
30#include "llvm/IR/Instructions.h"
31#include "llvm/IR/IntrinsicInst.h"
32#include "llvm/IR/Intrinsics.h"
33#include "llvm/IR/LLVMContext.h"
34#include "llvm/IR/PatternMatch.h"
35#include "llvm/IR/ValueHandle.h"
36#include "llvm/InitializePasses.h"
37#include "llvm/Support/Debug.h"
38#include "llvm/Support/FormattedStream.h"
39#include "llvm/Support/KnownBits.h"
40#include "llvm/Support/raw_ostream.h"
41#include <map>
42using namespace llvm;
43using namespace PatternMatch;
44
45#define DEBUG_TYPE"lazy-value-info" "lazy-value-info"
46
47// This is the number of worklist items we will process to try to discover an
48// answer for a given value.
49static const unsigned MaxProcessedPerValue = 500;
50
51char LazyValueInfoWrapperPass::ID = 0;
52LazyValueInfoWrapperPass::LazyValueInfoWrapperPass() : FunctionPass(ID) {
53 initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
54}
55INITIALIZE_PASS_BEGIN(LazyValueInfoWrapperPass, "lazy-value-info",static void *initializeLazyValueInfoWrapperPassPassOnce(PassRegistry
&Registry) {
56 "Lazy Value Information Analysis", false, true)static void *initializeLazyValueInfoWrapperPassPassOnce(PassRegistry
&Registry) {
57INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)initializeAssumptionCacheTrackerPass(Registry);
58INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
59INITIALIZE_PASS_END(LazyValueInfoWrapperPass, "lazy-value-info",PassInfo *PI = new PassInfo( "Lazy Value Information Analysis"
, "lazy-value-info", &LazyValueInfoWrapperPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<LazyValueInfoWrapperPass>
), false, true); Registry.registerPass(*PI, true); return PI;
} static llvm::once_flag InitializeLazyValueInfoWrapperPassPassFlag
; void llvm::initializeLazyValueInfoWrapperPassPass(PassRegistry
&Registry) { llvm::call_once(InitializeLazyValueInfoWrapperPassPassFlag
, initializeLazyValueInfoWrapperPassPassOnce, std::ref(Registry
)); }
60 "Lazy Value Information Analysis", false, true)PassInfo *PI = new PassInfo( "Lazy Value Information Analysis"
, "lazy-value-info", &LazyValueInfoWrapperPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<LazyValueInfoWrapperPass>
), false, true); Registry.registerPass(*PI, true); return PI;
} static llvm::once_flag InitializeLazyValueInfoWrapperPassPassFlag
; void llvm::initializeLazyValueInfoWrapperPassPass(PassRegistry
&Registry) { llvm::call_once(InitializeLazyValueInfoWrapperPassPassFlag
, initializeLazyValueInfoWrapperPassPassOnce, std::ref(Registry
)); }
61
62namespace llvm {
63 FunctionPass *createLazyValueInfoPass() { return new LazyValueInfoWrapperPass(); }
64}
65
66AnalysisKey LazyValueAnalysis::Key;
67
68/// Returns true if this lattice value represents at most one possible value.
69/// This is as precise as any lattice value can get while still representing
70/// reachable code.
71static bool hasSingleValue(const ValueLatticeElement &Val) {
72 if (Val.isConstantRange() &&
73 Val.getConstantRange().isSingleElement())
74 // Integer constants are single element ranges
75 return true;
76 if (Val.isConstant())
77 // Non integer constants
78 return true;
79 return false;
80}
81
82/// Combine two sets of facts about the same value into a single set of
83/// facts. Note that this method is not suitable for merging facts along
84/// different paths in a CFG; that's what the mergeIn function is for. This
85/// is for merging facts gathered about the same value at the same location
86/// through two independent means.
87/// Notes:
88/// * This method does not promise to return the most precise possible lattice
89/// value implied by A and B. It is allowed to return any lattice element
90/// which is at least as strong as *either* A or B (unless our facts
91/// conflict, see below).
92/// * Due to unreachable code, the intersection of two lattice values could be
93/// contradictory. If this happens, we return some valid lattice value so as
94/// not confuse the rest of LVI. Ideally, we'd always return Undefined, but
95/// we do not make this guarantee. TODO: This would be a useful enhancement.
96static ValueLatticeElement intersect(const ValueLatticeElement &A,
97 const ValueLatticeElement &B) {
98 // Undefined is the strongest state. It means the value is known to be along
99 // an unreachable path.
100 if (A.isUnknown())
101 return A;
102 if (B.isUnknown())
103 return B;
104
105 // If we gave up for one, but got a useable fact from the other, use it.
106 if (A.isOverdefined())
107 return B;
108 if (B.isOverdefined())
109 return A;
110
111 // Can't get any more precise than constants.
112 if (hasSingleValue(A))
113 return A;
114 if (hasSingleValue(B))
115 return B;
116
117 // Could be either constant range or not constant here.
118 if (!A.isConstantRange() || !B.isConstantRange()) {
119 // TODO: Arbitrary choice, could be improved
120 return A;
121 }
122
123 // Intersect two constant ranges
124 ConstantRange Range =
125 A.getConstantRange().intersectWith(B.getConstantRange());
126 // Note: An empty range is implicitly converted to unknown or undef depending
127 // on MayIncludeUndef internally.
128 return ValueLatticeElement::getRange(
129 std::move(Range), /*MayIncludeUndef=*/A.isConstantRangeIncludingUndef() |
130 B.isConstantRangeIncludingUndef());
131}
132
133//===----------------------------------------------------------------------===//
134// LazyValueInfoCache Decl
135//===----------------------------------------------------------------------===//
136
137namespace {
138 /// A callback value handle updates the cache when values are erased.
139 class LazyValueInfoCache;
140 struct LVIValueHandle final : public CallbackVH {
141 LazyValueInfoCache *Parent;
142
143 LVIValueHandle(Value *V, LazyValueInfoCache *P = nullptr)
144 : CallbackVH(V), Parent(P) { }
145
146 void deleted() override;
147 void allUsesReplacedWith(Value *V) override {
148 deleted();
149 }
150 };
151} // end anonymous namespace
152
153namespace {
154 using NonNullPointerSet = SmallDenseSet<AssertingVH<Value>, 2>;
155
156 /// This is the cache kept by LazyValueInfo which
157 /// maintains information about queries across the clients' queries.
158 class LazyValueInfoCache {
159 /// This is all of the cached information for one basic block. It contains
160 /// the per-value lattice elements, as well as a separate set for
161 /// overdefined values to reduce memory usage. Additionally pointers
162 /// dereferenced in the block are cached for nullability queries.
163 struct BlockCacheEntry {
164 SmallDenseMap<AssertingVH<Value>, ValueLatticeElement, 4> LatticeElements;
165 SmallDenseSet<AssertingVH<Value>, 4> OverDefined;
166 // None indicates that the nonnull pointers for this basic block
167 // block have not been computed yet.
168 Optional<NonNullPointerSet> NonNullPointers;
169 };
170
171 /// Cached information per basic block.
172 DenseMap<PoisoningVH<BasicBlock>, std::unique_ptr<BlockCacheEntry>>
173 BlockCache;
174 /// Set of value handles used to erase values from the cache on deletion.
175 DenseSet<LVIValueHandle, DenseMapInfo<Value *>> ValueHandles;
176
177 const BlockCacheEntry *getBlockEntry(BasicBlock *BB) const {
178 auto It = BlockCache.find_as(BB);
179 if (It == BlockCache.end())
180 return nullptr;
181 return It->second.get();
182 }
183
184 BlockCacheEntry *getOrCreateBlockEntry(BasicBlock *BB) {
185 auto It = BlockCache.find_as(BB);
186 if (It == BlockCache.end())
187 It = BlockCache.insert({ BB, std::make_unique<BlockCacheEntry>() })
188 .first;
189
190 return It->second.get();
191 }
192
193 void addValueHandle(Value *Val) {
194 auto HandleIt = ValueHandles.find_as(Val);
195 if (HandleIt == ValueHandles.end())
196 ValueHandles.insert({ Val, this });
197 }
198
199 public:
200 void insertResult(Value *Val, BasicBlock *BB,
201 const ValueLatticeElement &Result) {
202 BlockCacheEntry *Entry = getOrCreateBlockEntry(BB);
203
204 // Insert over-defined values into their own cache to reduce memory
205 // overhead.
206 if (Result.isOverdefined())
207 Entry->OverDefined.insert(Val);
208 else
209 Entry->LatticeElements.insert({ Val, Result });
210
211 addValueHandle(Val);
212 }
213
214 Optional<ValueLatticeElement> getCachedValueInfo(Value *V,
215 BasicBlock *BB) const {
216 const BlockCacheEntry *Entry = getBlockEntry(BB);
217 if (!Entry)
218 return None;
219
220 if (Entry->OverDefined.count(V))
221 return ValueLatticeElement::getOverdefined();
222
223 auto LatticeIt = Entry->LatticeElements.find_as(V);
224 if (LatticeIt == Entry->LatticeElements.end())
225 return None;
226
227 return LatticeIt->second;
228 }
229
230 bool isNonNullAtEndOfBlock(
231 Value *V, BasicBlock *BB,
232 function_ref<NonNullPointerSet(BasicBlock *)> InitFn) {
233 BlockCacheEntry *Entry = getOrCreateBlockEntry(BB);
234 if (!Entry->NonNullPointers) {
235 Entry->NonNullPointers = InitFn(BB);
236 for (Value *V : *Entry->NonNullPointers)
237 addValueHandle(V);
238 }
239
240 return Entry->NonNullPointers->count(V);
241 }
242
243 /// clear - Empty the cache.
244 void clear() {
245 BlockCache.clear();
246 ValueHandles.clear();
247 }
248
249 /// Inform the cache that a given value has been deleted.
250 void eraseValue(Value *V);
251
252 /// This is part of the update interface to inform the cache
253 /// that a block has been deleted.
254 void eraseBlock(BasicBlock *BB);
255
256 /// Updates the cache to remove any influence an overdefined value in
257 /// OldSucc might have (unless also overdefined in NewSucc). This just
258 /// flushes elements from the cache and does not add any.
259 void threadEdgeImpl(BasicBlock *OldSucc,BasicBlock *NewSucc);
260 };
261}
262
263void LazyValueInfoCache::eraseValue(Value *V) {
264 for (auto &Pair : BlockCache) {
265 Pair.second->LatticeElements.erase(V);
266 Pair.second->OverDefined.erase(V);
267 if (Pair.second->NonNullPointers)
268 Pair.second->NonNullPointers->erase(V);
269 }
270
271 auto HandleIt = ValueHandles.find_as(V);
272 if (HandleIt != ValueHandles.end())
273 ValueHandles.erase(HandleIt);
274}
275
276void LVIValueHandle::deleted() {
277 // This erasure deallocates *this, so it MUST happen after we're done
278 // using any and all members of *this.
279 Parent->eraseValue(*this);
280}
281
282void LazyValueInfoCache::eraseBlock(BasicBlock *BB) {
283 BlockCache.erase(BB);
284}
285
286void LazyValueInfoCache::threadEdgeImpl(BasicBlock *OldSucc,
287 BasicBlock *NewSucc) {
288 // When an edge in the graph has been threaded, values that we could not
289 // determine a value for before (i.e. were marked overdefined) may be
290 // possible to solve now. We do NOT try to proactively update these values.
291 // Instead, we clear their entries from the cache, and allow lazy updating to
292 // recompute them when needed.
293
294 // The updating process is fairly simple: we need to drop cached info
295 // for all values that were marked overdefined in OldSucc, and for those same
296 // values in any successor of OldSucc (except NewSucc) in which they were
297 // also marked overdefined.
298 std::vector<BasicBlock*> worklist;
299 worklist.push_back(OldSucc);
300
301 const BlockCacheEntry *Entry = getBlockEntry(OldSucc);
302 if (!Entry || Entry->OverDefined.empty())
303 return; // Nothing to process here.
304 SmallVector<Value *, 4> ValsToClear(Entry->OverDefined.begin(),
305 Entry->OverDefined.end());
306
307 // Use a worklist to perform a depth-first search of OldSucc's successors.
308 // NOTE: We do not need a visited list since any blocks we have already
309 // visited will have had their overdefined markers cleared already, and we
310 // thus won't loop to their successors.
311 while (!worklist.empty()) {
312 BasicBlock *ToUpdate = worklist.back();
313 worklist.pop_back();
314
315 // Skip blocks only accessible through NewSucc.
316 if (ToUpdate == NewSucc) continue;
317
318 // If a value was marked overdefined in OldSucc, and is here too...
319 auto OI = BlockCache.find_as(ToUpdate);
320 if (OI == BlockCache.end() || OI->second->OverDefined.empty())
321 continue;
322 auto &ValueSet = OI->second->OverDefined;
323
324 bool changed = false;
325 for (Value *V : ValsToClear) {
326 if (!ValueSet.erase(V))
327 continue;
328
329 // If we removed anything, then we potentially need to update
330 // blocks successors too.
331 changed = true;
332 }
333
334 if (!changed) continue;
335
336 llvm::append_range(worklist, successors(ToUpdate));
337 }
338}
339
340
341namespace {
342/// An assembly annotator class to print LazyValueCache information in
343/// comments.
344class LazyValueInfoImpl;
345class LazyValueInfoAnnotatedWriter : public AssemblyAnnotationWriter {
346 LazyValueInfoImpl *LVIImpl;
347 // While analyzing which blocks we can solve values for, we need the dominator
348 // information.
349 DominatorTree &DT;
350
351public:
352 LazyValueInfoAnnotatedWriter(LazyValueInfoImpl *L, DominatorTree &DTree)
353 : LVIImpl(L), DT(DTree) {}
354
355 void emitBasicBlockStartAnnot(const BasicBlock *BB,
356 formatted_raw_ostream &OS) override;
357
358 void emitInstructionAnnot(const Instruction *I,
359 formatted_raw_ostream &OS) override;
360};
361}
362namespace {
363// The actual implementation of the lazy analysis and update. Note that the
364// inheritance from LazyValueInfoCache is intended to be temporary while
365// splitting the code and then transitioning to a has-a relationship.
366class LazyValueInfoImpl {
367
368 /// Cached results from previous queries
369 LazyValueInfoCache TheCache;
370
371 /// This stack holds the state of the value solver during a query.
372 /// It basically emulates the callstack of the naive
373 /// recursive value lookup process.
374 SmallVector<std::pair<BasicBlock*, Value*>, 8> BlockValueStack;
375
376 /// Keeps track of which block-value pairs are in BlockValueStack.
377 DenseSet<std::pair<BasicBlock*, Value*> > BlockValueSet;
378
379 /// Push BV onto BlockValueStack unless it's already in there.
380 /// Returns true on success.
381 bool pushBlockValue(const std::pair<BasicBlock *, Value *> &BV) {
382 if (!BlockValueSet.insert(BV).second)
383 return false; // It's already in the stack.
384
385 LLVM_DEBUG(dbgs() << "PUSH: " << *BV.second << " in "do { } while (false)
386 << BV.first->getName() << "\n")do { } while (false);
387 BlockValueStack.push_back(BV);
388 return true;
389 }
390
391 AssumptionCache *AC; ///< A pointer to the cache of @llvm.assume calls.
392 const DataLayout &DL; ///< A mandatory DataLayout
393
394 /// Declaration of the llvm.experimental.guard() intrinsic,
395 /// if it exists in the module.
396 Function *GuardDecl;
397
398 Optional<ValueLatticeElement> getBlockValue(Value *Val, BasicBlock *BB);
399 Optional<ValueLatticeElement> getEdgeValue(Value *V, BasicBlock *F,
400 BasicBlock *T, Instruction *CxtI = nullptr);
401
402 // These methods process one work item and may add more. A false value
403 // returned means that the work item was not completely processed and must
404 // be revisited after going through the new items.
405 bool solveBlockValue(Value *Val, BasicBlock *BB);
406 Optional<ValueLatticeElement> solveBlockValueImpl(Value *Val, BasicBlock *BB);
407 Optional<ValueLatticeElement> solveBlockValueNonLocal(Value *Val,
408 BasicBlock *BB);
409 Optional<ValueLatticeElement> solveBlockValuePHINode(PHINode *PN,
410 BasicBlock *BB);
411 Optional<ValueLatticeElement> solveBlockValueSelect(SelectInst *S,
412 BasicBlock *BB);
413 Optional<ConstantRange> getRangeFor(Value *V, Instruction *CxtI,
414 BasicBlock *BB);
415 Optional<ValueLatticeElement> solveBlockValueBinaryOpImpl(
416 Instruction *I, BasicBlock *BB,
417 std::function<ConstantRange(const ConstantRange &,
418 const ConstantRange &)> OpFn);
419 Optional<ValueLatticeElement> solveBlockValueBinaryOp(BinaryOperator *BBI,
420 BasicBlock *BB);
421 Optional<ValueLatticeElement> solveBlockValueCast(CastInst *CI,
422 BasicBlock *BB);
423 Optional<ValueLatticeElement> solveBlockValueOverflowIntrinsic(
424 WithOverflowInst *WO, BasicBlock *BB);
425 Optional<ValueLatticeElement> solveBlockValueIntrinsic(IntrinsicInst *II,
426 BasicBlock *BB);
427 Optional<ValueLatticeElement> solveBlockValueExtractValue(
428 ExtractValueInst *EVI, BasicBlock *BB);
429 bool isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB);
430 void intersectAssumeOrGuardBlockValueConstantRange(Value *Val,
431 ValueLatticeElement &BBLV,
432 Instruction *BBI);
433
434 void solve();
435
436public:
437 /// This is the query interface to determine the lattice value for the
438 /// specified Value* at the context instruction (if specified) or at the
439 /// start of the block.
440 ValueLatticeElement getValueInBlock(Value *V, BasicBlock *BB,
441 Instruction *CxtI = nullptr);
442
443 /// This is the query interface to determine the lattice value for the
444 /// specified Value* at the specified instruction using only information
445 /// from assumes/guards and range metadata. Unlike getValueInBlock(), no
446 /// recursive query is performed.
447 ValueLatticeElement getValueAt(Value *V, Instruction *CxtI);
448
449 /// This is the query interface to determine the lattice
450 /// value for the specified Value* that is true on the specified edge.
451 ValueLatticeElement getValueOnEdge(Value *V, BasicBlock *FromBB,
452 BasicBlock *ToBB,
453 Instruction *CxtI = nullptr);
454
455 /// Complete flush all previously computed values
456 void clear() {
457 TheCache.clear();
458 }
459
460 /// Printing the LazyValueInfo Analysis.
461 void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
462 LazyValueInfoAnnotatedWriter Writer(this, DTree);
463 F.print(OS, &Writer);
464 }
465
466 /// This is part of the update interface to inform the cache
467 /// that a block has been deleted.
468 void eraseBlock(BasicBlock *BB) {
469 TheCache.eraseBlock(BB);
470 }
471
472 /// This is the update interface to inform the cache that an edge from
473 /// PredBB to OldSucc has been threaded to be from PredBB to NewSucc.
474 void threadEdge(BasicBlock *PredBB,BasicBlock *OldSucc,BasicBlock *NewSucc);
475
476 LazyValueInfoImpl(AssumptionCache *AC, const DataLayout &DL,
477 Function *GuardDecl)
478 : AC(AC), DL(DL), GuardDecl(GuardDecl) {}
479};
480} // end anonymous namespace
481
482
483void LazyValueInfoImpl::solve() {
484 SmallVector<std::pair<BasicBlock *, Value *>, 8> StartingStack(
485 BlockValueStack.begin(), BlockValueStack.end());
486
487 unsigned processedCount = 0;
488 while (!BlockValueStack.empty()) {
489 processedCount++;
490 // Abort if we have to process too many values to get a result for this one.
491 // Because of the design of the overdefined cache currently being per-block
492 // to avoid naming-related issues (IE it wants to try to give different
493 // results for the same name in different blocks), overdefined results don't
494 // get cached globally, which in turn means we will often try to rediscover
495 // the same overdefined result again and again. Once something like
496 // PredicateInfo is used in LVI or CVP, we should be able to make the
497 // overdefined cache global, and remove this throttle.
498 if (processedCount > MaxProcessedPerValue) {
499 LLVM_DEBUG(do { } while (false)
500 dbgs() << "Giving up on stack because we are getting too deep\n")do { } while (false);
501 // Fill in the original values
502 while (!StartingStack.empty()) {
503 std::pair<BasicBlock *, Value *> &e = StartingStack.back();
504 TheCache.insertResult(e.second, e.first,
505 ValueLatticeElement::getOverdefined());
506 StartingStack.pop_back();
507 }
508 BlockValueSet.clear();
509 BlockValueStack.clear();
510 return;
511 }
512 std::pair<BasicBlock *, Value *> e = BlockValueStack.back();
513 assert(BlockValueSet.count(e) && "Stack value should be in BlockValueSet!")(static_cast<void> (0));
514
515 if (solveBlockValue(e.second, e.first)) {
516 // The work item was completely processed.
517 assert(BlockValueStack.back() == e && "Nothing should have been pushed!")(static_cast<void> (0));
518#ifndef NDEBUG1
519 Optional<ValueLatticeElement> BBLV =
520 TheCache.getCachedValueInfo(e.second, e.first);
521 assert(BBLV && "Result should be in cache!")(static_cast<void> (0));
522 LLVM_DEBUG(do { } while (false)
523 dbgs() << "POP " << *e.second << " in " << e.first->getName() << " = "do { } while (false)
524 << *BBLV << "\n")do { } while (false);
525#endif
526
527 BlockValueStack.pop_back();
528 BlockValueSet.erase(e);
529 } else {
530 // More work needs to be done before revisiting.
531 assert(BlockValueStack.back() != e && "Stack should have been pushed!")(static_cast<void> (0));
532 }
533 }
534}
535
536Optional<ValueLatticeElement> LazyValueInfoImpl::getBlockValue(Value *Val,
537 BasicBlock *BB) {
538 // If already a constant, there is nothing to compute.
539 if (Constant *VC = dyn_cast<Constant>(Val))
540 return ValueLatticeElement::get(VC);
541
542 if (Optional<ValueLatticeElement> OptLatticeVal =
543 TheCache.getCachedValueInfo(Val, BB))
544 return OptLatticeVal;
545
546 // We have hit a cycle, assume overdefined.
547 if (!pushBlockValue({ BB, Val }))
548 return ValueLatticeElement::getOverdefined();
549
550 // Yet to be resolved.
551 return None;
552}
553
554static ValueLatticeElement getFromRangeMetadata(Instruction *BBI) {
555 switch (BBI->getOpcode()) {
556 default: break;
557 case Instruction::Load:
558 case Instruction::Call:
559 case Instruction::Invoke:
560 if (MDNode *Ranges = BBI->getMetadata(LLVMContext::MD_range))
561 if (isa<IntegerType>(BBI->getType())) {
562 return ValueLatticeElement::getRange(
563 getConstantRangeFromMetadata(*Ranges));
564 }
565 break;
566 };
567 // Nothing known - will be intersected with other facts
568 return ValueLatticeElement::getOverdefined();
569}
570
571bool LazyValueInfoImpl::solveBlockValue(Value *Val, BasicBlock *BB) {
572 assert(!isa<Constant>(Val) && "Value should not be constant")(static_cast<void> (0));
573 assert(!TheCache.getCachedValueInfo(Val, BB) &&(static_cast<void> (0))
574 "Value should not be in cache")(static_cast<void> (0));
575
576 // Hold off inserting this value into the Cache in case we have to return
577 // false and come back later.
578 Optional<ValueLatticeElement> Res = solveBlockValueImpl(Val, BB);
579 if (!Res)
580 // Work pushed, will revisit
581 return false;
582
583 TheCache.insertResult(Val, BB, *Res);
584 return true;
585}
586
587Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueImpl(
588 Value *Val, BasicBlock *BB) {
589 Instruction *BBI = dyn_cast<Instruction>(Val);
590 if (!BBI || BBI->getParent() != BB)
591 return solveBlockValueNonLocal(Val, BB);
592
593 if (PHINode *PN = dyn_cast<PHINode>(BBI))
594 return solveBlockValuePHINode(PN, BB);
595
596 if (auto *SI = dyn_cast<SelectInst>(BBI))
597 return solveBlockValueSelect(SI, BB);
598
599 // If this value is a nonnull pointer, record it's range and bailout. Note
600 // that for all other pointer typed values, we terminate the search at the
601 // definition. We could easily extend this to look through geps, bitcasts,
602 // and the like to prove non-nullness, but it's not clear that's worth it
603 // compile time wise. The context-insensitive value walk done inside
604 // isKnownNonZero gets most of the profitable cases at much less expense.
605 // This does mean that we have a sensitivity to where the defining
606 // instruction is placed, even if it could legally be hoisted much higher.
607 // That is unfortunate.
608 PointerType *PT = dyn_cast<PointerType>(BBI->getType());
609 if (PT && isKnownNonZero(BBI, DL))
610 return ValueLatticeElement::getNot(ConstantPointerNull::get(PT));
611
612 if (BBI->getType()->isIntegerTy()) {
613 if (auto *CI = dyn_cast<CastInst>(BBI))
614 return solveBlockValueCast(CI, BB);
615
616 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(BBI))
617 return solveBlockValueBinaryOp(BO, BB);
618
619 if (auto *EVI = dyn_cast<ExtractValueInst>(BBI))
620 return solveBlockValueExtractValue(EVI, BB);
621
622 if (auto *II = dyn_cast<IntrinsicInst>(BBI))
623 return solveBlockValueIntrinsic(II, BB);
624 }
625
626 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
627 << "' - unknown inst def found.\n")do { } while (false);
628 return getFromRangeMetadata(BBI);
629}
630
631static void AddNonNullPointer(Value *Ptr, NonNullPointerSet &PtrSet) {
632 // TODO: Use NullPointerIsDefined instead.
633 if (Ptr->getType()->getPointerAddressSpace() == 0)
634 PtrSet.insert(getUnderlyingObject(Ptr));
635}
636
637static void AddNonNullPointersByInstruction(
638 Instruction *I, NonNullPointerSet &PtrSet) {
639 if (LoadInst *L = dyn_cast<LoadInst>(I)) {
640 AddNonNullPointer(L->getPointerOperand(), PtrSet);
641 } else if (StoreInst *S = dyn_cast<StoreInst>(I)) {
642 AddNonNullPointer(S->getPointerOperand(), PtrSet);
643 } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) {
644 if (MI->isVolatile()) return;
645
646 // FIXME: check whether it has a valuerange that excludes zero?
647 ConstantInt *Len = dyn_cast<ConstantInt>(MI->getLength());
648 if (!Len || Len->isZero()) return;
649
650 AddNonNullPointer(MI->getRawDest(), PtrSet);
651 if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI))
652 AddNonNullPointer(MTI->getRawSource(), PtrSet);
653 }
654}
655
656bool LazyValueInfoImpl::isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB) {
657 if (NullPointerIsDefined(BB->getParent(),
658 Val->getType()->getPointerAddressSpace()))
659 return false;
660
661 Val = Val->stripInBoundsOffsets();
662 return TheCache.isNonNullAtEndOfBlock(Val, BB, [](BasicBlock *BB) {
663 NonNullPointerSet NonNullPointers;
664 for (Instruction &I : *BB)
665 AddNonNullPointersByInstruction(&I, NonNullPointers);
666 return NonNullPointers;
667 });
668}
669
670Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueNonLocal(
671 Value *Val, BasicBlock *BB) {
672 ValueLatticeElement Result; // Start Undefined.
673
674 // If this is the entry block, we must be asking about an argument. The
675 // value is overdefined.
676 if (BB->isEntryBlock()) {
677 assert(isa<Argument>(Val) && "Unknown live-in to the entry block")(static_cast<void> (0));
678 return ValueLatticeElement::getOverdefined();
679 }
680
681 // Loop over all of our predecessors, merging what we know from them into
682 // result. If we encounter an unexplored predecessor, we eagerly explore it
683 // in a depth first manner. In practice, this has the effect of discovering
684 // paths we can't analyze eagerly without spending compile times analyzing
685 // other paths. This heuristic benefits from the fact that predecessors are
686 // frequently arranged such that dominating ones come first and we quickly
687 // find a path to function entry. TODO: We should consider explicitly
688 // canonicalizing to make this true rather than relying on this happy
689 // accident.
690 for (BasicBlock *Pred : predecessors(BB)) {
691 Optional<ValueLatticeElement> EdgeResult = getEdgeValue(Val, Pred, BB);
692 if (!EdgeResult)
693 // Explore that input, then return here
694 return None;
695
696 Result.mergeIn(*EdgeResult);
697
698 // If we hit overdefined, exit early. The BlockVals entry is already set
699 // to overdefined.
700 if (Result.isOverdefined()) {
701 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
702 << "' - overdefined because of pred (non local).\n")do { } while (false);
703 return Result;
704 }
705 }
706
707 // Return the merged value, which is more precise than 'overdefined'.
708 assert(!Result.isOverdefined())(static_cast<void> (0));
709 return Result;
710}
711
712Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValuePHINode(
713 PHINode *PN, BasicBlock *BB) {
714 ValueLatticeElement Result; // Start Undefined.
715
716 // Loop over all of our predecessors, merging what we know from them into
717 // result. See the comment about the chosen traversal order in
718 // solveBlockValueNonLocal; the same reasoning applies here.
719 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
720 BasicBlock *PhiBB = PN->getIncomingBlock(i);
721 Value *PhiVal = PN->getIncomingValue(i);
722 // Note that we can provide PN as the context value to getEdgeValue, even
723 // though the results will be cached, because PN is the value being used as
724 // the cache key in the caller.
725 Optional<ValueLatticeElement> EdgeResult =
726 getEdgeValue(PhiVal, PhiBB, BB, PN);
727 if (!EdgeResult)
728 // Explore that input, then return here
729 return None;
730
731 Result.mergeIn(*EdgeResult);
732
733 // If we hit overdefined, exit early. The BlockVals entry is already set
734 // to overdefined.
735 if (Result.isOverdefined()) {
736 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
737 << "' - overdefined because of pred (local).\n")do { } while (false);
738
739 return Result;
740 }
741 }
742
743 // Return the merged value, which is more precise than 'overdefined'.
744 assert(!Result.isOverdefined() && "Possible PHI in entry block?")(static_cast<void> (0));
745 return Result;
746}
747
748static ValueLatticeElement getValueFromCondition(Value *Val, Value *Cond,
749 bool isTrueDest = true);
750
751// If we can determine a constraint on the value given conditions assumed by
752// the program, intersect those constraints with BBLV
753void LazyValueInfoImpl::intersectAssumeOrGuardBlockValueConstantRange(
754 Value *Val, ValueLatticeElement &BBLV, Instruction *BBI) {
755 BBI = BBI ? BBI : dyn_cast<Instruction>(Val);
756 if (!BBI)
757 return;
758
759 BasicBlock *BB = BBI->getParent();
760 for (auto &AssumeVH : AC->assumptionsFor(Val)) {
761 if (!AssumeVH)
762 continue;
763
764 // Only check assumes in the block of the context instruction. Other
765 // assumes will have already been taken into account when the value was
766 // propagated from predecessor blocks.
767 auto *I = cast<CallInst>(AssumeVH);
768 if (I->getParent() != BB || !isValidAssumeForContext(I, BBI))
769 continue;
770
771 BBLV = intersect(BBLV, getValueFromCondition(Val, I->getArgOperand(0)));
772 }
773
774 // If guards are not used in the module, don't spend time looking for them
775 if (GuardDecl && !GuardDecl->use_empty() &&
776 BBI->getIterator() != BB->begin()) {
777 for (Instruction &I : make_range(std::next(BBI->getIterator().getReverse()),
778 BB->rend())) {
779 Value *Cond = nullptr;
780 if (match(&I, m_Intrinsic<Intrinsic::experimental_guard>(m_Value(Cond))))
781 BBLV = intersect(BBLV, getValueFromCondition(Val, Cond));
782 }
783 }
784
785 if (BBLV.isOverdefined()) {
786 // Check whether we're checking at the terminator, and the pointer has
787 // been dereferenced in this block.
788 PointerType *PTy = dyn_cast<PointerType>(Val->getType());
789 if (PTy && BB->getTerminator() == BBI &&
790 isNonNullAtEndOfBlock(Val, BB))
791 BBLV = ValueLatticeElement::getNot(ConstantPointerNull::get(PTy));
792 }
793}
794
795Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueSelect(
796 SelectInst *SI, BasicBlock *BB) {
797 // Recurse on our inputs if needed
798 Optional<ValueLatticeElement> OptTrueVal =
799 getBlockValue(SI->getTrueValue(), BB);
800 if (!OptTrueVal)
801 return None;
802 ValueLatticeElement &TrueVal = *OptTrueVal;
803
804 Optional<ValueLatticeElement> OptFalseVal =
805 getBlockValue(SI->getFalseValue(), BB);
806 if (!OptFalseVal)
807 return None;
808 ValueLatticeElement &FalseVal = *OptFalseVal;
809
810 if (TrueVal.isConstantRange() && FalseVal.isConstantRange()) {
811 const ConstantRange &TrueCR = TrueVal.getConstantRange();
812 const ConstantRange &FalseCR = FalseVal.getConstantRange();
813 Value *LHS = nullptr;
814 Value *RHS = nullptr;
815 SelectPatternResult SPR = matchSelectPattern(SI, LHS, RHS);
816 // Is this a min specifically of our two inputs? (Avoid the risk of
817 // ValueTracking getting smarter looking back past our immediate inputs.)
818 if (SelectPatternResult::isMinOrMax(SPR.Flavor) &&
819 LHS == SI->getTrueValue() && RHS == SI->getFalseValue()) {
820 ConstantRange ResultCR = [&]() {
821 switch (SPR.Flavor) {
822 default:
823 llvm_unreachable("unexpected minmax type!")__builtin_unreachable();
824 case SPF_SMIN: /// Signed minimum
825 return TrueCR.smin(FalseCR);
826 case SPF_UMIN: /// Unsigned minimum
827 return TrueCR.umin(FalseCR);
828 case SPF_SMAX: /// Signed maximum
829 return TrueCR.smax(FalseCR);
830 case SPF_UMAX: /// Unsigned maximum
831 return TrueCR.umax(FalseCR);
832 };
833 }();
834 return ValueLatticeElement::getRange(
835 ResultCR, TrueVal.isConstantRangeIncludingUndef() |
836 FalseVal.isConstantRangeIncludingUndef());
837 }
838
839 if (SPR.Flavor == SPF_ABS) {
840 if (LHS == SI->getTrueValue())
841 return ValueLatticeElement::getRange(
842 TrueCR.abs(), TrueVal.isConstantRangeIncludingUndef());
843 if (LHS == SI->getFalseValue())
844 return ValueLatticeElement::getRange(
845 FalseCR.abs(), FalseVal.isConstantRangeIncludingUndef());
846 }
847
848 if (SPR.Flavor == SPF_NABS) {
849 ConstantRange Zero(APInt::getNullValue(TrueCR.getBitWidth()));
850 if (LHS == SI->getTrueValue())
851 return ValueLatticeElement::getRange(
852 Zero.sub(TrueCR.abs()), FalseVal.isConstantRangeIncludingUndef());
853 if (LHS == SI->getFalseValue())
854 return ValueLatticeElement::getRange(
855 Zero.sub(FalseCR.abs()), FalseVal.isConstantRangeIncludingUndef());
856 }
857 }
858
859 // Can we constrain the facts about the true and false values by using the
860 // condition itself? This shows up with idioms like e.g. select(a > 5, a, 5).
861 // TODO: We could potentially refine an overdefined true value above.
862 Value *Cond = SI->getCondition();
863 TrueVal = intersect(TrueVal,
864 getValueFromCondition(SI->getTrueValue(), Cond, true));
865 FalseVal = intersect(FalseVal,
866 getValueFromCondition(SI->getFalseValue(), Cond, false));
867
868 ValueLatticeElement Result = TrueVal;
869 Result.mergeIn(FalseVal);
870 return Result;
871}
872
873Optional<ConstantRange> LazyValueInfoImpl::getRangeFor(Value *V,
874 Instruction *CxtI,
875 BasicBlock *BB) {
876 Optional<ValueLatticeElement> OptVal = getBlockValue(V, BB);
877 if (!OptVal)
878 return None;
879
880 ValueLatticeElement &Val = *OptVal;
881 intersectAssumeOrGuardBlockValueConstantRange(V, Val, CxtI);
882 if (Val.isConstantRange())
883 return Val.getConstantRange();
884
885 const unsigned OperandBitWidth = DL.getTypeSizeInBits(V->getType());
886 return ConstantRange::getFull(OperandBitWidth);
887}
888
889Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueCast(
890 CastInst *CI, BasicBlock *BB) {
891 // Without knowing how wide the input is, we can't analyze it in any useful
892 // way.
893 if (!CI->getOperand(0)->getType()->isSized())
894 return ValueLatticeElement::getOverdefined();
895
896 // Filter out casts we don't know how to reason about before attempting to
897 // recurse on our operand. This can cut a long search short if we know we're
898 // not going to be able to get any useful information anways.
899 switch (CI->getOpcode()) {
900 case Instruction::Trunc:
901 case Instruction::SExt:
902 case Instruction::ZExt:
903 case Instruction::BitCast:
904 break;
905 default:
906 // Unhandled instructions are overdefined.
907 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
908 << "' - overdefined (unknown cast).\n")do { } while (false);
909 return ValueLatticeElement::getOverdefined();
910 }
911
912 // Figure out the range of the LHS. If that fails, we still apply the
913 // transfer rule on the full set since we may be able to locally infer
914 // interesting facts.
915 Optional<ConstantRange> LHSRes = getRangeFor(CI->getOperand(0), CI, BB);
916 if (!LHSRes.hasValue())
917 // More work to do before applying this transfer rule.
918 return None;
919 const ConstantRange &LHSRange = LHSRes.getValue();
920
921 const unsigned ResultBitWidth = CI->getType()->getIntegerBitWidth();
922
923 // NOTE: We're currently limited by the set of operations that ConstantRange
924 // can evaluate symbolically. Enhancing that set will allows us to analyze
925 // more definitions.
926 return ValueLatticeElement::getRange(LHSRange.castOp(CI->getOpcode(),
927 ResultBitWidth));
928}
929
930Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOpImpl(
931 Instruction *I, BasicBlock *BB,
932 std::function<ConstantRange(const ConstantRange &,
933 const ConstantRange &)> OpFn) {
934 // Figure out the ranges of the operands. If that fails, use a
935 // conservative range, but apply the transfer rule anyways. This
936 // lets us pick up facts from expressions like "and i32 (call i32
937 // @foo()), 32"
938 Optional<ConstantRange> LHSRes = getRangeFor(I->getOperand(0), I, BB);
939 Optional<ConstantRange> RHSRes = getRangeFor(I->getOperand(1), I, BB);
940 if (!LHSRes.hasValue() || !RHSRes.hasValue())
941 // More work to do before applying this transfer rule.
942 return None;
943
944 const ConstantRange &LHSRange = LHSRes.getValue();
945 const ConstantRange &RHSRange = RHSRes.getValue();
946 return ValueLatticeElement::getRange(OpFn(LHSRange, RHSRange));
947}
948
949Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOp(
950 BinaryOperator *BO, BasicBlock *BB) {
951 assert(BO->getOperand(0)->getType()->isSized() &&(static_cast<void> (0))
952 "all operands to binary operators are sized")(static_cast<void> (0));
953 if (BO->getOpcode() == Instruction::Xor) {
954 // Xor is the only operation not supported by ConstantRange::binaryOp().
955 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
956 << "' - overdefined (unknown binary operator).\n")do { } while (false);
957 return ValueLatticeElement::getOverdefined();
958 }
959
960 if (auto *OBO = dyn_cast<OverflowingBinaryOperator>(BO)) {
961 unsigned NoWrapKind = 0;
962 if (OBO->hasNoUnsignedWrap())
963 NoWrapKind |= OverflowingBinaryOperator::NoUnsignedWrap;
964 if (OBO->hasNoSignedWrap())
965 NoWrapKind |= OverflowingBinaryOperator::NoSignedWrap;
966
967 return solveBlockValueBinaryOpImpl(
968 BO, BB,
969 [BO, NoWrapKind](const ConstantRange &CR1, const ConstantRange &CR2) {
970 return CR1.overflowingBinaryOp(BO->getOpcode(), CR2, NoWrapKind);
971 });
972 }
973
974 return solveBlockValueBinaryOpImpl(
975 BO, BB, [BO](const ConstantRange &CR1, const ConstantRange &CR2) {
976 return CR1.binaryOp(BO->getOpcode(), CR2);
977 });
978}
979
980Optional<ValueLatticeElement>
981LazyValueInfoImpl::solveBlockValueOverflowIntrinsic(WithOverflowInst *WO,
982 BasicBlock *BB) {
983 return solveBlockValueBinaryOpImpl(
984 WO, BB, [WO](const ConstantRange &CR1, const ConstantRange &CR2) {
985 return CR1.binaryOp(WO->getBinaryOp(), CR2);
986 });
987}
988
989Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueIntrinsic(
990 IntrinsicInst *II, BasicBlock *BB) {
991 if (!ConstantRange::isIntrinsicSupported(II->getIntrinsicID())) {
992 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
993 << "' - unknown intrinsic.\n")do { } while (false);
994 return getFromRangeMetadata(II);
995 }
996
997 SmallVector<ConstantRange, 2> OpRanges;
998 for (Value *Op : II->args()) {
999 Optional<ConstantRange> Range = getRangeFor(Op, II, BB);
1000 if (!Range)
1001 return None;
1002 OpRanges.push_back(*Range);
1003 }
1004
1005 return ValueLatticeElement::getRange(
1006 ConstantRange::intrinsic(II->getIntrinsicID(), OpRanges));
1007}
1008
1009Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueExtractValue(
1010 ExtractValueInst *EVI, BasicBlock *BB) {
1011 if (auto *WO = dyn_cast<WithOverflowInst>(EVI->getAggregateOperand()))
1012 if (EVI->getNumIndices() == 1 && *EVI->idx_begin() == 0)
1013 return solveBlockValueOverflowIntrinsic(WO, BB);
1014
1015 // Handle extractvalue of insertvalue to allow further simplification
1016 // based on replaced with.overflow intrinsics.
1017 if (Value *V = SimplifyExtractValueInst(
1018 EVI->getAggregateOperand(), EVI->getIndices(),
1019 EVI->getModule()->getDataLayout()))
1020 return getBlockValue(V, BB);
1021
1022 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()do { } while (false)
1023 << "' - overdefined (unknown extractvalue).\n")do { } while (false);
1024 return ValueLatticeElement::getOverdefined();
1025}
1026
1027static bool matchICmpOperand(APInt &Offset, Value *LHS, Value *Val,
1028 ICmpInst::Predicate Pred) {
1029 if (LHS == Val)
1030 return true;
1031
1032 // Handle range checking idiom produced by InstCombine. We will subtract the
1033 // offset from the allowed range for RHS in this case.
1034 const APInt *C;
1035 if (match(LHS, m_Add(m_Specific(Val), m_APInt(C)))) {
1036 Offset = *C;
1037 return true;
1038 }
1039
1040 // Handle the symmetric case. This appears in saturation patterns like
1041 // (x == 16) ? 16 : (x + 1).
1042 if (match(Val, m_Add(m_Specific(LHS), m_APInt(C)))) {
1043 Offset = -*C;
1044 return true;
1045 }
1046
1047 // If (x | y) < C, then (x < C) && (y < C).
1048 if (match(LHS, m_c_Or(m_Specific(Val), m_Value())) &&
1049 (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE))
1050 return true;
1051
1052 // If (x & y) > C, then (x > C) && (y > C).
1053 if (match(LHS, m_c_And(m_Specific(Val), m_Value())) &&
1054 (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE))
1055 return true;
1056
1057 return false;
1058}
1059
1060/// Get value range for a "(Val + Offset) Pred RHS" condition.
1061static ValueLatticeElement getValueFromSimpleICmpCondition(
1062 CmpInst::Predicate Pred, Value *RHS, const APInt &Offset) {
1063 ConstantRange RHSRange(RHS->getType()->getIntegerBitWidth(),
1064 /*isFullSet=*/true);
1065 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS))
1066 RHSRange = ConstantRange(CI->getValue());
1067 else if (Instruction *I = dyn_cast<Instruction>(RHS))
1068 if (auto *Ranges = I->getMetadata(LLVMContext::MD_range))
1069 RHSRange = getConstantRangeFromMetadata(*Ranges);
1070
1071 ConstantRange TrueValues =
1072 ConstantRange::makeAllowedICmpRegion(Pred, RHSRange);
1073 return ValueLatticeElement::getRange(TrueValues.subtract(Offset));
1074}
1075
1076static ValueLatticeElement getValueFromICmpCondition(Value *Val, ICmpInst *ICI,
1077 bool isTrueDest) {
1078 Value *LHS = ICI->getOperand(0);
1079 Value *RHS = ICI->getOperand(1);
1080
1081 // Get the predicate that must hold along the considered edge.
1082 CmpInst::Predicate EdgePred =
1083 isTrueDest ? ICI->getPredicate() : ICI->getInversePredicate();
1084
1085 if (isa<Constant>(RHS)) {
1086 if (ICI->isEquality() && LHS == Val) {
1087 if (EdgePred == ICmpInst::ICMP_EQ)
1088 return ValueLatticeElement::get(cast<Constant>(RHS));
1089 else if (!isa<UndefValue>(RHS))
1090 return ValueLatticeElement::getNot(cast<Constant>(RHS));
1091 }
1092 }
1093
1094 Type *Ty = Val->getType();
1095 if (!Ty->isIntegerTy())
1096 return ValueLatticeElement::getOverdefined();
1097
1098 APInt Offset(Ty->getScalarSizeInBits(), 0);
1099 if (matchICmpOperand(Offset, LHS, Val, EdgePred))
1100 return getValueFromSimpleICmpCondition(EdgePred, RHS, Offset);
1101
1102 CmpInst::Predicate SwappedPred = CmpInst::getSwappedPredicate(EdgePred);
1103 if (matchICmpOperand(Offset, RHS, Val, SwappedPred))
1104 return getValueFromSimpleICmpCondition(SwappedPred, LHS, Offset);
1105
1106 const APInt *Mask, *C;
1107 if (match(LHS, m_And(m_Specific(Val), m_APInt(Mask))) &&
1108 match(RHS, m_APInt(C))) {
1109 // If (Val & Mask) == C then all the masked bits are known and we can
1110 // compute a value range based on that.
1111 if (EdgePred == ICmpInst::ICMP_EQ) {
1112 KnownBits Known;
1113 Known.Zero = ~*C & *Mask;
1114 Known.One = *C & *Mask;
1115 return ValueLatticeElement::getRange(
1116 ConstantRange::fromKnownBits(Known, /*IsSigned*/ false));
1117 }
1118 // If (Val & Mask) != 0 then the value must be larger than the lowest set
1119 // bit of Mask.
1120 if (EdgePred == ICmpInst::ICMP_NE && !Mask->isNullValue() &&
1121 C->isNullValue()) {
1122 unsigned BitWidth = Ty->getIntegerBitWidth();
1123 return ValueLatticeElement::getRange(ConstantRange::getNonEmpty(
1124 APInt::getOneBitSet(BitWidth, Mask->countTrailingZeros()),
1125 APInt::getNullValue(BitWidth)));
1126 }
1127 }
1128
1129 return ValueLatticeElement::getOverdefined();
1130}
1131
1132// Handle conditions of the form
1133// extractvalue(op.with.overflow(%x, C), 1).
1134static ValueLatticeElement getValueFromOverflowCondition(
1135 Value *Val, WithOverflowInst *WO, bool IsTrueDest) {
1136 // TODO: This only works with a constant RHS for now. We could also compute
1137 // the range of the RHS, but this doesn't fit into the current structure of
1138 // the edge value calculation.
1139 const APInt *C;
1140 if (WO->getLHS() != Val || !match(WO->getRHS(), m_APInt(C)))
1141 return ValueLatticeElement::getOverdefined();
1142
1143 // Calculate the possible values of %x for which no overflow occurs.
1144 ConstantRange NWR = ConstantRange::makeExactNoWrapRegion(
1145 WO->getBinaryOp(), *C, WO->getNoWrapKind());
1146
1147 // If overflow is false, %x is constrained to NWR. If overflow is true, %x is
1148 // constrained to it's inverse (all values that might cause overflow).
1149 if (IsTrueDest)
1150 NWR = NWR.inverse();
1151 return ValueLatticeElement::getRange(NWR);
1152}
1153
1154static Optional<ValueLatticeElement>
1155getValueFromConditionImpl(Value *Val, Value *Cond, bool isTrueDest,
1156 bool isRevisit,
1157 SmallDenseMap<Value *, ValueLatticeElement> &Visited,
1158 SmallVectorImpl<Value *> &Worklist) {
1159 if (!isRevisit) {
1160 if (ICmpInst *ICI = dyn_cast<ICmpInst>(Cond))
1161 return getValueFromICmpCondition(Val, ICI, isTrueDest);
1162
1163 if (auto *EVI = dyn_cast<ExtractValueInst>(Cond))
1164 if (auto *WO = dyn_cast<WithOverflowInst>(EVI->getAggregateOperand()))
1165 if (EVI->getNumIndices() == 1 && *EVI->idx_begin() == 1)
1166 return getValueFromOverflowCondition(Val, WO, isTrueDest);
1167 }
1168
1169 Value *L, *R;
1170 bool IsAnd;
1171 if (match(Cond, m_LogicalAnd(m_Value(L), m_Value(R))))
1172 IsAnd = true;
1173 else if (match(Cond, m_LogicalOr(m_Value(L), m_Value(R))))
1174 IsAnd = false;
1175 else
1176 return ValueLatticeElement::getOverdefined();
1177
1178 auto LV = Visited.find(L);
1179 auto RV = Visited.find(R);
1180
1181 // if (L && R) -> intersect L and R
1182 // if (!(L || R)) -> intersect L and R
1183 // if (L || R) -> union L and R
1184 // if (!(L && R)) -> union L and R
1185 if ((isTrueDest ^ IsAnd) && (LV != Visited.end())) {
1186 ValueLatticeElement V = LV->second;
1187 if (V.isOverdefined())
1188 return V;
1189 if (RV != Visited.end()) {
1190 V.mergeIn(RV->second);
1191 return V;
1192 }
1193 }
1194
1195 if (LV == Visited.end() || RV == Visited.end()) {
1196 assert(!isRevisit)(static_cast<void> (0));
1197 if (LV == Visited.end())
1198 Worklist.push_back(L);
1199 if (RV == Visited.end())
1200 Worklist.push_back(R);
1201 return None;
1202 }
1203
1204 return intersect(LV->second, RV->second);
1205}
1206
1207ValueLatticeElement getValueFromCondition(Value *Val, Value *Cond,
1208 bool isTrueDest) {
1209 assert(Cond && "precondition")(static_cast<void> (0));
1210 SmallDenseMap<Value*, ValueLatticeElement> Visited;
1211 SmallVector<Value *> Worklist;
1212
1213 Worklist.push_back(Cond);
1214 do {
1215 Value *CurrentCond = Worklist.back();
1216 // Insert an Overdefined placeholder into the set to prevent
1217 // infinite recursion if there exists IRs that use not
1218 // dominated by its def as in this example:
1219 // "%tmp3 = or i1 undef, %tmp4"
1220 // "%tmp4 = or i1 undef, %tmp3"
1221 auto Iter =
1222 Visited.try_emplace(CurrentCond, ValueLatticeElement::getOverdefined());
1223 bool isRevisit = !Iter.second;
1224 Optional<ValueLatticeElement> Result = getValueFromConditionImpl(
1225 Val, CurrentCond, isTrueDest, isRevisit, Visited, Worklist);
1226 if (Result) {
1227 Visited[CurrentCond] = *Result;
1228 Worklist.pop_back();
1229 }
1230 } while (!Worklist.empty());
1231
1232 auto Result = Visited.find(Cond);
1233 assert(Result != Visited.end())(static_cast<void> (0));
1234 return Result->second;
1235}
1236
1237// Return true if Usr has Op as an operand, otherwise false.
1238static bool usesOperand(User *Usr, Value *Op) {
1239 return is_contained(Usr->operands(), Op);
1240}
1241
1242// Return true if the instruction type of Val is supported by
1243// constantFoldUser(). Currently CastInst, BinaryOperator and FreezeInst only.
1244// Call this before calling constantFoldUser() to find out if it's even worth
1245// attempting to call it.
1246static bool isOperationFoldable(User *Usr) {
1247 return isa<CastInst>(Usr) || isa<BinaryOperator>(Usr) || isa<FreezeInst>(Usr);
1248}
1249
1250// Check if Usr can be simplified to an integer constant when the value of one
1251// of its operands Op is an integer constant OpConstVal. If so, return it as an
1252// lattice value range with a single element or otherwise return an overdefined
1253// lattice value.
1254static ValueLatticeElement constantFoldUser(User *Usr, Value *Op,
1255 const APInt &OpConstVal,
1256 const DataLayout &DL) {
1257 assert(isOperationFoldable(Usr) && "Precondition")(static_cast<void> (0));
1258 Constant* OpConst = Constant::getIntegerValue(Op->getType(), OpConstVal);
1259 // Check if Usr can be simplified to a constant.
1260 if (auto *CI = dyn_cast<CastInst>(Usr)) {
1261 assert(CI->getOperand(0) == Op && "Operand 0 isn't Op")(static_cast<void> (0));
1262 if (auto *C = dyn_cast_or_null<ConstantInt>(
1263 SimplifyCastInst(CI->getOpcode(), OpConst,
1264 CI->getDestTy(), DL))) {
1265 return ValueLatticeElement::getRange(ConstantRange(C->getValue()));
1266 }
1267 } else if (auto *BO = dyn_cast<BinaryOperator>(Usr)) {
1268 bool Op0Match = BO->getOperand(0) == Op;
1269 bool Op1Match = BO->getOperand(1) == Op;
1270 assert((Op0Match || Op1Match) &&(static_cast<void> (0))
1271 "Operand 0 nor Operand 1 isn't a match")(static_cast<void> (0));
1272 Value *LHS = Op0Match ? OpConst : BO->getOperand(0);
1273 Value *RHS = Op1Match ? OpConst : BO->getOperand(1);
1274 if (auto *C = dyn_cast_or_null<ConstantInt>(
1275 SimplifyBinOp(BO->getOpcode(), LHS, RHS, DL))) {
1276 return ValueLatticeElement::getRange(ConstantRange(C->getValue()));
1277 }
1278 } else if (isa<FreezeInst>(Usr)) {
1279 assert(cast<FreezeInst>(Usr)->getOperand(0) == Op && "Operand 0 isn't Op")(static_cast<void> (0));
1280 return ValueLatticeElement::getRange(ConstantRange(OpConstVal));
1281 }
1282 return ValueLatticeElement::getOverdefined();
1283}
1284
1285/// Compute the value of Val on the edge BBFrom -> BBTo. Returns false if
1286/// Val is not constrained on the edge. Result is unspecified if return value
1287/// is false.
1288static Optional<ValueLatticeElement> getEdgeValueLocal(Value *Val,
1289 BasicBlock *BBFrom,
1290 BasicBlock *BBTo) {
1291 // TODO: Handle more complex conditionals. If (v == 0 || v2 < 1) is false, we
1292 // know that v != 0.
1293 if (BranchInst *BI
37.1
'BI' is non-null
37.1
'BI' is non-null
37.1
'BI' is non-null
37.1
'BI' is non-null
= dyn_cast<BranchInst>(BBFrom->getTerminator())) {
37
Assuming the object is a 'BranchInst'
1294 // If this is a conditional branch and only one successor goes to BBTo, then
1295 // we may be able to infer something from the condition.
1296 if (BI->isConditional() &&
38
Calling 'BranchInst::isConditional'
41
Returning from 'BranchInst::isConditional'
42
Taking true branch
1297 BI->getSuccessor(0) != BI->getSuccessor(1)) {
1298 bool isTrueDest = BI->getSuccessor(0) == BBTo;
43
Assuming pointer value is null
1299 assert(BI->getSuccessor(!isTrueDest) == BBTo &&(static_cast<void> (0))
1300 "BBTo isn't a successor of BBFrom")(static_cast<void> (0));
1301 Value *Condition = BI->getCondition();
1302
1303 // If V is the condition of the branch itself, then we know exactly what
1304 // it is.
1305 if (Condition == Val)
44
Assuming 'Condition' is not equal to 'Val'
45
Taking false branch
1306 return ValueLatticeElement::get(ConstantInt::get(
1307 Type::getInt1Ty(Val->getContext()), isTrueDest));
1308
1309 // If the condition of the branch is an equality comparison, we may be
1310 // able to infer the value.
1311 ValueLatticeElement Result = getValueFromCondition(Val, Condition,
1312 isTrueDest);
1313 if (!Result.isOverdefined())
46
Calling 'ValueLatticeElement::isOverdefined'
49
Returning from 'ValueLatticeElement::isOverdefined'
50
Taking false branch
1314 return Result;
1315
1316 if (User *Usr
51.1
'Usr' is non-null
51.1
'Usr' is non-null
51.1
'Usr' is non-null
51.1
'Usr' is non-null
= dyn_cast<User>(Val)) {
51
Assuming 'Val' is a 'User'
52
Taking true branch
1317 assert(Result.isOverdefined() && "Result isn't overdefined")(static_cast<void> (0));
1318 // Check with isOperationFoldable() first to avoid linearly iterating
1319 // over the operands unnecessarily which can be expensive for
1320 // instructions with many operands.
1321 if (isa<IntegerType>(Usr->getType()) && isOperationFoldable(Usr)) {
53
Assuming the object is a 'IntegerType'
54
Assuming the condition is true
55
Taking true branch
1322 const DataLayout &DL = BBTo->getModule()->getDataLayout();
56
Called C++ object pointer is null
1323 if (usesOperand(Usr, Condition)) {
1324 // If Val has Condition as an operand and Val can be folded into a
1325 // constant with either Condition == true or Condition == false,
1326 // propagate the constant.
1327 // eg.
1328 // ; %Val is true on the edge to %then.
1329 // %Val = and i1 %Condition, true.
1330 // br %Condition, label %then, label %else
1331 APInt ConditionVal(1, isTrueDest ? 1 : 0);
1332 Result = constantFoldUser(Usr, Condition, ConditionVal, DL);
1333 } else {
1334 // If one of Val's operand has an inferred value, we may be able to
1335 // infer the value of Val.
1336 // eg.
1337 // ; %Val is 94 on the edge to %then.
1338 // %Val = add i8 %Op, 1
1339 // %Condition = icmp eq i8 %Op, 93
1340 // br i1 %Condition, label %then, label %else
1341 for (unsigned i = 0; i < Usr->getNumOperands(); ++i) {
1342 Value *Op = Usr->getOperand(i);
1343 ValueLatticeElement OpLatticeVal =
1344 getValueFromCondition(Op, Condition, isTrueDest);
1345 if (Optional<APInt> OpConst = OpLatticeVal.asConstantInteger()) {
1346 Result = constantFoldUser(Usr, Op, OpConst.getValue(), DL);
1347 break;
1348 }
1349 }
1350 }
1351 }
1352 }
1353 if (!Result.isOverdefined())
1354 return Result;
1355 }
1356 }
1357
1358 // If the edge was formed by a switch on the value, then we may know exactly
1359 // what it is.
1360 if (SwitchInst *SI = dyn_cast<SwitchInst>(BBFrom->getTerminator())) {
1361 Value *Condition = SI->getCondition();
1362 if (!isa<IntegerType>(Val->getType()))
1363 return None;
1364 bool ValUsesConditionAndMayBeFoldable = false;
1365 if (Condition != Val) {
1366 // Check if Val has Condition as an operand.
1367 if (User *Usr = dyn_cast<User>(Val))
1368 ValUsesConditionAndMayBeFoldable = isOperationFoldable(Usr) &&
1369 usesOperand(Usr, Condition);
1370 if (!ValUsesConditionAndMayBeFoldable)
1371 return None;
1372 }
1373 assert((Condition == Val || ValUsesConditionAndMayBeFoldable) &&(static_cast<void> (0))
1374 "Condition != Val nor Val doesn't use Condition")(static_cast<void> (0));
1375
1376 bool DefaultCase = SI->getDefaultDest() == BBTo;
1377 unsigned BitWidth = Val->getType()->getIntegerBitWidth();
1378 ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);
1379
1380 for (auto Case : SI->cases()) {
1381 APInt CaseValue = Case.getCaseValue()->getValue();
1382 ConstantRange EdgeVal(CaseValue);
1383 if (ValUsesConditionAndMayBeFoldable) {
1384 User *Usr = cast<User>(Val);
1385 const DataLayout &DL = BBTo->getModule()->getDataLayout();
1386 ValueLatticeElement EdgeLatticeVal =
1387 constantFoldUser(Usr, Condition, CaseValue, DL);
1388 if (EdgeLatticeVal.isOverdefined())
1389 return None;
1390 EdgeVal = EdgeLatticeVal.getConstantRange();
1391 }
1392 if (DefaultCase) {
1393 // It is possible that the default destination is the destination of
1394 // some cases. We cannot perform difference for those cases.
1395 // We know Condition != CaseValue in BBTo. In some cases we can use
1396 // this to infer Val == f(Condition) is != f(CaseValue). For now, we
1397 // only do this when f is identity (i.e. Val == Condition), but we
1398 // should be able to do this for any injective f.
1399 if (Case.getCaseSuccessor() != BBTo && Condition == Val)
1400 EdgesVals = EdgesVals.difference(EdgeVal);
1401 } else if (Case.getCaseSuccessor() == BBTo)
1402 EdgesVals = EdgesVals.unionWith(EdgeVal);
1403 }
1404 return ValueLatticeElement::getRange(std::move(EdgesVals));
1405 }
1406 return None;
1407}
1408
1409/// Compute the value of Val on the edge BBFrom -> BBTo or the value at
1410/// the basic block if the edge does not constrain Val.
1411Optional<ValueLatticeElement> LazyValueInfoImpl::getEdgeValue(
1412 Value *Val, BasicBlock *BBFrom, BasicBlock *BBTo, Instruction *CxtI) {
1413 // If already a constant, there is nothing to compute.
1414 if (Constant *VC
33.1
'VC' is null
33.1
'VC' is null
33.1
'VC' is null
33.1
'VC' is null
= dyn_cast<Constant>(Val))
33
'Val' is not a 'Constant'
34
Taking false branch
1415 return ValueLatticeElement::get(VC);
1416
1417 ValueLatticeElement LocalResult = getEdgeValueLocal(Val, BBFrom, BBTo)
35
Passing value via 3rd parameter 'BBTo'
36
Calling 'getEdgeValueLocal'
1418 .getValueOr(ValueLatticeElement::getOverdefined());
1419 if (hasSingleValue(LocalResult))
1420 // Can't get any more precise here
1421 return LocalResult;
1422
1423 Optional<ValueLatticeElement> OptInBlock = getBlockValue(Val, BBFrom);
1424 if (!OptInBlock)
1425 return None;
1426 ValueLatticeElement &InBlock = *OptInBlock;
1427
1428 // Try to intersect ranges of the BB and the constraint on the edge.
1429 intersectAssumeOrGuardBlockValueConstantRange(Val, InBlock,
1430 BBFrom->getTerminator());
1431 // We can use the context instruction (generically the ultimate instruction
1432 // the calling pass is trying to simplify) here, even though the result of
1433 // this function is generally cached when called from the solve* functions
1434 // (and that cached result might be used with queries using a different
1435 // context instruction), because when this function is called from the solve*
1436 // functions, the context instruction is not provided. When called from
1437 // LazyValueInfoImpl::getValueOnEdge, the context instruction is provided,
1438 // but then the result is not cached.
1439 intersectAssumeOrGuardBlockValueConstantRange(Val, InBlock, CxtI);
1440
1441 return intersect(LocalResult, InBlock);
1442}
1443
1444ValueLatticeElement LazyValueInfoImpl::getValueInBlock(Value *V, BasicBlock *BB,
1445 Instruction *CxtI) {
1446 LLVM_DEBUG(dbgs() << "LVI Getting block end value " << *V << " at '"do { } while (false)
1447 << BB->getName() << "'\n")do { } while (false);
1448
1449 assert(BlockValueStack.empty() && BlockValueSet.empty())(static_cast<void> (0));
1450 Optional<ValueLatticeElement> OptResult = getBlockValue(V, BB);
1451 if (!OptResult) {
1452 solve();
1453 OptResult = getBlockValue(V, BB);
1454 assert(OptResult && "Value not available after solving")(static_cast<void> (0));
1455 }
1456 ValueLatticeElement Result = *OptResult;
1457 intersectAssumeOrGuardBlockValueConstantRange(V, Result, CxtI);
1458
1459 LLVM_DEBUG(dbgs() << " Result = " << Result << "\n")do { } while (false);
1460 return Result;
1461}
1462
1463ValueLatticeElement LazyValueInfoImpl::getValueAt(Value *V, Instruction *CxtI) {
1464 LLVM_DEBUG(dbgs() << "LVI Getting value " << *V << " at '" << CxtI->getName()do { } while (false)
11
Loop condition is false. Exiting loop
1465 << "'\n")do { } while (false);
1466
1467 if (auto *C
12.1
'C' is null
12.1
'C' is null
12.1
'C' is null
12.1
'C' is null
= dyn_cast<Constant>(V))
12
Assuming 'V' is not a 'Constant'
13
Taking false branch
1468 return ValueLatticeElement::get(C);
1469
1470 ValueLatticeElement Result = ValueLatticeElement::getOverdefined();
1471 if (auto *I
14.1
'I' is null
14.1
'I' is null
14.1
'I' is null
14.1
'I' is null
= dyn_cast<Instruction>(V))
14
Assuming 'V' is not a 'Instruction'
15
Taking false branch
1472 Result = getFromRangeMetadata(I);
1473 intersectAssumeOrGuardBlockValueConstantRange(V, Result, CxtI);
16
Value assigned to field 'Parent'
1474
1475 LLVM_DEBUG(dbgs() << " Result = " << Result << "\n")do { } while (false);
17
Loop condition is false. Exiting loop
1476 return Result;
1477}
1478
1479ValueLatticeElement LazyValueInfoImpl::
1480getValueOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
1481 Instruction *CxtI) {
1482 LLVM_DEBUG(dbgs() << "LVI Getting edge value " << *V << " from '"do { } while (false)
30
Loop condition is false. Exiting loop
1483 << FromBB->getName() << "' to '" << ToBB->getName()do { } while (false)
1484 << "'\n")do { } while (false);
1485
1486 Optional<ValueLatticeElement> Result = getEdgeValue(V, FromBB, ToBB, CxtI);
31
Passing value via 3rd parameter 'BBTo'
32
Calling 'LazyValueInfoImpl::getEdgeValue'
1487 if (!Result) {
1488 solve();
1489 Result = getEdgeValue(V, FromBB, ToBB, CxtI);
1490 assert(Result && "More work to do after problem solved?")(static_cast<void> (0));
1491 }
1492
1493 LLVM_DEBUG(dbgs() << " Result = " << *Result << "\n")do { } while (false);
1494 return *Result;
1495}
1496
1497void LazyValueInfoImpl::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
1498 BasicBlock *NewSucc) {
1499 TheCache.threadEdgeImpl(OldSucc, NewSucc);
1500}
1501
1502//===----------------------------------------------------------------------===//
1503// LazyValueInfo Impl
1504//===----------------------------------------------------------------------===//
1505
1506/// This lazily constructs the LazyValueInfoImpl.
1507static LazyValueInfoImpl &getImpl(void *&PImpl, AssumptionCache *AC,
1508 const Module *M) {
1509 if (!PImpl) {
1510 assert(M && "getCache() called with a null Module")(static_cast<void> (0));
1511 const DataLayout &DL = M->getDataLayout();
1512 Function *GuardDecl = M->getFunction(
1513 Intrinsic::getName(Intrinsic::experimental_guard));
1514 PImpl = new LazyValueInfoImpl(AC, DL, GuardDecl);
1515 }
1516 return *static_cast<LazyValueInfoImpl*>(PImpl);
1517}
1518
1519bool LazyValueInfoWrapperPass::runOnFunction(Function &F) {
1520 Info.AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
1521 Info.TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
1522
1523 if (Info.PImpl)
1524 getImpl(Info.PImpl, Info.AC, F.getParent()).clear();
1525
1526 // Fully lazy.
1527 return false;
1528}
1529
1530void LazyValueInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
1531 AU.setPreservesAll();
1532 AU.addRequired<AssumptionCacheTracker>();
1533 AU.addRequired<TargetLibraryInfoWrapperPass>();
1534}
1535
1536LazyValueInfo &LazyValueInfoWrapperPass::getLVI() { return Info; }
1537
1538LazyValueInfo::~LazyValueInfo() { releaseMemory(); }
1539
1540void LazyValueInfo::releaseMemory() {
1541 // If the cache was allocated, free it.
1542 if (PImpl) {
1543 delete &getImpl(PImpl, AC, nullptr);
1544 PImpl = nullptr;
1545 }
1546}
1547
1548bool LazyValueInfo::invalidate(Function &F, const PreservedAnalyses &PA,
1549 FunctionAnalysisManager::Invalidator &Inv) {
1550 // We need to invalidate if we have either failed to preserve this analyses
1551 // result directly or if any of its dependencies have been invalidated.
1552 auto PAC = PA.getChecker<LazyValueAnalysis>();
1553 if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()))
1554 return true;
1555
1556 return false;
1557}
1558
1559void LazyValueInfoWrapperPass::releaseMemory() { Info.releaseMemory(); }
1560
1561LazyValueInfo LazyValueAnalysis::run(Function &F,
1562 FunctionAnalysisManager &FAM) {
1563 auto &AC = FAM.getResult<AssumptionAnalysis>(F);
1564 auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F);
1565
1566 return LazyValueInfo(&AC, &F.getParent()->getDataLayout(), &TLI);
1567}
1568
1569/// Returns true if we can statically tell that this value will never be a
1570/// "useful" constant. In practice, this means we've got something like an
1571/// alloca or a malloc call for which a comparison against a constant can
1572/// only be guarding dead code. Note that we are potentially giving up some
1573/// precision in dead code (a constant result) in favour of avoiding a
1574/// expensive search for a easily answered common query.
1575static bool isKnownNonConstant(Value *V) {
1576 V = V->stripPointerCasts();
1577 // The return val of alloc cannot be a Constant.
1578 if (isa<AllocaInst>(V))
1579 return true;
1580 return false;
1581}
1582
1583Constant *LazyValueInfo::getConstant(Value *V, Instruction *CxtI) {
1584 // Bail out early if V is known not to be a Constant.
1585 if (isKnownNonConstant(V))
1586 return nullptr;
1587
1588 BasicBlock *BB = CxtI->getParent();
1589 ValueLatticeElement Result =
1590 getImpl(PImpl, AC, BB->getModule()).getValueInBlock(V, BB, CxtI);
1591
1592 if (Result.isConstant())
1593 return Result.getConstant();
1594 if (Result.isConstantRange()) {
1595 const ConstantRange &CR = Result.getConstantRange();
1596 if (const APInt *SingleVal = CR.getSingleElement())
1597 return ConstantInt::get(V->getContext(), *SingleVal);
1598 }
1599 return nullptr;
1600}
1601
1602ConstantRange LazyValueInfo::getConstantRange(Value *V, Instruction *CxtI,
1603 bool UndefAllowed) {
1604 assert(V->getType()->isIntegerTy())(static_cast<void> (0));
1605 unsigned Width = V->getType()->getIntegerBitWidth();
1606 BasicBlock *BB = CxtI->getParent();
1607 ValueLatticeElement Result =
1608 getImpl(PImpl, AC, BB->getModule()).getValueInBlock(V, BB, CxtI);
1609 if (Result.isUnknown())
1610 return ConstantRange::getEmpty(Width);
1611 if (Result.isConstantRange(UndefAllowed))
1612 return Result.getConstantRange(UndefAllowed);
1613 // We represent ConstantInt constants as constant ranges but other kinds
1614 // of integer constants, i.e. ConstantExpr will be tagged as constants
1615 assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&(static_cast<void> (0))
1616 "ConstantInt value must be represented as constantrange")(static_cast<void> (0));
1617 return ConstantRange::getFull(Width);
1618}
1619
1620/// Determine whether the specified value is known to be a
1621/// constant on the specified edge. Return null if not.
1622Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB,
1623 BasicBlock *ToBB,
1624 Instruction *CxtI) {
1625 Module *M = FromBB->getModule();
1626 ValueLatticeElement Result =
1627 getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
1628
1629 if (Result.isConstant())
1630 return Result.getConstant();
1631 if (Result.isConstantRange()) {
1632 const ConstantRange &CR = Result.getConstantRange();
1633 if (const APInt *SingleVal = CR.getSingleElement())
1634 return ConstantInt::get(V->getContext(), *SingleVal);
1635 }
1636 return nullptr;
1637}
1638
1639ConstantRange LazyValueInfo::getConstantRangeOnEdge(Value *V,
1640 BasicBlock *FromBB,
1641 BasicBlock *ToBB,
1642 Instruction *CxtI) {
1643 unsigned Width = V->getType()->getIntegerBitWidth();
1644 Module *M = FromBB->getModule();
1645 ValueLatticeElement Result =
1646 getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
1647
1648 if (Result.isUnknown())
1649 return ConstantRange::getEmpty(Width);
1650 if (Result.isConstantRange())
1651 return Result.getConstantRange();
1652 // We represent ConstantInt constants as constant ranges but other kinds
1653 // of integer constants, i.e. ConstantExpr will be tagged as constants
1654 assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&(static_cast<void> (0))
1655 "ConstantInt value must be represented as constantrange")(static_cast<void> (0));
1656 return ConstantRange::getFull(Width);
1657}
1658
1659static LazyValueInfo::Tristate
1660getPredicateResult(unsigned Pred, Constant *C, const ValueLatticeElement &Val,
1661 const DataLayout &DL, TargetLibraryInfo *TLI) {
1662 // If we know the value is a constant, evaluate the conditional.
1663 Constant *Res = nullptr;
1664 if (Val.isConstant()) {
1665 Res = ConstantFoldCompareInstOperands(Pred, Val.getConstant(), C, DL, TLI);
1666 if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
1667 return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
1668 return LazyValueInfo::Unknown;
1669 }
1670
1671 if (Val.isConstantRange()) {
1672 ConstantInt *CI = dyn_cast<ConstantInt>(C);
1673 if (!CI) return LazyValueInfo::Unknown;
1674
1675 const ConstantRange &CR = Val.getConstantRange();
1676 if (Pred == ICmpInst::ICMP_EQ) {
1677 if (!CR.contains(CI->getValue()))
1678 return LazyValueInfo::False;
1679
1680 if (CR.isSingleElement())
1681 return LazyValueInfo::True;
1682 } else if (Pred == ICmpInst::ICMP_NE) {
1683 if (!CR.contains(CI->getValue()))
1684 return LazyValueInfo::True;
1685
1686 if (CR.isSingleElement())
1687 return LazyValueInfo::False;
1688 } else {
1689 // Handle more complex predicates.
1690 ConstantRange TrueValues = ConstantRange::makeExactICmpRegion(
1691 (ICmpInst::Predicate)Pred, CI->getValue());
1692 if (TrueValues.contains(CR))
1693 return LazyValueInfo::True;
1694 if (TrueValues.inverse().contains(CR))
1695 return LazyValueInfo::False;
1696 }
1697 return LazyValueInfo::Unknown;
1698 }
1699
1700 if (Val.isNotConstant()) {
1701 // If this is an equality comparison, we can try to fold it knowing that
1702 // "V != C1".
1703 if (Pred == ICmpInst::ICMP_EQ) {
1704 // !C1 == C -> false iff C1 == C.
1705 Res = ConstantFoldCompareInstOperands(ICmpInst::ICMP_NE,
1706 Val.getNotConstant(), C, DL,
1707 TLI);
1708 if (Res->isNullValue())
1709 return LazyValueInfo::False;
1710 } else if (Pred == ICmpInst::ICMP_NE) {
1711 // !C1 != C -> true iff C1 == C.
1712 Res = ConstantFoldCompareInstOperands(ICmpInst::ICMP_NE,
1713 Val.getNotConstant(), C, DL,
1714 TLI);
1715 if (Res->isNullValue())
1716 return LazyValueInfo::True;
1717 }
1718 return LazyValueInfo::Unknown;
1719 }
1720
1721 return LazyValueInfo::Unknown;
1722}
1723
1724/// Determine whether the specified value comparison with a constant is known to
1725/// be true or false on the specified CFG edge. Pred is a CmpInst predicate.
1726LazyValueInfo::Tristate
1727LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
1728 BasicBlock *FromBB, BasicBlock *ToBB,
1729 Instruction *CxtI) {
1730 Module *M = FromBB->getModule();
1731 ValueLatticeElement Result =
1732 getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
28
Passing 'BB' via 3rd parameter 'ToBB'
29
Calling 'LazyValueInfoImpl::getValueOnEdge'
1733
1734 return getPredicateResult(Pred, C, Result, M->getDataLayout(), TLI);
1735}
1736
1737LazyValueInfo::Tristate
1738LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
1739 Instruction *CxtI, bool UseBlockValue) {
1740 // Is or is not NonNull are common predicates being queried. If
1741 // isKnownNonZero can tell us the result of the predicate, we can
1742 // return it quickly. But this is only a fastpath, and falling
1743 // through would still be correct.
1744 Module *M = CxtI->getModule();
1745 const DataLayout &DL = M->getDataLayout();
1746 if (V->getType()->isPointerTy() && C->isNullValue() &&
4
Calling 'Type::isPointerTy'
7
Returning from 'Type::isPointerTy'
1747 isKnownNonZero(V->stripPointerCastsSameRepresentation(), DL)) {
1748 if (Pred == ICmpInst::ICMP_EQ)
1749 return LazyValueInfo::False;
1750 else if (Pred == ICmpInst::ICMP_NE)
1751 return LazyValueInfo::True;
1752 }
1753
1754 ValueLatticeElement Result = UseBlockValue
8
Assuming 'UseBlockValue' is false
9
'?' condition is false
1755 ? getImpl(PImpl, AC, M).getValueInBlock(V, CxtI->getParent(), CxtI)
1756 : getImpl(PImpl, AC, M).getValueAt(V, CxtI);
10
Calling 'LazyValueInfoImpl::getValueAt'
18
Returning from 'LazyValueInfoImpl::getValueAt'
1757 Tristate Ret = getPredicateResult(Pred, C, Result, DL, TLI);
1758 if (Ret
18.1
'Ret' is equal to Unknown
18.1
'Ret' is equal to Unknown
18.1
'Ret' is equal to Unknown
18.1
'Ret' is equal to Unknown
!= Unknown)
19
Taking false branch
1759 return Ret;
1760
1761 // Note: The following bit of code is somewhat distinct from the rest of LVI;
1762 // LVI as a whole tries to compute a lattice value which is conservatively
1763 // correct at a given location. In this case, we have a predicate which we
1764 // weren't able to prove about the merged result, and we're pushing that
1765 // predicate back along each incoming edge to see if we can prove it
1766 // separately for each input. As a motivating example, consider:
1767 // bb1:
1768 // %v1 = ... ; constantrange<1, 5>
1769 // br label %merge
1770 // bb2:
1771 // %v2 = ... ; constantrange<10, 20>
1772 // br label %merge
1773 // merge:
1774 // %phi = phi [%v1, %v2] ; constantrange<1,20>
1775 // %pred = icmp eq i32 %phi, 8
1776 // We can't tell from the lattice value for '%phi' that '%pred' is false
1777 // along each path, but by checking the predicate over each input separately,
1778 // we can.
1779 // We limit the search to one step backwards from the current BB and value.
1780 // We could consider extending this to search further backwards through the
1781 // CFG and/or value graph, but there are non-obvious compile time vs quality
1782 // tradeoffs.
1783 if (CxtI
19.1
'CxtI' is non-null
19.1
'CxtI' is non-null
19.1
'CxtI' is non-null
19.1
'CxtI' is non-null
) {
20
Taking true branch
1784 BasicBlock *BB = CxtI->getParent();
21
'BB' initialized here
1785
1786 // Function entry or an unreachable block. Bail to avoid confusing
1787 // analysis below.
1788 pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
1789 if (PI == PE)
22
Assuming the condition is false
23
Taking false branch
1790 return Unknown;
1791
1792 // If V is a PHI node in the same block as the context, we need to ask
1793 // questions about the predicate as applied to the incoming value along
1794 // each edge. This is useful for eliminating cases where the predicate is
1795 // known along all incoming edges.
1796 if (auto *PHI
24.1
'PHI' is null
24.1
'PHI' is null
24.1
'PHI' is null
24.1
'PHI' is null
= dyn_cast<PHINode>(V))
24
Assuming 'V' is not a 'PHINode'
1797 if (PHI->getParent() == BB) {
1798 Tristate Baseline = Unknown;
1799 for (unsigned i = 0, e = PHI->getNumIncomingValues(); i < e; i++) {
1800 Value *Incoming = PHI->getIncomingValue(i);
1801 BasicBlock *PredBB = PHI->getIncomingBlock(i);
1802 // Note that PredBB may be BB itself.
1803 Tristate Result = getPredicateOnEdge(Pred, Incoming, C, PredBB, BB,
1804 CxtI);
1805
1806 // Keep going as long as we've seen a consistent known result for
1807 // all inputs.
1808 Baseline = (i == 0) ? Result /* First iteration */
1809 : (Baseline == Result ? Baseline : Unknown); /* All others */
1810 if (Baseline == Unknown)
1811 break;
1812 }
1813 if (Baseline != Unknown)
1814 return Baseline;
1815 }
1816
1817 // For a comparison where the V is outside this block, it's possible
1818 // that we've branched on it before. Look to see if the value is known
1819 // on all incoming edges.
1820 if (!isa<Instruction>(V) ||
25
'V' is not a 'Instruction'
1821 cast<Instruction>(V)->getParent() != BB) {
1822 // For predecessor edge, determine if the comparison is true or false
1823 // on that edge. If they're all true or all false, we can conclude
1824 // the value of the comparison in this block.
1825 Tristate Baseline = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
26
Passing 'BB' via 5th parameter 'ToBB'
27
Calling 'LazyValueInfo::getPredicateOnEdge'
1826 if (Baseline != Unknown) {
1827 // Check that all remaining incoming values match the first one.
1828 while (++PI != PE) {
1829 Tristate Ret = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
1830 if (Ret != Baseline) break;
1831 }
1832 // If we terminated early, then one of the values didn't match.
1833 if (PI == PE) {
1834 return Baseline;
1835 }
1836 }
1837 }
1838 }
1839 return Unknown;
1840}
1841
1842LazyValueInfo::Tristate LazyValueInfo::getPredicateAt(unsigned P, Value *LHS,
1843 Value *RHS,
1844 Instruction *CxtI,
1845 bool UseBlockValue) {
1846 CmpInst::Predicate Pred = (CmpInst::Predicate)P;
1847
1848 if (auto *C
1.1
'C' is non-null
1.1
'C' is non-null
1.1
'C' is non-null
1.1
'C' is non-null
= dyn_cast<Constant>(RHS))
1
Assuming 'RHS' is a 'Constant'
2
Taking true branch
1849 return getPredicateAt(P, LHS, C, CxtI, UseBlockValue);
3
Calling 'LazyValueInfo::getPredicateAt'
1850 if (auto *C = dyn_cast<Constant>(LHS))
1851 return getPredicateAt(CmpInst::getSwappedPredicate(Pred), RHS, C, CxtI,
1852 UseBlockValue);
1853
1854 // Got two non-Constant values. While we could handle them somewhat,
1855 // by getting their constant ranges, and applying ConstantRange::icmp(),
1856 // so far it did not appear to be profitable.
1857 return LazyValueInfo::Unknown;
1858}
1859
1860void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
1861 BasicBlock *NewSucc) {
1862 if (PImpl) {
1863 getImpl(PImpl, AC, PredBB->getModule())
1864 .threadEdge(PredBB, OldSucc, NewSucc);
1865 }
1866}
1867
1868void LazyValueInfo::eraseBlock(BasicBlock *BB) {
1869 if (PImpl) {
1870 getImpl(PImpl, AC, BB->getModule()).eraseBlock(BB);
1871 }
1872}
1873
1874
1875void LazyValueInfo::printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
1876 if (PImpl) {
1877 getImpl(PImpl, AC, F.getParent()).printLVI(F, DTree, OS);
1878 }
1879}
1880
1881// Print the LVI for the function arguments at the start of each basic block.
1882void LazyValueInfoAnnotatedWriter::emitBasicBlockStartAnnot(
1883 const BasicBlock *BB, formatted_raw_ostream &OS) {
1884 // Find if there are latticevalues defined for arguments of the function.
1885 auto *F = BB->getParent();
1886 for (auto &Arg : F->args()) {
1887 ValueLatticeElement Result = LVIImpl->getValueInBlock(
1888 const_cast<Argument *>(&Arg), const_cast<BasicBlock *>(BB));
1889 if (Result.isUnknown())
1890 continue;
1891 OS << "; LatticeVal for: '" << Arg << "' is: " << Result << "\n";
1892 }
1893}
1894
1895// This function prints the LVI analysis for the instruction I at the beginning
1896// of various basic blocks. It relies on calculated values that are stored in
1897// the LazyValueInfoCache, and in the absence of cached values, recalculate the
1898// LazyValueInfo for `I`, and print that info.
1899void LazyValueInfoAnnotatedWriter::emitInstructionAnnot(
1900 const Instruction *I, formatted_raw_ostream &OS) {
1901
1902 auto *ParentBB = I->getParent();
1903 SmallPtrSet<const BasicBlock*, 16> BlocksContainingLVI;
1904 // We can generate (solve) LVI values only for blocks that are dominated by
1905 // the I's parent. However, to avoid generating LVI for all dominating blocks,
1906 // that contain redundant/uninteresting information, we print LVI for
1907 // blocks that may use this LVI information (such as immediate successor
1908 // blocks, and blocks that contain uses of `I`).
1909 auto printResult = [&](const BasicBlock *BB) {
1910 if (!BlocksContainingLVI.insert(BB).second)
1911 return;
1912 ValueLatticeElement Result = LVIImpl->getValueInBlock(
1913 const_cast<Instruction *>(I), const_cast<BasicBlock *>(BB));
1914 OS << "; LatticeVal for: '" << *I << "' in BB: '";
1915 BB->printAsOperand(OS, false);
1916 OS << "' is: " << Result << "\n";
1917 };
1918
1919 printResult(ParentBB);
1920 // Print the LVI analysis results for the immediate successor blocks, that
1921 // are dominated by `ParentBB`.
1922 for (auto *BBSucc : successors(ParentBB))
1923 if (DT.dominates(ParentBB, BBSucc))
1924 printResult(BBSucc);
1925
1926 // Print LVI in blocks where `I` is used.
1927 for (auto *U : I->users())
1928 if (auto *UseI = dyn_cast<Instruction>(U))
1929 if (!isa<PHINode>(UseI) || DT.dominates(ParentBB, UseI->getParent()))
1930 printResult(UseI->getParent());
1931
1932}
1933
1934namespace {
1935// Printer class for LazyValueInfo results.
1936class LazyValueInfoPrinter : public FunctionPass {
1937public:
1938 static char ID; // Pass identification, replacement for typeid
1939 LazyValueInfoPrinter() : FunctionPass(ID) {
1940 initializeLazyValueInfoPrinterPass(*PassRegistry::getPassRegistry());
1941 }
1942
1943 void getAnalysisUsage(AnalysisUsage &AU) const override {
1944 AU.setPreservesAll();
1945 AU.addRequired<LazyValueInfoWrapperPass>();
1946 AU.addRequired<DominatorTreeWrapperPass>();
1947 }
1948
1949 // Get the mandatory dominator tree analysis and pass this in to the
1950 // LVIPrinter. We cannot rely on the LVI's DT, since it's optional.
1951 bool runOnFunction(Function &F) override {
1952 dbgs() << "LVI for function '" << F.getName() << "':\n";
1953 auto &LVI = getAnalysis<LazyValueInfoWrapperPass>().getLVI();
1954 auto &DTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1955 LVI.printLVI(F, DTree, dbgs());
1956 return false;
1957 }
1958};
1959}
1960
1961char LazyValueInfoPrinter::ID = 0;
1962INITIALIZE_PASS_BEGIN(LazyValueInfoPrinter, "print-lazy-value-info",static void *initializeLazyValueInfoPrinterPassOnce(PassRegistry
&Registry) {
1963 "Lazy Value Info Printer Pass", false, false)static void *initializeLazyValueInfoPrinterPassOnce(PassRegistry
&Registry) {
1964INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass)initializeLazyValueInfoWrapperPassPass(Registry);
1965INITIALIZE_PASS_END(LazyValueInfoPrinter, "print-lazy-value-info",PassInfo *PI = new PassInfo( "Lazy Value Info Printer Pass", "print-lazy-value-info"
, &LazyValueInfoPrinter::ID, PassInfo::NormalCtor_t(callDefaultCtor
<LazyValueInfoPrinter>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeLazyValueInfoPrinterPassFlag
; void llvm::initializeLazyValueInfoPrinterPass(PassRegistry &
Registry) { llvm::call_once(InitializeLazyValueInfoPrinterPassFlag
, initializeLazyValueInfoPrinterPassOnce, std::ref(Registry))
; }
1966 "Lazy Value Info Printer Pass", false, false)PassInfo *PI = new PassInfo( "Lazy Value Info Printer Pass", "print-lazy-value-info"
, &LazyValueInfoPrinter::ID, PassInfo::NormalCtor_t(callDefaultCtor
<LazyValueInfoPrinter>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeLazyValueInfoPrinterPassFlag
; void llvm::initializeLazyValueInfoPrinterPass(PassRegistry &
Registry) { llvm::call_once(InitializeLazyValueInfoPrinterPassFlag
, initializeLazyValueInfoPrinterPassOnce, std::ref(Registry))
; }

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/Type.h

1//===- llvm/Type.h - Classes for handling data types ------------*- 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 contains the declaration of the Type class. For more "Type"
10// stuff, look in DerivedTypes.h.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_TYPE_H
15#define LLVM_IR_TYPE_H
16
17#include "llvm/ADT/APFloat.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/SmallPtrSet.h"
20#include "llvm/Support/CBindingWrapping.h"
21#include "llvm/Support/Casting.h"
22#include "llvm/Support/Compiler.h"
23#include "llvm/Support/ErrorHandling.h"
24#include "llvm/Support/TypeSize.h"
25#include <cassert>
26#include <cstdint>
27#include <iterator>
28
29namespace llvm {
30
31class IntegerType;
32class LLVMContext;
33class PointerType;
34class raw_ostream;
35class StringRef;
36
37/// The instances of the Type class are immutable: once they are created,
38/// they are never changed. Also note that only one instance of a particular
39/// type is ever created. Thus seeing if two types are equal is a matter of
40/// doing a trivial pointer comparison. To enforce that no two equal instances
41/// are created, Type instances can only be created via static factory methods
42/// in class Type and in derived classes. Once allocated, Types are never
43/// free'd.
44///
45class Type {
46public:
47 //===--------------------------------------------------------------------===//
48 /// Definitions of all of the base types for the Type system. Based on this
49 /// value, you can cast to a class defined in DerivedTypes.h.
50 /// Note: If you add an element to this, you need to add an element to the
51 /// Type::getPrimitiveType function, or else things will break!
52 /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
53 ///
54 enum TypeID {
55 // PrimitiveTypes
56 HalfTyID = 0, ///< 16-bit floating point type
57 BFloatTyID, ///< 16-bit floating point type (7-bit significand)
58 FloatTyID, ///< 32-bit floating point type
59 DoubleTyID, ///< 64-bit floating point type
60 X86_FP80TyID, ///< 80-bit floating point type (X87)
61 FP128TyID, ///< 128-bit floating point type (112-bit significand)
62 PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
63 VoidTyID, ///< type with no size
64 LabelTyID, ///< Labels
65 MetadataTyID, ///< Metadata
66 X86_MMXTyID, ///< MMX vectors (64 bits, X86 specific)
67 X86_AMXTyID, ///< AMX vectors (8192 bits, X86 specific)
68 TokenTyID, ///< Tokens
69
70 // Derived types... see DerivedTypes.h file.
71 IntegerTyID, ///< Arbitrary bit width integers
72 FunctionTyID, ///< Functions
73 PointerTyID, ///< Pointers
74 StructTyID, ///< Structures
75 ArrayTyID, ///< Arrays
76 FixedVectorTyID, ///< Fixed width SIMD vector type
77 ScalableVectorTyID ///< Scalable SIMD vector type
78 };
79
80private:
81 /// This refers to the LLVMContext in which this type was uniqued.
82 LLVMContext &Context;
83
84 TypeID ID : 8; // The current base type of this type.
85 unsigned SubclassData : 24; // Space for subclasses to store data.
86 // Note that this should be synchronized with
87 // MAX_INT_BITS value in IntegerType class.
88
89protected:
90 friend class LLVMContextImpl;
91
92 explicit Type(LLVMContext &C, TypeID tid)
93 : Context(C), ID(tid), SubclassData(0) {}
94 ~Type() = default;
95
96 unsigned getSubclassData() const { return SubclassData; }
97
98 void setSubclassData(unsigned val) {
99 SubclassData = val;
100 // Ensure we don't have any accidental truncation.
101 assert(getSubclassData() == val && "Subclass data too large for field")(static_cast<void> (0));
102 }
103
104 /// Keeps track of how many Type*'s there are in the ContainedTys list.
105 unsigned NumContainedTys = 0;
106
107 /// A pointer to the array of Types contained by this Type. For example, this
108 /// includes the arguments of a function type, the elements of a structure,
109 /// the pointee of a pointer, the element type of an array, etc. This pointer
110 /// may be 0 for types that don't contain other types (Integer, Double,
111 /// Float).
112 Type * const *ContainedTys = nullptr;
113
114public:
115 /// Print the current type.
116 /// Omit the type details if \p NoDetails == true.
117 /// E.g., let %st = type { i32, i16 }
118 /// When \p NoDetails is true, we only print %st.
119 /// Put differently, \p NoDetails prints the type as if
120 /// inlined with the operands when printing an instruction.
121 void print(raw_ostream &O, bool IsForDebug = false,
122 bool NoDetails = false) const;
123
124 void dump() const;
125
126 /// Return the LLVMContext in which this type was uniqued.
127 LLVMContext &getContext() const { return Context; }
128
129 //===--------------------------------------------------------------------===//
130 // Accessors for working with types.
131 //
132
133 /// Return the type id for the type. This will return one of the TypeID enum
134 /// elements defined above.
135 TypeID getTypeID() const { return ID; }
136
137 /// Return true if this is 'void'.
138 bool isVoidTy() const { return getTypeID() == VoidTyID; }
139
140 /// Return true if this is 'half', a 16-bit IEEE fp type.
141 bool isHalfTy() const { return getTypeID() == HalfTyID; }
142
143 /// Return true if this is 'bfloat', a 16-bit bfloat type.
144 bool isBFloatTy() const { return getTypeID() == BFloatTyID; }
145
146 /// Return true if this is 'float', a 32-bit IEEE fp type.
147 bool isFloatTy() const { return getTypeID() == FloatTyID; }
148
149 /// Return true if this is 'double', a 64-bit IEEE fp type.
150 bool isDoubleTy() const { return getTypeID() == DoubleTyID; }
151
152 /// Return true if this is x86 long double.
153 bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; }
154
155 /// Return true if this is 'fp128'.
156 bool isFP128Ty() const { return getTypeID() == FP128TyID; }
157
158 /// Return true if this is powerpc long double.
159 bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; }
160
161 /// Return true if this is one of the six floating-point types
162 bool isFloatingPointTy() const {
163 return getTypeID() == HalfTyID || getTypeID() == BFloatTyID ||
164 getTypeID() == FloatTyID || getTypeID() == DoubleTyID ||
165 getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
166 getTypeID() == PPC_FP128TyID;
167 }
168
169 const fltSemantics &getFltSemantics() const {
170 switch (getTypeID()) {
171 case HalfTyID: return APFloat::IEEEhalf();
172 case BFloatTyID: return APFloat::BFloat();
173 case FloatTyID: return APFloat::IEEEsingle();
174 case DoubleTyID: return APFloat::IEEEdouble();
175 case X86_FP80TyID: return APFloat::x87DoubleExtended();
176 case FP128TyID: return APFloat::IEEEquad();
177 case PPC_FP128TyID: return APFloat::PPCDoubleDouble();
178 default: llvm_unreachable("Invalid floating type")__builtin_unreachable();
179 }
180 }
181
182 /// Return true if this is X86 MMX.
183 bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
184
185 /// Return true if this is X86 AMX.
186 bool isX86_AMXTy() const { return getTypeID() == X86_AMXTyID; }
187
188 /// Return true if this is a FP type or a vector of FP.
189 bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
190
191 /// Return true if this is 'label'.
192 bool isLabelTy() const { return getTypeID() == LabelTyID; }
193
194 /// Return true if this is 'metadata'.
195 bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
196
197 /// Return true if this is 'token'.
198 bool isTokenTy() const { return getTypeID() == TokenTyID; }
199
200 /// True if this is an instance of IntegerType.
201 bool isIntegerTy() const { return getTypeID() == IntegerTyID; }
202
203 /// Return true if this is an IntegerType of the given width.
204 bool isIntegerTy(unsigned Bitwidth) const;
205
206 /// Return true if this is an integer type or a vector of integer types.
207 bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
208
209 /// Return true if this is an integer type or a vector of integer types of
210 /// the given width.
211 bool isIntOrIntVectorTy(unsigned BitWidth) const {
212 return getScalarType()->isIntegerTy(BitWidth);
213 }
214
215 /// Return true if this is an integer type or a pointer type.
216 bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); }
217
218 /// True if this is an instance of FunctionType.
219 bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
220
221 /// True if this is an instance of StructType.
222 bool isStructTy() const { return getTypeID() == StructTyID; }
223
224 /// True if this is an instance of ArrayType.
225 bool isArrayTy() const { return getTypeID() == ArrayTyID; }
226
227 /// True if this is an instance of PointerType.
228 bool isPointerTy() const { return getTypeID() == PointerTyID; }
5
Assuming the condition is false
6
Returning zero, which participates in a condition later
229
230 /// True if this is an instance of an opaque PointerType.
231 bool isOpaquePointerTy() const;
232
233 /// Return true if this is a pointer type or a vector of pointer types.
234 bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
235
236 /// True if this is an instance of VectorType.
237 inline bool isVectorTy() const {
238 return getTypeID() == ScalableVectorTyID || getTypeID() == FixedVectorTyID;
239 }
240
241 /// Return true if this type could be converted with a lossless BitCast to
242 /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
243 /// same size only where no re-interpretation of the bits is done.
244 /// Determine if this type could be losslessly bitcast to Ty
245 bool canLosslesslyBitCastTo(Type *Ty) const;
246
247 /// Return true if this type is empty, that is, it has no elements or all of
248 /// its elements are empty.
249 bool isEmptyTy() const;
250
251 /// Return true if the type is "first class", meaning it is a valid type for a
252 /// Value.
253 bool isFirstClassType() const {
254 return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
255 }
256
257 /// Return true if the type is a valid type for a register in codegen. This
258 /// includes all first-class types except struct and array types.
259 bool isSingleValueType() const {
260 return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
261 isPointerTy() || isVectorTy() || isX86_AMXTy();
262 }
263
264 /// Return true if the type is an aggregate type. This means it is valid as
265 /// the first operand of an insertvalue or extractvalue instruction. This
266 /// includes struct and array types, but does not include vector types.
267 bool isAggregateType() const {
268 return getTypeID() == StructTyID || getTypeID() == ArrayTyID;
269 }
270
271 /// Return true if it makes sense to take the size of this type. To get the
272 /// actual size for a particular target, it is reasonable to use the
273 /// DataLayout subsystem to do this.
274 bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
275 // If it's a primitive, it is always sized.
276 if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
277 getTypeID() == PointerTyID || getTypeID() == X86_MMXTyID ||
278 getTypeID() == X86_AMXTyID)
279 return true;
280 // If it is not something that can have a size (e.g. a function or label),
281 // it doesn't have a size.
282 if (getTypeID() != StructTyID && getTypeID() != ArrayTyID && !isVectorTy())
283 return false;
284 // Otherwise we have to try harder to decide.
285 return isSizedDerivedType(Visited);
286 }
287
288 /// Return the basic size of this type if it is a primitive type. These are
289 /// fixed by LLVM and are not target-dependent.
290 /// This will return zero if the type does not have a size or is not a
291 /// primitive type.
292 ///
293 /// If this is a scalable vector type, the scalable property will be set and
294 /// the runtime size will be a positive integer multiple of the base size.
295 ///
296 /// Note that this may not reflect the size of memory allocated for an
297 /// instance of the type or the number of bytes that are written when an
298 /// instance of the type is stored to memory. The DataLayout class provides
299 /// additional query functions to provide this information.
300 ///
301 TypeSize getPrimitiveSizeInBits() const LLVM_READONLY__attribute__((__pure__));
302
303 /// If this is a vector type, return the getPrimitiveSizeInBits value for the
304 /// element type. Otherwise return the getPrimitiveSizeInBits value for this
305 /// type.
306 unsigned getScalarSizeInBits() const LLVM_READONLY__attribute__((__pure__));
307
308 /// Return the width of the mantissa of this type. This is only valid on
309 /// floating-point types. If the FP type does not have a stable mantissa (e.g.
310 /// ppc long double), this method returns -1.
311 int getFPMantissaWidth() const;
312
313 /// Return whether the type is IEEE compatible, as defined by the eponymous
314 /// method in APFloat.
315 bool isIEEE() const { return APFloat::getZero(getFltSemantics()).isIEEE(); }
316
317 /// If this is a vector type, return the element type, otherwise return
318 /// 'this'.
319 inline Type *getScalarType() const {
320 if (isVectorTy())
321 return getContainedType(0);
322 return const_cast<Type *>(this);
323 }
324
325 //===--------------------------------------------------------------------===//
326 // Type Iteration support.
327 //
328 using subtype_iterator = Type * const *;
329
330 subtype_iterator subtype_begin() const { return ContainedTys; }
331 subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
332 ArrayRef<Type*> subtypes() const {
333 return makeArrayRef(subtype_begin(), subtype_end());
334 }
335
336 using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
337
338 subtype_reverse_iterator subtype_rbegin() const {
339 return subtype_reverse_iterator(subtype_end());
340 }
341 subtype_reverse_iterator subtype_rend() const {
342 return subtype_reverse_iterator(subtype_begin());
343 }
344
345 /// This method is used to implement the type iterator (defined at the end of
346 /// the file). For derived types, this returns the types 'contained' in the
347 /// derived type.
348 Type *getContainedType(unsigned i) const {
349 assert(i < NumContainedTys && "Index out of range!")(static_cast<void> (0));
350 return ContainedTys[i];
351 }
352
353 /// Return the number of types in the derived type.
354 unsigned getNumContainedTypes() const { return NumContainedTys; }
355
356 //===--------------------------------------------------------------------===//
357 // Helper methods corresponding to subclass methods. This forces a cast to
358 // the specified subclass and calls its accessor. "getArrayNumElements" (for
359 // example) is shorthand for cast<ArrayType>(Ty)->getNumElements(). This is
360 // only intended to cover the core methods that are frequently used, helper
361 // methods should not be added here.
362
363 inline unsigned getIntegerBitWidth() const;
364
365 inline Type *getFunctionParamType(unsigned i) const;
366 inline unsigned getFunctionNumParams() const;
367 inline bool isFunctionVarArg() const;
368
369 inline StringRef getStructName() const;
370 inline unsigned getStructNumElements() const;
371 inline Type *getStructElementType(unsigned N) const;
372
373 inline uint64_t getArrayNumElements() const;
374
375 Type *getArrayElementType() const {
376 assert(getTypeID() == ArrayTyID)(static_cast<void> (0));
377 return ContainedTys[0];
378 }
379
380 Type *getPointerElementType() const {
381 assert(getTypeID() == PointerTyID)(static_cast<void> (0));
382 return ContainedTys[0];
383 }
384
385 /// Given vector type, change the element type,
386 /// whilst keeping the old number of elements.
387 /// For non-vectors simply returns \p EltTy.
388 inline Type *getWithNewType(Type *EltTy) const;
389
390 /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
391 /// whilst keeping the old number of lanes.
392 inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;
393
394 /// Given scalar/vector integer type, returns a type with elements twice as
395 /// wide as in the original type. For vectors, preserves element count.
396 inline Type *getExtendedType() const;
397
398 /// Get the address space of this pointer or pointer vector type.
399 inline unsigned getPointerAddressSpace() const;
400
401 //===--------------------------------------------------------------------===//
402 // Static members exported by the Type class itself. Useful for getting
403 // instances of Type.
404 //
405
406 /// Return a type based on an identifier.
407 static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
408
409 //===--------------------------------------------------------------------===//
410 // These are the builtin types that are always available.
411 //
412 static Type *getVoidTy(LLVMContext &C);
413 static Type *getLabelTy(LLVMContext &C);
414 static Type *getHalfTy(LLVMContext &C);
415 static Type *getBFloatTy(LLVMContext &C);
416 static Type *getFloatTy(LLVMContext &C);
417 static Type *getDoubleTy(LLVMContext &C);
418 static Type *getMetadataTy(LLVMContext &C);
419 static Type *getX86_FP80Ty(LLVMContext &C);
420 static Type *getFP128Ty(LLVMContext &C);
421 static Type *getPPC_FP128Ty(LLVMContext &C);
422 static Type *getX86_MMXTy(LLVMContext &C);
423 static Type *getX86_AMXTy(LLVMContext &C);
424 static Type *getTokenTy(LLVMContext &C);
425 static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
426 static IntegerType *getInt1Ty(LLVMContext &C);
427 static IntegerType *getInt8Ty(LLVMContext &C);
428 static IntegerType *getInt16Ty(LLVMContext &C);
429 static IntegerType *getInt32Ty(LLVMContext &C);
430 static IntegerType *getInt64Ty(LLVMContext &C);
431 static IntegerType *getInt128Ty(LLVMContext &C);
432 template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
433 int noOfBits = sizeof(ScalarTy) * CHAR_BIT8;
434 if (std::is_integral<ScalarTy>::value) {
435 return (Type*) Type::getIntNTy(C, noOfBits);
436 } else if (std::is_floating_point<ScalarTy>::value) {
437 switch (noOfBits) {
438 case 32:
439 return Type::getFloatTy(C);
440 case 64:
441 return Type::getDoubleTy(C);
442 }
443 }
444 llvm_unreachable("Unsupported type in Type::getScalarTy")__builtin_unreachable();
445 }
446 static Type *getFloatingPointTy(LLVMContext &C, const fltSemantics &S) {
447 Type *Ty;
448 if (&S == &APFloat::IEEEhalf())
449 Ty = Type::getHalfTy(C);
450 else if (&S == &APFloat::BFloat())
451 Ty = Type::getBFloatTy(C);
452 else if (&S == &APFloat::IEEEsingle())
453 Ty = Type::getFloatTy(C);
454 else if (&S == &APFloat::IEEEdouble())
455 Ty = Type::getDoubleTy(C);
456 else if (&S == &APFloat::x87DoubleExtended())
457 Ty = Type::getX86_FP80Ty(C);
458 else if (&S == &APFloat::IEEEquad())
459 Ty = Type::getFP128Ty(C);
460 else {
461 assert(&S == &APFloat::PPCDoubleDouble() && "Unknown FP format")(static_cast<void> (0));
462 Ty = Type::getPPC_FP128Ty(C);
463 }
464 return Ty;
465 }
466
467 //===--------------------------------------------------------------------===//
468 // Convenience methods for getting pointer types with one of the above builtin
469 // types as pointee.
470 //
471 static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
472 static PointerType *getBFloatPtrTy(LLVMContext &C, unsigned AS = 0);
473 static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
474 static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
475 static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
476 static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
477 static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
478 static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
479 static PointerType *getX86_AMXPtrTy(LLVMContext &C, unsigned AS = 0);
480 static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
481 static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
482 static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
483 static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
484 static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
485 static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
486
487 /// Return a pointer to the current type. This is equivalent to
488 /// PointerType::get(Foo, AddrSpace).
489 /// TODO: Remove this after opaque pointer transition is complete.
490 PointerType *getPointerTo(unsigned AddrSpace = 0) const;
491
492private:
493 /// Derived types like structures and arrays are sized iff all of the members
494 /// of the type are sized as well. Since asking for their size is relatively
495 /// uncommon, move this operation out-of-line.
496 bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
497};
498
499// Printing of types.
500inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
501 T.print(OS);
502 return OS;
503}
504
505// allow isa<PointerType>(x) to work without DerivedTypes.h included.
506template <> struct isa_impl<PointerType, Type> {
507 static inline bool doit(const Type &Ty) {
508 return Ty.getTypeID() == Type::PointerTyID;
509 }
510};
511
512// Create wrappers for C Binding types (see CBindingWrapping.h).
513DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef)inline Type *unwrap(LLVMTypeRef P) { return reinterpret_cast<
Type*>(P); } inline LLVMTypeRef wrap(const Type *P) { return
reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(
P)); } template<typename T> inline T *unwrap(LLVMTypeRef
P) { return cast<T>(unwrap(P)); }
514
515/* Specialized opaque type conversions.
516 */
517inline Type **unwrap(LLVMTypeRef* Tys) {
518 return reinterpret_cast<Type**>(Tys);
519}
520
521inline LLVMTypeRef *wrap(Type **Tys) {
522 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
523}
524
525} // end namespace llvm
526
527#endif // LLVM_IR_TYPE_H

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/Instructions.h

1//===- llvm/Instructions.h - Instruction subclass definitions ---*- 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 exposes the class definitions of all of the subclasses of the
10// Instruction class. This is meant to be an easy way to get access to all
11// instruction subclasses.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H
17
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/Bitfields.h"
20#include "llvm/ADT/MapVector.h"
21#include "llvm/ADT/None.h"
22#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/Twine.h"
26#include "llvm/ADT/iterator.h"
27#include "llvm/ADT/iterator_range.h"
28#include "llvm/IR/Attributes.h"
29#include "llvm/IR/BasicBlock.h"
30#include "llvm/IR/CallingConv.h"
31#include "llvm/IR/CFG.h"
32#include "llvm/IR/Constant.h"
33#include "llvm/IR/DerivedTypes.h"
34#include "llvm/IR/Function.h"
35#include "llvm/IR/InstrTypes.h"
36#include "llvm/IR/Instruction.h"
37#include "llvm/IR/OperandTraits.h"
38#include "llvm/IR/Type.h"
39#include "llvm/IR/Use.h"
40#include "llvm/IR/User.h"
41#include "llvm/IR/Value.h"
42#include "llvm/Support/AtomicOrdering.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/ErrorHandling.h"
45#include <cassert>
46#include <cstddef>
47#include <cstdint>
48#include <iterator>
49
50namespace llvm {
51
52class APInt;
53class ConstantInt;
54class DataLayout;
55class LLVMContext;
56
57//===----------------------------------------------------------------------===//
58// AllocaInst Class
59//===----------------------------------------------------------------------===//
60
61/// an instruction to allocate memory on the stack
62class AllocaInst : public UnaryInstruction {
63 Type *AllocatedType;
64
65 using AlignmentField = AlignmentBitfieldElementT<0>;
66 using UsedWithInAllocaField = BoolBitfieldElementT<AlignmentField::NextBit>;
67 using SwiftErrorField = BoolBitfieldElementT<UsedWithInAllocaField::NextBit>;
68 static_assert(Bitfield::areContiguous<AlignmentField, UsedWithInAllocaField,
69 SwiftErrorField>(),
70 "Bitfields must be contiguous");
71
72protected:
73 // Note: Instruction needs to be a friend here to call cloneImpl.
74 friend class Instruction;
75
76 AllocaInst *cloneImpl() const;
77
78public:
79 explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
80 const Twine &Name, Instruction *InsertBefore);
81 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
82 const Twine &Name, BasicBlock *InsertAtEnd);
83
84 AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
85 Instruction *InsertBefore);
86 AllocaInst(Type *Ty, unsigned AddrSpace,
87 const Twine &Name, BasicBlock *InsertAtEnd);
88
89 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
90 const Twine &Name = "", Instruction *InsertBefore = nullptr);
91 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
92 const Twine &Name, BasicBlock *InsertAtEnd);
93
94 /// Return true if there is an allocation size parameter to the allocation
95 /// instruction that is not 1.
96 bool isArrayAllocation() const;
97
98 /// Get the number of elements allocated. For a simple allocation of a single
99 /// element, this will return a constant 1 value.
100 const Value *getArraySize() const { return getOperand(0); }
101 Value *getArraySize() { return getOperand(0); }
102
103 /// Overload to return most specific pointer type.
104 PointerType *getType() const {
105 return cast<PointerType>(Instruction::getType());
106 }
107
108 /// Get allocation size in bits. Returns None if size can't be determined,
109 /// e.g. in case of a VLA.
110 Optional<TypeSize> getAllocationSizeInBits(const DataLayout &DL) const;
111
112 /// Return the type that is being allocated by the instruction.
113 Type *getAllocatedType() const { return AllocatedType; }
114 /// for use only in special circumstances that need to generically
115 /// transform a whole instruction (eg: IR linking and vectorization).
116 void setAllocatedType(Type *Ty) { AllocatedType = Ty; }
117
118 /// Return the alignment of the memory that is being allocated by the
119 /// instruction.
120 Align getAlign() const {
121 return Align(1ULL << getSubclassData<AlignmentField>());
122 }
123
124 void setAlignment(Align Align) {
125 setSubclassData<AlignmentField>(Log2(Align));
126 }
127
128 // FIXME: Remove this one transition to Align is over.
129 unsigned getAlignment() const { return getAlign().value(); }
130
131 /// Return true if this alloca is in the entry block of the function and is a
132 /// constant size. If so, the code generator will fold it into the
133 /// prolog/epilog code, so it is basically free.
134 bool isStaticAlloca() const;
135
136 /// Return true if this alloca is used as an inalloca argument to a call. Such
137 /// allocas are never considered static even if they are in the entry block.
138 bool isUsedWithInAlloca() const {
139 return getSubclassData<UsedWithInAllocaField>();
140 }
141
142 /// Specify whether this alloca is used to represent the arguments to a call.
143 void setUsedWithInAlloca(bool V) {
144 setSubclassData<UsedWithInAllocaField>(V);
145 }
146
147 /// Return true if this alloca is used as a swifterror argument to a call.
148 bool isSwiftError() const { return getSubclassData<SwiftErrorField>(); }
149 /// Specify whether this alloca is used to represent a swifterror.
150 void setSwiftError(bool V) { setSubclassData<SwiftErrorField>(V); }
151
152 // Methods for support type inquiry through isa, cast, and dyn_cast:
153 static bool classof(const Instruction *I) {
154 return (I->getOpcode() == Instruction::Alloca);
155 }
156 static bool classof(const Value *V) {
157 return isa<Instruction>(V) && classof(cast<Instruction>(V));
158 }
159
160private:
161 // Shadow Instruction::setInstructionSubclassData with a private forwarding
162 // method so that subclasses cannot accidentally use it.
163 template <typename Bitfield>
164 void setSubclassData(typename Bitfield::Type Value) {
165 Instruction::setSubclassData<Bitfield>(Value);
166 }
167};
168
169//===----------------------------------------------------------------------===//
170// LoadInst Class
171//===----------------------------------------------------------------------===//
172
173/// An instruction for reading from memory. This uses the SubclassData field in
174/// Value to store whether or not the load is volatile.
175class LoadInst : public UnaryInstruction {
176 using VolatileField = BoolBitfieldElementT<0>;
177 using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
178 using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
179 static_assert(
180 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
181 "Bitfields must be contiguous");
182
183 void AssertOK();
184
185protected:
186 // Note: Instruction needs to be a friend here to call cloneImpl.
187 friend class Instruction;
188
189 LoadInst *cloneImpl() const;
190
191public:
192 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
193 Instruction *InsertBefore);
194 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
195 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
196 Instruction *InsertBefore);
197 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
198 BasicBlock *InsertAtEnd);
199 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
200 Align Align, Instruction *InsertBefore = nullptr);
201 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
202 Align Align, BasicBlock *InsertAtEnd);
203 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
204 Align Align, AtomicOrdering Order,
205 SyncScope::ID SSID = SyncScope::System,
206 Instruction *InsertBefore = nullptr);
207 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
208 Align Align, AtomicOrdering Order, SyncScope::ID SSID,
209 BasicBlock *InsertAtEnd);
210
211 /// Return true if this is a load from a volatile memory location.
212 bool isVolatile() const { return getSubclassData<VolatileField>(); }
213
214 /// Specify whether this is a volatile load or not.
215 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
216
217 /// Return the alignment of the access that is being performed.
218 /// FIXME: Remove this function once transition to Align is over.
219 /// Use getAlign() instead.
220 unsigned getAlignment() const { return getAlign().value(); }
221
222 /// Return the alignment of the access that is being performed.
223 Align getAlign() const {
224 return Align(1ULL << (getSubclassData<AlignmentField>()));
225 }
226
227 void setAlignment(Align Align) {
228 setSubclassData<AlignmentField>(Log2(Align));
229 }
230
231 /// Returns the ordering constraint of this load instruction.
232 AtomicOrdering getOrdering() const {
233 return getSubclassData<OrderingField>();
234 }
235 /// Sets the ordering constraint of this load instruction. May not be Release
236 /// or AcquireRelease.
237 void setOrdering(AtomicOrdering Ordering) {
238 setSubclassData<OrderingField>(Ordering);
239 }
240
241 /// Returns the synchronization scope ID of this load instruction.
242 SyncScope::ID getSyncScopeID() const {
243 return SSID;
244 }
245
246 /// Sets the synchronization scope ID of this load instruction.
247 void setSyncScopeID(SyncScope::ID SSID) {
248 this->SSID = SSID;
249 }
250
251 /// Sets the ordering constraint and the synchronization scope ID of this load
252 /// instruction.
253 void setAtomic(AtomicOrdering Ordering,
254 SyncScope::ID SSID = SyncScope::System) {
255 setOrdering(Ordering);
256 setSyncScopeID(SSID);
257 }
258
259 bool isSimple() const { return !isAtomic() && !isVolatile(); }
260
261 bool isUnordered() const {
262 return (getOrdering() == AtomicOrdering::NotAtomic ||
263 getOrdering() == AtomicOrdering::Unordered) &&
264 !isVolatile();
265 }
266
267 Value *getPointerOperand() { return getOperand(0); }
268 const Value *getPointerOperand() const { return getOperand(0); }
269 static unsigned getPointerOperandIndex() { return 0U; }
270 Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
271
272 /// Returns the address space of the pointer operand.
273 unsigned getPointerAddressSpace() const {
274 return getPointerOperandType()->getPointerAddressSpace();
275 }
276
277 // Methods for support type inquiry through isa, cast, and dyn_cast:
278 static bool classof(const Instruction *I) {
279 return I->getOpcode() == Instruction::Load;
280 }
281 static bool classof(const Value *V) {
282 return isa<Instruction>(V) && classof(cast<Instruction>(V));
283 }
284
285private:
286 // Shadow Instruction::setInstructionSubclassData with a private forwarding
287 // method so that subclasses cannot accidentally use it.
288 template <typename Bitfield>
289 void setSubclassData(typename Bitfield::Type Value) {
290 Instruction::setSubclassData<Bitfield>(Value);
291 }
292
293 /// The synchronization scope ID of this load instruction. Not quite enough
294 /// room in SubClassData for everything, so synchronization scope ID gets its
295 /// own field.
296 SyncScope::ID SSID;
297};
298
299//===----------------------------------------------------------------------===//
300// StoreInst Class
301//===----------------------------------------------------------------------===//
302
303/// An instruction for storing to memory.
304class StoreInst : public Instruction {
305 using VolatileField = BoolBitfieldElementT<0>;
306 using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
307 using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
308 static_assert(
309 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
310 "Bitfields must be contiguous");
311
312 void AssertOK();
313
314protected:
315 // Note: Instruction needs to be a friend here to call cloneImpl.
316 friend class Instruction;
317
318 StoreInst *cloneImpl() const;
319
320public:
321 StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
322 StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
323 StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
324 StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
325 StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
326 Instruction *InsertBefore = nullptr);
327 StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
328 BasicBlock *InsertAtEnd);
329 StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
330 AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
331 Instruction *InsertBefore = nullptr);
332 StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
333 AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);
334
335 // allocate space for exactly two operands
336 void *operator new(size_t S) { return User::operator new(S, 2); }
337 void operator delete(void *Ptr) { User::operator delete(Ptr); }
338
339 /// Return true if this is a store to a volatile memory location.
340 bool isVolatile() const { return getSubclassData<VolatileField>(); }
341
342 /// Specify whether this is a volatile store or not.
343 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
344
345 /// Transparently provide more efficient getOperand methods.
346 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
347
348 /// Return the alignment of the access that is being performed
349 /// FIXME: Remove this function once transition to Align is over.
350 /// Use getAlign() instead.
351 unsigned getAlignment() const { return getAlign().value(); }
352
353 Align getAlign() const {
354 return Align(1ULL << (getSubclassData<AlignmentField>()));
355 }
356
357 void setAlignment(Align Align) {
358 setSubclassData<AlignmentField>(Log2(Align));
359 }
360
361 /// Returns the ordering constraint of this store instruction.
362 AtomicOrdering getOrdering() const {
363 return getSubclassData<OrderingField>();
364 }
365
366 /// Sets the ordering constraint of this store instruction. May not be
367 /// Acquire or AcquireRelease.
368 void setOrdering(AtomicOrdering Ordering) {
369 setSubclassData<OrderingField>(Ordering);
370 }
371
372 /// Returns the synchronization scope ID of this store instruction.
373 SyncScope::ID getSyncScopeID() const {
374 return SSID;
375 }
376
377 /// Sets the synchronization scope ID of this store instruction.
378 void setSyncScopeID(SyncScope::ID SSID) {
379 this->SSID = SSID;
380 }
381
382 /// Sets the ordering constraint and the synchronization scope ID of this
383 /// store instruction.
384 void setAtomic(AtomicOrdering Ordering,
385 SyncScope::ID SSID = SyncScope::System) {
386 setOrdering(Ordering);
387 setSyncScopeID(SSID);
388 }
389
390 bool isSimple() const { return !isAtomic() && !isVolatile(); }
391
392 bool isUnordered() const {
393 return (getOrdering() == AtomicOrdering::NotAtomic ||
394 getOrdering() == AtomicOrdering::Unordered) &&
395 !isVolatile();
396 }
397
398 Value *getValueOperand() { return getOperand(0); }
399 const Value *getValueOperand() const { return getOperand(0); }
400
401 Value *getPointerOperand() { return getOperand(1); }
402 const Value *getPointerOperand() const { return getOperand(1); }
403 static unsigned getPointerOperandIndex() { return 1U; }
404 Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
405
406 /// Returns the address space of the pointer operand.
407 unsigned getPointerAddressSpace() const {
408 return getPointerOperandType()->getPointerAddressSpace();
409 }
410
411 // Methods for support type inquiry through isa, cast, and dyn_cast:
412 static bool classof(const Instruction *I) {
413 return I->getOpcode() == Instruction::Store;
414 }
415 static bool classof(const Value *V) {
416 return isa<Instruction>(V) && classof(cast<Instruction>(V));
417 }
418
419private:
420 // Shadow Instruction::setInstructionSubclassData with a private forwarding
421 // method so that subclasses cannot accidentally use it.
422 template <typename Bitfield>
423 void setSubclassData(typename Bitfield::Type Value) {
424 Instruction::setSubclassData<Bitfield>(Value);
425 }
426
427 /// The synchronization scope ID of this store instruction. Not quite enough
428 /// room in SubClassData for everything, so synchronization scope ID gets its
429 /// own field.
430 SyncScope::ID SSID;
431};
432
433template <>
434struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
435};
436
437DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)StoreInst::op_iterator StoreInst::op_begin() { return OperandTraits
<StoreInst>::op_begin(this); } StoreInst::const_op_iterator
StoreInst::op_begin() const { return OperandTraits<StoreInst
>::op_begin(const_cast<StoreInst*>(this)); } StoreInst
::op_iterator StoreInst::op_end() { return OperandTraits<StoreInst
>::op_end(this); } StoreInst::const_op_iterator StoreInst::
op_end() const { return OperandTraits<StoreInst>::op_end
(const_cast<StoreInst*>(this)); } Value *StoreInst::getOperand
(unsigned i_nocapture) const { (static_cast<void> (0));
return cast_or_null<Value>( OperandTraits<StoreInst
>::op_begin(const_cast<StoreInst*>(this))[i_nocapture
].get()); } void StoreInst::setOperand(unsigned i_nocapture, Value
*Val_nocapture) { (static_cast<void> (0)); OperandTraits
<StoreInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned StoreInst::getNumOperands() const { return OperandTraits
<StoreInst>::operands(this); } template <int Idx_nocapture
> Use &StoreInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
StoreInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }
438
439//===----------------------------------------------------------------------===//
440// FenceInst Class
441//===----------------------------------------------------------------------===//
442
443/// An instruction for ordering other memory operations.
444class FenceInst : public Instruction {
445 using OrderingField = AtomicOrderingBitfieldElementT<0>;
446
447 void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
448
449protected:
450 // Note: Instruction needs to be a friend here to call cloneImpl.
451 friend class Instruction;
452
453 FenceInst *cloneImpl() const;
454
455public:
456 // Ordering may only be Acquire, Release, AcquireRelease, or
457 // SequentiallyConsistent.
458 FenceInst(LLVMContext &C, AtomicOrdering Ordering,
459 SyncScope::ID SSID = SyncScope::System,
460 Instruction *InsertBefore = nullptr);
461 FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
462 BasicBlock *InsertAtEnd);
463
464 // allocate space for exactly zero operands
465 void *operator new(size_t S) { return User::operator new(S, 0); }
466 void operator delete(void *Ptr) { User::operator delete(Ptr); }
467
468 /// Returns the ordering constraint of this fence instruction.
469 AtomicOrdering getOrdering() const {
470 return getSubclassData<OrderingField>();
471 }
472
473 /// Sets the ordering constraint of this fence instruction. May only be
474 /// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
475 void setOrdering(AtomicOrdering Ordering) {
476 setSubclassData<OrderingField>(Ordering);
477 }
478
479 /// Returns the synchronization scope ID of this fence instruction.
480 SyncScope::ID getSyncScopeID() const {
481 return SSID;
482 }
483
484 /// Sets the synchronization scope ID of this fence instruction.
485 void setSyncScopeID(SyncScope::ID SSID) {
486 this->SSID = SSID;
487 }
488
489 // Methods for support type inquiry through isa, cast, and dyn_cast:
490 static bool classof(const Instruction *I) {
491 return I->getOpcode() == Instruction::Fence;
492 }
493 static bool classof(const Value *V) {
494 return isa<Instruction>(V) && classof(cast<Instruction>(V));
495 }
496
497private:
498 // Shadow Instruction::setInstructionSubclassData with a private forwarding
499 // method so that subclasses cannot accidentally use it.
500 template <typename Bitfield>
501 void setSubclassData(typename Bitfield::Type Value) {
502 Instruction::setSubclassData<Bitfield>(Value);
503 }
504
505 /// The synchronization scope ID of this fence instruction. Not quite enough
506 /// room in SubClassData for everything, so synchronization scope ID gets its
507 /// own field.
508 SyncScope::ID SSID;
509};
510
511//===----------------------------------------------------------------------===//
512// AtomicCmpXchgInst Class
513//===----------------------------------------------------------------------===//
514
515/// An instruction that atomically checks whether a
516/// specified value is in a memory location, and, if it is, stores a new value
517/// there. The value returned by this instruction is a pair containing the
518/// original value as first element, and an i1 indicating success (true) or
519/// failure (false) as second element.
520///
521class AtomicCmpXchgInst : public Instruction {
522 void Init(Value *Ptr, Value *Cmp, Value *NewVal, Align Align,
523 AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
524 SyncScope::ID SSID);
525
526 template <unsigned Offset>
527 using AtomicOrderingBitfieldElement =
528 typename Bitfield::Element<AtomicOrdering, Offset, 3,
529 AtomicOrdering::LAST>;
530
531protected:
532 // Note: Instruction needs to be a friend here to call cloneImpl.
533 friend class Instruction;
534
535 AtomicCmpXchgInst *cloneImpl() const;
536
537public:
538 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
539 AtomicOrdering SuccessOrdering,
540 AtomicOrdering FailureOrdering, SyncScope::ID SSID,
541 Instruction *InsertBefore = nullptr);
542 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
543 AtomicOrdering SuccessOrdering,
544 AtomicOrdering FailureOrdering, SyncScope::ID SSID,
545 BasicBlock *InsertAtEnd);
546
547 // allocate space for exactly three operands
548 void *operator new(size_t S) { return User::operator new(S, 3); }
549 void operator delete(void *Ptr) { User::operator delete(Ptr); }
550
551 using VolatileField = BoolBitfieldElementT<0>;
552 using WeakField = BoolBitfieldElementT<VolatileField::NextBit>;
553 using SuccessOrderingField =
554 AtomicOrderingBitfieldElementT<WeakField::NextBit>;
555 using FailureOrderingField =
556 AtomicOrderingBitfieldElementT<SuccessOrderingField::NextBit>;
557 using AlignmentField =
558 AlignmentBitfieldElementT<FailureOrderingField::NextBit>;
559 static_assert(
560 Bitfield::areContiguous<VolatileField, WeakField, SuccessOrderingField,
561 FailureOrderingField, AlignmentField>(),
562 "Bitfields must be contiguous");
563
564 /// Return the alignment of the memory that is being allocated by the
565 /// instruction.
566 Align getAlign() const {
567 return Align(1ULL << getSubclassData<AlignmentField>());
568 }
569
570 void setAlignment(Align Align) {
571 setSubclassData<AlignmentField>(Log2(Align));
572 }
573
574 /// Return true if this is a cmpxchg from a volatile memory
575 /// location.
576 ///
577 bool isVolatile() const { return getSubclassData<VolatileField>(); }
578
579 /// Specify whether this is a volatile cmpxchg.
580 ///
581 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
582
583 /// Return true if this cmpxchg may spuriously fail.
584 bool isWeak() const { return getSubclassData<WeakField>(); }
585
586 void setWeak(bool IsWeak) { setSubclassData<WeakField>(IsWeak); }
587
588 /// Transparently provide more efficient getOperand methods.
589 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
590
591 static bool isValidSuccessOrdering(AtomicOrdering Ordering) {
592 return Ordering != AtomicOrdering::NotAtomic &&
593 Ordering != AtomicOrdering::Unordered;
594 }
595
596 static bool isValidFailureOrdering(AtomicOrdering Ordering) {
597 return Ordering != AtomicOrdering::NotAtomic &&
598 Ordering != AtomicOrdering::Unordered &&
599 Ordering != AtomicOrdering::AcquireRelease &&
600 Ordering != AtomicOrdering::Release;
601 }
602
603 /// Returns the success ordering constraint of this cmpxchg instruction.
604 AtomicOrdering getSuccessOrdering() const {
605 return getSubclassData<SuccessOrderingField>();
606 }
607
608 /// Sets the success ordering constraint of this cmpxchg instruction.
609 void setSuccessOrdering(AtomicOrdering Ordering) {
610 assert(isValidSuccessOrdering(Ordering) &&(static_cast<void> (0))
611 "invalid CmpXchg success ordering")(static_cast<void> (0));
612 setSubclassData<SuccessOrderingField>(Ordering);
613 }
614
615 /// Returns the failure ordering constraint of this cmpxchg instruction.
616 AtomicOrdering getFailureOrdering() const {
617 return getSubclassData<FailureOrderingField>();
618 }
619
620 /// Sets the failure ordering constraint of this cmpxchg instruction.
621 void setFailureOrdering(AtomicOrdering Ordering) {
622 assert(isValidFailureOrdering(Ordering) &&(static_cast<void> (0))
623 "invalid CmpXchg failure ordering")(static_cast<void> (0));
624 setSubclassData<FailureOrderingField>(Ordering);
625 }
626
627 /// Returns a single ordering which is at least as strong as both the
628 /// success and failure orderings for this cmpxchg.
629 AtomicOrdering getMergedOrdering() const {
630 if (getFailureOrdering() == AtomicOrdering::SequentiallyConsistent)
631 return AtomicOrdering::SequentiallyConsistent;
632 if (getFailureOrdering() == AtomicOrdering::Acquire) {
633 if (getSuccessOrdering() == AtomicOrdering::Monotonic)
634 return AtomicOrdering::Acquire;
635 if (getSuccessOrdering() == AtomicOrdering::Release)
636 return AtomicOrdering::AcquireRelease;
637 }
638 return getSuccessOrdering();
639 }
640
641 /// Returns the synchronization scope ID of this cmpxchg instruction.
642 SyncScope::ID getSyncScopeID() const {
643 return SSID;
644 }
645
646 /// Sets the synchronization scope ID of this cmpxchg instruction.
647 void setSyncScopeID(SyncScope::ID SSID) {
648 this->SSID = SSID;
649 }
650
651 Value *getPointerOperand() { return getOperand(0); }
652 const Value *getPointerOperand() const { return getOperand(0); }
653 static unsigned getPointerOperandIndex() { return 0U; }
654
655 Value *getCompareOperand() { return getOperand(1); }
656 const Value *getCompareOperand() const { return getOperand(1); }
657
658 Value *getNewValOperand() { return getOperand(2); }
659 const Value *getNewValOperand() const { return getOperand(2); }
660
661 /// Returns the address space of the pointer operand.
662 unsigned getPointerAddressSpace() const {
663 return getPointerOperand()->getType()->getPointerAddressSpace();
664 }
665
666 /// Returns the strongest permitted ordering on failure, given the
667 /// desired ordering on success.
668 ///
669 /// If the comparison in a cmpxchg operation fails, there is no atomic store
670 /// so release semantics cannot be provided. So this function drops explicit
671 /// Release requests from the AtomicOrdering. A SequentiallyConsistent
672 /// operation would remain SequentiallyConsistent.
673 static AtomicOrdering
674 getStrongestFailureOrdering(AtomicOrdering SuccessOrdering) {
675 switch (SuccessOrdering) {
676 default:
677 llvm_unreachable("invalid cmpxchg success ordering")__builtin_unreachable();
678 case AtomicOrdering::Release:
679 case AtomicOrdering::Monotonic:
680 return AtomicOrdering::Monotonic;
681 case AtomicOrdering::AcquireRelease:
682 case AtomicOrdering::Acquire:
683 return AtomicOrdering::Acquire;
684 case AtomicOrdering::SequentiallyConsistent:
685 return AtomicOrdering::SequentiallyConsistent;
686 }
687 }
688
689 // Methods for support type inquiry through isa, cast, and dyn_cast:
690 static bool classof(const Instruction *I) {
691 return I->getOpcode() == Instruction::AtomicCmpXchg;
692 }
693 static bool classof(const Value *V) {
694 return isa<Instruction>(V) && classof(cast<Instruction>(V));
695 }
696
697private:
698 // Shadow Instruction::setInstructionSubclassData with a private forwarding
699 // method so that subclasses cannot accidentally use it.
700 template <typename Bitfield>
701 void setSubclassData(typename Bitfield::Type Value) {
702 Instruction::setSubclassData<Bitfield>(Value);
703 }
704
705 /// The synchronization scope ID of this cmpxchg instruction. Not quite
706 /// enough room in SubClassData for everything, so synchronization scope ID
707 /// gets its own field.
708 SyncScope::ID SSID;
709};
710
711template <>
712struct OperandTraits<AtomicCmpXchgInst> :
713 public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
714};
715
716DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)AtomicCmpXchgInst::op_iterator AtomicCmpXchgInst::op_begin() {
return OperandTraits<AtomicCmpXchgInst>::op_begin(this
); } AtomicCmpXchgInst::const_op_iterator AtomicCmpXchgInst::
op_begin() const { return OperandTraits<AtomicCmpXchgInst>
::op_begin(const_cast<AtomicCmpXchgInst*>(this)); } AtomicCmpXchgInst
::op_iterator AtomicCmpXchgInst::op_end() { return OperandTraits
<AtomicCmpXchgInst>::op_end(this); } AtomicCmpXchgInst::
const_op_iterator AtomicCmpXchgInst::op_end() const { return OperandTraits
<AtomicCmpXchgInst>::op_end(const_cast<AtomicCmpXchgInst
*>(this)); } Value *AtomicCmpXchgInst::getOperand(unsigned
i_nocapture) const { (static_cast<void> (0)); return cast_or_null
<Value>( OperandTraits<AtomicCmpXchgInst>::op_begin
(const_cast<AtomicCmpXchgInst*>(this))[i_nocapture].get
()); } void AtomicCmpXchgInst::setOperand(unsigned i_nocapture
, Value *Val_nocapture) { (static_cast<void> (0)); OperandTraits
<AtomicCmpXchgInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned AtomicCmpXchgInst::getNumOperands() const { return
OperandTraits<AtomicCmpXchgInst>::operands(this); } template
<int Idx_nocapture> Use &AtomicCmpXchgInst::Op() {
return this->OpFrom<Idx_nocapture>(this); } template
<int Idx_nocapture> const Use &AtomicCmpXchgInst::
Op() const { return this->OpFrom<Idx_nocapture>(this
); }
717
718//===----------------------------------------------------------------------===//
719// AtomicRMWInst Class
720//===----------------------------------------------------------------------===//
721
722/// an instruction that atomically reads a memory location,
723/// combines it with another value, and then stores the result back. Returns
724/// the old value.
725///
726class AtomicRMWInst : public Instruction {
727protected:
728 // Note: Instruction needs to be a friend here to call cloneImpl.
729 friend class Instruction;
730
731 AtomicRMWInst *cloneImpl() const;
732
733public:
734 /// This enumeration lists the possible modifications atomicrmw can make. In
735 /// the descriptions, 'p' is the pointer to the instruction's memory location,
736 /// 'old' is the initial value of *p, and 'v' is the other value passed to the
737 /// instruction. These instructions always return 'old'.
738 enum BinOp : unsigned {
739 /// *p = v
740 Xchg,
741 /// *p = old + v
742 Add,
743 /// *p = old - v
744 Sub,
745 /// *p = old & v
746 And,
747 /// *p = ~(old & v)
748 Nand,
749 /// *p = old | v
750 Or,
751 /// *p = old ^ v
752 Xor,
753 /// *p = old >signed v ? old : v
754 Max,
755 /// *p = old <signed v ? old : v
756 Min,
757 /// *p = old >unsigned v ? old : v
758 UMax,
759 /// *p = old <unsigned v ? old : v
760 UMin,
761
762 /// *p = old + v
763 FAdd,
764
765 /// *p = old - v
766 FSub,
767
768 FIRST_BINOP = Xchg,
769 LAST_BINOP = FSub,
770 BAD_BINOP
771 };
772
773private:
774 template <unsigned Offset>
775 using AtomicOrderingBitfieldElement =
776 typename Bitfield::Element<AtomicOrdering, Offset, 3,
777 AtomicOrdering::LAST>;
778
779 template <unsigned Offset>
780 using BinOpBitfieldElement =
781 typename Bitfield::Element<BinOp, Offset, 4, BinOp::LAST_BINOP>;
782
783public:
784 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
785 AtomicOrdering Ordering, SyncScope::ID SSID,
786 Instruction *InsertBefore = nullptr);
787 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
788 AtomicOrdering Ordering, SyncScope::ID SSID,
789 BasicBlock *InsertAtEnd);
790
791 // allocate space for exactly two operands
792 void *operator new(size_t S) { return User::operator new(S, 2); }
793 void operator delete(void *Ptr) { User::operator delete(Ptr); }
794
795 using VolatileField = BoolBitfieldElementT<0>;
796 using AtomicOrderingField =
797 AtomicOrderingBitfieldElementT<VolatileField::NextBit>;
798 using OperationField = BinOpBitfieldElement<AtomicOrderingField::NextBit>;
799 using AlignmentField = AlignmentBitfieldElementT<OperationField::NextBit>;
800 static_assert(Bitfield::areContiguous<VolatileField, AtomicOrderingField,
801 OperationField, AlignmentField>(),
802 "Bitfields must be contiguous");
803
804 BinOp getOperation() const { return getSubclassData<OperationField>(); }
805
806 static StringRef getOperationName(BinOp Op);
807
808 static bool isFPOperation(BinOp Op) {
809 switch (Op) {
810 case AtomicRMWInst::FAdd:
811 case AtomicRMWInst::FSub:
812 return true;
813 default:
814 return false;
815 }
816 }
817
818 void setOperation(BinOp Operation) {
819 setSubclassData<OperationField>(Operation);
820 }
821
822 /// Return the alignment of the memory that is being allocated by the
823 /// instruction.
824 Align getAlign() const {
825 return Align(1ULL << getSubclassData<AlignmentField>());
826 }
827
828 void setAlignment(Align Align) {
829 setSubclassData<AlignmentField>(Log2(Align));
830 }
831
832 /// Return true if this is a RMW on a volatile memory location.
833 ///
834 bool isVolatile() const { return getSubclassData<VolatileField>(); }
835
836 /// Specify whether this is a volatile RMW or not.
837 ///
838 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
839
840 /// Transparently provide more efficient getOperand methods.
841 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
842
843 /// Returns the ordering constraint of this rmw instruction.
844 AtomicOrdering getOrdering() const {
845 return getSubclassData<AtomicOrderingField>();
846 }
847
848 /// Sets the ordering constraint of this rmw instruction.
849 void setOrdering(AtomicOrdering Ordering) {
850 assert(Ordering != AtomicOrdering::NotAtomic &&(static_cast<void> (0))
851 "atomicrmw instructions can only be atomic.")(static_cast<void> (0));
852 setSubclassData<AtomicOrderingField>(Ordering);
853 }
854
855 /// Returns the synchronization scope ID of this rmw instruction.
856 SyncScope::ID getSyncScopeID() const {
857 return SSID;
858 }
859
860 /// Sets the synchronization scope ID of this rmw instruction.
861 void setSyncScopeID(SyncScope::ID SSID) {
862 this->SSID = SSID;
863 }
864
865 Value *getPointerOperand() { return getOperand(0); }
866 const Value *getPointerOperand() const { return getOperand(0); }
867 static unsigned getPointerOperandIndex() { return 0U; }
868
869 Value *getValOperand() { return getOperand(1); }
870 const Value *getValOperand() const { return getOperand(1); }
871
872 /// Returns the address space of the pointer operand.
873 unsigned getPointerAddressSpace() const {
874 return getPointerOperand()->getType()->getPointerAddressSpace();
875 }
876
877 bool isFloatingPointOperation() const {
878 return isFPOperation(getOperation());
879 }
880
881 // Methods for support type inquiry through isa, cast, and dyn_cast:
882 static bool classof(const Instruction *I) {
883 return I->getOpcode() == Instruction::AtomicRMW;
884 }
885 static bool classof(const Value *V) {
886 return isa<Instruction>(V) && classof(cast<Instruction>(V));
887 }
888
889private:
890 void Init(BinOp Operation, Value *Ptr, Value *Val, Align Align,
891 AtomicOrdering Ordering, SyncScope::ID SSID);
892
893 // Shadow Instruction::setInstructionSubclassData with a private forwarding
894 // method so that subclasses cannot accidentally use it.
895 template <typename Bitfield>
896 void setSubclassData(typename Bitfield::Type Value) {
897 Instruction::setSubclassData<Bitfield>(Value);
898 }
899
900 /// The synchronization scope ID of this rmw instruction. Not quite enough
901 /// room in SubClassData for everything, so synchronization scope ID gets its
902 /// own field.
903 SyncScope::ID SSID;
904};
905
906template <>
907struct OperandTraits<AtomicRMWInst>
908 : public FixedNumOperandTraits<AtomicRMWInst,2> {
909};
910
911DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)AtomicRMWInst::op_iterator AtomicRMWInst::op_begin() { return
OperandTraits<AtomicRMWInst>::op_begin(this); } AtomicRMWInst
::const_op_iterator AtomicRMWInst::op_begin() const { return OperandTraits
<AtomicRMWInst>::op_begin(const_cast<AtomicRMWInst*>
(this)); } AtomicRMWInst::op_iterator AtomicRMWInst::op_end()
{ return OperandTraits<AtomicRMWInst>::op_end(this); }
AtomicRMWInst::const_op_iterator AtomicRMWInst::op_end() const
{ return OperandTraits<AtomicRMWInst>::op_end(const_cast
<AtomicRMWInst*>(this)); } Value *AtomicRMWInst::getOperand
(unsigned i_nocapture) const { (static_cast<void> (0));
return cast_or_null<Value>( OperandTraits<AtomicRMWInst
>::op_begin(const_cast<AtomicRMWInst*>(this))[i_nocapture
].get()); } void AtomicRMWInst::setOperand(unsigned i_nocapture
, Value *Val_nocapture) { (static_cast<void> (0)); OperandTraits
<AtomicRMWInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned AtomicRMWInst::getNumOperands() const { return OperandTraits
<AtomicRMWInst>::operands(this); } template <int Idx_nocapture
> Use &AtomicRMWInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
const Use &AtomicRMWInst::Op() const { return this->OpFrom
<Idx_nocapture>(this); }
912
913//===----------------------------------------------------------------------===//
914// GetElementPtrInst Class
915//===----------------------------------------------------------------------===//
916
917// checkGEPType - Simple wrapper function to give a better assertion failure
918// message on bad indexes for a gep instruction.
919//
920inline Type *checkGEPType(Type *Ty) {
921 assert(Ty && "Invalid GetElementPtrInst indices for type!")(static_cast<void> (0));
922 return Ty;
923}
924
925/// an instruction for type-safe pointer arithmetic to
926/// access elements of arrays and structs
927///
928class GetElementPtrInst : public Instruction {
929 Type *SourceElementType;
930 Type *ResultElementType;
931
932 GetElementPtrInst(const GetElementPtrInst &GEPI);
933
934 /// Constructors - Create a getelementptr instruction with a base pointer an
935 /// list of indices. The first ctor can optionally insert before an existing
936 /// instruction, the second appends the new instruction to the specified
937 /// BasicBlock.
938 inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
939 ArrayRef<Value *> IdxList, unsigned Values,
940 const Twine &NameStr, Instruction *InsertBefore);
941 inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
942 ArrayRef<Value *> IdxList, unsigned Values,
943 const Twine &NameStr, BasicBlock *InsertAtEnd);
944
945 void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
946
947protected:
948 // Note: Instruction needs to be a friend here to call cloneImpl.
949 friend class Instruction;
950
951 GetElementPtrInst *cloneImpl() const;
952
953public:
954 static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
955 ArrayRef<Value *> IdxList,
956 const Twine &NameStr = "",
957 Instruction *InsertBefore = nullptr) {
958 unsigned Values = 1 + unsigned(IdxList.size());
959 assert(PointeeType && "Must specify element type")(static_cast<void> (0));
960 assert(cast<PointerType>(Ptr->getType()->getScalarType())(static_cast<void> (0))
961 ->isOpaqueOrPointeeTypeMatches(PointeeType))(static_cast<void> (0));
962 return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
963 NameStr, InsertBefore);
964 }
965
966 static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
967 ArrayRef<Value *> IdxList,
968 const Twine &NameStr,
969 BasicBlock *InsertAtEnd) {
970 unsigned Values = 1 + unsigned(IdxList.size());
971 assert(PointeeType && "Must specify element type")(static_cast<void> (0));
972 assert(cast<PointerType>(Ptr->getType()->getScalarType())(static_cast<void> (0))
973 ->isOpaqueOrPointeeTypeMatches(PointeeType))(static_cast<void> (0));
974 return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
975 NameStr, InsertAtEnd);
976 }
977
978 LLVM_ATTRIBUTE_DEPRECATED(static GetElementPtrInst *CreateInBounds([[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
*InsertBefore = nullptr)
979 Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr = "",[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
*InsertBefore = nullptr)
980 Instruction *InsertBefore = nullptr),[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
*InsertBefore = nullptr)
981 "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr = "", Instruction
*InsertBefore = nullptr)
{
982 return CreateInBounds(
983 Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, IdxList,
984 NameStr, InsertBefore);
985 }
986
987 /// Create an "inbounds" getelementptr. See the documentation for the
988 /// "inbounds" flag in LangRef.html for details.
989 static GetElementPtrInst *
990 CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
991 const Twine &NameStr = "",
992 Instruction *InsertBefore = nullptr) {
993 GetElementPtrInst *GEP =
994 Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
995 GEP->setIsInBounds(true);
996 return GEP;
997 }
998
999 LLVM_ATTRIBUTE_DEPRECATED(static GetElementPtrInst *CreateInBounds([[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
*InsertAtEnd)
1000 Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr,[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
*InsertAtEnd)
1001 BasicBlock *InsertAtEnd),[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
*InsertAtEnd)
1002 "Use the version with explicit element type instead")[[deprecated("Use the version with explicit element type instead"
)]] static GetElementPtrInst *CreateInBounds( Value *Ptr, ArrayRef
<Value *> IdxList, const Twine &NameStr, BasicBlock
*InsertAtEnd)
{
1003 return CreateInBounds(
1004 Ptr->getType()->getScalarType()->getPointerElementType(), Ptr, IdxList,
1005 NameStr, InsertAtEnd);
1006 }
1007
1008 static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
1009 ArrayRef<Value *> IdxList,
1010 const Twine &NameStr,
1011 BasicBlock *InsertAtEnd) {
1012 GetElementPtrInst *GEP =
1013 Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
1014 GEP->setIsInBounds(true);
1015 return GEP;
1016 }
1017
1018 /// Transparently provide more efficient getOperand methods.
1019 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
1020
1021 Type *getSourceElementType() const { return SourceElementType; }
1022
1023 void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
1024 void setResultElementType(Type *Ty) { ResultElementType = Ty; }
1025
1026 Type *getResultElementType() const {
1027 assert(cast<PointerType>(getType()->getScalarType())(static_cast<void> (0))
1028 ->isOpaqueOrPointeeTypeMatches(ResultElementType))(static_cast<void> (0));
1029 return ResultElementType;
1030 }
1031
1032 /// Returns the address space of this instruction's pointer type.
1033 unsigned getAddressSpace() const {
1034 // Note that this is always the same as the pointer operand's address space
1035 // and that is cheaper to compute, so cheat here.
1036 return getPointerAddressSpace();
1037 }
1038
1039 /// Returns the result type of a getelementptr with the given source
1040 /// element type and indexes.
1041 ///
1042 /// Null is returned if the indices are invalid for the specified
1043 /// source element type.
1044 static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
1045 static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
1046 static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
1047
1048 /// Return the type of the element at the given index of an indexable
1049 /// type. This is equivalent to "getIndexedType(Agg, {Zero, Idx})".
1050 ///
1051 /// Returns null if the type can't be indexed, or the given index is not
1052 /// legal for the given type.
1053 static Type *getTypeAtIndex(Type *Ty, Value *Idx);
1054 static Type *getTypeAtIndex(Type *Ty, uint64_t Idx);
1055
1056 inline op_iterator idx_begin() { return op_begin()+1; }
1057 inline const_op_iterator idx_begin() const { return op_begin()+1; }
1058 inline op_iterator idx_end() { return op_end(); }
1059 inline const_op_iterator idx_end() const { return op_end(); }
1060
1061 inline iterator_range<op_iterator> indices() {
1062 return make_range(idx_begin(), idx_end());
1063 }
1064
1065 inline iterator_range<const_op_iterator> indices() const {
1066 return make_range(idx_begin(), idx_end());
1067 }
1068
1069 Value *getPointerOperand() {
1070 return getOperand(0);
1071 }
1072 const Value *getPointerOperand() const {
1073 return getOperand(0);
1074 }
1075 static unsigned getPointerOperandIndex() {
1076 return 0U; // get index for modifying correct operand.
1077 }
1078
1079 /// Method to return the pointer operand as a
1080 /// PointerType.
1081 Type *getPointerOperandType() const {
1082 return getPointerOperand()->getType();
1083 }
1084
1085 /// Returns the address space of the pointer operand.
1086 unsigned getPointerAddressSpace() const {
1087 return getPointerOperandType()->getPointerAddressSpace();
1088 }
1089
1090 /// Returns the pointer type returned by the GEP
1091 /// instruction, which may be a vector of pointers.
1092 static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
1093 ArrayRef<Value *> IdxList) {
1094 PointerType *OrigPtrTy = cast<PointerType>(Ptr->getType()->getScalarType());
1095 unsigned AddrSpace = OrigPtrTy->getAddressSpace();
1096 Type *ResultElemTy = checkGEPType(getIndexedType(ElTy, IdxList));
1097 Type *PtrTy = OrigPtrTy->isOpaque()
1098 ? PointerType::get(OrigPtrTy->getContext(), AddrSpace)
1099 : PointerType::get(ResultElemTy, AddrSpace);
1100 // Vector GEP
1101 if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
1102 ElementCount EltCount = PtrVTy->getElementCount();
1103 return VectorType::get(PtrTy, EltCount);
1104 }
1105 for (Value *Index : IdxList)
1106 if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
1107 ElementCount EltCount = IndexVTy->getElementCount();
1108 return VectorType::get(PtrTy, EltCount);
1109 }
1110 // Scalar GEP
1111 return PtrTy;
1112 }
1113
1114 unsigned getNumIndices() const { // Note: always non-negative
1115 return getNumOperands() - 1;
1116 }
1117
1118 bool hasIndices() const {
1119 return getNumOperands() > 1;
1120 }
1121
1122 /// Return true if all of the indices of this GEP are
1123 /// zeros. If so, the result pointer and the first operand have the same
1124 /// value, just potentially different types.
1125 bool hasAllZeroIndices() const;
1126
1127 /// Return true if all of the indices of this GEP are
1128 /// constant integers. If so, the result pointer and the first operand have
1129 /// a constant offset between them.
1130 bool hasAllConstantIndices() const;
1131
1132 /// Set or clear the inbounds flag on this GEP instruction.
1133 /// See LangRef.html for the meaning of inbounds on a getelementptr.
1134 void setIsInBounds(bool b = true);
1135
1136 /// Determine whether the GEP has the inbounds flag.
1137 bool isInBounds() const;
1138
1139 /// Accumulate the constant address offset of this GEP if possible.
1140 ///
1141 /// This routine accepts an APInt into which it will accumulate the constant
1142 /// offset of this GEP if the GEP is in fact constant. If the GEP is not
1143 /// all-constant, it returns false and the value of the offset APInt is
1144 /// undefined (it is *not* preserved!). The APInt passed into this routine
1145 /// must be at least as wide as the IntPtr type for the address space of
1146 /// the base GEP pointer.
1147 bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
1148 bool collectOffset(const DataLayout &DL, unsigned BitWidth,
1149 MapVector<Value *, APInt> &VariableOffsets,
1150 APInt &ConstantOffset) const;
1151 // Methods for support type inquiry through isa, cast, and dyn_cast:
1152 static bool classof(const Instruction *I) {
1153 return (I->getOpcode() == Instruction::GetElementPtr);
1154 }
1155 static bool classof(const Value *V) {
1156 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1157 }
1158};
1159
1160template <>
1161struct OperandTraits<GetElementPtrInst> :
1162 public VariadicOperandTraits<GetElementPtrInst, 1> {
1163};
1164
1165GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1166 ArrayRef<Value *> IdxList, unsigned Values,
1167 const Twine &NameStr,
1168 Instruction *InsertBefore)
1169 : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
1170 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
1171 Values, InsertBefore),
1172 SourceElementType(PointeeType),
1173 ResultElementType(getIndexedType(PointeeType, IdxList)) {
1174 assert(cast<PointerType>(getType()->getScalarType())(static_cast<void> (0))
1175 ->isOpaqueOrPointeeTypeMatches(ResultElementType))(static_cast<void> (0));
1176 init(Ptr, IdxList, NameStr);
1177}
1178
1179GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1180 ArrayRef<Value *> IdxList, unsigned Values,
1181 const Twine &NameStr,
1182 BasicBlock *InsertAtEnd)
1183 : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
1184 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
1185 Values, InsertAtEnd),
1186 SourceElementType(PointeeType),
1187 ResultElementType(getIndexedType(PointeeType, IdxList)) {
1188 assert(cast<PointerType>(getType()->getScalarType())(static_cast<void> (0))
1189 ->isOpaqueOrPointeeTypeMatches(ResultElementType))(static_cast<void> (0));
1190 init(Ptr, IdxList, NameStr);
1191}
1192
1193DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)GetElementPtrInst::op_iterator GetElementPtrInst::op_begin() {
return OperandTraits<GetElementPtrInst>::op_begin(this
); } GetElementPtrInst::const_op_iterator GetElementPtrInst::
op_begin() const { return OperandTraits<GetElementPtrInst>
::op_begin(const_cast<GetElementPtrInst*>(this)); } GetElementPtrInst
::op_iterator GetElementPtrInst::op_end() { return OperandTraits
<GetElementPtrInst>::op_end(this); } GetElementPtrInst::
const_op_iterator GetElementPtrInst::op_end() const { return OperandTraits
<GetElementPtrInst>::op_end(const_cast<GetElementPtrInst
*>(this)); } Value *GetElementPtrInst::getOperand(unsigned
i_nocapture) const { (static_cast<void> (0)); return cast_or_null
<Value>( OperandTraits<GetElementPtrInst>::op_begin
(const_cast<GetElementPtrInst*>(this))[i_nocapture].get
()); } void GetElementPtrInst::setOperand(unsigned i_nocapture
, Value *Val_nocapture) { (static_cast<void> (0)); OperandTraits
<GetElementPtrInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned GetElementPtrInst::getNumOperands() const { return
OperandTraits<GetElementPtrInst>::operands(this); } template
<int Idx_nocapture> Use &GetElementPtrInst::Op() {
return this->OpFrom<Idx_nocapture>(this); } template
<int Idx_nocapture> const Use &GetElementPtrInst::
Op() const { return this->OpFrom<Idx_nocapture>(this
); }
1194
1195//===----------------------------------------------------------------------===//
1196// ICmpInst Class
1197//===----------------------------------------------------------------------===//
1198
1199/// This instruction compares its operands according to the predicate given
1200/// to the constructor. It only operates on integers or pointers. The operands
1201/// must be identical types.
1202/// Represent an integer comparison operator.
1203class ICmpInst: public CmpInst {
1204 void AssertOK() {
1205 assert(isIntPredicate() &&(static_cast<void> (0))
1206 "Invalid ICmp predicate value")(static_cast<void> (0));
1207 assert(getOperand(0)->getType() == getOperand(1)->getType() &&(static_cast<void> (0))
1208 "Both operands to ICmp instruction are not of the same type!")(static_cast<void> (0));
1209 // Check that the operands are the right type
1210 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||(static_cast<void> (0))
1211 getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&(static_cast<void> (0))
1212 "Invalid operand types for ICmp instruction")(static_cast<void> (0));
1213 }
1214
1215protected:
1216 // Note: Instruction needs to be a friend here to call cloneImpl.
1217 friend class Instruction;
1218
1219 /// Clone an identical ICmpInst
1220 ICmpInst *cloneImpl() const;
1221
1222public:
1223 /// Constructor with insert-before-instruction semantics.
1224 ICmpInst(
1225 Instruction *InsertBefore, ///< Where to insert
1226 Predicate pred, ///< The predicate to use for the comparison
1227 Value *LHS, ///< The left-hand-side of the expression
1228 Value *RHS, ///< The right-hand-side of the expression
1229 const Twine &NameStr = "" ///< Name of the instruction
1230 ) : CmpInst(makeCmpResultType(LHS->getType()),
1231 Instruction::ICmp, pred, LHS, RHS, NameStr,
1232 InsertBefore) {
1233#ifndef NDEBUG1
1234 AssertOK();
1235#endif
1236 }
1237
1238 /// Constructor with insert-at-end semantics.
1239 ICmpInst(
1240 BasicBlock &InsertAtEnd, ///< Block to insert into.
1241 Predicate pred, ///< The predicate to use for the comparison
1242 Value *LHS, ///< The left-hand-side of the expression
1243 Value *RHS, ///< The right-hand-side of the expression
1244 const Twine &NameStr = "" ///< Name of the instruction
1245 ) : CmpInst(makeCmpResultType(LHS->getType()),
1246 Instruction::ICmp, pred, LHS, RHS, NameStr,
1247 &InsertAtEnd) {
1248#ifndef NDEBUG1
1249 AssertOK();
1250#endif
1251 }
1252
1253 /// Constructor with no-insertion semantics
1254 ICmpInst(
1255 Predicate pred, ///< The predicate to use for the comparison
1256 Value *LHS, ///< The left-hand-side of the expression
1257 Value *RHS, ///< The right-hand-side of the expression
1258 const Twine &NameStr = "" ///< Name of the instruction
1259 ) : CmpInst(makeCmpResultType(LHS->getType()),
1260 Instruction::ICmp, pred, LHS, RHS, NameStr) {
1261#ifndef NDEBUG1
1262 AssertOK();
1263#endif
1264 }
1265
1266 /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
1267 /// @returns the predicate that would be the result if the operand were
1268 /// regarded as signed.
1269 /// Return the signed version of the predicate
1270 Predicate getSignedPredicate() const {
1271 return getSignedPredicate(getPredicate());
1272 }
1273
1274 /// This is a static version that you can use without an instruction.
1275 /// Return the signed version of the predicate.
1276 static Predicate getSignedPredicate(Predicate pred);
1277
1278 /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
1279 /// @returns the predicate that would be the result if the operand were
1280 /// regarded as unsigned.
1281 /// Return the unsigned version of the predicate
1282 Predicate getUnsignedPredicate() const {
1283 return getUnsignedPredicate(getPredicate());
1284 }
1285
1286 /// This is a static version that you can use without an instruction.
1287 /// Return the unsigned version of the predicate.
1288 static Predicate getUnsignedPredicate(Predicate pred);
1289
1290 /// Return true if this predicate is either EQ or NE. This also
1291 /// tests for commutativity.
1292 static bool isEquality(Predicate P) {
1293 return P == ICMP_EQ || P == ICMP_NE;
1294 }
1295
1296 /// Return true if this predicate is either EQ or NE. This also
1297 /// tests for commutativity.
1298 bool isEquality() const {
1299 return isEquality(getPredicate());
1300 }
1301
1302 /// @returns true if the predicate of this ICmpInst is commutative
1303 /// Determine if this relation is commutative.
1304 bool isCommutative() const { return isEquality(); }
1305
1306 /// Return true if the predicate is relational (not EQ or NE).
1307 ///
1308 bool isRelational() const {
1309 return !isEquality();
1310 }
1311
1312 /// Return true if the predicate is relational (not EQ or NE).
1313 ///
1314 static bool isRelational(Predicate P) {
1315 return !isEquality(P);
1316 }
1317
1318 /// Return true if the predicate is SGT or UGT.
1319 ///
1320 static bool isGT(Predicate P) {
1321 return P == ICMP_SGT || P == ICMP_UGT;
1322 }
1323
1324 /// Return true if the predicate is SLT or ULT.
1325 ///
1326 static bool isLT(Predicate P) {
1327 return P == ICMP_SLT || P == ICMP_ULT;
1328 }
1329
1330 /// Return true if the predicate is SGE or UGE.
1331 ///
1332 static bool isGE(Predicate P) {
1333 return P == ICMP_SGE || P == ICMP_UGE;
1334 }
1335
1336 /// Return true if the predicate is SLE or ULE.
1337 ///
1338 static bool isLE(Predicate P) {
1339 return P == ICMP_SLE || P == ICMP_ULE;
1340 }
1341
1342 /// Exchange the two operands to this instruction in such a way that it does
1343 /// not modify the semantics of the instruction. The predicate value may be
1344 /// changed to retain the same result if the predicate is order dependent
1345 /// (e.g. ult).
1346 /// Swap operands and adjust predicate.
1347 void swapOperands() {
1348 setPredicate(getSwappedPredicate());
1349 Op<0>().swap(Op<1>());
1350 }
1351
1352 // Methods for support type inquiry through isa, cast, and dyn_cast:
1353 static bool classof(const Instruction *I) {
1354 return I->getOpcode() == Instruction::ICmp;
1355 }
1356 static bool classof(const Value *V) {
1357 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1358 }
1359};
1360
1361//===----------------------------------------------------------------------===//
1362// FCmpInst Class
1363//===----------------------------------------------------------------------===//
1364
1365/// This instruction compares its operands according to the predicate given
1366/// to the constructor. It only operates on floating point values or packed
1367/// vectors of floating point values. The operands must be identical types.
1368/// Represents a floating point comparison operator.
1369class FCmpInst: public CmpInst {
1370 void AssertOK() {
1371 assert(isFPPredicate() && "Invalid FCmp predicate value")(static_cast<void> (0));
1372 assert(getOperand(0)->getType() == getOperand(1)->getType() &&(static_cast<void> (0))
1373 "Both operands to FCmp instruction are not of the same type!")(static_cast<void> (0));
1374 // Check that the operands are the right type
1375 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&(static_cast<void> (0))
1376 "Invalid operand types for FCmp instruction")(static_cast<void> (0));
1377 }
1378
1379protected:
1380 // Note: Instruction needs to be a friend here to call cloneImpl.
1381 friend class Instruction;
1382
1383 /// Clone an identical FCmpInst
1384 FCmpInst *cloneImpl() const;
1385
1386public:
1387 /// Constructor with insert-before-instruction semantics.
1388 FCmpInst(
1389 Instruction *InsertBefore, ///< Where to insert
1390 Predicate pred, ///< The predicate to use for the comparison
1391 Value *LHS, ///< The left-hand-side of the expression
1392 Value *RHS, ///< The right-hand-side of the expression
1393 const Twine &NameStr = "" ///< Name of the instruction
1394 ) : CmpInst(makeCmpResultType(LHS->getType()),
1395 Instruction::FCmp, pred, LHS, RHS, NameStr,
1396 InsertBefore) {
1397 AssertOK();
1398 }
1399
1400 /// Constructor with insert-at-end semantics.
1401 FCmpInst(
1402 BasicBlock &InsertAtEnd, ///< Block to insert into.
1403 Predicate pred, ///< The predicate to use for the comparison
1404 Value *LHS, ///< The left-hand-side of the expression
1405 Value *RHS, ///< The right-hand-side of the expression
1406 const Twine &NameStr = "" ///< Name of the instruction
1407 ) : CmpInst(makeCmpResultType(LHS->getType()),
1408 Instruction::FCmp, pred, LHS, RHS, NameStr,
1409 &InsertAtEnd) {
1410 AssertOK();
1411 }
1412
1413 /// Constructor with no-insertion semantics
1414 FCmpInst(
1415 Predicate Pred, ///< The predicate to use for the comparison
1416 Value *LHS, ///< The left-hand-side of the expression
1417 Value *RHS, ///< The right-hand-side of the expression
1418 const Twine &NameStr = "", ///< Name of the instruction
1419 Instruction *FlagsSource = nullptr
1420 ) : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS,
1421 RHS, NameStr, nullptr, FlagsSource) {
1422 AssertOK();
1423 }
1424
1425 /// @returns true if the predicate of this instruction is EQ or NE.
1426 /// Determine if this is an equality predicate.
1427 static bool isEquality(Predicate Pred) {
1428 return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
1429 Pred == FCMP_UNE;
1430 }
1431
1432 /// @returns true if the predicate of this instruction is EQ or NE.
1433 /// Determine if this is an equality predicate.
1434 bool isEquality() const { return isEquality(getPredicate()); }
1435
1436 /// @returns true if the predicate of this instruction is commutative.
1437 /// Determine if this is a commutative predicate.
1438 bool isCommutative() const {
1439 return isEquality() ||
1440 getPredicate() == FCMP_FALSE ||
1441 getPredicate() == FCMP_TRUE ||
1442 getPredicate() == FCMP_ORD ||
1443 getPredicate() == FCMP_UNO;
1444 }
1445
1446 /// @returns true if the predicate is relational (not EQ or NE).
1447 /// Determine if this a relational predicate.
1448 bool isRelational() const { return !isEquality(); }
1449
1450 /// Exchange the two operands to this instruction in such a way that it does
1451 /// not modify the semantics of the instruction. The predicate value may be
1452 /// changed to retain the same result if the predicate is order dependent
1453 /// (e.g. ult).
1454 /// Swap operands and adjust predicate.
1455 void swapOperands() {
1456 setPredicate(getSwappedPredicate());
1457 Op<0>().swap(Op<1>());
1458 }
1459
1460 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1461 static bool classof(const Instruction *I) {
1462 return I->getOpcode() == Instruction::FCmp;
1463 }
1464 static bool classof(const Value *V) {
1465 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1466 }
1467};
1468
1469//===----------------------------------------------------------------------===//
1470/// This class represents a function call, abstracting a target
1471/// machine's calling convention. This class uses low bit of the SubClassData
1472/// field to indicate whether or not this is a tail call. The rest of the bits
1473/// hold the calling convention of the call.
1474///
1475class CallInst : public CallBase {
1476 CallInst(const CallInst &CI);
1477
1478 /// Construct a CallInst given a range of arguments.
1479 /// Construct a CallInst from a range of arguments
1480 inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1481 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1482 Instruction *InsertBefore);
1483
1484 inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1485 const Twine &NameStr, Instruction *InsertBefore)
1486 : CallInst(Ty, Func, Args, None, NameStr, InsertBefore) {}
1487
1488 /// Construct a CallInst given a range of arguments.
1489 /// Construct a CallInst from a range of arguments
1490 inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1491 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1492 BasicBlock *InsertAtEnd);
1493
1494 explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
1495 Instruction *InsertBefore);
1496
1497 CallInst(FunctionType *ty, Value *F, const Twine &NameStr,
1498 BasicBlock *InsertAtEnd);
1499
1500 void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
1501 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
1502 void init(FunctionType *FTy, Value *Func, const Twine &NameStr);
1503
1504 /// Compute the number of operands to allocate.
1505 static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
1506 // We need one operand for the called function, plus the input operand
1507 // counts provided.
1508 return 1 + NumArgs + NumBundleInputs;
1509 }
1510
1511protected:
1512 // Note: Instruction needs to be a friend here to call cloneImpl.
1513 friend class Instruction;
1514
1515 CallInst *cloneImpl() const;
1516
1517public:
1518 static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
1519 Instruction *InsertBefore = nullptr) {
1520 return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
1521 }
1522
1523 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1524 const Twine &NameStr,
1525 Instruction *InsertBefore = nullptr) {
1526 return new (ComputeNumOperands(Args.size()))
1527 CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
1528 }
1529
1530 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1531 ArrayRef<OperandBundleDef> Bundles = None,
1532 const Twine &NameStr = "",
1533 Instruction *InsertBefore = nullptr) {
1534 const int NumOperands =
1535 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
1536 const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
1537
1538 return new (NumOperands, DescriptorBytes)
1539 CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
1540 }
1541
1542 static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
1543 BasicBlock *InsertAtEnd) {
1544 return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd);
1545 }
1546
1547 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1548 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1549 return new (ComputeNumOperands(Args.size()))
1550 CallInst(Ty, Func, Args, None, NameStr, InsertAtEnd);
1551 }
1552
1553 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1554 ArrayRef<OperandBundleDef> Bundles,
1555 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1556 const int NumOperands =
1557 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
1558 const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
1559
1560 return new (NumOperands, DescriptorBytes)
1561 CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
1562 }
1563
1564 static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
1565 Instruction *InsertBefore = nullptr) {
1566 return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
1567 InsertBefore);
1568 }
1569
1570 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1571 ArrayRef<OperandBundleDef> Bundles = None,
1572 const Twine &NameStr = "",
1573 Instruction *InsertBefore = nullptr) {
1574 return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
1575 NameStr, InsertBefore);
1576 }
1577
1578 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1579 const Twine &NameStr,
1580 Instruction *InsertBefore = nullptr) {
1581 return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
1582 InsertBefore);
1583 }
1584
1585 static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
1586 BasicBlock *InsertAtEnd) {
1587 return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
1588 InsertAtEnd);
1589 }
1590
1591 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1592 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1593 return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
1594 InsertAtEnd);
1595 }
1596
1597 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1598 ArrayRef<OperandBundleDef> Bundles,
1599 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1600 return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
1601 NameStr, InsertAtEnd);
1602 }
1603
1604 /// Create a clone of \p CI with a different set of operand bundles and
1605 /// insert it before \p InsertPt.
1606 ///
1607 /// The returned call instruction is identical \p CI in every way except that
1608 /// the operand bundles for the new instruction are set to the operand bundles
1609 /// in \p Bundles.
1610 static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
1611 Instruction *InsertPt = nullptr);
1612
1613 /// Generate the IR for a call to malloc:
1614 /// 1. Compute the malloc call's argument as the specified type's size,
1615 /// possibly multiplied by the array size if the array size is not
1616 /// constant 1.
1617 /// 2. Call malloc with that argument.
1618 /// 3. Bitcast the result of the malloc call to the specified type.
1619 static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
1620 Type *AllocTy, Value *AllocSize,
1621 Value *ArraySize = nullptr,
1622 Function *MallocF = nullptr,
1623 const Twine &Name = "");
1624 static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
1625 Type *AllocTy, Value *AllocSize,
1626 Value *ArraySize = nullptr,
1627 Function *MallocF = nullptr,
1628 const Twine &Name = "");
1629 static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
1630 Type *AllocTy, Value *AllocSize,
1631 Value *ArraySize = nullptr,
1632 ArrayRef<OperandBundleDef> Bundles = None,
1633 Function *MallocF = nullptr,
1634 const Twine &Name = "");
1635 static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
1636 Type *AllocTy, Value *AllocSize,
1637 Value *ArraySize = nullptr,
1638 ArrayRef<OperandBundleDef> Bundles = None,
1639 Function *MallocF = nullptr,
1640 const Twine &Name = "");
1641 /// Generate the IR for a call to the builtin free function.
1642 static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
1643 static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
1644 static Instruction *CreateFree(Value *Source,
1645 ArrayRef<OperandBundleDef> Bundles,
1646 Instruction *InsertBefore);
1647 static Instruction *CreateFree(Value *Source,
1648 ArrayRef<OperandBundleDef> Bundles,
1649 BasicBlock *InsertAtEnd);
1650
1651 // Note that 'musttail' implies 'tail'.
1652 enum TailCallKind : unsigned {
1653 TCK_None = 0,
1654 TCK_Tail = 1,
1655 TCK_MustTail = 2,
1656 TCK_NoTail = 3,
1657 TCK_LAST = TCK_NoTail
1658 };
1659
1660 using TailCallKindField = Bitfield::Element<TailCallKind, 0, 2, TCK_LAST>;
1661 static_assert(
1662 Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
1663 "Bitfields must be contiguous");
1664
1665 TailCallKind getTailCallKind() const {
1666 return getSubclassData<TailCallKindField>();
1667 }
1668
1669 bool isTailCall() const {
1670 TailCallKind Kind = getTailCallKind();
1671 return Kind == TCK_Tail || Kind == TCK_MustTail;
1672 }
1673
1674 bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }
1675
1676 bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }
1677
1678 void setTailCallKind(TailCallKind TCK) {
1679 setSubclassData<TailCallKindField>(TCK);
1680 }
1681
1682 void setTailCall(bool IsTc = true) {
1683 setTailCallKind(IsTc ? TCK_Tail : TCK_None);
1684 }
1685
1686 /// Return true if the call can return twice
1687 bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
1688 void setCanReturnTwice() { addFnAttr(Attribute::ReturnsTwice); }
1689
1690 // Methods for support type inquiry through isa, cast, and dyn_cast:
1691 static bool classof(const Instruction *I) {
1692 return I->getOpcode() == Instruction::Call;
1693 }
1694 static bool classof(const Value *V) {
1695 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1696 }
1697
1698 /// Updates profile metadata by scaling it by \p S / \p T.
1699 void updateProfWeight(uint64_t S, uint64_t T);
1700
1701private:
1702 // Shadow Instruction::setInstructionSubclassData with a private forwarding
1703 // method so that subclasses cannot accidentally use it.
1704 template <typename Bitfield>
1705 void setSubclassData(typename Bitfield::Type Value) {
1706 Instruction::setSubclassData<Bitfield>(Value);
1707 }
1708};
1709
1710CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1711 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1712 BasicBlock *InsertAtEnd)
1713 : CallBase(Ty->getReturnType(), Instruction::Call,
1714 OperandTraits<CallBase>::op_end(this) -
1715 (Args.size() + CountBundleInputs(Bundles) + 1),
1716 unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
1717 InsertAtEnd) {
1718 init(Ty, Func, Args, Bundles, NameStr);
1719}
1720
1721CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1722 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1723 Instruction *InsertBefore)
1724 : CallBase(Ty->getReturnType(), Instruction::Call,
1725 OperandTraits<CallBase>::op_end(this) -
1726 (Args.size() + CountBundleInputs(Bundles) + 1),
1727 unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
1728 InsertBefore) {
1729 init(Ty, Func, Args, Bundles, NameStr);
1730}
1731
1732//===----------------------------------------------------------------------===//
1733// SelectInst Class
1734//===----------------------------------------------------------------------===//
1735
1736/// This class represents the LLVM 'select' instruction.
1737///
1738class SelectInst : public Instruction {
1739 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1740 Instruction *InsertBefore)
1741 : Instruction(S1->getType(), Instruction::Select,
1742 &Op<0>(), 3, InsertBefore) {
1743 init(C, S1, S2);
1744 setName(NameStr);
1745 }
1746
1747 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1748 BasicBlock *InsertAtEnd)
1749 : Instruction(S1->getType(), Instruction::Select,
1750 &Op<0>(), 3, InsertAtEnd) {
1751 init(C, S1, S2);
1752 setName(NameStr);
1753 }
1754
1755 void init(Value *C, Value *S1, Value *S2) {
1756 assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select")(static_cast<void> (0));
1757 Op<0>() = C;
1758 Op<1>() = S1;
1759 Op<2>() = S2;
1760 }
1761
1762protected:
1763 // Note: Instruction needs to be a friend here to call cloneImpl.
1764 friend class Instruction;
1765
1766 SelectInst *cloneImpl() const;
1767
1768public:
1769 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1770 const Twine &NameStr = "",
1771 Instruction *InsertBefore = nullptr,
1772 Instruction *MDFrom = nullptr) {
1773 SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
1774 if (MDFrom)
1775 Sel->copyMetadata(*MDFrom);
1776 return Sel;
1777 }
1778
1779 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1780 const Twine &NameStr,
1781 BasicBlock *InsertAtEnd) {
1782 return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
1783 }
1784
1785 const Value *getCondition() const { return Op<0>(); }
1786 const Value *getTrueValue() const { return Op<1>(); }
1787 const Value *getFalseValue() const { return Op<2>(); }
1788 Value *getCondition() { return Op<0>(); }
1789 Value *getTrueValue() { return Op<1>(); }
1790 Value *getFalseValue() { return Op<2>(); }
1791
1792 void setCondition(Value *V) { Op<0>() = V; }
1793 void setTrueValue(Value *V) { Op<1>() = V; }
1794 void setFalseValue(Value *V) { Op<2>() = V; }
1795
1796 /// Swap the true and false values of the select instruction.
1797 /// This doesn't swap prof metadata.
1798 void swapValues() { Op<1>().swap(Op<2>()); }
1799
1800 /// Return a string if the specified operands are invalid
1801 /// for a select operation, otherwise return null.
1802 static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
1803
1804 /// Transparently provide more efficient getOperand methods.
1805 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
1806
1807 OtherOps getOpcode() const {
1808 return static_cast<OtherOps>(Instruction::getOpcode());
1809 }
1810
1811 // Methods for support type inquiry through isa, cast, and dyn_cast:
1812 static bool classof(const Instruction *I) {
1813 return I->getOpcode() == Instruction::Select;
1814 }
1815 static bool classof(const Value *V) {
1816 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1817 }
1818};
1819
1820template <>
1821struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1822};
1823
1824DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)SelectInst::op_iterator SelectInst::op_begin() { return OperandTraits
<SelectInst>::op_begin(this); } SelectInst::const_op_iterator
SelectInst::op_begin() const { return OperandTraits<SelectInst
>::op_begin(const_cast<SelectInst*>(this)); } SelectInst
::op_iterator SelectInst::op_end() { return OperandTraits<
SelectInst>::op_end(this); } SelectInst::const_op_iterator
SelectInst::op_end() const { return OperandTraits<SelectInst
>::op_end(const_cast<SelectInst*>(this)); } Value *SelectInst
::getOperand(unsigned i_nocapture) const { (static_cast<void
> (0)); return cast_or_null<Value>( OperandTraits<
SelectInst>::op_begin(const_cast<SelectInst*>(this))
[i_nocapture].get()); } void SelectInst::setOperand(unsigned i_nocapture
, Value *Val_nocapture) { (static_cast<void> (0)); OperandTraits
<SelectInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned SelectInst::getNumOperands() const { return OperandTraits
<SelectInst>::operands(this); } template <int Idx_nocapture
> Use &SelectInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
SelectInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }
1825
1826//===----------------------------------------------------------------------===//
1827// VAArgInst Class
1828//===----------------------------------------------------------------------===//
1829
1830/// This class represents the va_arg llvm instruction, which returns
1831/// an argument of the specified type given a va_list and increments that list
1832///
1833class VAArgInst : public UnaryInstruction {
1834protected:
1835 // Note: Instruction needs to be a friend here to call cloneImpl.
1836 friend class Instruction;
1837
1838 VAArgInst *cloneImpl() const;
1839
1840public:
1841 VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
1842 Instruction *InsertBefore = nullptr)
1843 : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
1844 setName(NameStr);
1845 }
1846
1847 VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
1848 BasicBlock *InsertAtEnd)
1849 : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
1850 setName(NameStr);
1851 }
1852
1853 Value *getPointerOperand() { return getOperand(0); }
1854 const Value *getPointerOperand() const { return getOperand(0); }
1855 static unsigned getPointerOperandIndex() { return 0U; }
1856
1857 // Methods for support type inquiry through isa, cast, and dyn_cast:
1858 static bool classof(const Instruction *I) {
1859 return I->getOpcode() == VAArg;
1860 }
1861 static bool classof(const Value *V) {
1862 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1863 }
1864};
1865
1866//===----------------------------------------------------------------------===//
1867// ExtractElementInst Class
1868//===----------------------------------------------------------------------===//
1869
1870/// This instruction extracts a single (scalar)
1871/// element from a VectorType value
1872///
1873class ExtractElementInst : public Instruction {
1874 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
1875 Instruction *InsertBefore = nullptr);
1876 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
1877 BasicBlock *InsertAtEnd);
1878
1879protected:
1880 // Note: Instruction needs to be a friend here to call cloneImpl.
1881 friend class Instruction;
1882
1883 ExtractElementInst *cloneImpl() const;
1884
1885public:
1886 static ExtractElementInst *Create(Value *Vec, Value *Idx,
1887 const Twine &NameStr = "",
1888 Instruction *InsertBefore = nullptr) {
1889 return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
1890 }
1891
1892 static ExtractElementInst *Create(Value *Vec, Value *Idx,
1893 const Twine &NameStr,
1894 BasicBlock *InsertAtEnd) {
1895 return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
1896 }
1897
1898 /// Return true if an extractelement instruction can be
1899 /// formed with the specified operands.
1900 static bool isValidOperands(const Value *Vec, const Value *Idx);
1901
1902 Value *getVectorOperand() { return Op<0>(); }
1903 Value *getIndexOperand() { return Op<1>(); }
1904 const Value *getVectorOperand() const { return Op<0>(); }
1905 const Value *getIndexOperand() const { return Op<1>(); }
1906
1907 VectorType *getVectorOperandType() const {
1908 return cast<VectorType>(getVectorOperand()->getType());
1909 }
1910
1911 /// Transparently provide more efficient getOperand methods.
1912 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
1913
1914 // Methods for support type inquiry through isa, cast, and dyn_cast:
1915 static bool classof(const Instruction *I) {
1916 return I->getOpcode() == Instruction::ExtractElement;
1917 }
1918 static bool classof(const Value *V) {
1919 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1920 }
1921};
1922
1923template <>
1924struct OperandTraits<ExtractElementInst> :
1925 public FixedNumOperandTraits<ExtractElementInst, 2> {
1926};
1927
1928DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)ExtractElementInst::op_iterator ExtractElementInst::op_begin(
) { return OperandTraits<ExtractElementInst>::op_begin(
this); } ExtractElementInst::const_op_iterator ExtractElementInst
::op_begin() const { return OperandTraits<ExtractElementInst
>::op_begin(const_cast<ExtractElementInst*>(this)); }
ExtractElementInst::op_iterator ExtractElementInst::op_end()
{ return OperandTraits<ExtractElementInst>::op_end(this
); } ExtractElementInst::const_op_iterator ExtractElementInst
::op_end() const { return OperandTraits<ExtractElementInst
>::op_end(const_cast<ExtractElementInst*>(this)); } Value
*ExtractElementInst::getOperand(unsigned i_nocapture) const {
(static_cast<void> (0)); return cast_or_null<Value>
( OperandTraits<ExtractElementInst>::op_begin(const_cast
<ExtractElementInst*>(this))[i_nocapture].get()); } void
ExtractElementInst::setOperand(unsigned i_nocapture, Value *
Val_nocapture) { (static_cast<void> (0)); OperandTraits
<ExtractElementInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned ExtractElementInst::getNumOperands() const { return
OperandTraits<ExtractElementInst>::operands(this); } template
<int Idx_nocapture> Use &ExtractElementInst::Op() {
return this->OpFrom<Idx_nocapture>(this); } template
<int Idx_nocapture> const Use &ExtractElementInst::
Op() const { return this->OpFrom<Idx_nocapture>(this
); }
1929
1930//===----------------------------------------------------------------------===//
1931// InsertElementInst Class
1932//===----------------------------------------------------------------------===//
1933
1934/// This instruction inserts a single (scalar)
1935/// element into a VectorType value
1936///
1937class InsertElementInst : public Instruction {
1938 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1939 const Twine &NameStr = "",
1940 Instruction *InsertBefore = nullptr);
1941 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
1942 BasicBlock *InsertAtEnd);
1943
1944protected:
1945 // Note: Instruction needs to be a friend here to call cloneImpl.
1946 friend class Instruction;
1947
1948 InsertElementInst *cloneImpl() const;
1949
1950public:
1951 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1952 const Twine &NameStr = "",
1953 Instruction *InsertBefore = nullptr) {
1954 return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
1955 }
1956
1957 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1958 const Twine &NameStr,
1959 BasicBlock *InsertAtEnd) {
1960 return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
1961 }
1962
1963 /// Return true if an insertelement instruction can be
1964 /// formed with the specified operands.
1965 static bool isValidOperands(const Value *Vec, const Value *NewElt,
1966 const Value *Idx);
1967
1968 /// Overload to return most specific vector type.
1969 ///
1970 VectorType *getType() const {
1971 return cast<VectorType>(Instruction::getType());
1972 }
1973
1974 /// Transparently provide more efficient getOperand methods.
1975 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
1976
1977 // Methods for support type inquiry through isa, cast, and dyn_cast:
1978 static bool classof(const Instruction *I) {
1979 return I->getOpcode() == Instruction::InsertElement;
1980 }
1981 static bool classof(const Value *V) {
1982 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1983 }
1984};
1985
1986template <>
1987struct OperandTraits<InsertElementInst> :
1988 public FixedNumOperandTraits<InsertElementInst, 3> {
1989};
1990
1991DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)InsertElementInst::op_iterator InsertElementInst::op_begin() {
return OperandTraits<InsertElementInst>::op_begin(this
); } InsertElementInst::const_op_iterator InsertElementInst::
op_begin() const { return OperandTraits<InsertElementInst>
::op_begin(const_cast<InsertElementInst*>(this)); } InsertElementInst
::op_iterator InsertElementInst::op_end() { return OperandTraits
<InsertElementInst>::op_end(this); } InsertElementInst::
const_op_iterator InsertElementInst::op_end() const { return OperandTraits
<InsertElementInst>::op_end(const_cast<InsertElementInst
*>(this)); } Value *InsertElementInst::getOperand(unsigned
i_nocapture) const { (static_cast<void> (0)); return cast_or_null
<Value>( OperandTraits<InsertElementInst>::op_begin
(const_cast<InsertElementInst*>(this))[i_nocapture].get
()); } void InsertElementInst::setOperand(unsigned i_nocapture
, Value *Val_nocapture) { (static_cast<void> (0)); OperandTraits
<InsertElementInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned InsertElementInst::getNumOperands() const { return
OperandTraits<InsertElementInst>::operands(this); } template
<int Idx_nocapture> Use &InsertElementInst::Op() {
return this->OpFrom<Idx_nocapture>(this); } template
<int Idx_nocapture> const Use &InsertElementInst::
Op() const { return this->OpFrom<Idx_nocapture>(this
); }
1992
1993//===----------------------------------------------------------------------===//
1994// ShuffleVectorInst Class
1995//===----------------------------------------------------------------------===//
1996
1997constexpr int UndefMaskElem = -1;
1998
1999/// This instruction constructs a fixed permutation of two
2000/// input vectors.
2001///
2002/// For each element of the result vector, the shuffle mask selects an element
2003/// from one of the input vectors to copy to the result. Non-negative elements
2004/// in the mask represent an index into the concatenated pair of input vectors.
2005/// UndefMaskElem (-1) specifies that the result element is undefined.
2006///
2007/// For scalable vectors, all the elements of the mask must be 0 or -1. This
2008/// requirement may be relaxed in the future.
2009class ShuffleVectorInst : public Instruction {
2010 SmallVector<int, 4> ShuffleMask;
2011 Constant *ShuffleMaskForBitcode;
2012
2013protected:
2014 // Note: Instruction needs to be a friend here to call cloneImpl.
2015 friend class Instruction;
2016
2017 ShuffleVectorInst *cloneImpl() const;
2018
2019public:
2020 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
2021 const Twine &NameStr = "",
2022 Instruction *InsertBefor = nullptr);
2023 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
2024 const Twine &NameStr, BasicBlock *InsertAtEnd);
2025 ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
2026 const Twine &NameStr = "",
2027 Instruction *InsertBefor = nullptr);
2028 ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
2029 const Twine &NameStr, BasicBlock *InsertAtEnd);
2030
2031 void *operator new(size_t S) { return User::operator new(S, 2); }
2032 void operator delete(void *Ptr) { return User::operator delete(Ptr); }
2033
2034 /// Swap the operands and adjust the mask to preserve the semantics
2035 /// of the instruction.
2036 void commute();
2037
2038 /// Return true if a shufflevector instruction can be
2039 /// formed with the specified operands.
2040 static bool isValidOperands(const Value *V1, const Value *V2,
2041 const Value *Mask);
2042 static bool isValidOperands(const Value *V1, const Value *V2,
2043 ArrayRef<int> Mask);
2044
2045 /// Overload to return most specific vector type.
2046 ///
2047 VectorType *getType() const {
2048 return cast<VectorType>(Instruction::getType());
2049 }
2050
2051 /// Transparently provide more efficient getOperand methods.
2052 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
2053
2054 /// Return the shuffle mask value of this instruction for the given element
2055 /// index. Return UndefMaskElem if the element is undef.
2056 int getMaskValue(unsigned Elt) const { return ShuffleMask[Elt]; }
2057
2058 /// Convert the input shuffle mask operand to a vector of integers. Undefined
2059 /// elements of the mask are returned as UndefMaskElem.
2060 static void getShuffleMask(const Constant *Mask,
2061 SmallVectorImpl<int> &Result);
2062
2063 /// Return the mask for this instruction as a vector of integers. Undefined
2064 /// elements of the mask are returned as UndefMaskElem.
2065 void getShuffleMask(SmallVectorImpl<int> &Result) const {
2066 Result.assign(ShuffleMask.begin(), ShuffleMask.end());
2067 }
2068
2069 /// Return the mask for this instruction, for use in bitcode.
2070 ///
2071 /// TODO: This is temporary until we decide a new bitcode encoding for
2072 /// shufflevector.
2073 Constant *getShuffleMaskForBitcode() const { return ShuffleMaskForBitcode; }
2074
2075 static Constant *convertShuffleMaskForBitcode(ArrayRef<int> Mask,
2076 Type *ResultTy);
2077
2078 void setShuffleMask(ArrayRef<int> Mask);
2079
2080 ArrayRef<int> getShuffleMask() const { return ShuffleMask; }
2081
2082 /// Return true if this shuffle returns a vector with a different number of
2083 /// elements than its source vectors.
2084 /// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
2085 /// shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
2086 bool changesLength() const {
2087 unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
2088 ->getElementCount()
2089 .getKnownMinValue();
2090 unsigned NumMaskElts = ShuffleMask.size();
2091 return NumSourceElts != NumMaskElts;
2092 }
2093
2094 /// Return true if this shuffle returns a vector with a greater number of
2095 /// elements than its source vectors.
2096 /// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
2097 bool increasesLength() const {
2098 unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
2099 ->getElementCount()
2100 .getKnownMinValue();
2101 unsigned NumMaskElts = ShuffleMask.size();
2102 return NumSourceElts < NumMaskElts;
2103 }
2104
2105 /// Return true if this shuffle mask chooses elements from exactly one source
2106 /// vector.
2107 /// Example: <7,5,undef,7>
2108 /// This assumes that vector operands are the same length as the mask.
2109 static bool isSingleSourceMask(ArrayRef<int> Mask);
2110 static bool isSingleSourceMask(const Constant *Mask) {
2111 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2112 SmallVector<int, 16> MaskAsInts;
2113 getShuffleMask(Mask, MaskAsInts);
2114 return isSingleSourceMask(MaskAsInts);
2115 }
2116
2117 /// Return true if this shuffle chooses elements from exactly one source
2118 /// vector without changing the length of that vector.
2119 /// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
2120 /// TODO: Optionally allow length-changing shuffles.
2121 bool isSingleSource() const {
2122 return !changesLength() && isSingleSourceMask(ShuffleMask);
2123 }
2124
2125 /// Return true if this shuffle mask chooses elements from exactly one source
2126 /// vector without lane crossings. A shuffle using this mask is not
2127 /// necessarily a no-op because it may change the number of elements from its
2128 /// input vectors or it may provide demanded bits knowledge via undef lanes.
2129 /// Example: <undef,undef,2,3>
2130 static bool isIdentityMask(ArrayRef<int> Mask);
2131 static bool isIdentityMask(const Constant *Mask) {
2132 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2133 SmallVector<int, 16> MaskAsInts;
2134 getShuffleMask(Mask, MaskAsInts);
2135 return isIdentityMask(MaskAsInts);
2136 }
2137
2138 /// Return true if this shuffle chooses elements from exactly one source
2139 /// vector without lane crossings and does not change the number of elements
2140 /// from its input vectors.
2141 /// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
2142 bool isIdentity() const {
2143 return !changesLength() && isIdentityMask(ShuffleMask);
2144 }
2145
2146 /// Return true if this shuffle lengthens exactly one source vector with
2147 /// undefs in the high elements.
2148 bool isIdentityWithPadding() const;
2149
2150 /// Return true if this shuffle extracts the first N elements of exactly one
2151 /// source vector.
2152 bool isIdentityWithExtract() const;
2153
2154 /// Return true if this shuffle concatenates its 2 source vectors. This
2155 /// returns false if either input is undefined. In that case, the shuffle is
2156 /// is better classified as an identity with padding operation.
2157 bool isConcat() const;
2158
2159 /// Return true if this shuffle mask chooses elements from its source vectors
2160 /// without lane crossings. A shuffle using this mask would be
2161 /// equivalent to a vector select with a constant condition operand.
2162 /// Example: <4,1,6,undef>
2163 /// This returns false if the mask does not choose from both input vectors.
2164 /// In that case, the shuffle is better classified as an identity shuffle.
2165 /// This assumes that vector operands are the same length as the mask
2166 /// (a length-changing shuffle can never be equivalent to a vector select).
2167 static bool isSelectMask(ArrayRef<int> Mask);
2168 static bool isSelectMask(const Constant *Mask) {
2169 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2170 SmallVector<int, 16> MaskAsInts;
2171 getShuffleMask(Mask, MaskAsInts);
2172 return isSelectMask(MaskAsInts);
2173 }
2174
2175 /// Return true if this shuffle chooses elements from its source vectors
2176 /// without lane crossings and all operands have the same number of elements.
2177 /// In other words, this shuffle is equivalent to a vector select with a
2178 /// constant condition operand.
2179 /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
2180 /// This returns false if the mask does not choose from both input vectors.
2181 /// In that case, the shuffle is better classified as an identity shuffle.
2182 /// TODO: Optionally allow length-changing shuffles.
2183 bool isSelect() const {
2184 return !changesLength() && isSelectMask(ShuffleMask);
2185 }
2186
2187 /// Return true if this shuffle mask swaps the order of elements from exactly
2188 /// one source vector.
2189 /// Example: <7,6,undef,4>
2190 /// This assumes that vector operands are the same length as the mask.
2191 static bool isReverseMask(ArrayRef<int> Mask);
2192 static bool isReverseMask(const Constant *Mask) {
2193 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2194 SmallVector<int, 16> MaskAsInts;
2195 getShuffleMask(Mask, MaskAsInts);
2196 return isReverseMask(MaskAsInts);
2197 }
2198
2199 /// Return true if this shuffle swaps the order of elements from exactly
2200 /// one source vector.
2201 /// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
2202 /// TODO: Optionally allow length-changing shuffles.
2203 bool isReverse() const {
2204 return !changesLength() && isReverseMask(ShuffleMask);
2205 }
2206
2207 /// Return true if this shuffle mask chooses all elements with the same value
2208 /// as the first element of exactly one source vector.
2209 /// Example: <4,undef,undef,4>
2210 /// This assumes that vector operands are the same length as the mask.
2211 static bool isZeroEltSplatMask(ArrayRef<int> Mask);
2212 static bool isZeroEltSplatMask(const Constant *Mask) {
2213 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2214 SmallVector<int, 16> MaskAsInts;
2215 getShuffleMask(Mask, MaskAsInts);
2216 return isZeroEltSplatMask(MaskAsInts);
2217 }
2218
2219 /// Return true if all elements of this shuffle are the same value as the
2220 /// first element of exactly one source vector without changing the length
2221 /// of that vector.
2222 /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
2223 /// TODO: Optionally allow length-changing shuffles.
2224 /// TODO: Optionally allow splats from other elements.
2225 bool isZeroEltSplat() const {
2226 return !changesLength() && isZeroEltSplatMask(ShuffleMask);
2227 }
2228
2229 /// Return true if this shuffle mask is a transpose mask.
2230 /// Transpose vector masks transpose a 2xn matrix. They read corresponding
2231 /// even- or odd-numbered vector elements from two n-dimensional source
2232 /// vectors and write each result into consecutive elements of an
2233 /// n-dimensional destination vector. Two shuffles are necessary to complete
2234 /// the transpose, one for the even elements and another for the odd elements.
2235 /// This description closely follows how the TRN1 and TRN2 AArch64
2236 /// instructions operate.
2237 ///
2238 /// For example, a simple 2x2 matrix can be transposed with:
2239 ///
2240 /// ; Original matrix
2241 /// m0 = < a, b >
2242 /// m1 = < c, d >
2243 ///
2244 /// ; Transposed matrix
2245 /// t0 = < a, c > = shufflevector m0, m1, < 0, 2 >
2246 /// t1 = < b, d > = shufflevector m0, m1, < 1, 3 >
2247 ///
2248 /// For matrices having greater than n columns, the resulting nx2 transposed
2249 /// matrix is stored in two result vectors such that one vector contains
2250 /// interleaved elements from all the even-numbered rows and the other vector
2251 /// contains interleaved elements from all the odd-numbered rows. For example,
2252 /// a 2x4 matrix can be transposed with:
2253 ///
2254 /// ; Original matrix
2255 /// m0 = < a, b, c, d >
2256 /// m1 = < e, f, g, h >
2257 ///
2258 /// ; Transposed matrix
2259 /// t0 = < a, e, c, g > = shufflevector m0, m1 < 0, 4, 2, 6 >
2260 /// t1 = < b, f, d, h > = shufflevector m0, m1 < 1, 5, 3, 7 >
2261 static bool isTransposeMask(ArrayRef<int> Mask);
2262 static bool isTransposeMask(const Constant *Mask) {
2263 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2264 SmallVector<int, 16> MaskAsInts;
2265 getShuffleMask(Mask, MaskAsInts);
2266 return isTransposeMask(MaskAsInts);
2267 }
2268
2269 /// Return true if this shuffle transposes the elements of its inputs without
2270 /// changing the length of the vectors. This operation may also be known as a
2271 /// merge or interleave. See the description for isTransposeMask() for the
2272 /// exact specification.
2273 /// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
2274 bool isTranspose() const {
2275 return !changesLength() && isTransposeMask(ShuffleMask);
2276 }
2277
2278 /// Return true if this shuffle mask is an extract subvector mask.
2279 /// A valid extract subvector mask returns a smaller vector from a single
2280 /// source operand. The base extraction index is returned as well.
2281 static bool isExtractSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
2282 int &Index);
2283 static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
2284 int &Index) {
2285 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2286 // Not possible to express a shuffle mask for a scalable vector for this
2287 // case.
2288 if (isa<ScalableVectorType>(Mask->getType()))
2289 return false;
2290 SmallVector<int, 16> MaskAsInts;
2291 getShuffleMask(Mask, MaskAsInts);
2292 return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
2293 }
2294
2295 /// Return true if this shuffle mask is an extract subvector mask.
2296 bool isExtractSubvectorMask(int &Index) const {
2297 // Not possible to express a shuffle mask for a scalable vector for this
2298 // case.
2299 if (isa<ScalableVectorType>(getType()))
2300 return false;
2301
2302 int NumSrcElts =
2303 cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
2304 return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
2305 }
2306
2307 /// Return true if this shuffle mask is an insert subvector mask.
2308 /// A valid insert subvector mask inserts the lowest elements of a second
2309 /// source operand into an in-place first source operand operand.
2310 /// Both the sub vector width and the insertion index is returned.
2311 static bool isInsertSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
2312 int &NumSubElts, int &Index);
2313 static bool isInsertSubvectorMask(const Constant *Mask, int NumSrcElts,
2314 int &NumSubElts, int &Index) {
2315 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast<void> (0));
2316 // Not possible to express a shuffle mask for a scalable vector for this
2317 // case.
2318 if (isa<ScalableVectorType>(Mask->getType()))
2319 return false;
2320 SmallVector<int, 16> MaskAsInts;
2321 getShuffleMask(Mask, MaskAsInts);
2322 return isInsertSubvectorMask(MaskAsInts, NumSrcElts, NumSubElts, Index);
2323 }
2324
2325 /// Return true if this shuffle mask is an insert subvector mask.
2326 bool isInsertSubvectorMask(int &NumSubElts, int &Index) const {
2327 // Not possible to express a shuffle mask for a scalable vector for this
2328 // case.
2329 if (isa<ScalableVectorType>(getType()))
2330 return false;
2331
2332 int NumSrcElts =
2333 cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
2334 return isInsertSubvectorMask(ShuffleMask, NumSrcElts, NumSubElts, Index);
2335 }
2336
2337 /// Change values in a shuffle permute mask assuming the two vector operands
2338 /// of length InVecNumElts have swapped position.
2339 static void commuteShuffleMask(MutableArrayRef<int> Mask,
2340 unsigned InVecNumElts) {
2341 for (int &Idx : Mask) {
2342 if (Idx == -1)
2343 continue;
2344 Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
2345 assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&(static_cast<void> (0))
2346 "shufflevector mask index out of range")(static_cast<void> (0));
2347 }
2348 }
2349
2350 // Methods for support type inquiry through isa, cast, and dyn_cast:
2351 static bool classof(const Instruction *I) {
2352 return I->getOpcode() == Instruction::ShuffleVector;
2353 }
2354 static bool classof(const Value *V) {
2355 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2356 }
2357};
2358
2359template <>
2360struct OperandTraits<ShuffleVectorInst>
2361 : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};
2362
2363DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)ShuffleVectorInst::op_iterator ShuffleVectorInst::op_begin() {
return OperandTraits<ShuffleVectorInst>::op_begin(this
); } ShuffleVectorInst::const_op_iterator ShuffleVectorInst::
op_begin() const { return OperandTraits<ShuffleVectorInst>
::op_begin(const_cast<ShuffleVectorInst*>(this)); } ShuffleVectorInst
::op_iterator ShuffleVectorInst::op_end() { return OperandTraits
<ShuffleVectorInst>::op_end(this); } ShuffleVectorInst::
const_op_iterator ShuffleVectorInst::op_end() const { return OperandTraits
<ShuffleVectorInst>::op_end(const_cast<ShuffleVectorInst
*>(this)); } Value *ShuffleVectorInst::getOperand(unsigned
i_nocapture) const { (static_cast<void> (0)); return cast_or_null
<Value>( OperandTraits<ShuffleVectorInst>::op_begin
(const_cast<ShuffleVectorInst*>(this))[i_nocapture].get
()); } void ShuffleVectorInst::setOperand(unsigned i_nocapture
, Value *Val_nocapture) { (static_cast<void> (0)); OperandTraits
<ShuffleVectorInst>::op_begin(this)[i_nocapture] = Val_nocapture
; } unsigned ShuffleVectorInst::getNumOperands() const { return
OperandTraits<ShuffleVectorInst>::operands(this); } template
<int Idx_nocapture> Use &ShuffleVectorInst::Op() {
return this->OpFrom<Idx_nocapture>(this); } template
<int Idx_nocapture> const Use &ShuffleVectorInst::
Op() const { return this->OpFrom<Idx_nocapture>(this
); }
2364
2365//===----------------------------------------------------------------------===//
2366// ExtractValueInst Class
2367//===----------------------------------------------------------------------===//
2368
2369/// This instruction extracts a struct member or array
2370/// element value from an aggregate value.
2371///
2372class ExtractValueInst : public UnaryInstruction {
2373 SmallVector<unsigned, 4> Indices;
2374
2375 ExtractValueInst(const ExtractValueInst &EVI);
2376
2377 /// Constructors - Create a extractvalue instruction with a base aggregate
2378 /// value and a list of indices. The first ctor can optionally insert before
2379 /// an existing instruction, the second appends the new instruction to the
2380 /// specified BasicBlock.
2381 inline ExtractValueInst(Value *Agg,
2382 ArrayRef<unsigned> Idxs,
2383 const Twine &NameStr,
2384 Instruction *InsertBefore);
2385 inline ExtractValueInst(Value *Agg,
2386 ArrayRef<unsigned> Idxs,
2387 const Twine &NameStr, BasicBlock *InsertAtEnd);
2388
2389 void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
2390
2391protected:
2392 // Note: Instruction needs to be a friend here to call cloneImpl.
2393 friend class Instruction;
2394
2395 ExtractValueInst *cloneImpl() const;
2396
2397public:
2398 static ExtractValueInst *Create(Value *Agg,
2399 ArrayRef<unsigned> Idxs,
2400 const Twine &NameStr = "",
2401 Instruction *InsertBefore = nullptr) {
2402 return new
2403 ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
2404 }
2405
2406 static ExtractValueInst *Create(Value *Agg,
2407 ArrayRef<unsigned> Idxs,
2408 const Twine &NameStr,
2409 BasicBlock *InsertAtEnd) {
2410 return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
2411 }
2412
2413 /// Returns the type of the element that would be extracted
2414 /// with an extractvalue instruction with the specified parameters.
2415 ///
2416 /// Null is returned if the indices are invalid for the specified type.
2417 static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
2418
2419 using idx_iterator = const unsigned*;
2420
2421 inline idx_iterator idx_begin() const { return Indices.begin(); }
2422 inline idx_iterator idx_end() const { return Indices.end(); }
2423 inline iterator_range<idx_iterator> indices() const {
2424 return make_range(idx_begin(), idx_end());
2425 }
2426
2427 Value *getAggregateOperand() {
2428 return getOperand(0);
2429 }
2430 const Value *getAggregateOperand() const {
2431 return getOperand(0);
2432 }
2433 static unsigned getAggregateOperandIndex() {
2434 return 0U; // get index for modifying correct operand
2435 }
2436
2437 ArrayRef<unsigned> getIndices() const {
2438 return Indices;
2439 }
2440
2441 unsigned getNumIndices() const {
2442 return (unsigned)Indices.size();
2443 }
2444
2445 bool hasIndices() const {
2446 return true;
2447 }
2448
2449 // Methods for support type inquiry through isa, cast, and dyn_cast:
2450 static bool classof(const Instruction *I) {
2451 return I->getOpcode() == Instruction::ExtractValue;
2452 }
2453 static bool classof(const Value *V) {
2454 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2455 }
2456};
2457
2458ExtractValueInst::ExtractValueInst(Value *Agg,
2459 ArrayRef<unsigned> Idxs,
2460 const Twine &NameStr,
2461 Instruction *InsertBefore)
2462 : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
2463 ExtractValue, Agg, InsertBefore) {
2464 init(Idxs, NameStr);
2465}
2466
2467ExtractValueInst::ExtractValueInst(Value *Agg,
2468 ArrayRef<unsigned> Idxs,
2469 const Twine &NameStr,
2470 BasicBlock *InsertAtEnd)
2471 : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
2472 ExtractValue, Agg, InsertAtEnd) {
2473 init(Idxs, NameStr);
2474}
2475
2476//===----------------------------------------------------------------------===//
2477// InsertValueInst Class
2478//===----------------------------------------------------------------------===//
2479
2480/// This instruction inserts a struct field of array element
2481/// value into an aggregate value.
2482///
2483class InsertValueInst : public Instruction {
2484 SmallVector<unsigned, 4> Indices;
2485
2486 InsertValueInst(const InsertValueInst &IVI);
2487
2488 /// Constructors - Create a insertvalue instruction with a base aggregate
2489 /// value, a value to insert, and a list of indices. The first ctor can
2490 /// optionally insert before an existing instruction, the second appends
2491 /// the new instruction to the specified BasicBlock.
2492 inline InsertValueInst(Value *Agg, Value *Val,
2493 ArrayRef<unsigned> Idxs,
2494 const Twine &NameStr,
2495 Instruction *InsertBefore);
2496 inline InsertValueInst(Value *Agg, Value *Val,
2497 ArrayRef<unsigned> Idxs,
2498 const Twine &NameStr, BasicBlock *InsertAtEnd);
2499
2500 /// Constructors - These two constructors are convenience methods because one
2501 /// and two index insertvalue instructions are so common.
2502 InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
2503 const Twine &NameStr = "",
2504 Instruction *InsertBefore = nullptr);
2505 InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
2506 BasicBlock *InsertAtEnd);
2507
2508 void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
2509 const Twine &NameStr);
2510
2511protected:
2512 // Note: Instruction needs to be a friend here to call cloneImpl.
2513 friend class Instruction;
2514
2515 InsertValueInst *cloneImpl() const;
2516
2517public:
2518 // allocate space for exactly two operands
2519 void *operator new(size_t S) { return User::operator new(S, 2); }
2520 void operator delete(void *Ptr) { User::operator delete(Ptr); }
2521
2522 static InsertValueInst *Create(Value *Agg, Value *Val,
2523 ArrayRef<unsigned> Idxs,
2524 const Twine &NameStr = "",
2525 Instruction *InsertBefore = nullptr) {
2526 return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
2527 }
2528
2529 static InsertValueInst *Create(Value *Agg, Value *Val,
2530 ArrayRef<unsigned> Idxs,
2531 const Twine &NameStr,
2532 BasicBlock *InsertAtEnd) {
2533 return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
2534 }
2535
2536 /// Transparently provide more efficient getOperand methods.
2537 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
2538
2539 using idx_iterator = const unsigned*;
2540
2541 inline idx_iterator idx_begin() const { return Indices.begin(); }
2542 inline idx_iterator idx_end() const { return Indices.end(); }
2543 inline iterator_range<idx_iterator> indices() const {
2544 return make_range(idx_begin(), idx_end());
2545 }
2546
2547 Value *getAggregateOperand() {
2548 return getOperand(0);
2549 }
2550 const Value *getAggregateOperand() const {
2551 return getOperand(0);
2552 }
2553 static unsigned getAggregateOperandIndex() {
2554 return 0U; // get index for modifying correct operand
2555 }
2556
2557 Value *getInsertedValueOperand() {
2558 return getOperand(1);
2559 }
2560 const Value *getInsertedValueOperand() const {
2561 return getOperand(1);
2562 }
2563 static unsigned getInsertedValueOperandIndex() {
2564 return 1U; // get index for modifying correct operand
2565 }
2566
2567 ArrayRef<unsigned> getIndices() const {
2568 return Indices;
2569 }
2570
2571 unsigned getNumIndices() const {
2572 return (unsigned)Indices.size();
2573 }
2574
2575 bool hasIndices() const {
2576 return true;
2577 }
2578
2579 // Methods for support type inquiry through isa, cast, and dyn_cast:
2580 static bool classof(const Instruction *I) {
2581 return I->getOpcode() == Instruction::InsertValue;
2582 }
2583 static bool classof(const Value *V) {
2584 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2585 }
2586};
2587
2588template <>
2589struct OperandTraits<InsertValueInst> :
2590 public FixedNumOperandTraits<InsertValueInst, 2> {
2591};
2592
2593InsertValueInst::InsertValueInst(Value *Agg,
2594 Value *Val,
2595 ArrayRef<unsigned> Idxs,
2596 const Twine &NameStr,
2597 Instruction *InsertBefore)
2598 : Instruction(Agg->getType(), InsertValue,
2599 OperandTraits<InsertValueInst>::op_begin(this),
2600 2, InsertBefore) {
2601 init(Agg, Val, Idxs, NameStr);
2602}
2603
2604InsertValueInst::InsertValueInst(Value *Agg,
2605 Value *Val,
2606 ArrayRef<unsigned> Idxs,
2607 const Twine &NameStr,
2608 BasicBlock *InsertAtEnd)
2609 : Instruction(Agg->getType(), InsertValue,
2610 OperandTraits<InsertValueInst>::op_begin(this),
2611 2, InsertAtEnd) {
2612 init(Agg, Val, Idxs, NameStr);
2613}
2614
2615DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)InsertValueInst::op_iterator InsertValueInst::op_begin() { return
OperandTraits<InsertValueInst>::op_begin(this); } InsertValueInst
::const_op_iterator InsertValueInst::op_begin() const { return
OperandTraits<InsertValueInst>::op_begin(const_cast<
InsertValueInst*>(this)); } InsertValueInst::op_iterator InsertValueInst
::op_end() { return OperandTraits<InsertValueInst>::op_end
(this); } InsertValueInst::const_op_iterator InsertValueInst::
op_end() const { return OperandTraits<InsertValueInst>::
op_end(const_cast<InsertValueInst*>(this)); } Value *InsertValueInst
::getOperand(unsigned i_nocapture) const { (static_cast<void
> (0)); return cast_or_null<Value>( OperandTraits<
InsertValueInst>::op_begin(const_cast<InsertValueInst*>
(this))[i_nocapture].get()); } void InsertValueInst::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { (static_cast<
void> (0)); OperandTraits<InsertValueInst>::op_begin
(this)[i_nocapture] = Val_nocapture; } unsigned InsertValueInst
::getNumOperands() const { return OperandTraits<InsertValueInst
>::operands(this); } template <int Idx_nocapture> Use
&InsertValueInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
InsertValueInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }
2616
2617//===----------------------------------------------------------------------===//
2618// PHINode Class
2619//===----------------------------------------------------------------------===//
2620
2621// PHINode - The PHINode class is used to represent the magical mystical PHI
2622// node, that can not exist in nature, but can be synthesized in a computer
2623// scientist's overactive imagination.
2624//
2625class PHINode : public Instruction {
2626 /// The number of operands actually allocated. NumOperands is
2627 /// the number actually in use.
2628 unsigned ReservedSpace;
2629
2630 PHINode(const PHINode &PN);
2631
2632 explicit PHINode(Type *Ty, unsigned NumReservedValues,
2633 const Twine &NameStr = "",
2634 Instruction *InsertBefore = nullptr)
2635 : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
2636 ReservedSpace(NumReservedValues) {
2637 assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!")(static_cast<void> (0));
2638 setName(NameStr);
2639 allocHungoffUses(ReservedSpace);
2640 }
2641
2642 PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
2643 BasicBlock *InsertAtEnd)
2644 : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
2645 ReservedSpace(NumReservedValues) {
2646 assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!")(static_cast<void> (0));
2647 setName(NameStr);
2648 allocHungoffUses(ReservedSpace);
2649 }
2650
2651protected:
2652 // Note: Instruction needs to be a friend here to call cloneImpl.
2653 friend class Instruction;
2654
2655 PHINode *cloneImpl() const;
2656
2657 // allocHungoffUses - this is more complicated than the generic
2658 // User::allocHungoffUses, because we have to allocate Uses for the incoming
2659 // values and pointers to the incoming blocks, all in one allocation.
2660 void allocHungoffUses(unsigned N) {
2661 User::allocHungoffUses(N, /* IsPhi */ true);
2662 }
2663
2664public:
2665 /// Constructors - NumReservedValues is a hint for the number of incoming
2666 /// edges that this phi node will have (use 0 if you really have no idea).
2667 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2668 const Twine &NameStr = "",
2669 Instruction *InsertBefore = nullptr) {
2670 return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
2671 }
2672
2673 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2674 const Twine &NameStr, BasicBlock *InsertAtEnd) {
2675 return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
2676 }
2677
2678 /// Provide fast operand accessors
2679 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
2680
2681 // Block iterator interface. This provides access to the list of incoming
2682 // basic blocks, which parallels the list of incoming values.
2683
2684 using block_iterator = BasicBlock **;
2685 using const_block_iterator = BasicBlock * const *;
2686
2687 block_iterator block_begin() {
2688 return reinterpret_cast<block_iterator>(op_begin() + ReservedSpace);
2689 }
2690
2691 const_block_iterator block_begin() const {
2692 return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
2693 }
2694
2695 block_iterator block_end() {
2696 return block_begin() + getNumOperands();
2697 }
2698
2699 const_block_iterator block_end() const {
2700 return block_begin() + getNumOperands();
2701 }
2702
2703 iterator_range<block_iterator> blocks() {
2704 return make_range(block_begin(), block_end());
2705 }
2706
2707 iterator_range<const_block_iterator> blocks() const {
2708 return make_range(block_begin(), block_end());
2709 }
2710
2711 op_range incoming_values() { return operands(); }
2712
2713 const_op_range incoming_values() const { return operands(); }
2714
2715 /// Return the number of incoming edges
2716 ///
2717 unsigned getNumIncomingValues() const { return getNumOperands(); }
2718
2719 /// Return incoming value number x
2720 ///
2721 Value *getIncomingValue(unsigned i) const {
2722 return getOperand(i);
2723 }
2724 void setIncomingValue(unsigned i, Value *V) {
2725 assert(V && "PHI node got a null value!")(static_cast<void> (0));
2726 assert(getType() == V->getType() &&(static_cast<void> (0))
2727 "All operands to PHI node must be the same type as the PHI node!")(static_cast<void> (0));
2728 setOperand(i, V);
2729 }
2730
2731 static unsigned getOperandNumForIncomingValue(unsigned i) {
2732 return i;
2733 }
2734
2735 static unsigned getIncomingValueNumForOperand(unsigned i) {
2736 return i;
2737 }
2738
2739 /// Return incoming basic block number @p i.
2740 ///
2741 BasicBlock *getIncomingBlock(unsigned i) const {
2742 return block_begin()[i];
2743 }
2744
2745 /// Return incoming basic block corresponding
2746 /// to an operand of the PHI.
2747 ///
2748 BasicBlock *getIncomingBlock(const Use &U) const {
2749 assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?")(static_cast<void> (0));
2750 return getIncomingBlock(unsigned(&U - op_begin()));
2751 }
2752
2753 /// Return incoming basic block corresponding
2754 /// to value use iterator.
2755 ///
2756 BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
2757 return getIncomingBlock(I.getUse());
2758 }
2759
2760 void setIncomingBlock(unsigned i, BasicBlock *BB) {
2761 assert(BB && "PHI node got a null basic block!")(static_cast<void> (0));
2762 block_begin()[i] = BB;
2763 }
2764
2765 /// Replace every incoming basic block \p Old to basic block \p New.
2766 void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New) {
2767 assert(New && Old && "PHI node got a null basic block!")(static_cast<void> (0));
2768 for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
2769 if (getIncomingBlock(Op) == Old)
2770 setIncomingBlock(Op, New);
2771 }
2772
2773 /// Add an incoming value to the end of the PHI list
2774 ///
2775 void addIncoming(Value *V, BasicBlock *BB) {
2776 if (getNumOperands() == ReservedSpace)
2777 growOperands(); // Get more space!
2778 // Initialize some new operands.
2779 setNumHungOffUseOperands(getNumOperands() + 1);
2780 setIncomingValue(getNumOperands() - 1, V);
2781 setIncomingBlock(getNumOperands() - 1, BB);
2782 }
2783
2784 /// Remove an incoming value. This is useful if a
2785 /// predecessor basic block is deleted. The value removed is returned.
2786 ///
2787 /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
2788 /// is true), the PHI node is destroyed and any uses of it are replaced with
2789 /// dummy values. The only time there should be zero incoming values to a PHI
2790 /// node is when the block is dead, so this strategy is sound.
2791 ///
2792 Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
2793
2794 Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
2795 int Idx = getBasicBlockIndex(BB);
2796 assert(Idx >= 0 && "Invalid basic block argument to remove!")(static_cast<void> (0));
2797 return removeIncomingValue(Idx, DeletePHIIfEmpty);
2798 }
2799
2800 /// Return the first index of the specified basic
2801 /// block in the value list for this PHI. Returns -1 if no instance.
2802 ///
2803 int getBasicBlockIndex(const BasicBlock *BB) const {
2804 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
2805 if (block_begin()[i] == BB)
2806 return i;
2807 return -1;
2808 }
2809
2810 Value *getIncomingValueForBlock(const BasicBlock *BB) const {
2811 int Idx = getBasicBlockIndex(BB);
2812 assert(Idx >= 0 && "Invalid basic block argument!")(static_cast<void> (0));
2813 return getIncomingValue(Idx);
2814 }
2815
2816 /// Set every incoming value(s) for block \p BB to \p V.
2817 void setIncomingValueForBlock(const BasicBlock *BB, Value *V) {
2818 assert(BB && "PHI node got a null basic block!")(static_cast<void> (0));
2819 bool Found = false;
2820 for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
2821 if (getIncomingBlock(Op) == BB) {
2822 Found = true;
2823 setIncomingValue(Op, V);
2824 }
2825 (void)Found;
2826 assert(Found && "Invalid basic block argument to set!")(static_cast<void> (0));
2827 }
2828
2829 /// If the specified PHI node always merges together the
2830 /// same value, return the value, otherwise return null.
2831 Value *hasConstantValue() const;
2832
2833 /// Whether the specified PHI node always merges
2834 /// together the same value, assuming undefs are equal to a unique
2835 /// non-undef value.
2836 bool hasConstantOrUndefValue() const;
2837
2838 /// If the PHI node is complete which means all of its parent's predecessors
2839 /// have incoming value in this PHI, return true, otherwise return false.
2840 bool isComplete() const {
2841 return llvm::all_of(predecessors(getParent()),
2842 [this](const BasicBlock *Pred) {
2843 return getBasicBlockIndex(Pred) >= 0;
2844 });
2845 }
2846
2847 /// Methods for support type inquiry through isa, cast, and dyn_cast:
2848 static bool classof(const Instruction *I) {
2849 return I->getOpcode() == Instruction::PHI;
2850 }
2851 static bool classof(const Value *V) {
2852 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2853 }
2854
2855private:
2856 void growOperands();
2857};
2858
2859template <>
2860struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2861};
2862
2863DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)PHINode::op_iterator PHINode::op_begin() { return OperandTraits
<PHINode>::op_begin(this); } PHINode::const_op_iterator
PHINode::op_begin() const { return OperandTraits<PHINode>
::op_begin(const_cast<PHINode*>(this)); } PHINode::op_iterator
PHINode::op_end() { return OperandTraits<PHINode>::op_end
(this); } PHINode::const_op_iterator PHINode::op_end() const {
return OperandTraits<PHINode>::op_end(const_cast<PHINode
*>(this)); } Value *PHINode::getOperand(unsigned i_nocapture
) const { (static_cast<void> (0)); return cast_or_null<
Value>( OperandTraits<PHINode>::op_begin(const_cast<
PHINode*>(this))[i_nocapture].get()); } void PHINode::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { (static_cast<
void> (0)); OperandTraits<PHINode>::op_begin(this)[i_nocapture
] = Val_nocapture; } unsigned PHINode::getNumOperands() const
{ return OperandTraits<PHINode>::operands(this); } template
<int Idx_nocapture> Use &PHINode::Op() { return this
->OpFrom<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &PHINode::Op() const { return this->OpFrom
<Idx_nocapture>(this); }
2864
2865//===----------------------------------------------------------------------===//
2866// LandingPadInst Class
2867//===----------------------------------------------------------------------===//
2868
2869//===---------------------------------------------------------------------------
2870/// The landingpad instruction holds all of the information
2871/// necessary to generate correct exception handling. The landingpad instruction
2872/// cannot be moved from the top of a landing pad block, which itself is
2873/// accessible only from the 'unwind' edge of an invoke. This uses the
2874/// SubclassData field in Value to store whether or not the landingpad is a
2875/// cleanup.
2876///
2877class LandingPadInst : public Instruction {
2878 using CleanupField = BoolBitfieldElementT<0>;
2879
2880 /// The number of operands actually allocated. NumOperands is
2881 /// the number actually in use.
2882 unsigned ReservedSpace;
2883
2884 LandingPadInst(const LandingPadInst &LP);
2885
2886public:
2887 enum ClauseType { Catch, Filter };
2888
2889private:
2890 explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
2891 const Twine &NameStr, Instruction *InsertBefore);
2892 explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
2893 const Twine &NameStr, BasicBlock *InsertAtEnd);
2894
2895 // Allocate space for exactly zero operands.
2896 void *operator new(size_t S) { return User::operator new(S); }
2897
2898 void growOperands(unsigned Size);
2899 void init(unsigned NumReservedValues, const Twine &NameStr);
2900
2901protected:
2902 // Note: Instruction needs to be a friend here to call cloneImpl.
2903 friend class Instruction;
2904
2905 LandingPadInst *cloneImpl() const;
2906
2907public:
2908 void operator delete(void *Ptr) { User::operator delete(Ptr); }
2909
2910 /// Constructors - NumReservedClauses is a hint for the number of incoming
2911 /// clauses that this landingpad will have (use 0 if you really have no idea).
2912 static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
2913 const Twine &NameStr = "",
2914 Instruction *InsertBefore = nullptr);
2915 static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
2916 const Twine &NameStr, BasicBlock *InsertAtEnd);
2917
2918 /// Provide fast operand accessors
2919 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
2920
2921 /// Return 'true' if this landingpad instruction is a
2922 /// cleanup. I.e., it should be run when unwinding even if its landing pad
2923 /// doesn't catch the exception.
2924 bool isCleanup() const { return getSubclassData<CleanupField>(); }
2925
2926 /// Indicate that this landingpad instruction is a cleanup.
2927 void setCleanup(bool V) { setSubclassData<CleanupField>(V); }
2928
2929 /// Add a catch or filter clause to the landing pad.
2930 void addClause(Constant *ClauseVal);
2931
2932 /// Get the value of the clause at index Idx. Use isCatch/isFilter to
2933 /// determine what type of clause this is.
2934 Constant *getClause(unsigned Idx) const {
2935 return cast<Constant>(getOperandList()[Idx]);
2936 }
2937
2938 /// Return 'true' if the clause and index Idx is a catch clause.
2939 bool isCatch(unsigned Idx) const {
2940 return !isa<ArrayType>(getOperandList()[Idx]->getType());
2941 }
2942
2943 /// Return 'true' if the clause and index Idx is a filter clause.
2944 bool isFilter(unsigned Idx) const {
2945 return isa<ArrayType>(getOperandList()[Idx]->getType());
2946 }
2947
2948 /// Get the number of clauses for this landing pad.
2949 unsigned getNumClauses() const { return getNumOperands(); }
2950
2951 /// Grow the size of the operand list to accommodate the new
2952 /// number of clauses.
2953 void reserveClauses(unsigned Size) { growOperands(Size); }
2954
2955 // Methods for support type inquiry through isa, cast, and dyn_cast:
2956 static bool classof(const Instruction *I) {
2957 return I->getOpcode() == Instruction::LandingPad;
2958 }
2959 static bool classof(const Value *V) {
2960 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2961 }
2962};
2963
2964template <>
2965struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
2966};
2967
2968DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)LandingPadInst::op_iterator LandingPadInst::op_begin() { return
OperandTraits<LandingPadInst>::op_begin(this); } LandingPadInst
::const_op_iterator LandingPadInst::op_begin() const { return
OperandTraits<LandingPadInst>::op_begin(const_cast<
LandingPadInst*>(this)); } LandingPadInst::op_iterator LandingPadInst
::op_end() { return OperandTraits<LandingPadInst>::op_end
(this); } LandingPadInst::const_op_iterator LandingPadInst::op_end
() const { return OperandTraits<LandingPadInst>::op_end
(const_cast<LandingPadInst*>(this)); } Value *LandingPadInst
::getOperand(unsigned i_nocapture) const { (static_cast<void
> (0)); return cast_or_null<Value>( OperandTraits<
LandingPadInst>::op_begin(const_cast<LandingPadInst*>
(this))[i_nocapture].get()); } void LandingPadInst::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { (static_cast<
void> (0)); OperandTraits<LandingPadInst>::op_begin(
this)[i_nocapture] = Val_nocapture; } unsigned LandingPadInst
::getNumOperands() const { return OperandTraits<LandingPadInst
>::operands(this); } template <int Idx_nocapture> Use
&LandingPadInst::Op() { return this->OpFrom<Idx_nocapture
>(this); } template <int Idx_nocapture> const Use &
LandingPadInst::Op() const { return this->OpFrom<Idx_nocapture
>(this); }
2969
2970//===----------------------------------------------------------------------===//
2971// ReturnInst Class
2972//===----------------------------------------------------------------------===//
2973
2974//===---------------------------------------------------------------------------
2975/// Return a value (possibly void), from a function. Execution
2976/// does not continue in this function any longer.
2977///
2978class ReturnInst : public Instruction {
2979 ReturnInst(const ReturnInst &RI);
2980
2981private:
2982 // ReturnInst constructors:
2983 // ReturnInst() - 'ret void' instruction
2984 // ReturnInst( null) - 'ret void' instruction
2985 // ReturnInst(Value* X) - 'ret X' instruction
2986 // ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
2987 // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
2988 // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
2989 // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
2990 //
2991 // NOTE: If the Value* passed is of type void then the constructor behaves as
2992 // if it was passed NULL.
2993 explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
2994 Instruction *InsertBefore = nullptr);
2995 ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
2996 explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2997
2998protected:
2999 // Note: Instruction needs to be a friend here to call cloneImpl.
3000 friend class Instruction;
3001
3002 ReturnInst *cloneImpl() const;
3003
3004public:
3005 static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
3006 Instruction *InsertBefore = nullptr) {
3007 return new(!!retVal) ReturnInst(C, retVal, InsertBefore);