Bug Summary

File:lib/Transforms/Utils/Local.cpp
Warning:line 143, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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

/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp

1//===- Local.cpp - Functions to perform local transformations -------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This family of functions perform various local transformations to the
11// program.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/Transforms/Utils/Local.h"
16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/DenseMap.h"
18#include "llvm/ADT/DenseMapInfo.h"
19#include "llvm/ADT/DenseSet.h"
20#include "llvm/ADT/Hashing.h"
21#include "llvm/ADT/None.h"
22#include "llvm/ADT/Optional.h"
23#include "llvm/ADT/STLExtras.h"
24#include "llvm/ADT/SetVector.h"
25#include "llvm/ADT/SmallPtrSet.h"
26#include "llvm/ADT/SmallVector.h"
27#include "llvm/ADT/Statistic.h"
28#include "llvm/ADT/TinyPtrVector.h"
29#include "llvm/Analysis/ConstantFolding.h"
30#include "llvm/Analysis/EHPersonalities.h"
31#include "llvm/Analysis/InstructionSimplify.h"
32#include "llvm/Analysis/LazyValueInfo.h"
33#include "llvm/Analysis/MemoryBuiltins.h"
34#include "llvm/Analysis/MemorySSAUpdater.h"
35#include "llvm/Analysis/TargetLibraryInfo.h"
36#include "llvm/Analysis/ValueTracking.h"
37#include "llvm/Analysis/VectorUtils.h"
38#include "llvm/BinaryFormat/Dwarf.h"
39#include "llvm/IR/Argument.h"
40#include "llvm/IR/Attributes.h"
41#include "llvm/IR/BasicBlock.h"
42#include "llvm/IR/CFG.h"
43#include "llvm/IR/CallSite.h"
44#include "llvm/IR/Constant.h"
45#include "llvm/IR/ConstantRange.h"
46#include "llvm/IR/Constants.h"
47#include "llvm/IR/DIBuilder.h"
48#include "llvm/IR/DataLayout.h"
49#include "llvm/IR/DebugInfoMetadata.h"
50#include "llvm/IR/DebugLoc.h"
51#include "llvm/IR/DerivedTypes.h"
52#include "llvm/IR/DomTreeUpdater.h"
53#include "llvm/IR/Dominators.h"
54#include "llvm/IR/Function.h"
55#include "llvm/IR/GetElementPtrTypeIterator.h"
56#include "llvm/IR/GlobalObject.h"
57#include "llvm/IR/IRBuilder.h"
58#include "llvm/IR/InstrTypes.h"
59#include "llvm/IR/Instruction.h"
60#include "llvm/IR/Instructions.h"
61#include "llvm/IR/IntrinsicInst.h"
62#include "llvm/IR/Intrinsics.h"
63#include "llvm/IR/LLVMContext.h"
64#include "llvm/IR/MDBuilder.h"
65#include "llvm/IR/Metadata.h"
66#include "llvm/IR/Module.h"
67#include "llvm/IR/Operator.h"
68#include "llvm/IR/PatternMatch.h"
69#include "llvm/IR/Type.h"
70#include "llvm/IR/Use.h"
71#include "llvm/IR/User.h"
72#include "llvm/IR/Value.h"
73#include "llvm/IR/ValueHandle.h"
74#include "llvm/Support/Casting.h"
75#include "llvm/Support/Debug.h"
76#include "llvm/Support/ErrorHandling.h"
77#include "llvm/Support/KnownBits.h"
78#include "llvm/Support/raw_ostream.h"
79#include "llvm/Transforms/Utils/ValueMapper.h"
80#include <algorithm>
81#include <cassert>
82#include <climits>
83#include <cstdint>
84#include <iterator>
85#include <map>
86#include <utility>
87
88using namespace llvm;
89using namespace llvm::PatternMatch;
90
91#define DEBUG_TYPE"local" "local"
92
93STATISTIC(NumRemoved, "Number of unreachable basic blocks removed")static llvm::Statistic NumRemoved = {"local", "NumRemoved", "Number of unreachable basic blocks removed"
, {0}, {false}}
;
94
95//===----------------------------------------------------------------------===//
96// Local constant propagation.
97//
98
99/// ConstantFoldTerminator - If a terminator instruction is predicated on a
100/// constant value, convert it into an unconditional branch to the constant
101/// destination. This is a nontrivial operation because the successors of this
102/// basic block must have their PHI nodes updated.
103/// Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch/switch
104/// conditions and indirectbr addresses this might make dead if
105/// DeleteDeadConditions is true.
106bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions,
107 const TargetLibraryInfo *TLI,
108 DomTreeUpdater *DTU) {
109 Instruction *T = BB->getTerminator();
110 IRBuilder<> Builder(T);
111
112 // Branch - See if we are conditional jumping on constant
113 if (auto *BI = dyn_cast<BranchInst>(T)) {
5
Taking true branch
114 if (BI->isUnconditional()) return false; // Can't optimize uncond branch
6
Taking false branch
115 BasicBlock *Dest1 = BI->getSuccessor(0);
7
Calling 'BranchInst::getSuccessor'
18
Returning from 'BranchInst::getSuccessor'
19
'Dest1' initialized here
116 BasicBlock *Dest2 = BI->getSuccessor(1);
117
118 if (auto *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
20
Taking false branch
119 // Are we branching on constant?
120 // YES. Change to unconditional branch...
121 BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2;
122 BasicBlock *OldDest = Cond->getZExtValue() ? Dest2 : Dest1;
123
124 // Let the basic block know that we are letting go of it. Based on this,
125 // it will adjust it's PHI nodes.
126 OldDest->removePredecessor(BB);
127
128 // Replace the conditional branch with an unconditional one.
129 Builder.CreateBr(Destination);
130 BI->eraseFromParent();
131 if (DTU)
132 DTU->deleteEdgeRelaxed(BB, OldDest);
133 return true;
134 }
135
136 if (Dest2 == Dest1) { // Conditional branch to same location?
21
Assuming 'Dest2' is equal to 'Dest1'
22
Assuming pointer value is null
23
Taking true branch
137 // This branch matches something like this:
138 // br bool %cond, label %Dest, label %Dest
139 // and changes it into: br label %Dest
140
141 // Let the basic block know that we are letting go of one copy of it.
142 assert(BI->getParent() && "Terminator not inserted in block!")((BI->getParent() && "Terminator not inserted in block!"
) ? static_cast<void> (0) : __assert_fail ("BI->getParent() && \"Terminator not inserted in block!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 142, __PRETTY_FUNCTION__))
;
24
Assuming the condition is true
25
'?' condition is true
143 Dest1->removePredecessor(BI->getParent());
26
Called C++ object pointer is null
144
145 // Replace the conditional branch with an unconditional one.
146 Builder.CreateBr(Dest1);
147 Value *Cond = BI->getCondition();
148 BI->eraseFromParent();
149 if (DeleteDeadConditions)
150 RecursivelyDeleteTriviallyDeadInstructions(Cond, TLI);
151 return true;
152 }
153 return false;
154 }
155
156 if (auto *SI = dyn_cast<SwitchInst>(T)) {
157 // If we are switching on a constant, we can convert the switch to an
158 // unconditional branch.
159 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
160 BasicBlock *DefaultDest = SI->getDefaultDest();
161 BasicBlock *TheOnlyDest = DefaultDest;
162
163 // If the default is unreachable, ignore it when searching for TheOnlyDest.
164 if (isa<UnreachableInst>(DefaultDest->getFirstNonPHIOrDbg()) &&
165 SI->getNumCases() > 0) {
166 TheOnlyDest = SI->case_begin()->getCaseSuccessor();
167 }
168
169 // Figure out which case it goes to.
170 for (auto i = SI->case_begin(), e = SI->case_end(); i != e;) {
171 // Found case matching a constant operand?
172 if (i->getCaseValue() == CI) {
173 TheOnlyDest = i->getCaseSuccessor();
174 break;
175 }
176
177 // Check to see if this branch is going to the same place as the default
178 // dest. If so, eliminate it as an explicit compare.
179 if (i->getCaseSuccessor() == DefaultDest) {
180 MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
181 unsigned NCases = SI->getNumCases();
182 // Fold the case metadata into the default if there will be any branches
183 // left, unless the metadata doesn't match the switch.
184 if (NCases > 1 && MD && MD->getNumOperands() == 2 + NCases) {
185 // Collect branch weights into a vector.
186 SmallVector<uint32_t, 8> Weights;
187 for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
188 ++MD_i) {
189 auto *CI = mdconst::extract<ConstantInt>(MD->getOperand(MD_i));
190 Weights.push_back(CI->getValue().getZExtValue());
191 }
192 // Merge weight of this case to the default weight.
193 unsigned idx = i->getCaseIndex();
194 Weights[0] += Weights[idx+1];
195 // Remove weight for this case.
196 std::swap(Weights[idx+1], Weights.back());
197 Weights.pop_back();
198 SI->setMetadata(LLVMContext::MD_prof,
199 MDBuilder(BB->getContext()).
200 createBranchWeights(Weights));
201 }
202 // Remove this entry.
203 BasicBlock *ParentBB = SI->getParent();
204 DefaultDest->removePredecessor(ParentBB);
205 i = SI->removeCase(i);
206 e = SI->case_end();
207 if (DTU)
208 DTU->deleteEdgeRelaxed(ParentBB, DefaultDest);
209 continue;
210 }
211
212 // Otherwise, check to see if the switch only branches to one destination.
213 // We do this by reseting "TheOnlyDest" to null when we find two non-equal
214 // destinations.
215 if (i->getCaseSuccessor() != TheOnlyDest)
216 TheOnlyDest = nullptr;
217
218 // Increment this iterator as we haven't removed the case.
219 ++i;
220 }
221
222 if (CI && !TheOnlyDest) {
223 // Branching on a constant, but not any of the cases, go to the default
224 // successor.
225 TheOnlyDest = SI->getDefaultDest();
226 }
227
228 // If we found a single destination that we can fold the switch into, do so
229 // now.
230 if (TheOnlyDest) {
231 // Insert the new branch.
232 Builder.CreateBr(TheOnlyDest);
233 BasicBlock *BB = SI->getParent();
234 std::vector <DominatorTree::UpdateType> Updates;
235 if (DTU)
236 Updates.reserve(SI->getNumSuccessors() - 1);
237
238 // Remove entries from PHI nodes which we no longer branch to...
239 for (BasicBlock *Succ : successors(SI)) {
240 // Found case matching a constant operand?
241 if (Succ == TheOnlyDest) {
242 TheOnlyDest = nullptr; // Don't modify the first branch to TheOnlyDest
243 } else {
244 Succ->removePredecessor(BB);
245 if (DTU)
246 Updates.push_back({DominatorTree::Delete, BB, Succ});
247 }
248 }
249
250 // Delete the old switch.
251 Value *Cond = SI->getCondition();
252 SI->eraseFromParent();
253 if (DeleteDeadConditions)
254 RecursivelyDeleteTriviallyDeadInstructions(Cond, TLI);
255 if (DTU)
256 DTU->applyUpdates(Updates, /*ForceRemoveDuplicates*/ true);
257 return true;
258 }
259
260 if (SI->getNumCases() == 1) {
261 // Otherwise, we can fold this switch into a conditional branch
262 // instruction if it has only one non-default destination.
263 auto FirstCase = *SI->case_begin();
264 Value *Cond = Builder.CreateICmpEQ(SI->getCondition(),
265 FirstCase.getCaseValue(), "cond");
266
267 // Insert the new branch.
268 BranchInst *NewBr = Builder.CreateCondBr(Cond,
269 FirstCase.getCaseSuccessor(),
270 SI->getDefaultDest());
271 MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
272 if (MD && MD->getNumOperands() == 3) {
273 ConstantInt *SICase =
274 mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
275 ConstantInt *SIDef =
276 mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
277 assert(SICase && SIDef)((SICase && SIDef) ? static_cast<void> (0) : __assert_fail
("SICase && SIDef", "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 277, __PRETTY_FUNCTION__))
;
278 // The TrueWeight should be the weight for the single case of SI.
279 NewBr->setMetadata(LLVMContext::MD_prof,
280 MDBuilder(BB->getContext()).
281 createBranchWeights(SICase->getValue().getZExtValue(),
282 SIDef->getValue().getZExtValue()));
283 }
284
285 // Update make.implicit metadata to the newly-created conditional branch.
286 MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
287 if (MakeImplicitMD)
288 NewBr->setMetadata(LLVMContext::MD_make_implicit, MakeImplicitMD);
289
290 // Delete the old switch.
291 SI->eraseFromParent();
292 return true;
293 }
294 return false;
295 }
296
297 if (auto *IBI = dyn_cast<IndirectBrInst>(T)) {
298 // indirectbr blockaddress(@F, @BB) -> br label @BB
299 if (auto *BA =
300 dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
301 BasicBlock *TheOnlyDest = BA->getBasicBlock();
302 std::vector <DominatorTree::UpdateType> Updates;
303 if (DTU)
304 Updates.reserve(IBI->getNumDestinations() - 1);
305
306 // Insert the new branch.
307 Builder.CreateBr(TheOnlyDest);
308
309 for (unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) {
310 if (IBI->getDestination(i) == TheOnlyDest) {
311 TheOnlyDest = nullptr;
312 } else {
313 BasicBlock *ParentBB = IBI->getParent();
314 BasicBlock *DestBB = IBI->getDestination(i);
315 DestBB->removePredecessor(ParentBB);
316 if (DTU)
317 Updates.push_back({DominatorTree::Delete, ParentBB, DestBB});
318 }
319 }
320 Value *Address = IBI->getAddress();
321 IBI->eraseFromParent();
322 if (DeleteDeadConditions)
323 RecursivelyDeleteTriviallyDeadInstructions(Address, TLI);
324
325 // If we didn't find our destination in the IBI successor list, then we
326 // have undefined behavior. Replace the unconditional branch with an
327 // 'unreachable' instruction.
328 if (TheOnlyDest) {
329 BB->getTerminator()->eraseFromParent();
330 new UnreachableInst(BB->getContext(), BB);
331 }
332
333 if (DTU)
334 DTU->applyUpdates(Updates, /*ForceRemoveDuplicates*/ true);
335 return true;
336 }
337 }
338
339 return false;
340}
341
342//===----------------------------------------------------------------------===//
343// Local dead code elimination.
344//
345
346/// isInstructionTriviallyDead - Return true if the result produced by the
347/// instruction is not used, and the instruction has no side effects.
348///
349bool llvm::isInstructionTriviallyDead(Instruction *I,
350 const TargetLibraryInfo *TLI) {
351 if (!I->use_empty())
352 return false;
353 return wouldInstructionBeTriviallyDead(I, TLI);
354}
355
356bool llvm::wouldInstructionBeTriviallyDead(Instruction *I,
357 const TargetLibraryInfo *TLI) {
358 if (I->isTerminator())
359 return false;
360
361 // We don't want the landingpad-like instructions removed by anything this
362 // general.
363 if (I->isEHPad())
364 return false;
365
366 // We don't want debug info removed by anything this general, unless
367 // debug info is empty.
368 if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I)) {
369 if (DDI->getAddress())
370 return false;
371 return true;
372 }
373 if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(I)) {
374 if (DVI->getValue())
375 return false;
376 return true;
377 }
378 if (DbgLabelInst *DLI = dyn_cast<DbgLabelInst>(I)) {
379 if (DLI->getLabel())
380 return false;
381 return true;
382 }
383
384 if (!I->mayHaveSideEffects())
385 return true;
386
387 // Special case intrinsics that "may have side effects" but can be deleted
388 // when dead.
389 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
390 // Safe to delete llvm.stacksave and launder.invariant.group if dead.
391 if (II->getIntrinsicID() == Intrinsic::stacksave ||
392 II->getIntrinsicID() == Intrinsic::launder_invariant_group)
393 return true;
394
395 // Lifetime intrinsics are dead when their right-hand is undef.
396 if (II->isLifetimeStartOrEnd())
397 return isa<UndefValue>(II->getArgOperand(1));
398
399 // Assumptions are dead if their condition is trivially true. Guards on
400 // true are operationally no-ops. In the future we can consider more
401 // sophisticated tradeoffs for guards considering potential for check
402 // widening, but for now we keep things simple.
403 if (II->getIntrinsicID() == Intrinsic::assume ||
404 II->getIntrinsicID() == Intrinsic::experimental_guard) {
405 if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
406 return !Cond->isZero();
407
408 return false;
409 }
410 }
411
412 if (isAllocLikeFn(I, TLI))
413 return true;
414
415 if (CallInst *CI = isFreeCall(I, TLI))
416 if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
417 return C->isNullValue() || isa<UndefValue>(C);
418
419 if (CallSite CS = CallSite(I))
420 if (isMathLibCallNoop(CS, TLI))
421 return true;
422
423 return false;
424}
425
426/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
427/// trivially dead instruction, delete it. If that makes any of its operands
428/// trivially dead, delete them too, recursively. Return true if any
429/// instructions were deleted.
430bool llvm::RecursivelyDeleteTriviallyDeadInstructions(
431 Value *V, const TargetLibraryInfo *TLI, MemorySSAUpdater *MSSAU) {
432 Instruction *I = dyn_cast<Instruction>(V);
433 if (!I || !I->use_empty() || !isInstructionTriviallyDead(I, TLI))
434 return false;
435
436 SmallVector<Instruction*, 16> DeadInsts;
437 DeadInsts.push_back(I);
438 RecursivelyDeleteTriviallyDeadInstructions(DeadInsts, TLI, MSSAU);
439
440 return true;
441}
442
443void llvm::RecursivelyDeleteTriviallyDeadInstructions(
444 SmallVectorImpl<Instruction *> &DeadInsts, const TargetLibraryInfo *TLI,
445 MemorySSAUpdater *MSSAU) {
446 // Process the dead instruction list until empty.
447 while (!DeadInsts.empty()) {
448 Instruction &I = *DeadInsts.pop_back_val();
449 assert(I.use_empty() && "Instructions with uses are not dead.")((I.use_empty() && "Instructions with uses are not dead."
) ? static_cast<void> (0) : __assert_fail ("I.use_empty() && \"Instructions with uses are not dead.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 449, __PRETTY_FUNCTION__))
;
450 assert(isInstructionTriviallyDead(&I, TLI) &&((isInstructionTriviallyDead(&I, TLI) && "Live instruction found in dead worklist!"
) ? static_cast<void> (0) : __assert_fail ("isInstructionTriviallyDead(&I, TLI) && \"Live instruction found in dead worklist!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 451, __PRETTY_FUNCTION__))
451 "Live instruction found in dead worklist!")((isInstructionTriviallyDead(&I, TLI) && "Live instruction found in dead worklist!"
) ? static_cast<void> (0) : __assert_fail ("isInstructionTriviallyDead(&I, TLI) && \"Live instruction found in dead worklist!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 451, __PRETTY_FUNCTION__))
;
452
453 // Don't lose the debug info while deleting the instructions.
454 salvageDebugInfo(I);
455
456 // Null out all of the instruction's operands to see if any operand becomes
457 // dead as we go.
458 for (Use &OpU : I.operands()) {
459 Value *OpV = OpU.get();
460 OpU.set(nullptr);
461
462 if (!OpV->use_empty())
463 continue;
464
465 // If the operand is an instruction that became dead as we nulled out the
466 // operand, and if it is 'trivially' dead, delete it in a future loop
467 // iteration.
468 if (Instruction *OpI = dyn_cast<Instruction>(OpV))
469 if (isInstructionTriviallyDead(OpI, TLI))
470 DeadInsts.push_back(OpI);
471 }
472 if (MSSAU)
473 MSSAU->removeMemoryAccess(&I);
474
475 I.eraseFromParent();
476 }
477}
478
479bool llvm::replaceDbgUsesWithUndef(Instruction *I) {
480 SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
481 findDbgUsers(DbgUsers, I);
482 for (auto *DII : DbgUsers) {
483 Value *Undef = UndefValue::get(I->getType());
484 DII->setOperand(0, MetadataAsValue::get(DII->getContext(),
485 ValueAsMetadata::get(Undef)));
486 }
487 return !DbgUsers.empty();
488}
489
490/// areAllUsesEqual - Check whether the uses of a value are all the same.
491/// This is similar to Instruction::hasOneUse() except this will also return
492/// true when there are no uses or multiple uses that all refer to the same
493/// value.
494static bool areAllUsesEqual(Instruction *I) {
495 Value::user_iterator UI = I->user_begin();
496 Value::user_iterator UE = I->user_end();
497 if (UI == UE)
498 return true;
499
500 User *TheUse = *UI;
501 for (++UI; UI != UE; ++UI) {
502 if (*UI != TheUse)
503 return false;
504 }
505 return true;
506}
507
508/// RecursivelyDeleteDeadPHINode - If the specified value is an effectively
509/// dead PHI node, due to being a def-use chain of single-use nodes that
510/// either forms a cycle or is terminated by a trivially dead instruction,
511/// delete it. If that makes any of its operands trivially dead, delete them
512/// too, recursively. Return true if a change was made.
513bool llvm::RecursivelyDeleteDeadPHINode(PHINode *PN,
514 const TargetLibraryInfo *TLI) {
515 SmallPtrSet<Instruction*, 4> Visited;
516 for (Instruction *I = PN; areAllUsesEqual(I) && !I->mayHaveSideEffects();
517 I = cast<Instruction>(*I->user_begin())) {
518 if (I->use_empty())
519 return RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
520
521 // If we find an instruction more than once, we're on a cycle that
522 // won't prove fruitful.
523 if (!Visited.insert(I).second) {
524 // Break the cycle and delete the instruction and its operands.
525 I->replaceAllUsesWith(UndefValue::get(I->getType()));
526 (void)RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
527 return true;
528 }
529 }
530 return false;
531}
532
533static bool
534simplifyAndDCEInstruction(Instruction *I,
535 SmallSetVector<Instruction *, 16> &WorkList,
536 const DataLayout &DL,
537 const TargetLibraryInfo *TLI) {
538 if (isInstructionTriviallyDead(I, TLI)) {
539 salvageDebugInfo(*I);
540
541 // Null out all of the instruction's operands to see if any operand becomes
542 // dead as we go.
543 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
544 Value *OpV = I->getOperand(i);
545 I->setOperand(i, nullptr);
546
547 if (!OpV->use_empty() || I == OpV)
548 continue;
549
550 // If the operand is an instruction that became dead as we nulled out the
551 // operand, and if it is 'trivially' dead, delete it in a future loop
552 // iteration.
553 if (Instruction *OpI = dyn_cast<Instruction>(OpV))
554 if (isInstructionTriviallyDead(OpI, TLI))
555 WorkList.insert(OpI);
556 }
557
558 I->eraseFromParent();
559
560 return true;
561 }
562
563 if (Value *SimpleV = SimplifyInstruction(I, DL)) {
564 // Add the users to the worklist. CAREFUL: an instruction can use itself,
565 // in the case of a phi node.
566 for (User *U : I->users()) {
567 if (U != I) {
568 WorkList.insert(cast<Instruction>(U));
569 }
570 }
571
572 // Replace the instruction with its simplified value.
573 bool Changed = false;
574 if (!I->use_empty()) {
575 I->replaceAllUsesWith(SimpleV);
576 Changed = true;
577 }
578 if (isInstructionTriviallyDead(I, TLI)) {
579 I->eraseFromParent();
580 Changed = true;
581 }
582 return Changed;
583 }
584 return false;
585}
586
587/// SimplifyInstructionsInBlock - Scan the specified basic block and try to
588/// simplify any instructions in it and recursively delete dead instructions.
589///
590/// This returns true if it changed the code, note that it can delete
591/// instructions in other blocks as well in this block.
592bool llvm::SimplifyInstructionsInBlock(BasicBlock *BB,
593 const TargetLibraryInfo *TLI) {
594 bool MadeChange = false;
595 const DataLayout &DL = BB->getModule()->getDataLayout();
596
597#ifndef NDEBUG
598 // In debug builds, ensure that the terminator of the block is never replaced
599 // or deleted by these simplifications. The idea of simplification is that it
600 // cannot introduce new instructions, and there is no way to replace the
601 // terminator of a block without introducing a new instruction.
602 AssertingVH<Instruction> TerminatorVH(&BB->back());
603#endif
604
605 SmallSetVector<Instruction *, 16> WorkList;
606 // Iterate over the original function, only adding insts to the worklist
607 // if they actually need to be revisited. This avoids having to pre-init
608 // the worklist with the entire function's worth of instructions.
609 for (BasicBlock::iterator BI = BB->begin(), E = std::prev(BB->end());
610 BI != E;) {
611 assert(!BI->isTerminator())((!BI->isTerminator()) ? static_cast<void> (0) : __assert_fail
("!BI->isTerminator()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 611, __PRETTY_FUNCTION__))
;
612 Instruction *I = &*BI;
613 ++BI;
614
615 // We're visiting this instruction now, so make sure it's not in the
616 // worklist from an earlier visit.
617 if (!WorkList.count(I))
618 MadeChange |= simplifyAndDCEInstruction(I, WorkList, DL, TLI);
619 }
620
621 while (!WorkList.empty()) {
622 Instruction *I = WorkList.pop_back_val();
623 MadeChange |= simplifyAndDCEInstruction(I, WorkList, DL, TLI);
624 }
625 return MadeChange;
626}
627
628//===----------------------------------------------------------------------===//
629// Control Flow Graph Restructuring.
630//
631
632/// RemovePredecessorAndSimplify - Like BasicBlock::removePredecessor, this
633/// method is called when we're about to delete Pred as a predecessor of BB. If
634/// BB contains any PHI nodes, this drops the entries in the PHI nodes for Pred.
635///
636/// Unlike the removePredecessor method, this attempts to simplify uses of PHI
637/// nodes that collapse into identity values. For example, if we have:
638/// x = phi(1, 0, 0, 0)
639/// y = and x, z
640///
641/// .. and delete the predecessor corresponding to the '1', this will attempt to
642/// recursively fold the and to 0.
643void llvm::RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred,
644 DomTreeUpdater *DTU) {
645 // This only adjusts blocks with PHI nodes.
646 if (!isa<PHINode>(BB->begin()))
647 return;
648
649 // Remove the entries for Pred from the PHI nodes in BB, but do not simplify
650 // them down. This will leave us with single entry phi nodes and other phis
651 // that can be removed.
652 BB->removePredecessor(Pred, true);
653
654 WeakTrackingVH PhiIt = &BB->front();
655 while (PHINode *PN = dyn_cast<PHINode>(PhiIt)) {
656 PhiIt = &*++BasicBlock::iterator(cast<Instruction>(PhiIt));
657 Value *OldPhiIt = PhiIt;
658
659 if (!recursivelySimplifyInstruction(PN))
660 continue;
661
662 // If recursive simplification ended up deleting the next PHI node we would
663 // iterate to, then our iterator is invalid, restart scanning from the top
664 // of the block.
665 if (PhiIt != OldPhiIt) PhiIt = &BB->front();
666 }
667 if (DTU)
668 DTU->deleteEdgeRelaxed(Pred, BB);
669}
670
671/// MergeBasicBlockIntoOnlyPred - DestBB is a block with one predecessor and its
672/// predecessor is known to have one successor (DestBB!). Eliminate the edge
673/// between them, moving the instructions in the predecessor into DestBB and
674/// deleting the predecessor block.
675void llvm::MergeBasicBlockIntoOnlyPred(BasicBlock *DestBB,
676 DomTreeUpdater *DTU) {
677
678 // If BB has single-entry PHI nodes, fold them.
679 while (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
680 Value *NewVal = PN->getIncomingValue(0);
681 // Replace self referencing PHI with undef, it must be dead.
682 if (NewVal == PN) NewVal = UndefValue::get(PN->getType());
683 PN->replaceAllUsesWith(NewVal);
684 PN->eraseFromParent();
685 }
686
687 BasicBlock *PredBB = DestBB->getSinglePredecessor();
688 assert(PredBB && "Block doesn't have a single predecessor!")((PredBB && "Block doesn't have a single predecessor!"
) ? static_cast<void> (0) : __assert_fail ("PredBB && \"Block doesn't have a single predecessor!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 688, __PRETTY_FUNCTION__))
;
689
690 bool ReplaceEntryBB = false;
691 if (PredBB == &DestBB->getParent()->getEntryBlock())
692 ReplaceEntryBB = true;
693
694 // DTU updates: Collect all the edges that enter
695 // PredBB. These dominator edges will be redirected to DestBB.
696 SmallVector<DominatorTree::UpdateType, 32> Updates;
697
698 if (DTU) {
699 Updates.push_back({DominatorTree::Delete, PredBB, DestBB});
700 for (auto I = pred_begin(PredBB), E = pred_end(PredBB); I != E; ++I) {
701 Updates.push_back({DominatorTree::Delete, *I, PredBB});
702 // This predecessor of PredBB may already have DestBB as a successor.
703 if (llvm::find(successors(*I), DestBB) == succ_end(*I))
704 Updates.push_back({DominatorTree::Insert, *I, DestBB});
705 }
706 }
707
708 // Zap anything that took the address of DestBB. Not doing this will give the
709 // address an invalid value.
710 if (DestBB->hasAddressTaken()) {
711 BlockAddress *BA = BlockAddress::get(DestBB);
712 Constant *Replacement =
713 ConstantInt::get(Type::getInt32Ty(BA->getContext()), 1);
714 BA->replaceAllUsesWith(ConstantExpr::getIntToPtr(Replacement,
715 BA->getType()));
716 BA->destroyConstant();
717 }
718
719 // Anything that branched to PredBB now branches to DestBB.
720 PredBB->replaceAllUsesWith(DestBB);
721
722 // Splice all the instructions from PredBB to DestBB.
723 PredBB->getTerminator()->eraseFromParent();
724 DestBB->getInstList().splice(DestBB->begin(), PredBB->getInstList());
725 new UnreachableInst(PredBB->getContext(), PredBB);
726
727 // If the PredBB is the entry block of the function, move DestBB up to
728 // become the entry block after we erase PredBB.
729 if (ReplaceEntryBB)
730 DestBB->moveAfter(PredBB);
731
732 if (DTU) {
733 assert(PredBB->getInstList().size() == 1 &&((PredBB->getInstList().size() == 1 && isa<UnreachableInst
>(PredBB->getTerminator()) && "The successor list of PredBB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("PredBB->getInstList().size() == 1 && isa<UnreachableInst>(PredBB->getTerminator()) && \"The successor list of PredBB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 736, __PRETTY_FUNCTION__))
734 isa<UnreachableInst>(PredBB->getTerminator()) &&((PredBB->getInstList().size() == 1 && isa<UnreachableInst
>(PredBB->getTerminator()) && "The successor list of PredBB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("PredBB->getInstList().size() == 1 && isa<UnreachableInst>(PredBB->getTerminator()) && \"The successor list of PredBB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 736, __PRETTY_FUNCTION__))
735 "The successor list of PredBB isn't empty before "((PredBB->getInstList().size() == 1 && isa<UnreachableInst
>(PredBB->getTerminator()) && "The successor list of PredBB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("PredBB->getInstList().size() == 1 && isa<UnreachableInst>(PredBB->getTerminator()) && \"The successor list of PredBB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 736, __PRETTY_FUNCTION__))
736 "applying corresponding DTU updates.")((PredBB->getInstList().size() == 1 && isa<UnreachableInst
>(PredBB->getTerminator()) && "The successor list of PredBB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("PredBB->getInstList().size() == 1 && isa<UnreachableInst>(PredBB->getTerminator()) && \"The successor list of PredBB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 736, __PRETTY_FUNCTION__))
;
737 DTU->applyUpdates(Updates, /*ForceRemoveDuplicates*/ true);
738 DTU->deleteBB(PredBB);
739 // Recalculation of DomTree is needed when updating a forward DomTree and
740 // the Entry BB is replaced.
741 if (ReplaceEntryBB && DTU->hasDomTree()) {
742 // The entry block was removed and there is no external interface for
743 // the dominator tree to be notified of this change. In this corner-case
744 // we recalculate the entire tree.
745 DTU->recalculate(*(DestBB->getParent()));
746 }
747 }
748
749 else {
750 PredBB->eraseFromParent(); // Nuke BB if DTU is nullptr.
751 }
752}
753
754/// CanMergeValues - Return true if we can choose one of these values to use
755/// in place of the other. Note that we will always choose the non-undef
756/// value to keep.
757static bool CanMergeValues(Value *First, Value *Second) {
758 return First == Second || isa<UndefValue>(First) || isa<UndefValue>(Second);
759}
760
761/// CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an
762/// almost-empty BB ending in an unconditional branch to Succ, into Succ.
763///
764/// Assumption: Succ is the single successor for BB.
765static bool CanPropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
766 assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!")((*succ_begin(BB) == Succ && "Succ is not successor of BB!"
) ? static_cast<void> (0) : __assert_fail ("*succ_begin(BB) == Succ && \"Succ is not successor of BB!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 766, __PRETTY_FUNCTION__))
;
767
768 LLVM_DEBUG(dbgs() << "Looking to fold " << BB->getName() << " into "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Looking to fold " << BB->
getName() << " into " << Succ->getName() <<
"\n"; } } while (false)
769 << Succ->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Looking to fold " << BB->
getName() << " into " << Succ->getName() <<
"\n"; } } while (false)
;
770 // Shortcut, if there is only a single predecessor it must be BB and merging
771 // is always safe
772 if (Succ->getSinglePredecessor()) return true;
773
774 // Make a list of the predecessors of BB
775 SmallPtrSet<BasicBlock*, 16> BBPreds(pred_begin(BB), pred_end(BB));
776
777 // Look at all the phi nodes in Succ, to see if they present a conflict when
778 // merging these blocks
779 for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
780 PHINode *PN = cast<PHINode>(I);
781
782 // If the incoming value from BB is again a PHINode in
783 // BB which has the same incoming value for *PI as PN does, we can
784 // merge the phi nodes and then the blocks can still be merged
785 PHINode *BBPN = dyn_cast<PHINode>(PN->getIncomingValueForBlock(BB));
786 if (BBPN && BBPN->getParent() == BB) {
787 for (unsigned PI = 0, PE = PN->getNumIncomingValues(); PI != PE; ++PI) {
788 BasicBlock *IBB = PN->getIncomingBlock(PI);
789 if (BBPreds.count(IBB) &&
790 !CanMergeValues(BBPN->getIncomingValueForBlock(IBB),
791 PN->getIncomingValue(PI))) {
792 LLVM_DEBUG(dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with " << BBPN->getName()
<< " with regard to common predecessor " << IBB->
getName() << "\n"; } } while (false)
793 << "Can't fold, phi node " << PN->getName() << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with " << BBPN->getName()
<< " with regard to common predecessor " << IBB->
getName() << "\n"; } } while (false)
794 << Succ->getName() << " is conflicting with "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with " << BBPN->getName()
<< " with regard to common predecessor " << IBB->
getName() << "\n"; } } while (false)
795 << BBPN->getName() << " with regard to common predecessor "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with " << BBPN->getName()
<< " with regard to common predecessor " << IBB->
getName() << "\n"; } } while (false)
796 << IBB->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with " << BBPN->getName()
<< " with regard to common predecessor " << IBB->
getName() << "\n"; } } while (false)
;
797 return false;
798 }
799 }
800 } else {
801 Value* Val = PN->getIncomingValueForBlock(BB);
802 for (unsigned PI = 0, PE = PN->getNumIncomingValues(); PI != PE; ++PI) {
803 // See if the incoming value for the common predecessor is equal to the
804 // one for BB, in which case this phi node will not prevent the merging
805 // of the block.
806 BasicBlock *IBB = PN->getIncomingBlock(PI);
807 if (BBPreds.count(IBB) &&
808 !CanMergeValues(Val, PN->getIncomingValue(PI))) {
809 LLVM_DEBUG(dbgs() << "Can't fold, phi node " << PN->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with regard to common " << "predecessor "
<< IBB->getName() << "\n"; } } while (false)
810 << " in " << Succ->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with regard to common " << "predecessor "
<< IBB->getName() << "\n"; } } while (false)
811 << " is conflicting with regard to common "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with regard to common " << "predecessor "
<< IBB->getName() << "\n"; } } while (false)
812 << "predecessor " << IBB->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Can't fold, phi node " <<
PN->getName() << " in " << Succ->getName()
<< " is conflicting with regard to common " << "predecessor "
<< IBB->getName() << "\n"; } } while (false)
;
813 return false;
814 }
815 }
816 }
817 }
818
819 return true;
820}
821
822using PredBlockVector = SmallVector<BasicBlock *, 16>;
823using IncomingValueMap = DenseMap<BasicBlock *, Value *>;
824
825/// Determines the value to use as the phi node input for a block.
826///
827/// Select between \p OldVal any value that we know flows from \p BB
828/// to a particular phi on the basis of which one (if either) is not
829/// undef. Update IncomingValues based on the selected value.
830///
831/// \param OldVal The value we are considering selecting.
832/// \param BB The block that the value flows in from.
833/// \param IncomingValues A map from block-to-value for other phi inputs
834/// that we have examined.
835///
836/// \returns the selected value.
837static Value *selectIncomingValueForBlock(Value *OldVal, BasicBlock *BB,
838 IncomingValueMap &IncomingValues) {
839 if (!isa<UndefValue>(OldVal)) {
840 assert((!IncomingValues.count(BB) ||(((!IncomingValues.count(BB) || IncomingValues.find(BB)->second
== OldVal) && "Expected OldVal to match incoming value from BB!"
) ? static_cast<void> (0) : __assert_fail ("(!IncomingValues.count(BB) || IncomingValues.find(BB)->second == OldVal) && \"Expected OldVal to match incoming value from BB!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 842, __PRETTY_FUNCTION__))
841 IncomingValues.find(BB)->second == OldVal) &&(((!IncomingValues.count(BB) || IncomingValues.find(BB)->second
== OldVal) && "Expected OldVal to match incoming value from BB!"
) ? static_cast<void> (0) : __assert_fail ("(!IncomingValues.count(BB) || IncomingValues.find(BB)->second == OldVal) && \"Expected OldVal to match incoming value from BB!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 842, __PRETTY_FUNCTION__))
842 "Expected OldVal to match incoming value from BB!")(((!IncomingValues.count(BB) || IncomingValues.find(BB)->second
== OldVal) && "Expected OldVal to match incoming value from BB!"
) ? static_cast<void> (0) : __assert_fail ("(!IncomingValues.count(BB) || IncomingValues.find(BB)->second == OldVal) && \"Expected OldVal to match incoming value from BB!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 842, __PRETTY_FUNCTION__))
;
843
844 IncomingValues.insert(std::make_pair(BB, OldVal));
845 return OldVal;
846 }
847
848 IncomingValueMap::const_iterator It = IncomingValues.find(BB);
849 if (It != IncomingValues.end()) return It->second;
850
851 return OldVal;
852}
853
854/// Create a map from block to value for the operands of a
855/// given phi.
856///
857/// Create a map from block to value for each non-undef value flowing
858/// into \p PN.
859///
860/// \param PN The phi we are collecting the map for.
861/// \param IncomingValues [out] The map from block to value for this phi.
862static void gatherIncomingValuesToPhi(PHINode *PN,
863 IncomingValueMap &IncomingValues) {
864 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
865 BasicBlock *BB = PN->getIncomingBlock(i);
866 Value *V = PN->getIncomingValue(i);
867
868 if (!isa<UndefValue>(V))
869 IncomingValues.insert(std::make_pair(BB, V));
870 }
871}
872
873/// Replace the incoming undef values to a phi with the values
874/// from a block-to-value map.
875///
876/// \param PN The phi we are replacing the undefs in.
877/// \param IncomingValues A map from block to value.
878static void replaceUndefValuesInPhi(PHINode *PN,
879 const IncomingValueMap &IncomingValues) {
880 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
881 Value *V = PN->getIncomingValue(i);
882
883 if (!isa<UndefValue>(V)) continue;
884
885 BasicBlock *BB = PN->getIncomingBlock(i);
886 IncomingValueMap::const_iterator It = IncomingValues.find(BB);
887 if (It == IncomingValues.end()) continue;
888
889 PN->setIncomingValue(i, It->second);
890 }
891}
892
893/// Replace a value flowing from a block to a phi with
894/// potentially multiple instances of that value flowing from the
895/// block's predecessors to the phi.
896///
897/// \param BB The block with the value flowing into the phi.
898/// \param BBPreds The predecessors of BB.
899/// \param PN The phi that we are updating.
900static void redirectValuesFromPredecessorsToPhi(BasicBlock *BB,
901 const PredBlockVector &BBPreds,
902 PHINode *PN) {
903 Value *OldVal = PN->removeIncomingValue(BB, false);
904 assert(OldVal && "No entry in PHI for Pred BB!")((OldVal && "No entry in PHI for Pred BB!") ? static_cast
<void> (0) : __assert_fail ("OldVal && \"No entry in PHI for Pred BB!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 904, __PRETTY_FUNCTION__))
;
905
906 IncomingValueMap IncomingValues;
907
908 // We are merging two blocks - BB, and the block containing PN - and
909 // as a result we need to redirect edges from the predecessors of BB
910 // to go to the block containing PN, and update PN
911 // accordingly. Since we allow merging blocks in the case where the
912 // predecessor and successor blocks both share some predecessors,
913 // and where some of those common predecessors might have undef
914 // values flowing into PN, we want to rewrite those values to be
915 // consistent with the non-undef values.
916
917 gatherIncomingValuesToPhi(PN, IncomingValues);
918
919 // If this incoming value is one of the PHI nodes in BB, the new entries
920 // in the PHI node are the entries from the old PHI.
921 if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
922 PHINode *OldValPN = cast<PHINode>(OldVal);
923 for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i) {
924 // Note that, since we are merging phi nodes and BB and Succ might
925 // have common predecessors, we could end up with a phi node with
926 // identical incoming branches. This will be cleaned up later (and
927 // will trigger asserts if we try to clean it up now, without also
928 // simplifying the corresponding conditional branch).
929 BasicBlock *PredBB = OldValPN->getIncomingBlock(i);
930 Value *PredVal = OldValPN->getIncomingValue(i);
931 Value *Selected = selectIncomingValueForBlock(PredVal, PredBB,
932 IncomingValues);
933
934 // And add a new incoming value for this predecessor for the
935 // newly retargeted branch.
936 PN->addIncoming(Selected, PredBB);
937 }
938 } else {
939 for (unsigned i = 0, e = BBPreds.size(); i != e; ++i) {
940 // Update existing incoming values in PN for this
941 // predecessor of BB.
942 BasicBlock *PredBB = BBPreds[i];
943 Value *Selected = selectIncomingValueForBlock(OldVal, PredBB,
944 IncomingValues);
945
946 // And add a new incoming value for this predecessor for the
947 // newly retargeted branch.
948 PN->addIncoming(Selected, PredBB);
949 }
950 }
951
952 replaceUndefValuesInPhi(PN, IncomingValues);
953}
954
955/// TryToSimplifyUncondBranchFromEmptyBlock - BB is known to contain an
956/// unconditional branch, and contains no instructions other than PHI nodes,
957/// potential side-effect free intrinsics and the branch. If possible,
958/// eliminate BB by rewriting all the predecessors to branch to the successor
959/// block and return true. If we can't transform, return false.
960bool llvm::TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB,
961 DomTreeUpdater *DTU) {
962 assert(BB != &BB->getParent()->getEntryBlock() &&((BB != &BB->getParent()->getEntryBlock() &&
"TryToSimplifyUncondBranchFromEmptyBlock called on entry block!"
) ? static_cast<void> (0) : __assert_fail ("BB != &BB->getParent()->getEntryBlock() && \"TryToSimplifyUncondBranchFromEmptyBlock called on entry block!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 963, __PRETTY_FUNCTION__))
963 "TryToSimplifyUncondBranchFromEmptyBlock called on entry block!")((BB != &BB->getParent()->getEntryBlock() &&
"TryToSimplifyUncondBranchFromEmptyBlock called on entry block!"
) ? static_cast<void> (0) : __assert_fail ("BB != &BB->getParent()->getEntryBlock() && \"TryToSimplifyUncondBranchFromEmptyBlock called on entry block!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 963, __PRETTY_FUNCTION__))
;
964
965 // We can't eliminate infinite loops.
966 BasicBlock *Succ = cast<BranchInst>(BB->getTerminator())->getSuccessor(0);
967 if (BB == Succ) return false;
968
969 // Check to see if merging these blocks would cause conflicts for any of the
970 // phi nodes in BB or Succ. If not, we can safely merge.
971 if (!CanPropagatePredecessorsForPHIs(BB, Succ)) return false;
972
973 // Check for cases where Succ has multiple predecessors and a PHI node in BB
974 // has uses which will not disappear when the PHI nodes are merged. It is
975 // possible to handle such cases, but difficult: it requires checking whether
976 // BB dominates Succ, which is non-trivial to calculate in the case where
977 // Succ has multiple predecessors. Also, it requires checking whether
978 // constructing the necessary self-referential PHI node doesn't introduce any
979 // conflicts; this isn't too difficult, but the previous code for doing this
980 // was incorrect.
981 //
982 // Note that if this check finds a live use, BB dominates Succ, so BB is
983 // something like a loop pre-header (or rarely, a part of an irreducible CFG);
984 // folding the branch isn't profitable in that case anyway.
985 if (!Succ->getSinglePredecessor()) {
986 BasicBlock::iterator BBI = BB->begin();
987 while (isa<PHINode>(*BBI)) {
988 for (Use &U : BBI->uses()) {
989 if (PHINode* PN = dyn_cast<PHINode>(U.getUser())) {
990 if (PN->getIncomingBlock(U) != BB)
991 return false;
992 } else {
993 return false;
994 }
995 }
996 ++BBI;
997 }
998 }
999
1000 LLVM_DEBUG(dbgs() << "Killing Trivial BB: \n" << *BB)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Killing Trivial BB: \n" <<
*BB; } } while (false)
;
1001
1002 SmallVector<DominatorTree::UpdateType, 32> Updates;
1003 if (DTU) {
1004 Updates.push_back({DominatorTree::Delete, BB, Succ});
1005 // All predecessors of BB will be moved to Succ.
1006 for (auto I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
1007 Updates.push_back({DominatorTree::Delete, *I, BB});
1008 // This predecessor of BB may already have Succ as a successor.
1009 if (llvm::find(successors(*I), Succ) == succ_end(*I))
1010 Updates.push_back({DominatorTree::Insert, *I, Succ});
1011 }
1012 }
1013
1014 if (isa<PHINode>(Succ->begin())) {
1015 // If there is more than one pred of succ, and there are PHI nodes in
1016 // the successor, then we need to add incoming edges for the PHI nodes
1017 //
1018 const PredBlockVector BBPreds(pred_begin(BB), pred_end(BB));
1019
1020 // Loop over all of the PHI nodes in the successor of BB.
1021 for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
1022 PHINode *PN = cast<PHINode>(I);
1023
1024 redirectValuesFromPredecessorsToPhi(BB, BBPreds, PN);
1025 }
1026 }
1027
1028 if (Succ->getSinglePredecessor()) {
1029 // BB is the only predecessor of Succ, so Succ will end up with exactly
1030 // the same predecessors BB had.
1031
1032 // Copy over any phi, debug or lifetime instruction.
1033 BB->getTerminator()->eraseFromParent();
1034 Succ->getInstList().splice(Succ->getFirstNonPHI()->getIterator(),
1035 BB->getInstList());
1036 } else {
1037 while (PHINode *PN = dyn_cast<PHINode>(&BB->front())) {
1038 // We explicitly check for such uses in CanPropagatePredecessorsForPHIs.
1039 assert(PN->use_empty() && "There shouldn't be any uses here!")((PN->use_empty() && "There shouldn't be any uses here!"
) ? static_cast<void> (0) : __assert_fail ("PN->use_empty() && \"There shouldn't be any uses here!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1039, __PRETTY_FUNCTION__))
;
1040 PN->eraseFromParent();
1041 }
1042 }
1043
1044 // If the unconditional branch we replaced contains llvm.loop metadata, we
1045 // add the metadata to the branch instructions in the predecessors.
1046 unsigned LoopMDKind = BB->getContext().getMDKindID("llvm.loop");
1047 Instruction *TI = BB->getTerminator();
1048 if (TI)
1049 if (MDNode *LoopMD = TI->getMetadata(LoopMDKind))
1050 for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
1051 BasicBlock *Pred = *PI;
1052 Pred->getTerminator()->setMetadata(LoopMDKind, LoopMD);
1053 }
1054
1055 // Everything that jumped to BB now goes to Succ.
1056 BB->replaceAllUsesWith(Succ);
1057 if (!Succ->hasName()) Succ->takeName(BB);
1058
1059 // Clear the successor list of BB to match updates applying to DTU later.
1060 if (BB->getTerminator())
1061 BB->getInstList().pop_back();
1062 new UnreachableInst(BB->getContext(), BB);
1063 assert(succ_empty(BB) && "The successor list of BB isn't empty before "((succ_empty(BB) && "The successor list of BB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("succ_empty(BB) && \"The successor list of BB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1064, __PRETTY_FUNCTION__))
1064 "applying corresponding DTU updates.")((succ_empty(BB) && "The successor list of BB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("succ_empty(BB) && \"The successor list of BB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1064, __PRETTY_FUNCTION__))
;
1065
1066 if (DTU) {
1067 DTU->applyUpdates(Updates, /*ForceRemoveDuplicates*/ true);
1068 DTU->deleteBB(BB);
1069 } else {
1070 BB->eraseFromParent(); // Delete the old basic block.
1071 }
1072 return true;
1073}
1074
1075/// EliminateDuplicatePHINodes - Check for and eliminate duplicate PHI
1076/// nodes in this block. This doesn't try to be clever about PHI nodes
1077/// which differ only in the order of the incoming values, but instcombine
1078/// orders them so it usually won't matter.
1079bool llvm::EliminateDuplicatePHINodes(BasicBlock *BB) {
1080 // This implementation doesn't currently consider undef operands
1081 // specially. Theoretically, two phis which are identical except for
1082 // one having an undef where the other doesn't could be collapsed.
1083
1084 struct PHIDenseMapInfo {
1085 static PHINode *getEmptyKey() {
1086 return DenseMapInfo<PHINode *>::getEmptyKey();
1087 }
1088
1089 static PHINode *getTombstoneKey() {
1090 return DenseMapInfo<PHINode *>::getTombstoneKey();
1091 }
1092
1093 static unsigned getHashValue(PHINode *PN) {
1094 // Compute a hash value on the operands. Instcombine will likely have
1095 // sorted them, which helps expose duplicates, but we have to check all
1096 // the operands to be safe in case instcombine hasn't run.
1097 return static_cast<unsigned>(hash_combine(
1098 hash_combine_range(PN->value_op_begin(), PN->value_op_end()),
1099 hash_combine_range(PN->block_begin(), PN->block_end())));
1100 }
1101
1102 static bool isEqual(PHINode *LHS, PHINode *RHS) {
1103 if (LHS == getEmptyKey() || LHS == getTombstoneKey() ||
1104 RHS == getEmptyKey() || RHS == getTombstoneKey())
1105 return LHS == RHS;
1106 return LHS->isIdenticalTo(RHS);
1107 }
1108 };
1109
1110 // Set of unique PHINodes.
1111 DenseSet<PHINode *, PHIDenseMapInfo> PHISet;
1112
1113 // Examine each PHI.
1114 bool Changed = false;
1115 for (auto I = BB->begin(); PHINode *PN = dyn_cast<PHINode>(I++);) {
1116 auto Inserted = PHISet.insert(PN);
1117 if (!Inserted.second) {
1118 // A duplicate. Replace this PHI with its duplicate.
1119 PN->replaceAllUsesWith(*Inserted.first);
1120 PN->eraseFromParent();
1121 Changed = true;
1122
1123 // The RAUW can change PHIs that we already visited. Start over from the
1124 // beginning.
1125 PHISet.clear();
1126 I = BB->begin();
1127 }
1128 }
1129
1130 return Changed;
1131}
1132
1133/// enforceKnownAlignment - If the specified pointer points to an object that
1134/// we control, modify the object's alignment to PrefAlign. This isn't
1135/// often possible though. If alignment is important, a more reliable approach
1136/// is to simply align all global variables and allocation instructions to
1137/// their preferred alignment from the beginning.
1138static unsigned enforceKnownAlignment(Value *V, unsigned Align,
1139 unsigned PrefAlign,
1140 const DataLayout &DL) {
1141 assert(PrefAlign > Align)((PrefAlign > Align) ? static_cast<void> (0) : __assert_fail
("PrefAlign > Align", "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1141, __PRETTY_FUNCTION__))
;
1142
1143 V = V->stripPointerCasts();
1144
1145 if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1146 // TODO: ideally, computeKnownBits ought to have used
1147 // AllocaInst::getAlignment() in its computation already, making
1148 // the below max redundant. But, as it turns out,
1149 // stripPointerCasts recurses through infinite layers of bitcasts,
1150 // while computeKnownBits is not allowed to traverse more than 6
1151 // levels.
1152 Align = std::max(AI->getAlignment(), Align);
1153 if (PrefAlign <= Align)
1154 return Align;
1155
1156 // If the preferred alignment is greater than the natural stack alignment
1157 // then don't round up. This avoids dynamic stack realignment.
1158 if (DL.exceedsNaturalStackAlignment(PrefAlign))
1159 return Align;
1160 AI->setAlignment(PrefAlign);
1161 return PrefAlign;
1162 }
1163
1164 if (auto *GO = dyn_cast<GlobalObject>(V)) {
1165 // TODO: as above, this shouldn't be necessary.
1166 Align = std::max(GO->getAlignment(), Align);
1167 if (PrefAlign <= Align)
1168 return Align;
1169
1170 // If there is a large requested alignment and we can, bump up the alignment
1171 // of the global. If the memory we set aside for the global may not be the
1172 // memory used by the final program then it is impossible for us to reliably
1173 // enforce the preferred alignment.
1174 if (!GO->canIncreaseAlignment())
1175 return Align;
1176
1177 GO->setAlignment(PrefAlign);
1178 return PrefAlign;
1179 }
1180
1181 return Align;
1182}
1183
1184unsigned llvm::getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
1185 const DataLayout &DL,
1186 const Instruction *CxtI,
1187 AssumptionCache *AC,
1188 const DominatorTree *DT) {
1189 assert(V->getType()->isPointerTy() &&((V->getType()->isPointerTy() && "getOrEnforceKnownAlignment expects a pointer!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isPointerTy() && \"getOrEnforceKnownAlignment expects a pointer!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1190, __PRETTY_FUNCTION__))
1190 "getOrEnforceKnownAlignment expects a pointer!")((V->getType()->isPointerTy() && "getOrEnforceKnownAlignment expects a pointer!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isPointerTy() && \"getOrEnforceKnownAlignment expects a pointer!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1190, __PRETTY_FUNCTION__))
;
1191
1192 KnownBits Known = computeKnownBits(V, DL, 0, AC, CxtI, DT);
1193 unsigned TrailZ = Known.countMinTrailingZeros();
1194
1195 // Avoid trouble with ridiculously large TrailZ values, such as
1196 // those computed from a null pointer.
1197 TrailZ = std::min(TrailZ, unsigned(sizeof(unsigned) * CHAR_BIT8 - 1));
1198
1199 unsigned Align = 1u << std::min(Known.getBitWidth() - 1, TrailZ);
1200
1201 // LLVM doesn't support alignments larger than this currently.
1202 Align = std::min(Align, +Value::MaximumAlignment);
1203
1204 if (PrefAlign > Align)
1205 Align = enforceKnownAlignment(V, Align, PrefAlign, DL);
1206
1207 // We don't need to make any adjustment.
1208 return Align;
1209}
1210
1211///===---------------------------------------------------------------------===//
1212/// Dbg Intrinsic utilities
1213///
1214
1215/// See if there is a dbg.value intrinsic for DIVar before I.
1216static bool LdStHasDebugValue(DILocalVariable *DIVar, DIExpression *DIExpr,
1217 Instruction *I) {
1218 // Since we can't guarantee that the original dbg.declare instrinsic
1219 // is removed by LowerDbgDeclare(), we need to make sure that we are
1220 // not inserting the same dbg.value intrinsic over and over.
1221 BasicBlock::InstListType::iterator PrevI(I);
1222 if (PrevI != I->getParent()->getInstList().begin()) {
1223 --PrevI;
1224 if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(PrevI))
1225 if (DVI->getValue() == I->getOperand(0) &&
1226 DVI->getVariable() == DIVar &&
1227 DVI->getExpression() == DIExpr)
1228 return true;
1229 }
1230 return false;
1231}
1232
1233/// See if there is a dbg.value intrinsic for DIVar for the PHI node.
1234static bool PhiHasDebugValue(DILocalVariable *DIVar,
1235 DIExpression *DIExpr,
1236 PHINode *APN) {
1237 // Since we can't guarantee that the original dbg.declare instrinsic
1238 // is removed by LowerDbgDeclare(), we need to make sure that we are
1239 // not inserting the same dbg.value intrinsic over and over.
1240 SmallVector<DbgValueInst *, 1> DbgValues;
1241 findDbgValues(DbgValues, APN);
1242 for (auto *DVI : DbgValues) {
1243 assert(DVI->getValue() == APN)((DVI->getValue() == APN) ? static_cast<void> (0) : __assert_fail
("DVI->getValue() == APN", "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1243, __PRETTY_FUNCTION__))
;
1244 if ((DVI->getVariable() == DIVar) && (DVI->getExpression() == DIExpr))
1245 return true;
1246 }
1247 return false;
1248}
1249
1250/// Check if the alloc size of \p ValTy is large enough to cover the variable
1251/// (or fragment of the variable) described by \p DII.
1252///
1253/// This is primarily intended as a helper for the different
1254/// ConvertDebugDeclareToDebugValue functions. The dbg.declare/dbg.addr that is
1255/// converted describes an alloca'd variable, so we need to use the
1256/// alloc size of the value when doing the comparison. E.g. an i1 value will be
1257/// identified as covering an n-bit fragment, if the store size of i1 is at
1258/// least n bits.
1259static bool valueCoversEntireFragment(Type *ValTy, DbgVariableIntrinsic *DII) {
1260 const DataLayout &DL = DII->getModule()->getDataLayout();
1261 uint64_t ValueSize = DL.getTypeAllocSizeInBits(ValTy);
1262 if (auto FragmentSize = DII->getFragmentSizeInBits())
1263 return ValueSize >= *FragmentSize;
1264 // We can't always calculate the size of the DI variable (e.g. if it is a
1265 // VLA). Try to use the size of the alloca that the dbg intrinsic describes
1266 // intead.
1267 if (DII->isAddressOfVariable())
1268 if (auto *AI = dyn_cast_or_null<AllocaInst>(DII->getVariableLocation()))
1269 if (auto FragmentSize = AI->getAllocationSizeInBits(DL))
1270 return ValueSize >= *FragmentSize;
1271 // Could not determine size of variable. Conservatively return false.
1272 return false;
1273}
1274
1275/// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value
1276/// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic.
1277void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
1278 StoreInst *SI, DIBuilder &Builder) {
1279 assert(DII->isAddressOfVariable())((DII->isAddressOfVariable()) ? static_cast<void> (0
) : __assert_fail ("DII->isAddressOfVariable()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1279, __PRETTY_FUNCTION__))
;
1280 auto *DIVar = DII->getVariable();
1281 assert(DIVar && "Missing variable")((DIVar && "Missing variable") ? static_cast<void>
(0) : __assert_fail ("DIVar && \"Missing variable\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1281, __PRETTY_FUNCTION__))
;
1282 auto *DIExpr = DII->getExpression();
1283 Value *DV = SI->getOperand(0);
1284
1285 if (!valueCoversEntireFragment(SI->getValueOperand()->getType(), DII)) {
1286 // FIXME: If storing to a part of the variable described by the dbg.declare,
1287 // then we want to insert a dbg.value for the corresponding fragment.
1288 LLVM_DEBUG(dbgs() << "Failed to convert dbg.declare to dbg.value: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Failed to convert dbg.declare to dbg.value: "
<< *DII << '\n'; } } while (false)
1289 << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Failed to convert dbg.declare to dbg.value: "
<< *DII << '\n'; } } while (false)
;
1290 // For now, when there is a store to parts of the variable (but we do not
1291 // know which part) we insert an dbg.value instrinsic to indicate that we
1292 // know nothing about the variable's content.
1293 DV = UndefValue::get(DV->getType());
1294 if (!LdStHasDebugValue(DIVar, DIExpr, SI))
1295 Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, DII->getDebugLoc(),
1296 SI);
1297 return;
1298 }
1299
1300 if (!LdStHasDebugValue(DIVar, DIExpr, SI))
1301 Builder.insertDbgValueIntrinsic(DV, DIVar, DIExpr, DII->getDebugLoc(),
1302 SI);
1303}
1304
1305/// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value
1306/// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic.
1307void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
1308 LoadInst *LI, DIBuilder &Builder) {
1309 auto *DIVar = DII->getVariable();
1310 auto *DIExpr = DII->getExpression();
1311 assert(DIVar && "Missing variable")((DIVar && "Missing variable") ? static_cast<void>
(0) : __assert_fail ("DIVar && \"Missing variable\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1311, __PRETTY_FUNCTION__))
;
1312
1313 if (LdStHasDebugValue(DIVar, DIExpr, LI))
1314 return;
1315
1316 if (!valueCoversEntireFragment(LI->getType(), DII)) {
1317 // FIXME: If only referring to a part of the variable described by the
1318 // dbg.declare, then we want to insert a dbg.value for the corresponding
1319 // fragment.
1320 LLVM_DEBUG(dbgs() << "Failed to convert dbg.declare to dbg.value: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Failed to convert dbg.declare to dbg.value: "
<< *DII << '\n'; } } while (false)
1321 << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Failed to convert dbg.declare to dbg.value: "
<< *DII << '\n'; } } while (false)
;
1322 return;
1323 }
1324
1325 // We are now tracking the loaded value instead of the address. In the
1326 // future if multi-location support is added to the IR, it might be
1327 // preferable to keep tracking both the loaded value and the original
1328 // address in case the alloca can not be elided.
1329 Instruction *DbgValue = Builder.insertDbgValueIntrinsic(
1330 LI, DIVar, DIExpr, DII->getDebugLoc(), (Instruction *)nullptr);
1331 DbgValue->insertAfter(LI);
1332}
1333
1334/// Inserts a llvm.dbg.value intrinsic after a phi that has an associated
1335/// llvm.dbg.declare or llvm.dbg.addr intrinsic.
1336void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
1337 PHINode *APN, DIBuilder &Builder) {
1338 auto *DIVar = DII->getVariable();
1339 auto *DIExpr = DII->getExpression();
1340 assert(DIVar && "Missing variable")((DIVar && "Missing variable") ? static_cast<void>
(0) : __assert_fail ("DIVar && \"Missing variable\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1340, __PRETTY_FUNCTION__))
;
1341
1342 if (PhiHasDebugValue(DIVar, DIExpr, APN))
1343 return;
1344
1345 if (!valueCoversEntireFragment(APN->getType(), DII)) {
1346 // FIXME: If only referring to a part of the variable described by the
1347 // dbg.declare, then we want to insert a dbg.value for the corresponding
1348 // fragment.
1349 LLVM_DEBUG(dbgs() << "Failed to convert dbg.declare to dbg.value: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Failed to convert dbg.declare to dbg.value: "
<< *DII << '\n'; } } while (false)
1350 << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Failed to convert dbg.declare to dbg.value: "
<< *DII << '\n'; } } while (false)
;
1351 return;
1352 }
1353
1354 BasicBlock *BB = APN->getParent();
1355 auto InsertionPt = BB->getFirstInsertionPt();
1356
1357 // The block may be a catchswitch block, which does not have a valid
1358 // insertion point.
1359 // FIXME: Insert dbg.value markers in the successors when appropriate.
1360 if (InsertionPt != BB->end())
1361 Builder.insertDbgValueIntrinsic(APN, DIVar, DIExpr, DII->getDebugLoc(),
1362 &*InsertionPt);
1363}
1364
1365/// Determine whether this alloca is either a VLA or an array.
1366static bool isArray(AllocaInst *AI) {
1367 return AI->isArrayAllocation() ||
1368 AI->getType()->getElementType()->isArrayTy();
1369}
1370
1371/// LowerDbgDeclare - Lowers llvm.dbg.declare intrinsics into appropriate set
1372/// of llvm.dbg.value intrinsics.
1373bool llvm::LowerDbgDeclare(Function &F) {
1374 DIBuilder DIB(*F.getParent(), /*AllowUnresolved*/ false);
1375 SmallVector<DbgDeclareInst *, 4> Dbgs;
1376 for (auto &FI : F)
1377 for (Instruction &BI : FI)
1378 if (auto DDI = dyn_cast<DbgDeclareInst>(&BI))
1379 Dbgs.push_back(DDI);
1380
1381 if (Dbgs.empty())
1382 return false;
1383
1384 for (auto &I : Dbgs) {
1385 DbgDeclareInst *DDI = I;
1386 AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress());
1387 // If this is an alloca for a scalar variable, insert a dbg.value
1388 // at each load and store to the alloca and erase the dbg.declare.
1389 // The dbg.values allow tracking a variable even if it is not
1390 // stored on the stack, while the dbg.declare can only describe
1391 // the stack slot (and at a lexical-scope granularity). Later
1392 // passes will attempt to elide the stack slot.
1393 if (!AI || isArray(AI))
1394 continue;
1395
1396 // A volatile load/store means that the alloca can't be elided anyway.
1397 if (llvm::any_of(AI->users(), [](User *U) -> bool {
1398 if (LoadInst *LI = dyn_cast<LoadInst>(U))
1399 return LI->isVolatile();
1400 if (StoreInst *SI = dyn_cast<StoreInst>(U))
1401 return SI->isVolatile();
1402 return false;
1403 }))
1404 continue;
1405
1406 for (auto &AIUse : AI->uses()) {
1407 User *U = AIUse.getUser();
1408 if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
1409 if (AIUse.getOperandNo() == 1)
1410 ConvertDebugDeclareToDebugValue(DDI, SI, DIB);
1411 } else if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
1412 ConvertDebugDeclareToDebugValue(DDI, LI, DIB);
1413 } else if (CallInst *CI = dyn_cast<CallInst>(U)) {
1414 // This is a call by-value or some other instruction that takes a
1415 // pointer to the variable. Insert a *value* intrinsic that describes
1416 // the variable by dereferencing the alloca.
1417 auto *DerefExpr =
1418 DIExpression::append(DDI->getExpression(), dwarf::DW_OP_deref);
1419 DIB.insertDbgValueIntrinsic(AI, DDI->getVariable(), DerefExpr,
1420 DDI->getDebugLoc(), CI);
1421 }
1422 }
1423 DDI->eraseFromParent();
1424 }
1425 return true;
1426}
1427
1428/// Propagate dbg.value intrinsics through the newly inserted PHIs.
1429void llvm::insertDebugValuesForPHIs(BasicBlock *BB,
1430 SmallVectorImpl<PHINode *> &InsertedPHIs) {
1431 assert(BB && "No BasicBlock to clone dbg.value(s) from.")((BB && "No BasicBlock to clone dbg.value(s) from.") ?
static_cast<void> (0) : __assert_fail ("BB && \"No BasicBlock to clone dbg.value(s) from.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1431, __PRETTY_FUNCTION__))
;
1432 if (InsertedPHIs.size() == 0)
1433 return;
1434
1435 // Map existing PHI nodes to their dbg.values.
1436 ValueToValueMapTy DbgValueMap;
1437 for (auto &I : *BB) {
1438 if (auto DbgII = dyn_cast<DbgVariableIntrinsic>(&I)) {
1439 if (auto *Loc = dyn_cast_or_null<PHINode>(DbgII->getVariableLocation()))
1440 DbgValueMap.insert({Loc, DbgII});
1441 }
1442 }
1443 if (DbgValueMap.size() == 0)
1444 return;
1445
1446 // Then iterate through the new PHIs and look to see if they use one of the
1447 // previously mapped PHIs. If so, insert a new dbg.value intrinsic that will
1448 // propagate the info through the new PHI.
1449 LLVMContext &C = BB->getContext();
1450 for (auto PHI : InsertedPHIs) {
1451 BasicBlock *Parent = PHI->getParent();
1452 // Avoid inserting an intrinsic into an EH block.
1453 if (Parent->getFirstNonPHI()->isEHPad())
1454 continue;
1455 auto PhiMAV = MetadataAsValue::get(C, ValueAsMetadata::get(PHI));
1456 for (auto VI : PHI->operand_values()) {
1457 auto V = DbgValueMap.find(VI);
1458 if (V != DbgValueMap.end()) {
1459 auto *DbgII = cast<DbgVariableIntrinsic>(V->second);
1460 Instruction *NewDbgII = DbgII->clone();
1461 NewDbgII->setOperand(0, PhiMAV);
1462 auto InsertionPt = Parent->getFirstInsertionPt();
1463 assert(InsertionPt != Parent->end() && "Ill-formed basic block")((InsertionPt != Parent->end() && "Ill-formed basic block"
) ? static_cast<void> (0) : __assert_fail ("InsertionPt != Parent->end() && \"Ill-formed basic block\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1463, __PRETTY_FUNCTION__))
;
1464 NewDbgII->insertBefore(&*InsertionPt);
1465 }
1466 }
1467 }
1468}
1469
1470/// Finds all intrinsics declaring local variables as living in the memory that
1471/// 'V' points to. This may include a mix of dbg.declare and
1472/// dbg.addr intrinsics.
1473TinyPtrVector<DbgVariableIntrinsic *> llvm::FindDbgAddrUses(Value *V) {
1474 // This function is hot. Check whether the value has any metadata to avoid a
1475 // DenseMap lookup.
1476 if (!V->isUsedByMetadata())
1477 return {};
1478 auto *L = LocalAsMetadata::getIfExists(V);
1479 if (!L)
1480 return {};
1481 auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L);
1482 if (!MDV)
1483 return {};
1484
1485 TinyPtrVector<DbgVariableIntrinsic *> Declares;
1486 for (User *U : MDV->users()) {
1487 if (auto *DII = dyn_cast<DbgVariableIntrinsic>(U))
1488 if (DII->isAddressOfVariable())
1489 Declares.push_back(DII);
1490 }
1491
1492 return Declares;
1493}
1494
1495void llvm::findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V) {
1496 // This function is hot. Check whether the value has any metadata to avoid a
1497 // DenseMap lookup.
1498 if (!V->isUsedByMetadata())
1499 return;
1500 if (auto *L = LocalAsMetadata::getIfExists(V))
1501 if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
1502 for (User *U : MDV->users())
1503 if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
1504 DbgValues.push_back(DVI);
1505}
1506
1507void llvm::findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgUsers,
1508 Value *V) {
1509 // This function is hot. Check whether the value has any metadata to avoid a
1510 // DenseMap lookup.
1511 if (!V->isUsedByMetadata())
1512 return;
1513 if (auto *L = LocalAsMetadata::getIfExists(V))
1514 if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
1515 for (User *U : MDV->users())
1516 if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
1517 DbgUsers.push_back(DII);
1518}
1519
1520bool llvm::replaceDbgDeclare(Value *Address, Value *NewAddress,
1521 Instruction *InsertBefore, DIBuilder &Builder,
1522 bool DerefBefore, int Offset, bool DerefAfter) {
1523 auto DbgAddrs = FindDbgAddrUses(Address);
1524 for (DbgVariableIntrinsic *DII : DbgAddrs) {
1525 DebugLoc Loc = DII->getDebugLoc();
1526 auto *DIVar = DII->getVariable();
1527 auto *DIExpr = DII->getExpression();
1528 assert(DIVar && "Missing variable")((DIVar && "Missing variable") ? static_cast<void>
(0) : __assert_fail ("DIVar && \"Missing variable\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1528, __PRETTY_FUNCTION__))
;
1529 DIExpr = DIExpression::prepend(DIExpr, DerefBefore, Offset, DerefAfter);
1530 // Insert llvm.dbg.declare immediately before InsertBefore, and remove old
1531 // llvm.dbg.declare.
1532 Builder.insertDeclare(NewAddress, DIVar, DIExpr, Loc, InsertBefore);
1533 if (DII == InsertBefore)
1534 InsertBefore = InsertBefore->getNextNode();
1535 DII->eraseFromParent();
1536 }
1537 return !DbgAddrs.empty();
1538}
1539
1540bool llvm::replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
1541 DIBuilder &Builder, bool DerefBefore,
1542 int Offset, bool DerefAfter) {
1543 return replaceDbgDeclare(AI, NewAllocaAddress, AI->getNextNode(), Builder,
1544 DerefBefore, Offset, DerefAfter);
1545}
1546
1547static void replaceOneDbgValueForAlloca(DbgValueInst *DVI, Value *NewAddress,
1548 DIBuilder &Builder, int Offset) {
1549 DebugLoc Loc = DVI->getDebugLoc();
1550 auto *DIVar = DVI->getVariable();
1551 auto *DIExpr = DVI->getExpression();
1552 assert(DIVar && "Missing variable")((DIVar && "Missing variable") ? static_cast<void>
(0) : __assert_fail ("DIVar && \"Missing variable\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1552, __PRETTY_FUNCTION__))
;
1553
1554 // This is an alloca-based llvm.dbg.value. The first thing it should do with
1555 // the alloca pointer is dereference it. Otherwise we don't know how to handle
1556 // it and give up.
1557 if (!DIExpr || DIExpr->getNumElements() < 1 ||
1558 DIExpr->getElement(0) != dwarf::DW_OP_deref)
1559 return;
1560
1561 // Insert the offset immediately after the first deref.
1562 // We could just change the offset argument of dbg.value, but it's unsigned...
1563 if (Offset) {
1564 SmallVector<uint64_t, 4> Ops;
1565 Ops.push_back(dwarf::DW_OP_deref);
1566 DIExpression::appendOffset(Ops, Offset);
1567 Ops.append(DIExpr->elements_begin() + 1, DIExpr->elements_end());
1568 DIExpr = Builder.createExpression(Ops);
1569 }
1570
1571 Builder.insertDbgValueIntrinsic(NewAddress, DIVar, DIExpr, Loc, DVI);
1572 DVI->eraseFromParent();
1573}
1574
1575void llvm::replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
1576 DIBuilder &Builder, int Offset) {
1577 if (auto *L = LocalAsMetadata::getIfExists(AI))
1578 if (auto *MDV = MetadataAsValue::getIfExists(AI->getContext(), L))
1579 for (auto UI = MDV->use_begin(), UE = MDV->use_end(); UI != UE;) {
1580 Use &U = *UI++;
1581 if (auto *DVI = dyn_cast<DbgValueInst>(U.getUser()))
1582 replaceOneDbgValueForAlloca(DVI, NewAllocaAddress, Builder, Offset);
1583 }
1584}
1585
1586/// Wrap \p V in a ValueAsMetadata instance.
1587static MetadataAsValue *wrapValueInMetadata(LLVMContext &C, Value *V) {
1588 return MetadataAsValue::get(C, ValueAsMetadata::get(V));
1589}
1590
1591bool llvm::salvageDebugInfo(Instruction &I) {
1592 SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
1593 findDbgUsers(DbgUsers, &I);
1594 if (DbgUsers.empty())
1595 return false;
1596
1597 auto &M = *I.getModule();
1598 auto &DL = M.getDataLayout();
1599 auto &Ctx = I.getContext();
1600 auto wrapMD = [&](Value *V) { return wrapValueInMetadata(Ctx, V); };
1601
1602 auto doSalvage = [&](DbgVariableIntrinsic *DII, SmallVectorImpl<uint64_t> &Ops) {
1603 auto *DIExpr = DII->getExpression();
1604 if (!Ops.empty()) {
1605 // Do not add DW_OP_stack_value for DbgDeclare and DbgAddr, because they
1606 // are implicitly pointing out the value as a DWARF memory location
1607 // description.
1608 bool WithStackValue = isa<DbgValueInst>(DII);
1609 DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
1610 }
1611 DII->setOperand(0, wrapMD(I.getOperand(0)));
1612 DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
1613 LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "SALVAGE: " << *DII <<
'\n'; } } while (false)
;
1614 };
1615
1616 auto applyOffset = [&](DbgVariableIntrinsic *DII, uint64_t Offset) {
1617 SmallVector<uint64_t, 8> Ops;
1618 DIExpression::appendOffset(Ops, Offset);
1619 doSalvage(DII, Ops);
1620 };
1621
1622 auto applyOps = [&](DbgVariableIntrinsic *DII,
1623 std::initializer_list<uint64_t> Opcodes) {
1624 SmallVector<uint64_t, 8> Ops(Opcodes);
1625 doSalvage(DII, Ops);
1626 };
1627
1628 if (auto *CI = dyn_cast<CastInst>(&I)) {
1629 if (!CI->isNoopCast(DL))
1630 return false;
1631
1632 // No-op casts are irrelevant for debug info.
1633 MetadataAsValue *CastSrc = wrapMD(I.getOperand(0));
1634 for (auto *DII : DbgUsers) {
1635 DII->setOperand(0, CastSrc);
1636 LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "SALVAGE: " << *DII <<
'\n'; } } while (false)
;
1637 }
1638 return true;
1639 } else if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
1640 unsigned BitWidth =
1641 M.getDataLayout().getIndexSizeInBits(GEP->getPointerAddressSpace());
1642 // Rewrite a constant GEP into a DIExpression. Since we are performing
1643 // arithmetic to compute the variable's *value* in the DIExpression, we
1644 // need to mark the expression with a DW_OP_stack_value.
1645 APInt Offset(BitWidth, 0);
1646 if (GEP->accumulateConstantOffset(M.getDataLayout(), Offset))
1647 for (auto *DII : DbgUsers)
1648 applyOffset(DII, Offset.getSExtValue());
1649 return true;
1650 } else if (auto *BI = dyn_cast<BinaryOperator>(&I)) {
1651 // Rewrite binary operations with constant integer operands.
1652 auto *ConstInt = dyn_cast<ConstantInt>(I.getOperand(1));
1653 if (!ConstInt || ConstInt->getBitWidth() > 64)
1654 return false;
1655
1656 uint64_t Val = ConstInt->getSExtValue();
1657 for (auto *DII : DbgUsers) {
1658 switch (BI->getOpcode()) {
1659 case Instruction::Add:
1660 applyOffset(DII, Val);
1661 break;
1662 case Instruction::Sub:
1663 applyOffset(DII, -int64_t(Val));
1664 break;
1665 case Instruction::Mul:
1666 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_mul});
1667 break;
1668 case Instruction::SDiv:
1669 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_div});
1670 break;
1671 case Instruction::SRem:
1672 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_mod});
1673 break;
1674 case Instruction::Or:
1675 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_or});
1676 break;
1677 case Instruction::And:
1678 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_and});
1679 break;
1680 case Instruction::Xor:
1681 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_xor});
1682 break;
1683 case Instruction::Shl:
1684 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_shl});
1685 break;
1686 case Instruction::LShr:
1687 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_shr});
1688 break;
1689 case Instruction::AShr:
1690 applyOps(DII, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_shra});
1691 break;
1692 default:
1693 // TODO: Salvage constants from each kind of binop we know about.
1694 return false;
1695 }
1696 }
1697 return true;
1698 } else if (isa<LoadInst>(&I)) {
1699 MetadataAsValue *AddrMD = wrapMD(I.getOperand(0));
1700 for (auto *DII : DbgUsers) {
1701 // Rewrite the load into DW_OP_deref.
1702 auto *DIExpr = DII->getExpression();
1703 DIExpr = DIExpression::prepend(DIExpr, DIExpression::WithDeref);
1704 DII->setOperand(0, AddrMD);
1705 DII->setOperand(2, MetadataAsValue::get(Ctx, DIExpr));
1706 LLVM_DEBUG(dbgs() << "SALVAGE: " << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "SALVAGE: " << *DII <<
'\n'; } } while (false)
;
1707 }
1708 return true;
1709 }
1710 return false;
1711}
1712
1713/// A replacement for a dbg.value expression.
1714using DbgValReplacement = Optional<DIExpression *>;
1715
1716/// Point debug users of \p From to \p To using exprs given by \p RewriteExpr,
1717/// possibly moving/deleting users to prevent use-before-def. Returns true if
1718/// changes are made.
1719static bool rewriteDebugUsers(
1720 Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT,
1721 function_ref<DbgValReplacement(DbgVariableIntrinsic &DII)> RewriteExpr) {
1722 // Find debug users of From.
1723 SmallVector<DbgVariableIntrinsic *, 1> Users;
1724 findDbgUsers(Users, &From);
1725 if (Users.empty())
1726 return false;
1727
1728 // Prevent use-before-def of To.
1729 bool Changed = false;
1730 SmallPtrSet<DbgVariableIntrinsic *, 1> DeleteOrSalvage;
1731 if (isa<Instruction>(&To)) {
1732 bool DomPointAfterFrom = From.getNextNonDebugInstruction() == &DomPoint;
1733
1734 for (auto *DII : Users) {
1735 // It's common to see a debug user between From and DomPoint. Move it
1736 // after DomPoint to preserve the variable update without any reordering.
1737 if (DomPointAfterFrom && DII->getNextNonDebugInstruction() == &DomPoint) {
1738 LLVM_DEBUG(dbgs() << "MOVE: " << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "MOVE: " << *DII <<
'\n'; } } while (false)
;
1739 DII->moveAfter(&DomPoint);
1740 Changed = true;
1741
1742 // Users which otherwise aren't dominated by the replacement value must
1743 // be salvaged or deleted.
1744 } else if (!DT.dominates(&DomPoint, DII)) {
1745 DeleteOrSalvage.insert(DII);
1746 }
1747 }
1748 }
1749
1750 // Update debug users without use-before-def risk.
1751 for (auto *DII : Users) {
1752 if (DeleteOrSalvage.count(DII))
1753 continue;
1754
1755 LLVMContext &Ctx = DII->getContext();
1756 DbgValReplacement DVR = RewriteExpr(*DII);
1757 if (!DVR)
1758 continue;
1759
1760 DII->setOperand(0, wrapValueInMetadata(Ctx, &To));
1761 DII->setOperand(2, MetadataAsValue::get(Ctx, *DVR));
1762 LLVM_DEBUG(dbgs() << "REWRITE: " << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "REWRITE: " << *DII <<
'\n'; } } while (false)
;
1763 Changed = true;
1764 }
1765
1766 if (!DeleteOrSalvage.empty()) {
1767 // Try to salvage the remaining debug users.
1768 Changed |= salvageDebugInfo(From);
1769
1770 // Delete the debug users which weren't salvaged.
1771 for (auto *DII : DeleteOrSalvage) {
1772 if (DII->getVariableLocation() == &From) {
1773 LLVM_DEBUG(dbgs() << "Erased UseBeforeDef: " << *DII << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Erased UseBeforeDef: " <<
*DII << '\n'; } } while (false)
;
1774 DII->eraseFromParent();
1775 Changed = true;
1776 }
1777 }
1778 }
1779
1780 return Changed;
1781}
1782
1783/// Check if a bitcast between a value of type \p FromTy to type \p ToTy would
1784/// losslessly preserve the bits and semantics of the value. This predicate is
1785/// symmetric, i.e swapping \p FromTy and \p ToTy should give the same result.
1786///
1787/// Note that Type::canLosslesslyBitCastTo is not suitable here because it
1788/// allows semantically unequivalent bitcasts, such as <2 x i64> -> <4 x i32>,
1789/// and also does not allow lossless pointer <-> integer conversions.
1790static bool isBitCastSemanticsPreserving(const DataLayout &DL, Type *FromTy,
1791 Type *ToTy) {
1792 // Trivially compatible types.
1793 if (FromTy == ToTy)
1794 return true;
1795
1796 // Handle compatible pointer <-> integer conversions.
1797 if (FromTy->isIntOrPtrTy() && ToTy->isIntOrPtrTy()) {
1798 bool SameSize = DL.getTypeSizeInBits(FromTy) == DL.getTypeSizeInBits(ToTy);
1799 bool LosslessConversion = !DL.isNonIntegralPointerType(FromTy) &&
1800 !DL.isNonIntegralPointerType(ToTy);
1801 return SameSize && LosslessConversion;
1802 }
1803
1804 // TODO: This is not exhaustive.
1805 return false;
1806}
1807
1808bool llvm::replaceAllDbgUsesWith(Instruction &From, Value &To,
1809 Instruction &DomPoint, DominatorTree &DT) {
1810 // Exit early if From has no debug users.
1811 if (!From.isUsedByMetadata())
1812 return false;
1813
1814 assert(&From != &To && "Can't replace something with itself")((&From != &To && "Can't replace something with itself"
) ? static_cast<void> (0) : __assert_fail ("&From != &To && \"Can't replace something with itself\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1814, __PRETTY_FUNCTION__))
;
1815
1816 Type *FromTy = From.getType();
1817 Type *ToTy = To.getType();
1818
1819 auto Identity = [&](DbgVariableIntrinsic &DII) -> DbgValReplacement {
1820 return DII.getExpression();
1821 };
1822
1823 // Handle no-op conversions.
1824 Module &M = *From.getModule();
1825 const DataLayout &DL = M.getDataLayout();
1826 if (isBitCastSemanticsPreserving(DL, FromTy, ToTy))
1827 return rewriteDebugUsers(From, To, DomPoint, DT, Identity);
1828
1829 // Handle integer-to-integer widening and narrowing.
1830 // FIXME: Use DW_OP_convert when it's available everywhere.
1831 if (FromTy->isIntegerTy() && ToTy->isIntegerTy()) {
1832 uint64_t FromBits = FromTy->getPrimitiveSizeInBits();
1833 uint64_t ToBits = ToTy->getPrimitiveSizeInBits();
1834 assert(FromBits != ToBits && "Unexpected no-op conversion")((FromBits != ToBits && "Unexpected no-op conversion"
) ? static_cast<void> (0) : __assert_fail ("FromBits != ToBits && \"Unexpected no-op conversion\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 1834, __PRETTY_FUNCTION__))
;
1835
1836 // When the width of the result grows, assume that a debugger will only
1837 // access the low `FromBits` bits when inspecting the source variable.
1838 if (FromBits < ToBits)
1839 return rewriteDebugUsers(From, To, DomPoint, DT, Identity);
1840
1841 // The width of the result has shrunk. Use sign/zero extension to describe
1842 // the source variable's high bits.
1843 auto SignOrZeroExt = [&](DbgVariableIntrinsic &DII) -> DbgValReplacement {
1844 DILocalVariable *Var = DII.getVariable();
1845
1846 // Without knowing signedness, sign/zero extension isn't possible.
1847 auto Signedness = Var->getSignedness();
1848 if (!Signedness)
1849 return None;
1850
1851 bool Signed = *Signedness == DIBasicType::Signedness::Signed;
1852
1853 if (!Signed) {
1854 // In the unsigned case, assume that a debugger will initialize the
1855 // high bits to 0 and do a no-op conversion.
1856 return Identity(DII);
1857 } else {
1858 // In the signed case, the high bits are given by sign extension, i.e:
1859 // (To >> (ToBits - 1)) * ((2 ^ FromBits) - 1)
1860 // Calculate the high bits and OR them together with the low bits.
1861 SmallVector<uint64_t, 8> Ops({dwarf::DW_OP_dup, dwarf::DW_OP_constu,
1862 (ToBits - 1), dwarf::DW_OP_shr,
1863 dwarf::DW_OP_lit0, dwarf::DW_OP_not,
1864 dwarf::DW_OP_mul, dwarf::DW_OP_or});
1865 return DIExpression::appendToStack(DII.getExpression(), Ops);
1866 }
1867 };
1868 return rewriteDebugUsers(From, To, DomPoint, DT, SignOrZeroExt);
1869 }
1870
1871 // TODO: Floating-point conversions, vectors.
1872 return false;
1873}
1874
1875unsigned llvm::removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB) {
1876 unsigned NumDeadInst = 0;
1877 // Delete the instructions backwards, as it has a reduced likelihood of
1878 // having to update as many def-use and use-def chains.
1879 Instruction *EndInst = BB->getTerminator(); // Last not to be deleted.
1880 while (EndInst != &BB->front()) {
1881 // Delete the next to last instruction.
1882 Instruction *Inst = &*--EndInst->getIterator();
1883 if (!Inst->use_empty() && !Inst->getType()->isTokenTy())
1884 Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
1885 if (Inst->isEHPad() || Inst->getType()->isTokenTy()) {
1886 EndInst = Inst;
1887 continue;
1888 }
1889 if (!isa<DbgInfoIntrinsic>(Inst))
1890 ++NumDeadInst;
1891 Inst->eraseFromParent();
1892 }
1893 return NumDeadInst;
1894}
1895
1896unsigned llvm::changeToUnreachable(Instruction *I, bool UseLLVMTrap,
1897 bool PreserveLCSSA, DomTreeUpdater *DTU) {
1898 BasicBlock *BB = I->getParent();
1899 std::vector <DominatorTree::UpdateType> Updates;
1900
1901 // Loop over all of the successors, removing BB's entry from any PHI
1902 // nodes.
1903 if (DTU)
1904 Updates.reserve(BB->getTerminator()->getNumSuccessors());
1905 for (BasicBlock *Successor : successors(BB)) {
1906 Successor->removePredecessor(BB, PreserveLCSSA);
1907 if (DTU)
1908 Updates.push_back({DominatorTree::Delete, BB, Successor});
1909 }
1910 // Insert a call to llvm.trap right before this. This turns the undefined
1911 // behavior into a hard fail instead of falling through into random code.
1912 if (UseLLVMTrap) {
1913 Function *TrapFn =
1914 Intrinsic::getDeclaration(BB->getParent()->getParent(), Intrinsic::trap);
1915 CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
1916 CallTrap->setDebugLoc(I->getDebugLoc());
1917 }
1918 auto *UI = new UnreachableInst(I->getContext(), I);
1919 UI->setDebugLoc(I->getDebugLoc());
1920
1921 // All instructions after this are dead.
1922 unsigned NumInstrsRemoved = 0;
1923 BasicBlock::iterator BBI = I->getIterator(), BBE = BB->end();
1924 while (BBI != BBE) {
1925 if (!BBI->use_empty())
1926 BBI->replaceAllUsesWith(UndefValue::get(BBI->getType()));
1927 BB->getInstList().erase(BBI++);
1928 ++NumInstrsRemoved;
1929 }
1930 if (DTU)
1931 DTU->applyUpdates(Updates, /*ForceRemoveDuplicates*/ true);
1932 return NumInstrsRemoved;
1933}
1934
1935/// changeToCall - Convert the specified invoke into a normal call.
1936static void changeToCall(InvokeInst *II, DomTreeUpdater *DTU = nullptr) {
1937 SmallVector<Value*, 8> Args(II->arg_begin(), II->arg_end());
1938 SmallVector<OperandBundleDef, 1> OpBundles;
1939 II->getOperandBundlesAsDefs(OpBundles);
1940 CallInst *NewCall = CallInst::Create(II->getCalledValue(), Args, OpBundles,
1941 "", II);
1942 NewCall->takeName(II);
1943 NewCall->setCallingConv(II->getCallingConv());
1944 NewCall->setAttributes(II->getAttributes());
1945 NewCall->setDebugLoc(II->getDebugLoc());
1946 NewCall->copyMetadata(*II);
1947 II->replaceAllUsesWith(NewCall);
1948
1949 // Follow the call by a branch to the normal destination.
1950 BasicBlock *NormalDestBB = II->getNormalDest();
1951 BranchInst::Create(NormalDestBB, II);
1952
1953 // Update PHI nodes in the unwind destination
1954 BasicBlock *BB = II->getParent();
1955 BasicBlock *UnwindDestBB = II->getUnwindDest();
1956 UnwindDestBB->removePredecessor(BB);
1957 II->eraseFromParent();
1958 if (DTU)
1959 DTU->deleteEdgeRelaxed(BB, UnwindDestBB);
1960}
1961
1962BasicBlock *llvm::changeToInvokeAndSplitBasicBlock(CallInst *CI,
1963 BasicBlock *UnwindEdge) {
1964 BasicBlock *BB = CI->getParent();
1965
1966 // Convert this function call into an invoke instruction. First, split the
1967 // basic block.
1968 BasicBlock *Split =
1969 BB->splitBasicBlock(CI->getIterator(), CI->getName() + ".noexc");
1970
1971 // Delete the unconditional branch inserted by splitBasicBlock
1972 BB->getInstList().pop_back();
1973
1974 // Create the new invoke instruction.
1975 SmallVector<Value *, 8> InvokeArgs(CI->arg_begin(), CI->arg_end());
1976 SmallVector<OperandBundleDef, 1> OpBundles;
1977
1978 CI->getOperandBundlesAsDefs(OpBundles);
1979
1980 // Note: we're round tripping operand bundles through memory here, and that
1981 // can potentially be avoided with a cleverer API design that we do not have
1982 // as of this time.
1983
1984 InvokeInst *II = InvokeInst::Create(CI->getCalledValue(), Split, UnwindEdge,
1985 InvokeArgs, OpBundles, CI->getName(), BB);
1986 II->setDebugLoc(CI->getDebugLoc());
1987 II->setCallingConv(CI->getCallingConv());
1988 II->setAttributes(CI->getAttributes());
1989
1990 // Make sure that anything using the call now uses the invoke! This also
1991 // updates the CallGraph if present, because it uses a WeakTrackingVH.
1992 CI->replaceAllUsesWith(II);
1993
1994 // Delete the original call
1995 Split->getInstList().pop_front();
1996 return Split;
1997}
1998
1999static bool markAliveBlocks(Function &F,
2000 SmallPtrSetImpl<BasicBlock *> &Reachable,
2001 DomTreeUpdater *DTU = nullptr) {
2002 SmallVector<BasicBlock*, 128> Worklist;
2003 BasicBlock *BB = &F.front();
2004 Worklist.push_back(BB);
2005 Reachable.insert(BB);
2006 bool Changed = false;
2007 do {
2008 BB = Worklist.pop_back_val();
2009
2010 // Do a quick scan of the basic block, turning any obviously unreachable
2011 // instructions into LLVM unreachable insts. The instruction combining pass
2012 // canonicalizes unreachable insts into stores to null or undef.
2013 for (Instruction &I : *BB) {
2014 if (auto *CI = dyn_cast<CallInst>(&I)) {
2015 Value *Callee = CI->getCalledValue();
2016 // Handle intrinsic calls.
2017 if (Function *F = dyn_cast<Function>(Callee)) {
2018 auto IntrinsicID = F->getIntrinsicID();
2019 // Assumptions that are known to be false are equivalent to
2020 // unreachable. Also, if the condition is undefined, then we make the
2021 // choice most beneficial to the optimizer, and choose that to also be
2022 // unreachable.
2023 if (IntrinsicID == Intrinsic::assume) {
2024 if (match(CI->getArgOperand(0), m_CombineOr(m_Zero(), m_Undef()))) {
2025 // Don't insert a call to llvm.trap right before the unreachable.
2026 changeToUnreachable(CI, false, false, DTU);
2027 Changed = true;
2028 break;
2029 }
2030 } else if (IntrinsicID == Intrinsic::experimental_guard) {
2031 // A call to the guard intrinsic bails out of the current
2032 // compilation unit if the predicate passed to it is false. If the
2033 // predicate is a constant false, then we know the guard will bail
2034 // out of the current compile unconditionally, so all code following
2035 // it is dead.
2036 //
2037 // Note: unlike in llvm.assume, it is not "obviously profitable" for
2038 // guards to treat `undef` as `false` since a guard on `undef` can
2039 // still be useful for widening.
2040 if (match(CI->getArgOperand(0), m_Zero()))
2041 if (!isa<UnreachableInst>(CI->getNextNode())) {
2042 changeToUnreachable(CI->getNextNode(), /*UseLLVMTrap=*/false,
2043 false, DTU);
2044 Changed = true;
2045 break;
2046 }
2047 }
2048 } else if ((isa<ConstantPointerNull>(Callee) &&
2049 !NullPointerIsDefined(CI->getFunction())) ||
2050 isa<UndefValue>(Callee)) {
2051 changeToUnreachable(CI, /*UseLLVMTrap=*/false, false, DTU);
2052 Changed = true;
2053 break;
2054 }
2055 if (CI->doesNotReturn()) {
2056 // If we found a call to a no-return function, insert an unreachable
2057 // instruction after it. Make sure there isn't *already* one there
2058 // though.
2059 if (!isa<UnreachableInst>(CI->getNextNode())) {
2060 // Don't insert a call to llvm.trap right before the unreachable.
2061 changeToUnreachable(CI->getNextNode(), false, false, DTU);
2062 Changed = true;
2063 }
2064 break;
2065 }
2066 } else if (auto *SI = dyn_cast<StoreInst>(&I)) {
2067 // Store to undef and store to null are undefined and used to signal
2068 // that they should be changed to unreachable by passes that can't
2069 // modify the CFG.
2070
2071 // Don't touch volatile stores.
2072 if (SI->isVolatile()) continue;
2073
2074 Value *Ptr = SI->getOperand(1);
2075
2076 if (isa<UndefValue>(Ptr) ||
2077 (isa<ConstantPointerNull>(Ptr) &&
2078 !NullPointerIsDefined(SI->getFunction(),
2079 SI->getPointerAddressSpace()))) {
2080 changeToUnreachable(SI, true, false, DTU);
2081 Changed = true;
2082 break;
2083 }
2084 }
2085 }
2086
2087 Instruction *Terminator = BB->getTerminator();
2088 if (auto *II = dyn_cast<InvokeInst>(Terminator)) {
2
Taking false branch
2089 // Turn invokes that call 'nounwind' functions into ordinary calls.
2090 Value *Callee = II->getCalledValue();
2091 if ((isa<ConstantPointerNull>(Callee) &&
2092 !NullPointerIsDefined(BB->getParent())) ||
2093 isa<UndefValue>(Callee)) {
2094 changeToUnreachable(II, true, false, DTU);
2095 Changed = true;
2096 } else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(&F)) {
2097 if (II->use_empty() && II->onlyReadsMemory()) {
2098 // jump to the normal destination branch.
2099 BasicBlock *NormalDestBB = II->getNormalDest();
2100 BasicBlock *UnwindDestBB = II->getUnwindDest();
2101 BranchInst::Create(NormalDestBB, II);
2102 UnwindDestBB->removePredecessor(II->getParent());
2103 II->eraseFromParent();
2104 if (DTU)
2105 DTU->deleteEdgeRelaxed(BB, UnwindDestBB);
2106 } else
2107 changeToCall(II, DTU);
2108 Changed = true;
2109 }
2110 } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Terminator)) {
3
Taking false branch
2111 // Remove catchpads which cannot be reached.
2112 struct CatchPadDenseMapInfo {
2113 static CatchPadInst *getEmptyKey() {
2114 return DenseMapInfo<CatchPadInst *>::getEmptyKey();
2115 }
2116
2117 static CatchPadInst *getTombstoneKey() {
2118 return DenseMapInfo<CatchPadInst *>::getTombstoneKey();
2119 }
2120
2121 static unsigned getHashValue(CatchPadInst *CatchPad) {
2122 return static_cast<unsigned>(hash_combine_range(
2123 CatchPad->value_op_begin(), CatchPad->value_op_end()));
2124 }
2125
2126 static bool isEqual(CatchPadInst *LHS, CatchPadInst *RHS) {
2127 if (LHS == getEmptyKey() || LHS == getTombstoneKey() ||
2128 RHS == getEmptyKey() || RHS == getTombstoneKey())
2129 return LHS == RHS;
2130 return LHS->isIdenticalTo(RHS);
2131 }
2132 };
2133
2134 // Set of unique CatchPads.
2135 SmallDenseMap<CatchPadInst *, detail::DenseSetEmpty, 4,
2136 CatchPadDenseMapInfo, detail::DenseSetPair<CatchPadInst *>>
2137 HandlerSet;
2138 detail::DenseSetEmpty Empty;
2139 for (CatchSwitchInst::handler_iterator I = CatchSwitch->handler_begin(),
2140 E = CatchSwitch->handler_end();
2141 I != E; ++I) {
2142 BasicBlock *HandlerBB = *I;
2143 auto *CatchPad = cast<CatchPadInst>(HandlerBB->getFirstNonPHI());
2144 if (!HandlerSet.insert({CatchPad, Empty}).second) {
2145 CatchSwitch->removeHandler(I);
2146 --I;
2147 --E;
2148 Changed = true;
2149 }
2150 }
2151 }
2152
2153 Changed |= ConstantFoldTerminator(BB, true, nullptr, DTU);
4
Calling 'ConstantFoldTerminator'
2154 for (BasicBlock *Successor : successors(BB))
2155 if (Reachable.insert(Successor).second)
2156 Worklist.push_back(Successor);
2157 } while (!Worklist.empty());
2158 return Changed;
2159}
2160
2161void llvm::removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU) {
2162 Instruction *TI = BB->getTerminator();
2163
2164 if (auto *II = dyn_cast<InvokeInst>(TI)) {
2165 changeToCall(II, DTU);
2166 return;
2167 }
2168
2169 Instruction *NewTI;
2170 BasicBlock *UnwindDest;
2171
2172 if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
2173 NewTI = CleanupReturnInst::Create(CRI->getCleanupPad(), nullptr, CRI);
2174 UnwindDest = CRI->getUnwindDest();
2175 } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
2176 auto *NewCatchSwitch = CatchSwitchInst::Create(
2177 CatchSwitch->getParentPad(), nullptr, CatchSwitch->getNumHandlers(),
2178 CatchSwitch->getName(), CatchSwitch);
2179 for (BasicBlock *PadBB : CatchSwitch->handlers())
2180 NewCatchSwitch->addHandler(PadBB);
2181
2182 NewTI = NewCatchSwitch;
2183 UnwindDest = CatchSwitch->getUnwindDest();
2184 } else {
2185 llvm_unreachable("Could not find unwind successor")::llvm::llvm_unreachable_internal("Could not find unwind successor"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2185)
;
2186 }
2187
2188 NewTI->takeName(TI);
2189 NewTI->setDebugLoc(TI->getDebugLoc());
2190 UnwindDest->removePredecessor(BB);
2191 TI->replaceAllUsesWith(NewTI);
2192 TI->eraseFromParent();
2193 if (DTU)
2194 DTU->deleteEdgeRelaxed(BB, UnwindDest);
2195}
2196
2197/// removeUnreachableBlocks - Remove blocks that are not reachable, even
2198/// if they are in a dead cycle. Return true if a change was made, false
2199/// otherwise. If `LVI` is passed, this function preserves LazyValueInfo
2200/// after modifying the CFG.
2201bool llvm::removeUnreachableBlocks(Function &F, LazyValueInfo *LVI,
2202 DomTreeUpdater *DTU,
2203 MemorySSAUpdater *MSSAU) {
2204 SmallPtrSet<BasicBlock*, 16> Reachable;
2205 bool Changed = markAliveBlocks(F, Reachable, DTU);
1
Calling 'markAliveBlocks'
2206
2207 // If there are unreachable blocks in the CFG...
2208 if (Reachable.size() == F.size())
2209 return Changed;
2210
2211 assert(Reachable.size() < F.size())((Reachable.size() < F.size()) ? static_cast<void> (
0) : __assert_fail ("Reachable.size() < F.size()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2211, __PRETTY_FUNCTION__))
;
2212 NumRemoved += F.size()-Reachable.size();
2213
2214 SmallPtrSet<BasicBlock *, 16> DeadBlockSet;
2215 for (Function::iterator I = ++F.begin(), E = F.end(); I != E; ++I) {
2216 auto *BB = &*I;
2217 if (Reachable.count(BB))
2218 continue;
2219 DeadBlockSet.insert(BB);
2220 }
2221
2222 if (MSSAU)
2223 MSSAU->removeBlocks(DeadBlockSet);
2224
2225 // Loop over all of the basic blocks that are not reachable, dropping all of
2226 // their internal references. Update DTU and LVI if available.
2227 std::vector<DominatorTree::UpdateType> Updates;
2228 for (auto *BB : DeadBlockSet) {
2229 for (BasicBlock *Successor : successors(BB)) {
2230 if (!DeadBlockSet.count(Successor))
2231 Successor->removePredecessor(BB);
2232 if (DTU)
2233 Updates.push_back({DominatorTree::Delete, BB, Successor});
2234 }
2235 if (LVI)
2236 LVI->eraseBlock(BB);
2237 BB->dropAllReferences();
2238 }
2239 for (Function::iterator I = ++F.begin(); I != F.end();) {
2240 auto *BB = &*I;
2241 if (Reachable.count(BB)) {
2242 ++I;
2243 continue;
2244 }
2245 if (DTU) {
2246 // Remove the terminator of BB to clear the successor list of BB.
2247 if (BB->getTerminator())
2248 BB->getInstList().pop_back();
2249 new UnreachableInst(BB->getContext(), BB);
2250 assert(succ_empty(BB) && "The successor list of BB isn't empty before "((succ_empty(BB) && "The successor list of BB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("succ_empty(BB) && \"The successor list of BB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2251, __PRETTY_FUNCTION__))
2251 "applying corresponding DTU updates.")((succ_empty(BB) && "The successor list of BB isn't empty before "
"applying corresponding DTU updates.") ? static_cast<void
> (0) : __assert_fail ("succ_empty(BB) && \"The successor list of BB isn't empty before \" \"applying corresponding DTU updates.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2251, __PRETTY_FUNCTION__))
;
2252 ++I;
2253 } else {
2254 I = F.getBasicBlockList().erase(I);
2255 }
2256 }
2257
2258 if (DTU) {
2259 DTU->applyUpdates(Updates, /*ForceRemoveDuplicates*/ true);
2260 bool Deleted = false;
2261 for (auto *BB : DeadBlockSet) {
2262 if (DTU->isBBPendingDeletion(BB))
2263 --NumRemoved;
2264 else
2265 Deleted = true;
2266 DTU->deleteBB(BB);
2267 }
2268 if (!Deleted)
2269 return false;
2270 }
2271 return true;
2272}
2273
2274void llvm::combineMetadata(Instruction *K, const Instruction *J,
2275 ArrayRef<unsigned> KnownIDs, bool DoesKMove) {
2276 SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
2277 K->dropUnknownNonDebugMetadata(KnownIDs);
2278 K->getAllMetadataOtherThanDebugLoc(Metadata);
2279 for (const auto &MD : Metadata) {
2280 unsigned Kind = MD.first;
2281 MDNode *JMD = J->getMetadata(Kind);
2282 MDNode *KMD = MD.second;
2283
2284 switch (Kind) {
2285 default:
2286 K->setMetadata(Kind, nullptr); // Remove unknown metadata
2287 break;
2288 case LLVMContext::MD_dbg:
2289 llvm_unreachable("getAllMetadataOtherThanDebugLoc returned a MD_dbg")::llvm::llvm_unreachable_internal("getAllMetadataOtherThanDebugLoc returned a MD_dbg"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2289)
;
2290 case LLVMContext::MD_tbaa:
2291 K->setMetadata(Kind, MDNode::getMostGenericTBAA(JMD, KMD));
2292 break;
2293 case LLVMContext::MD_alias_scope:
2294 K->setMetadata(Kind, MDNode::getMostGenericAliasScope(JMD, KMD));
2295 break;
2296 case LLVMContext::MD_noalias:
2297 case LLVMContext::MD_mem_parallel_loop_access:
2298 K->setMetadata(Kind, MDNode::intersect(JMD, KMD));
2299 break;
2300 case LLVMContext::MD_access_group:
2301 K->setMetadata(LLVMContext::MD_access_group,
2302 intersectAccessGroups(K, J));
2303 break;
2304 case LLVMContext::MD_range:
2305
2306 // If K does move, use most generic range. Otherwise keep the range of
2307 // K.
2308 if (DoesKMove)
2309 // FIXME: If K does move, we should drop the range info and nonnull.
2310 // Currently this function is used with DoesKMove in passes
2311 // doing hoisting/sinking and the current behavior of using the
2312 // most generic range is correct in those cases.
2313 K->setMetadata(Kind, MDNode::getMostGenericRange(JMD, KMD));
2314 break;
2315 case LLVMContext::MD_fpmath:
2316 K->setMetadata(Kind, MDNode::getMostGenericFPMath(JMD, KMD));
2317 break;
2318 case LLVMContext::MD_invariant_load:
2319 // Only set the !invariant.load if it is present in both instructions.
2320 K->setMetadata(Kind, JMD);
2321 break;
2322 case LLVMContext::MD_nonnull:
2323 // If K does move, keep nonull if it is present in both instructions.
2324 if (DoesKMove)
2325 K->setMetadata(Kind, JMD);
2326 break;
2327 case LLVMContext::MD_invariant_group:
2328 // Preserve !invariant.group in K.
2329 break;
2330 case LLVMContext::MD_align:
2331 K->setMetadata(Kind,
2332 MDNode::getMostGenericAlignmentOrDereferenceable(JMD, KMD));
2333 break;
2334 case LLVMContext::MD_dereferenceable:
2335 case LLVMContext::MD_dereferenceable_or_null:
2336 K->setMetadata(Kind,
2337 MDNode::getMostGenericAlignmentOrDereferenceable(JMD, KMD));
2338 break;
2339 }
2340 }
2341 // Set !invariant.group from J if J has it. If both instructions have it
2342 // then we will just pick it from J - even when they are different.
2343 // Also make sure that K is load or store - f.e. combining bitcast with load
2344 // could produce bitcast with invariant.group metadata, which is invalid.
2345 // FIXME: we should try to preserve both invariant.group md if they are
2346 // different, but right now instruction can only have one invariant.group.
2347 if (auto *JMD = J->getMetadata(LLVMContext::MD_invariant_group))
2348 if (isa<LoadInst>(K) || isa<StoreInst>(K))
2349 K->setMetadata(LLVMContext::MD_invariant_group, JMD);
2350}
2351
2352void llvm::combineMetadataForCSE(Instruction *K, const Instruction *J,
2353 bool KDominatesJ) {
2354 unsigned KnownIDs[] = {
2355 LLVMContext::MD_tbaa, LLVMContext::MD_alias_scope,
2356 LLVMContext::MD_noalias, LLVMContext::MD_range,
2357 LLVMContext::MD_invariant_load, LLVMContext::MD_nonnull,
2358 LLVMContext::MD_invariant_group, LLVMContext::MD_align,
2359 LLVMContext::MD_dereferenceable,
2360 LLVMContext::MD_dereferenceable_or_null,
2361 LLVMContext::MD_access_group};
2362 combineMetadata(K, J, KnownIDs, KDominatesJ);
2363}
2364
2365void llvm::patchReplacementInstruction(Instruction *I, Value *Repl) {
2366 auto *ReplInst = dyn_cast<Instruction>(Repl);
2367 if (!ReplInst)
2368 return;
2369
2370 // Patch the replacement so that it is not more restrictive than the value
2371 // being replaced.
2372 // Note that if 'I' is a load being replaced by some operation,
2373 // for example, by an arithmetic operation, then andIRFlags()
2374 // would just erase all math flags from the original arithmetic
2375 // operation, which is clearly not wanted and not needed.
2376 if (!isa<LoadInst>(I))
2377 ReplInst->andIRFlags(I);
2378
2379 // FIXME: If both the original and replacement value are part of the
2380 // same control-flow region (meaning that the execution of one
2381 // guarantees the execution of the other), then we can combine the
2382 // noalias scopes here and do better than the general conservative
2383 // answer used in combineMetadata().
2384
2385 // In general, GVN unifies expressions over different control-flow
2386 // regions, and so we need a conservative combination of the noalias
2387 // scopes.
2388 static const unsigned KnownIDs[] = {
2389 LLVMContext::MD_tbaa, LLVMContext::MD_alias_scope,
2390 LLVMContext::MD_noalias, LLVMContext::MD_range,
2391 LLVMContext::MD_fpmath, LLVMContext::MD_invariant_load,
2392 LLVMContext::MD_invariant_group, LLVMContext::MD_nonnull,
2393 LLVMContext::MD_access_group};
2394 combineMetadata(ReplInst, I, KnownIDs, false);
2395}
2396
2397template <typename RootType, typename DominatesFn>
2398static unsigned replaceDominatedUsesWith(Value *From, Value *To,
2399 const RootType &Root,
2400 const DominatesFn &Dominates) {
2401 assert(From->getType() == To->getType())((From->getType() == To->getType()) ? static_cast<void
> (0) : __assert_fail ("From->getType() == To->getType()"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2401, __PRETTY_FUNCTION__))
;
2402
2403 unsigned Count = 0;
2404 for (Value::use_iterator UI = From->use_begin(), UE = From->use_end();
2405 UI != UE;) {
2406 Use &U = *UI++;
2407 if (!Dominates(Root, U))
2408 continue;
2409 U.set(To);
2410 LLVM_DEBUG(dbgs() << "Replace dominated use of '" << From->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Replace dominated use of '" <<
From->getName() << "' as " << *To << " in "
<< *U << "\n"; } } while (false)
2411 << "' as " << *To << " in " << *U << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("local")) { dbgs() << "Replace dominated use of '" <<
From->getName() << "' as " << *To << " in "
<< *U << "\n"; } } while (false)
;
2412 ++Count;
2413 }
2414 return Count;
2415}
2416
2417unsigned llvm::replaceNonLocalUsesWith(Instruction *From, Value *To) {
2418 assert(From->getType() == To->getType())((From->getType() == To->getType()) ? static_cast<void
> (0) : __assert_fail ("From->getType() == To->getType()"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/Transforms/Utils/Local.cpp"
, 2418, __PRETTY_FUNCTION__))
;
2419 auto *BB = From->getParent();
2420 unsigned Count = 0;
2421
2422 for (Value::use_iterator UI = From->use_begin(), UE = From->use_end();
2423 UI != UE;) {
2424 Use &U = *UI++;
2425 auto *I = cast<Instruction>(U.getUser());
2426 if (I->getParent() == BB)
2427 continue;
2428 U.set(To);
2429 ++Count;
2430 }
2431 return Count;
2432}
2433
2434unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To,
2435 DominatorTree &DT,
2436 const BasicBlockEdge &Root) {
2437 auto Dominates = [&DT](const BasicBlockEdge &Root, const Use &U) {
2438 return DT.dominates(Root, U);
2439 };
2440 return ::replaceDominatedUsesWith(From, To, Root, Dominates);
2441}
2442
2443unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To,
2444 DominatorTree &DT,
2445 const BasicBlock *BB) {
2446 auto ProperlyDominates = [&DT](const BasicBlock *BB, const Use &U) {
2447 auto *I = cast<Instruction>(U.getUser())->getParent();
2448 return DT.properlyDominates(BB, I);
2449 };
2450 return ::replaceDominatedUsesWith(From, To, BB, ProperlyDominates);
2451}
2452
2453bool llvm::callsGCLeafFunction(ImmutableCallSite CS,
2454 const TargetLibraryInfo &TLI) {
2455 // Check if the function is specifically marked as a gc leaf function.
2456 if (CS.hasFnAttr("gc-leaf-function"))
2457 return true;
2458 if (const Function *F = CS.getCalledFunction()) {
2459 if (F->hasFnAttribute("gc-leaf-function"))
2460 return true;
2461
2462 if (auto IID = F->getIntrinsicID())
2463 // Most LLVM intrinsics do not take safepoints.
2464 return IID != Intrinsic::experimental_gc_statepoint &&
2465 IID != Intrinsic::experimental_deoptimize;
2466 }
2467
2468 // Lib calls can be materialized by some passes, and won't be
2469 // marked as 'gc-leaf-function.' All available Libcalls are
2470 // GC-leaf.
2471 LibFunc LF;
2472 if (TLI.getLibFunc(CS, LF)) {
2473 return TLI.has(LF);
2474 }
2475
2476 return false;
2477}
2478
2479void llvm::copyNonnullMetadata(const LoadInst &OldLI, MDNode *N,
2480 LoadInst &NewLI) {
2481 auto *NewTy = NewLI.getType();
2482
2483 // This only directly applies if the new type is also a pointer.
2484 if (NewTy->isPointerTy()) {
2485 NewLI.setMetadata(LLVMContext::MD_nonnull, N);
2486 return;
2487 }
2488
2489 // The only other translation we can do is to integral loads with !range
2490 // metadata.
2491 if (!NewTy->isIntegerTy())
2492 return;
2493
2494 MDBuilder MDB(NewLI.getContext());
2495 const Value *Ptr = OldLI.getPointerOperand();
2496 auto *ITy = cast<IntegerType>(NewTy);
2497 auto *NullInt = ConstantExpr::getPtrToInt(
2498 ConstantPointerNull::get(cast<PointerType>(Ptr->getType())), ITy);
2499 auto *NonNullInt = ConstantExpr::getAdd(NullInt, ConstantInt::get(ITy, 1));
2500 NewLI.setMetadata(LLVMContext::MD_range,
2501 MDB.createRange(NonNullInt, NullInt));
2502}
2503
2504void llvm::copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI,
2505 MDNode *N, LoadInst &NewLI) {
2506 auto *NewTy = NewLI.getType();
2507
2508 // Give up unless it is converted to a pointer where there is a single very
2509 // valuable mapping we can do reliably.
2510 // FIXME: It would be nice to propagate this in more ways, but the type
2511 // conversions make it hard.
2512 if (!NewTy->isPointerTy())
2513 return;
2514
2515 unsigned BitWidth = DL.getIndexTypeSizeInBits(NewTy);
2516 if (!getConstantRangeFromMetadata(*N).contains(APInt(BitWidth, 0))) {
2517 MDNode *NN = MDNode::get(OldLI.getContext(), None);
2518 NewLI.setMetadata(LLVMContext::MD_nonnull, NN);
2519 }
2520}
2521
2522void llvm::dropDebugUsers(Instruction &I) {
2523 SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
2524 findDbgUsers(DbgUsers, &I);
2525 for (auto *DII : DbgUsers)
2526 DII->eraseFromParent();
2527}
2528
2529void llvm::hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt,
2530 BasicBlock *BB) {
2531 // Since we are moving the instructions out of its basic block, we do not
2532 // retain their original debug locations (DILocations) and debug intrinsic
2533 // instructions (dbg.values).
2534 //
2535 // Doing so would degrade the debugging experience and adversely affect the
2536 // accuracy of profiling information.
2537 //
2538 // Currently, when hoisting the instructions, we take the following actions:
2539 // - Remove their dbg.values.
2540 // - Set their debug locations to the values from the insertion point.
2541 //
2542 // As per PR39141 (comment #8), the more fundamental reason why the dbg.values
2543 // need to be deleted, is because there will not be any instructions with a
2544 // DILocation in either branch left after performing the transformation. We
2545 // can only insert a dbg.value after the two branches are joined again.
2546 //
2547 // See PR38762, PR39243 for more details.
2548 //
2549 // TODO: Extend llvm.dbg.value to take more than one SSA Value (PR39141) to
2550 // encode predicated DIExpressions that yield different results on different
2551 // code paths.
2552 for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE;) {
2553 Instruction *I = &*II;
2554 I->dropUnknownNonDebugMetadata();
2555 if (I->isUsedByMetadata())
2556 dropDebugUsers(*I);
2557 if (isa<DbgVariableIntrinsic>(I)) {
2558 // Remove DbgInfo Intrinsics.
2559 II = I->eraseFromParent();
2560 continue;
2561 }
2562 I->setDebugLoc(InsertPt->getDebugLoc());
2563 ++II;
2564 }
2565 DomBlock->getInstList().splice(InsertPt->getIterator(), BB->getInstList(),
2566 BB->begin(),
2567 BB->getTerminator()->getIterator());
2568}
2569
2570namespace {
2571
2572/// A potential constituent of a bitreverse or bswap expression. See
2573/// collectBitParts for a fuller explanation.
2574struct BitPart {
2575 BitPart(Value *P, unsigned BW) : Provider(P) {
2576 Provenance.resize(BW);
2577 }
2578
2579 /// The Value that this is a bitreverse/bswap of.
2580 Value *Provider;
2581
2582 /// The "provenance" of each bit. Provenance[A] = B means that bit A
2583 /// in Provider becomes bit B in the result of this expression.
2584 SmallVector<int8_t, 32> Provenance; // int8_t means max size is i128.
2585
2586 enum { Unset = -1 };
2587};
2588
2589} // end anonymous namespace
2590
2591/// Analyze the specified subexpression and see if it is capable of providing
2592/// pieces of a bswap or bitreverse. The subexpression provides a potential
2593/// piece of a bswap or bitreverse if it can be proven that each non-zero bit in
2594/// the output of the expression came from a corresponding bit in some other
2595/// value. This function is recursive, and the end result is a mapping of
2596/// bitnumber to bitnumber. It is the caller's responsibility to validate that
2597/// the bitnumber to bitnumber mapping is correct for a bswap or bitreverse.
2598///
2599/// For example, if the current subexpression if "(shl i32 %X, 24)" then we know
2600/// that the expression deposits the low byte of %X into the high byte of the
2601/// result and that all other bits are zero. This expression is accepted and a
2602/// BitPart is returned with Provider set to %X and Provenance[24-31] set to
2603/// [0-7].
2604///
2605/// To avoid revisiting values, the BitPart results are memoized into the
2606/// provided map. To avoid unnecessary copying of BitParts, BitParts are
2607/// constructed in-place in the \c BPS map. Because of this \c BPS needs to
2608/// store BitParts objects, not pointers. As we need the concept of a nullptr
2609/// BitParts (Value has been analyzed and the analysis failed), we an Optional
2610/// type instead to provide the same functionality.
2611///
2612/// Because we pass around references into \c BPS, we must use a container that
2613/// does not invalidate internal references (std::map instead of DenseMap).
2614static const Optional<BitPart> &
2615collectBitParts(Value *V, bool MatchBSwaps, bool MatchBitReversals,
2616 std::map<Value *, Optional<BitPart>> &BPS) {
2617 auto I = BPS.find(V);
2618 if (I != BPS.end())
2619 return I->second;
2620
2621 auto &Result = BPS[V] = None;
2622 auto BitWidth = cast<IntegerType>(V->getType())->getBitWidth();
2623
2624 if (Instruction *I = dyn_cast<Instruction>(V)) {
2625 // If this is an or instruction, it may be an inner node of the bswap.
2626 if (I->getOpcode() == Instruction::Or) {
2627 auto &A = collectBitParts(I->getOperand(0), MatchBSwaps,
2628 MatchBitReversals, BPS);
2629 auto &B = collectBitParts(I->getOperand(1), MatchBSwaps,
2630 MatchBitReversals, BPS);
2631 if (!A || !B)
2632 return Result;
2633
2634 // Try and merge the two together.
2635 if (!A->Provider || A->Provider != B->Provider)
2636 return Result;
2637
2638 Result = BitPart(A->Provider, BitWidth);
2639 for (unsigned i = 0; i < A->Provenance.size(); ++i) {
2640 if (A->Provenance[i] != BitPart::Unset &&
2641 B->Provenance[i] != BitPart::Unset &&
2642 A->Provenance[i] != B->Provenance[i])
2643 return Result = None;
2644
2645 if (A->Provenance[i] == BitPart::Unset)
2646 Result->Provenance[i] = B->Provenance[i];
2647 else
2648 Result->Provenance[i] = A->Provenance[i];
2649 }
2650
2651 return Result;
2652 }
2653
2654 // If this is a logical shift by a constant, recurse then shift the result.
2655 if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) {
2656 unsigned BitShift =
2657 cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U);
2658 // Ensure the shift amount is defined.
2659 if (BitShift > BitWidth)
2660 return Result;
2661
2662 auto &Res = collectBitParts(I->getOperand(0), MatchBSwaps,
2663 MatchBitReversals, BPS);
2664 if (!Res)
2665 return Result;
2666 Result = Res;
2667
2668 // Perform the "shift" on BitProvenance.
2669 auto &P = Result->Provenance;
2670 if (I->getOpcode() == Instruction::Shl) {
2671 P.erase(std::prev(P.end(), BitShift), P.end());
2672 P.insert(P.begin(), BitShift, BitPart::Unset);
2673 } else {
2674 P.erase(P.begin(), std::next(P.begin(), BitShift));
2675 P.insert(P.end(), BitShift, BitPart::Unset);
2676 }
2677
2678 return Result;
2679 }
2680
2681 // If this is a logical 'and' with a mask that clears bits, recurse then
2682 // unset the appropriate bits.
2683 if (I->getOpcode() == Instruction::And &&
2684 isa<ConstantInt>(I->getOperand(1))) {
2685 APInt Bit(I->getType()->getPrimitiveSizeInBits(), 1);
2686 const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue();
2687
2688 // Check that the mask allows a multiple of 8 bits for a bswap, for an
2689 // early exit.
2690 unsigned NumMaskedBits = AndMask.countPopulation();
2691 if (!MatchBitReversals && NumMaskedBits % 8 != 0)
2692 return Result;
2693
2694 auto &Res = collectBitParts(I->getOperand(0), MatchBSwaps,
2695 MatchBitReversals, BPS);
2696 if (!Res)
2697 return Result;
2698 Result = Res;
2699
2700 for (unsigned i = 0; i < BitWidth; ++i, Bit <<= 1)
2701 // If the AndMask is zero for this bit, clear the bit.
2702 if ((AndMask & Bit) == 0)
2703 Result->Provenance[i] = BitPart::Unset;
2704 return Result;
2705 }
2706
2707 // If this is a zext instruction zero extend the result.
2708 if (I->getOpcode() == Instruction::ZExt) {
2709 auto &Res = collectBitParts(I->getOperand(0), MatchBSwaps,
2710 MatchBitReversals, BPS);
2711 if (!Res)
2712 return Result;
2713
2714 Result = BitPart(Res->Provider, BitWidth);
2715 auto NarrowBitWidth =
2716 cast<IntegerType>(cast<ZExtInst>(I)->getSrcTy())->getBitWidth();
2717 for (unsigned i = 0; i < NarrowBitWidth; ++i)
2718 Result->Provenance[i] = Res->Provenance[i];
2719 for (unsigned i = NarrowBitWidth; i < BitWidth; ++i)
2720 Result->Provenance[i] = BitPart::Unset;
2721 return Result;
2722 }
2723 }
2724
2725 // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be
2726 // the input value to the bswap/bitreverse.
2727 Result = BitPart(V, BitWidth);
2728 for (unsigned i = 0; i < BitWidth; ++i)
2729 Result->Provenance[i] = i;
2730 return Result;
2731}
2732
2733static bool bitTransformIsCorrectForBSwap(unsigned From, unsigned To,
2734 unsigned BitWidth) {
2735 if (From % 8 != To % 8)
2736 return false;
2737 // Convert from bit indices to byte indices and check for a byte reversal.
2738 From >>= 3;
2739 To >>= 3;
2740 BitWidth >>= 3;
2741 return From == BitWidth - To - 1;
2742}
2743
2744static bool bitTransformIsCorrectForBitReverse(unsigned From, unsigned To,
2745 unsigned BitWidth) {
2746 return From == BitWidth - To - 1;
2747}
2748
2749bool llvm::recognizeBSwapOrBitReverseIdiom(
2750 Instruction *I, bool MatchBSwaps, bool MatchBitReversals,
2751 SmallVectorImpl<Instruction *> &InsertedInsts) {
2752 if (Operator::getOpcode(I) != Instruction::Or)
2753 return false;
2754 if (!MatchBSwaps && !MatchBitReversals)
2755 return false;
2756 IntegerType *ITy = dyn_cast<IntegerType>(I->getType());
2757 if (!ITy || ITy->getBitWidth() > 128)
2758 return false; // Can't do vectors or integers > 128 bits.
2759 unsigned BW = ITy->getBitWidth();
2760
2761 unsigned DemandedBW = BW;
2762 IntegerType *DemandedTy = ITy;
2763 if (I->hasOneUse()) {
2764 if (TruncInst *Trunc = dyn_cast<TruncInst>(I->user_back())) {
2765 DemandedTy = cast<IntegerType>(Trunc->getType());
2766 DemandedBW = DemandedTy->getBitWidth();
2767 }
2768 }
2769
2770 // Try to find all the pieces corresponding to the bswap.
2771 std::map<Value *, Optional<BitPart>> BPS;
2772 auto Res = collectBitParts(I, MatchBSwaps, MatchBitReversals, BPS);
2773 if (!Res)
2774 return false;
2775 auto &BitProvenance = Res->Provenance;
2776
2777 // Now, is the bit permutation correct for a bswap or a bitreverse? We can
2778 // only byteswap values with an even number of bytes.
2779 bool OKForBSwap = DemandedBW % 16 == 0, OKForBitReverse = true;
2780 for (unsigned i = 0; i < DemandedBW; ++i) {
2781 OKForBSwap &=
2782 bitTransformIsCorrectForBSwap(BitProvenance[i], i, DemandedBW);
2783 OKForBitReverse &=
2784 bitTransformIsCorrectForBitReverse(BitProvenance[i], i, DemandedBW);
2785 }
2786
2787 Intrinsic::ID Intrin;
2788 if (OKForBSwap && MatchBSwaps)
2789 Intrin = Intrinsic::bswap;
2790 else if (OKForBitReverse && MatchBitReversals)
2791 Intrin = Intrinsic::bitreverse;
2792 else
2793 return false;
2794
2795 if (ITy != DemandedTy) {
2796 Function *F = Intrinsic::getDeclaration(I->getModule(), Intrin, DemandedTy);
2797 Value *Provider = Res->Provider;
2798 IntegerType *ProviderTy = cast<IntegerType>(Provider->getType());
2799 // We may need to truncate the provider.
2800 if (DemandedTy != ProviderTy) {
2801 auto *Trunc = CastInst::Create(Instruction::Trunc, Provider, DemandedTy,
2802 "trunc", I);
2803 InsertedInsts.push_back(Trunc);
2804 Provider = Trunc;
2805 }
2806 auto *CI = CallInst::Create(F, Provider, "rev", I);
2807 InsertedInsts.push_back(CI);
2808 auto *ExtInst = CastInst::Create(Instruction::ZExt, CI, ITy, "zext", I);
2809 InsertedInsts.push_back(ExtInst);
2810 return true;
2811 }
2812
2813 Function *F = Intrinsic::getDeclaration(I->getModule(), Intrin, ITy);
2814 InsertedInsts.push_back(CallInst::Create(F, Res->Provider, "rev", I));
2815 return true;
2816}
2817
2818// CodeGen has special handling for some string functions that may replace
2819// them with target-specific intrinsics. Since that'd skip our interceptors
2820// in ASan/MSan/TSan/DFSan, and thus make us miss some memory accesses,
2821// we mark affected calls as NoBuiltin, which will disable optimization
2822// in CodeGen.
2823void llvm::maybeMarkSanitizerLibraryCallNoBuiltin(
2824 CallInst *CI, const TargetLibraryInfo *TLI) {
2825 Function *F = CI->getCalledFunction();
2826 LibFunc Func;
2827 if (F && !F->hasLocalLinkage() && F->hasName() &&
2828 TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) &&
2829 !F->doesNotAccessMemory())
2830 CI->addAttribute(AttributeList::FunctionIndex, Attribute::NoBuiltin);
2831}
2832
2833bool llvm::canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx) {
2834 // We can't have a PHI with a metadata type.
2835 if (I->getOperand(OpIdx)->getType()->isMetadataTy())
2836 return false;
2837
2838 // Early exit.
2839 if (!isa<Constant>(I->getOperand(OpIdx)))
2840 return true;
2841
2842 switch (I->getOpcode()) {
2843 default:
2844 return true;
2845 case Instruction::Call:
2846 case Instruction::Invoke:
2847 // Can't handle inline asm. Skip it.
2848 if (isa<InlineAsm>(ImmutableCallSite(I).getCalledValue()))
2849 return false;
2850 // Many arithmetic intrinsics have no issue taking a
2851 // variable, however it's hard to distingish these from
2852 // specials such as @llvm.frameaddress that require a constant.
2853 if (isa<IntrinsicInst>(I))
2854 return false;
2855
2856 // Constant bundle operands may need to retain their constant-ness for
2857 // correctness.
2858 if (ImmutableCallSite(I).isBundleOperand(OpIdx))
2859 return false;
2860 return true;
2861 case Instruction::ShuffleVector:
2862 // Shufflevector masks are constant.
2863 return OpIdx != 2;
2864 case Instruction::Switch:
2865 case Instruction::ExtractValue:
2866 // All operands apart from the first are constant.
2867 return OpIdx == 0;
2868 case Instruction::InsertValue:
2869 // All operands apart from the first and the second are constant.
2870 return OpIdx < 2;
2871 case Instruction::Alloca:
2872 // Static allocas (constant size in the entry block) are handled by
2873 // prologue/epilogue insertion so they're free anyway. We definitely don't
2874 // want to make them non-constant.
2875 return !cast<AllocaInst>(I)->isStaticAlloca();
2876 case Instruction::GetElementPtr:
2877 if (OpIdx == 0)
2878 return true;
2879 gep_type_iterator It = gep_type_begin(I);
2880 for (auto E = std::next(It, OpIdx); It != E; ++It)
2881 if (It.isStruct())
2882 return false;
2883 return true;
2884 }
2885}

/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/IR/Instructions.h

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