1 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Instruction class for the IR library.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm/IR/Instruction.h"
14 #include "llvm/ADT/DenseSet.h"
15 #include "llvm/IR/Constants.h"
16 #include "llvm/IR/Instructions.h"
17 #include "llvm/IR/IntrinsicInst.h"
18 #include "llvm/IR/Intrinsics.h"
19 #include "llvm/IR/MDBuilder.h"
20 #include "llvm/IR/Operator.h"
21 #include "llvm/IR/Type.h"
22 using namespace llvm;
23
Instruction(Type * ty,unsigned it,Use * Ops,unsigned NumOps,Instruction * InsertBefore)24 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
25 Instruction *InsertBefore)
26 : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
27
28 // If requested, insert this instruction into a basic block...
29 if (InsertBefore) {
30 BasicBlock *BB = InsertBefore->getParent();
31 assert(BB && "Instruction to insert before is not in a basic block!");
32 BB->getInstList().insert(InsertBefore->getIterator(), this);
33 }
34 }
35
Instruction(Type * ty,unsigned it,Use * Ops,unsigned NumOps,BasicBlock * InsertAtEnd)36 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
37 BasicBlock *InsertAtEnd)
38 : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
39
40 // append this instruction into the basic block
41 assert(InsertAtEnd && "Basic block to append to may not be NULL!");
42 InsertAtEnd->getInstList().push_back(this);
43 }
44
~Instruction()45 Instruction::~Instruction() {
46 assert(!Parent && "Instruction still linked in the program!");
47
48 // Replace any extant metadata uses of this instruction with undef to
49 // preserve debug info accuracy. Some alternatives include:
50 // - Treat Instruction like any other Value, and point its extant metadata
51 // uses to an empty ValueAsMetadata node. This makes extant dbg.value uses
52 // trivially dead (i.e. fair game for deletion in many passes), leading to
53 // stale dbg.values being in effect for too long.
54 // - Call salvageDebugInfoOrMarkUndef. Not needed to make instruction removal
55 // correct. OTOH results in wasted work in some common cases (e.g. when all
56 // instructions in a BasicBlock are deleted).
57 if (isUsedByMetadata())
58 ValueAsMetadata::handleRAUW(this, UndefValue::get(getType()));
59 }
60
61
setParent(BasicBlock * P)62 void Instruction::setParent(BasicBlock *P) {
63 Parent = P;
64 }
65
getModule() const66 const Module *Instruction::getModule() const {
67 return getParent()->getModule();
68 }
69
getFunction() const70 const Function *Instruction::getFunction() const {
71 return getParent()->getParent();
72 }
73
removeFromParent()74 void Instruction::removeFromParent() {
75 getParent()->getInstList().remove(getIterator());
76 }
77
eraseFromParent()78 iplist<Instruction>::iterator Instruction::eraseFromParent() {
79 return getParent()->getInstList().erase(getIterator());
80 }
81
82 /// Insert an unlinked instruction into a basic block immediately before the
83 /// specified instruction.
insertBefore(Instruction * InsertPos)84 void Instruction::insertBefore(Instruction *InsertPos) {
85 InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this);
86 }
87
88 /// Insert an unlinked instruction into a basic block immediately after the
89 /// specified instruction.
insertAfter(Instruction * InsertPos)90 void Instruction::insertAfter(Instruction *InsertPos) {
91 InsertPos->getParent()->getInstList().insertAfter(InsertPos->getIterator(),
92 this);
93 }
94
95 /// Unlink this instruction from its current basic block and insert it into the
96 /// basic block that MovePos lives in, right before MovePos.
moveBefore(Instruction * MovePos)97 void Instruction::moveBefore(Instruction *MovePos) {
98 moveBefore(*MovePos->getParent(), MovePos->getIterator());
99 }
100
moveAfter(Instruction * MovePos)101 void Instruction::moveAfter(Instruction *MovePos) {
102 moveBefore(*MovePos->getParent(), ++MovePos->getIterator());
103 }
104
moveBefore(BasicBlock & BB,SymbolTableList<Instruction>::iterator I)105 void Instruction::moveBefore(BasicBlock &BB,
106 SymbolTableList<Instruction>::iterator I) {
107 assert(I == BB.end() || I->getParent() == &BB);
108 BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
109 }
110
comesBefore(const Instruction * Other) const111 bool Instruction::comesBefore(const Instruction *Other) const {
112 assert(Parent && Other->Parent &&
113 "instructions without BB parents have no order");
114 assert(Parent == Other->Parent && "cross-BB instruction order comparison");
115 if (!Parent->isInstrOrderValid())
116 Parent->renumberInstructions();
117 return Order < Other->Order;
118 }
119
isOnlyUserOfAnyOperand()120 bool Instruction::isOnlyUserOfAnyOperand() {
121 return any_of(operands(), [](Value *V) { return V->hasOneUser(); });
122 }
123
setHasNoUnsignedWrap(bool b)124 void Instruction::setHasNoUnsignedWrap(bool b) {
125 cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b);
126 }
127
setHasNoSignedWrap(bool b)128 void Instruction::setHasNoSignedWrap(bool b) {
129 cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b);
130 }
131
setIsExact(bool b)132 void Instruction::setIsExact(bool b) {
133 cast<PossiblyExactOperator>(this)->setIsExact(b);
134 }
135
hasNoUnsignedWrap() const136 bool Instruction::hasNoUnsignedWrap() const {
137 return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap();
138 }
139
hasNoSignedWrap() const140 bool Instruction::hasNoSignedWrap() const {
141 return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
142 }
143
dropPoisonGeneratingFlags()144 void Instruction::dropPoisonGeneratingFlags() {
145 switch (getOpcode()) {
146 case Instruction::Add:
147 case Instruction::Sub:
148 case Instruction::Mul:
149 case Instruction::Shl:
150 cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(false);
151 cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(false);
152 break;
153
154 case Instruction::UDiv:
155 case Instruction::SDiv:
156 case Instruction::AShr:
157 case Instruction::LShr:
158 cast<PossiblyExactOperator>(this)->setIsExact(false);
159 break;
160
161 case Instruction::GetElementPtr:
162 cast<GetElementPtrInst>(this)->setIsInBounds(false);
163 break;
164 }
165 // TODO: FastMathFlags!
166 }
167
dropUndefImplyingAttrsAndUnknownMetadata(ArrayRef<unsigned> KnownIDs)168 void Instruction::dropUndefImplyingAttrsAndUnknownMetadata(
169 ArrayRef<unsigned> KnownIDs) {
170 dropUnknownNonDebugMetadata(KnownIDs);
171 auto *CB = dyn_cast<CallBase>(this);
172 if (!CB)
173 return;
174 // For call instructions, we also need to drop parameter and return attributes
175 // that are can cause UB if the call is moved to a location where the
176 // attribute is not valid.
177 AttributeList AL = CB->getAttributes();
178 if (AL.isEmpty())
179 return;
180 AttrBuilder UBImplyingAttributes = AttributeFuncs::getUBImplyingAttributes();
181 for (unsigned ArgNo = 0; ArgNo < CB->getNumArgOperands(); ArgNo++)
182 CB->removeParamAttrs(ArgNo, UBImplyingAttributes);
183 CB->removeAttributes(AttributeList::ReturnIndex, UBImplyingAttributes);
184 }
185
isExact() const186 bool Instruction::isExact() const {
187 return cast<PossiblyExactOperator>(this)->isExact();
188 }
189
setFast(bool B)190 void Instruction::setFast(bool B) {
191 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
192 cast<FPMathOperator>(this)->setFast(B);
193 }
194
setHasAllowReassoc(bool B)195 void Instruction::setHasAllowReassoc(bool B) {
196 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
197 cast<FPMathOperator>(this)->setHasAllowReassoc(B);
198 }
199
setHasNoNaNs(bool B)200 void Instruction::setHasNoNaNs(bool B) {
201 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
202 cast<FPMathOperator>(this)->setHasNoNaNs(B);
203 }
204
setHasNoInfs(bool B)205 void Instruction::setHasNoInfs(bool B) {
206 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
207 cast<FPMathOperator>(this)->setHasNoInfs(B);
208 }
209
setHasNoSignedZeros(bool B)210 void Instruction::setHasNoSignedZeros(bool B) {
211 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
212 cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
213 }
214
setHasAllowReciprocal(bool B)215 void Instruction::setHasAllowReciprocal(bool B) {
216 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
217 cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
218 }
219
setHasAllowContract(bool B)220 void Instruction::setHasAllowContract(bool B) {
221 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
222 cast<FPMathOperator>(this)->setHasAllowContract(B);
223 }
224
setHasApproxFunc(bool B)225 void Instruction::setHasApproxFunc(bool B) {
226 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
227 cast<FPMathOperator>(this)->setHasApproxFunc(B);
228 }
229
setFastMathFlags(FastMathFlags FMF)230 void Instruction::setFastMathFlags(FastMathFlags FMF) {
231 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
232 cast<FPMathOperator>(this)->setFastMathFlags(FMF);
233 }
234
copyFastMathFlags(FastMathFlags FMF)235 void Instruction::copyFastMathFlags(FastMathFlags FMF) {
236 assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op");
237 cast<FPMathOperator>(this)->copyFastMathFlags(FMF);
238 }
239
isFast() const240 bool Instruction::isFast() const {
241 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
242 return cast<FPMathOperator>(this)->isFast();
243 }
244
hasAllowReassoc() const245 bool Instruction::hasAllowReassoc() const {
246 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
247 return cast<FPMathOperator>(this)->hasAllowReassoc();
248 }
249
hasNoNaNs() const250 bool Instruction::hasNoNaNs() const {
251 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
252 return cast<FPMathOperator>(this)->hasNoNaNs();
253 }
254
hasNoInfs() const255 bool Instruction::hasNoInfs() const {
256 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
257 return cast<FPMathOperator>(this)->hasNoInfs();
258 }
259
hasNoSignedZeros() const260 bool Instruction::hasNoSignedZeros() const {
261 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
262 return cast<FPMathOperator>(this)->hasNoSignedZeros();
263 }
264
hasAllowReciprocal() const265 bool Instruction::hasAllowReciprocal() const {
266 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
267 return cast<FPMathOperator>(this)->hasAllowReciprocal();
268 }
269
hasAllowContract() const270 bool Instruction::hasAllowContract() const {
271 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
272 return cast<FPMathOperator>(this)->hasAllowContract();
273 }
274
hasApproxFunc() const275 bool Instruction::hasApproxFunc() const {
276 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
277 return cast<FPMathOperator>(this)->hasApproxFunc();
278 }
279
getFastMathFlags() const280 FastMathFlags Instruction::getFastMathFlags() const {
281 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
282 return cast<FPMathOperator>(this)->getFastMathFlags();
283 }
284
copyFastMathFlags(const Instruction * I)285 void Instruction::copyFastMathFlags(const Instruction *I) {
286 copyFastMathFlags(I->getFastMathFlags());
287 }
288
copyIRFlags(const Value * V,bool IncludeWrapFlags)289 void Instruction::copyIRFlags(const Value *V, bool IncludeWrapFlags) {
290 // Copy the wrapping flags.
291 if (IncludeWrapFlags && isa<OverflowingBinaryOperator>(this)) {
292 if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
293 setHasNoSignedWrap(OB->hasNoSignedWrap());
294 setHasNoUnsignedWrap(OB->hasNoUnsignedWrap());
295 }
296 }
297
298 // Copy the exact flag.
299 if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
300 if (isa<PossiblyExactOperator>(this))
301 setIsExact(PE->isExact());
302
303 // Copy the fast-math flags.
304 if (auto *FP = dyn_cast<FPMathOperator>(V))
305 if (isa<FPMathOperator>(this))
306 copyFastMathFlags(FP->getFastMathFlags());
307
308 if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
309 if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
310 DestGEP->setIsInBounds(SrcGEP->isInBounds() | DestGEP->isInBounds());
311 }
312
andIRFlags(const Value * V)313 void Instruction::andIRFlags(const Value *V) {
314 if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
315 if (isa<OverflowingBinaryOperator>(this)) {
316 setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap());
317 setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap());
318 }
319 }
320
321 if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
322 if (isa<PossiblyExactOperator>(this))
323 setIsExact(isExact() & PE->isExact());
324
325 if (auto *FP = dyn_cast<FPMathOperator>(V)) {
326 if (isa<FPMathOperator>(this)) {
327 FastMathFlags FM = getFastMathFlags();
328 FM &= FP->getFastMathFlags();
329 copyFastMathFlags(FM);
330 }
331 }
332
333 if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
334 if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
335 DestGEP->setIsInBounds(SrcGEP->isInBounds() & DestGEP->isInBounds());
336 }
337
getOpcodeName(unsigned OpCode)338 const char *Instruction::getOpcodeName(unsigned OpCode) {
339 switch (OpCode) {
340 // Terminators
341 case Ret: return "ret";
342 case Br: return "br";
343 case Switch: return "switch";
344 case IndirectBr: return "indirectbr";
345 case Invoke: return "invoke";
346 case Resume: return "resume";
347 case Unreachable: return "unreachable";
348 case CleanupRet: return "cleanupret";
349 case CatchRet: return "catchret";
350 case CatchPad: return "catchpad";
351 case CatchSwitch: return "catchswitch";
352 case CallBr: return "callbr";
353
354 // Standard unary operators...
355 case FNeg: return "fneg";
356
357 // Standard binary operators...
358 case Add: return "add";
359 case FAdd: return "fadd";
360 case Sub: return "sub";
361 case FSub: return "fsub";
362 case Mul: return "mul";
363 case FMul: return "fmul";
364 case UDiv: return "udiv";
365 case SDiv: return "sdiv";
366 case FDiv: return "fdiv";
367 case URem: return "urem";
368 case SRem: return "srem";
369 case FRem: return "frem";
370
371 // Logical operators...
372 case And: return "and";
373 case Or : return "or";
374 case Xor: return "xor";
375
376 // Memory instructions...
377 case Alloca: return "alloca";
378 case Load: return "load";
379 case Store: return "store";
380 case AtomicCmpXchg: return "cmpxchg";
381 case AtomicRMW: return "atomicrmw";
382 case Fence: return "fence";
383 case GetElementPtr: return "getelementptr";
384
385 // Convert instructions...
386 case Trunc: return "trunc";
387 case ZExt: return "zext";
388 case SExt: return "sext";
389 case FPTrunc: return "fptrunc";
390 case FPExt: return "fpext";
391 case FPToUI: return "fptoui";
392 case FPToSI: return "fptosi";
393 case UIToFP: return "uitofp";
394 case SIToFP: return "sitofp";
395 case IntToPtr: return "inttoptr";
396 case PtrToInt: return "ptrtoint";
397 case BitCast: return "bitcast";
398 case AddrSpaceCast: return "addrspacecast";
399
400 // Other instructions...
401 case ICmp: return "icmp";
402 case FCmp: return "fcmp";
403 case PHI: return "phi";
404 case Select: return "select";
405 case Call: return "call";
406 case Shl: return "shl";
407 case LShr: return "lshr";
408 case AShr: return "ashr";
409 case VAArg: return "va_arg";
410 case ExtractElement: return "extractelement";
411 case InsertElement: return "insertelement";
412 case ShuffleVector: return "shufflevector";
413 case ExtractValue: return "extractvalue";
414 case InsertValue: return "insertvalue";
415 case LandingPad: return "landingpad";
416 case CleanupPad: return "cleanuppad";
417 case Freeze: return "freeze";
418
419 default: return "<Invalid operator> ";
420 }
421 }
422
423 /// Return true if both instructions have the same special state. This must be
424 /// kept in sync with FunctionComparator::cmpOperations in
425 /// lib/Transforms/IPO/MergeFunctions.cpp.
haveSameSpecialState(const Instruction * I1,const Instruction * I2,bool IgnoreAlignment=false)426 static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2,
427 bool IgnoreAlignment = false) {
428 assert(I1->getOpcode() == I2->getOpcode() &&
429 "Can not compare special state of different instructions");
430
431 if (const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
432 return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
433 (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
434 IgnoreAlignment);
435 if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
436 return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
437 (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
438 IgnoreAlignment) &&
439 LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
440 LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
441 if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
442 return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
443 (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
444 IgnoreAlignment) &&
445 SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
446 SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
447 if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
448 return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
449 if (const CallInst *CI = dyn_cast<CallInst>(I1))
450 return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
451 CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
452 CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
453 CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
454 if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
455 return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
456 CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
457 CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
458 if (const CallBrInst *CI = dyn_cast<CallBrInst>(I1))
459 return CI->getCallingConv() == cast<CallBrInst>(I2)->getCallingConv() &&
460 CI->getAttributes() == cast<CallBrInst>(I2)->getAttributes() &&
461 CI->hasIdenticalOperandBundleSchema(*cast<CallBrInst>(I2));
462 if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
463 return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
464 if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
465 return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
466 if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
467 return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
468 FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
469 if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
470 return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
471 CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
472 CXI->getSuccessOrdering() ==
473 cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
474 CXI->getFailureOrdering() ==
475 cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
476 CXI->getSyncScopeID() ==
477 cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
478 if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
479 return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
480 RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
481 RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
482 RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
483 if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I1))
484 return SVI->getShuffleMask() ==
485 cast<ShuffleVectorInst>(I2)->getShuffleMask();
486
487 return true;
488 }
489
isIdenticalTo(const Instruction * I) const490 bool Instruction::isIdenticalTo(const Instruction *I) const {
491 return isIdenticalToWhenDefined(I) &&
492 SubclassOptionalData == I->SubclassOptionalData;
493 }
494
isIdenticalToWhenDefined(const Instruction * I) const495 bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const {
496 if (getOpcode() != I->getOpcode() ||
497 getNumOperands() != I->getNumOperands() ||
498 getType() != I->getType())
499 return false;
500
501 // If both instructions have no operands, they are identical.
502 if (getNumOperands() == 0 && I->getNumOperands() == 0)
503 return haveSameSpecialState(this, I);
504
505 // We have two instructions of identical opcode and #operands. Check to see
506 // if all operands are the same.
507 if (!std::equal(op_begin(), op_end(), I->op_begin()))
508 return false;
509
510 // WARNING: this logic must be kept in sync with EliminateDuplicatePHINodes()!
511 if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
512 const PHINode *otherPHI = cast<PHINode>(I);
513 return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
514 otherPHI->block_begin());
515 }
516
517 return haveSameSpecialState(this, I);
518 }
519
520 // Keep this in sync with FunctionComparator::cmpOperations in
521 // lib/Transforms/IPO/MergeFunctions.cpp.
isSameOperationAs(const Instruction * I,unsigned flags) const522 bool Instruction::isSameOperationAs(const Instruction *I,
523 unsigned flags) const {
524 bool IgnoreAlignment = flags & CompareIgnoringAlignment;
525 bool UseScalarTypes = flags & CompareUsingScalarTypes;
526
527 if (getOpcode() != I->getOpcode() ||
528 getNumOperands() != I->getNumOperands() ||
529 (UseScalarTypes ?
530 getType()->getScalarType() != I->getType()->getScalarType() :
531 getType() != I->getType()))
532 return false;
533
534 // We have two instructions of identical opcode and #operands. Check to see
535 // if all operands are the same type
536 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
537 if (UseScalarTypes ?
538 getOperand(i)->getType()->getScalarType() !=
539 I->getOperand(i)->getType()->getScalarType() :
540 getOperand(i)->getType() != I->getOperand(i)->getType())
541 return false;
542
543 return haveSameSpecialState(this, I, IgnoreAlignment);
544 }
545
isUsedOutsideOfBlock(const BasicBlock * BB) const546 bool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const {
547 for (const Use &U : uses()) {
548 // PHI nodes uses values in the corresponding predecessor block. For other
549 // instructions, just check to see whether the parent of the use matches up.
550 const Instruction *I = cast<Instruction>(U.getUser());
551 const PHINode *PN = dyn_cast<PHINode>(I);
552 if (!PN) {
553 if (I->getParent() != BB)
554 return true;
555 continue;
556 }
557
558 if (PN->getIncomingBlock(U) != BB)
559 return true;
560 }
561 return false;
562 }
563
mayReadFromMemory() const564 bool Instruction::mayReadFromMemory() const {
565 switch (getOpcode()) {
566 default: return false;
567 case Instruction::VAArg:
568 case Instruction::Load:
569 case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory
570 case Instruction::AtomicCmpXchg:
571 case Instruction::AtomicRMW:
572 case Instruction::CatchPad:
573 case Instruction::CatchRet:
574 return true;
575 case Instruction::Call:
576 case Instruction::Invoke:
577 case Instruction::CallBr:
578 return !cast<CallBase>(this)->doesNotReadMemory();
579 case Instruction::Store:
580 return !cast<StoreInst>(this)->isUnordered();
581 }
582 }
583
mayWriteToMemory() const584 bool Instruction::mayWriteToMemory() const {
585 switch (getOpcode()) {
586 default: return false;
587 case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory
588 case Instruction::Store:
589 case Instruction::VAArg:
590 case Instruction::AtomicCmpXchg:
591 case Instruction::AtomicRMW:
592 case Instruction::CatchPad:
593 case Instruction::CatchRet:
594 return true;
595 case Instruction::Call:
596 case Instruction::Invoke:
597 case Instruction::CallBr:
598 return !cast<CallBase>(this)->onlyReadsMemory();
599 case Instruction::Load:
600 return !cast<LoadInst>(this)->isUnordered();
601 }
602 }
603
isAtomic() const604 bool Instruction::isAtomic() const {
605 switch (getOpcode()) {
606 default:
607 return false;
608 case Instruction::AtomicCmpXchg:
609 case Instruction::AtomicRMW:
610 case Instruction::Fence:
611 return true;
612 case Instruction::Load:
613 return cast<LoadInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
614 case Instruction::Store:
615 return cast<StoreInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
616 }
617 }
618
hasAtomicLoad() const619 bool Instruction::hasAtomicLoad() const {
620 assert(isAtomic());
621 switch (getOpcode()) {
622 default:
623 return false;
624 case Instruction::AtomicCmpXchg:
625 case Instruction::AtomicRMW:
626 case Instruction::Load:
627 return true;
628 }
629 }
630
hasAtomicStore() const631 bool Instruction::hasAtomicStore() const {
632 assert(isAtomic());
633 switch (getOpcode()) {
634 default:
635 return false;
636 case Instruction::AtomicCmpXchg:
637 case Instruction::AtomicRMW:
638 case Instruction::Store:
639 return true;
640 }
641 }
642
isVolatile() const643 bool Instruction::isVolatile() const {
644 switch (getOpcode()) {
645 default:
646 return false;
647 case Instruction::AtomicRMW:
648 return cast<AtomicRMWInst>(this)->isVolatile();
649 case Instruction::Store:
650 return cast<StoreInst>(this)->isVolatile();
651 case Instruction::Load:
652 return cast<LoadInst>(this)->isVolatile();
653 case Instruction::AtomicCmpXchg:
654 return cast<AtomicCmpXchgInst>(this)->isVolatile();
655 case Instruction::Call:
656 case Instruction::Invoke:
657 // There are a very limited number of intrinsics with volatile flags.
658 if (auto *II = dyn_cast<IntrinsicInst>(this)) {
659 if (auto *MI = dyn_cast<MemIntrinsic>(II))
660 return MI->isVolatile();
661 switch (II->getIntrinsicID()) {
662 default: break;
663 case Intrinsic::matrix_column_major_load:
664 return cast<ConstantInt>(II->getArgOperand(2))->isOne();
665 case Intrinsic::matrix_column_major_store:
666 return cast<ConstantInt>(II->getArgOperand(3))->isOne();
667 }
668 }
669 return false;
670 }
671 }
672
mayThrow() const673 bool Instruction::mayThrow() const {
674 if (const CallInst *CI = dyn_cast<CallInst>(this))
675 return !CI->doesNotThrow();
676 if (const auto *CRI = dyn_cast<CleanupReturnInst>(this))
677 return CRI->unwindsToCaller();
678 if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(this))
679 return CatchSwitch->unwindsToCaller();
680 return isa<ResumeInst>(this);
681 }
682
mayHaveSideEffects() const683 bool Instruction::mayHaveSideEffects() const {
684 return mayWriteToMemory() || mayThrow() || !willReturn();
685 }
686
isSafeToRemove() const687 bool Instruction::isSafeToRemove() const {
688 return (!isa<CallInst>(this) || !this->mayHaveSideEffects()) &&
689 !this->isTerminator();
690 }
691
willReturn() const692 bool Instruction::willReturn() const {
693 // Volatile store isn't guaranteed to return; see LangRef.
694 if (auto *SI = dyn_cast<StoreInst>(this))
695 return !SI->isVolatile();
696
697 if (const auto *CB = dyn_cast<CallBase>(this))
698 // FIXME: Temporarily assume that all side-effect free intrinsics will
699 // return. Remove this workaround once all intrinsics are appropriately
700 // annotated.
701 return CB->hasFnAttr(Attribute::WillReturn) ||
702 (isa<IntrinsicInst>(CB) && CB->onlyReadsMemory());
703 return true;
704 }
705
isLifetimeStartOrEnd() const706 bool Instruction::isLifetimeStartOrEnd() const {
707 auto *II = dyn_cast<IntrinsicInst>(this);
708 if (!II)
709 return false;
710 Intrinsic::ID ID = II->getIntrinsicID();
711 return ID == Intrinsic::lifetime_start || ID == Intrinsic::lifetime_end;
712 }
713
isLaunderOrStripInvariantGroup() const714 bool Instruction::isLaunderOrStripInvariantGroup() const {
715 auto *II = dyn_cast<IntrinsicInst>(this);
716 if (!II)
717 return false;
718 Intrinsic::ID ID = II->getIntrinsicID();
719 return ID == Intrinsic::launder_invariant_group ||
720 ID == Intrinsic::strip_invariant_group;
721 }
722
isDebugOrPseudoInst() const723 bool Instruction::isDebugOrPseudoInst() const {
724 return isa<DbgInfoIntrinsic>(this) || isa<PseudoProbeInst>(this);
725 }
726
727 const Instruction *
getNextNonDebugInstruction(bool SkipPseudoOp) const728 Instruction::getNextNonDebugInstruction(bool SkipPseudoOp) const {
729 for (const Instruction *I = getNextNode(); I; I = I->getNextNode())
730 if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I)))
731 return I;
732 return nullptr;
733 }
734
735 const Instruction *
getPrevNonDebugInstruction(bool SkipPseudoOp) const736 Instruction::getPrevNonDebugInstruction(bool SkipPseudoOp) const {
737 for (const Instruction *I = getPrevNode(); I; I = I->getPrevNode())
738 if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I)))
739 return I;
740 return nullptr;
741 }
742
isAssociative() const743 bool Instruction::isAssociative() const {
744 unsigned Opcode = getOpcode();
745 if (isAssociative(Opcode))
746 return true;
747
748 switch (Opcode) {
749 case FMul:
750 case FAdd:
751 return cast<FPMathOperator>(this)->hasAllowReassoc() &&
752 cast<FPMathOperator>(this)->hasNoSignedZeros();
753 default:
754 return false;
755 }
756 }
757
isCommutative() const758 bool Instruction::isCommutative() const {
759 if (auto *II = dyn_cast<IntrinsicInst>(this))
760 return II->isCommutative();
761 // TODO: Should allow icmp/fcmp?
762 return isCommutative(getOpcode());
763 }
764
getNumSuccessors() const765 unsigned Instruction::getNumSuccessors() const {
766 switch (getOpcode()) {
767 #define HANDLE_TERM_INST(N, OPC, CLASS) \
768 case Instruction::OPC: \
769 return static_cast<const CLASS *>(this)->getNumSuccessors();
770 #include "llvm/IR/Instruction.def"
771 default:
772 break;
773 }
774 llvm_unreachable("not a terminator");
775 }
776
getSuccessor(unsigned idx) const777 BasicBlock *Instruction::getSuccessor(unsigned idx) const {
778 switch (getOpcode()) {
779 #define HANDLE_TERM_INST(N, OPC, CLASS) \
780 case Instruction::OPC: \
781 return static_cast<const CLASS *>(this)->getSuccessor(idx);
782 #include "llvm/IR/Instruction.def"
783 default:
784 break;
785 }
786 llvm_unreachable("not a terminator");
787 }
788
setSuccessor(unsigned idx,BasicBlock * B)789 void Instruction::setSuccessor(unsigned idx, BasicBlock *B) {
790 switch (getOpcode()) {
791 #define HANDLE_TERM_INST(N, OPC, CLASS) \
792 case Instruction::OPC: \
793 return static_cast<CLASS *>(this)->setSuccessor(idx, B);
794 #include "llvm/IR/Instruction.def"
795 default:
796 break;
797 }
798 llvm_unreachable("not a terminator");
799 }
800
replaceSuccessorWith(BasicBlock * OldBB,BasicBlock * NewBB)801 void Instruction::replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB) {
802 for (unsigned Idx = 0, NumSuccessors = Instruction::getNumSuccessors();
803 Idx != NumSuccessors; ++Idx)
804 if (getSuccessor(Idx) == OldBB)
805 setSuccessor(Idx, NewBB);
806 }
807
cloneImpl() const808 Instruction *Instruction::cloneImpl() const {
809 llvm_unreachable("Subclass of Instruction failed to implement cloneImpl");
810 }
811
swapProfMetadata()812 void Instruction::swapProfMetadata() {
813 MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
814 if (!ProfileData || ProfileData->getNumOperands() != 3 ||
815 !isa<MDString>(ProfileData->getOperand(0)))
816 return;
817
818 MDString *MDName = cast<MDString>(ProfileData->getOperand(0));
819 if (MDName->getString() != "branch_weights")
820 return;
821
822 // The first operand is the name. Fetch them backwards and build a new one.
823 Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
824 ProfileData->getOperand(1)};
825 setMetadata(LLVMContext::MD_prof,
826 MDNode::get(ProfileData->getContext(), Ops));
827 }
828
copyMetadata(const Instruction & SrcInst,ArrayRef<unsigned> WL)829 void Instruction::copyMetadata(const Instruction &SrcInst,
830 ArrayRef<unsigned> WL) {
831 if (!SrcInst.hasMetadata())
832 return;
833
834 DenseSet<unsigned> WLS;
835 for (unsigned M : WL)
836 WLS.insert(M);
837
838 // Otherwise, enumerate and copy over metadata from the old instruction to the
839 // new one.
840 SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs;
841 SrcInst.getAllMetadataOtherThanDebugLoc(TheMDs);
842 for (const auto &MD : TheMDs) {
843 if (WL.empty() || WLS.count(MD.first))
844 setMetadata(MD.first, MD.second);
845 }
846 if (WL.empty() || WLS.count(LLVMContext::MD_dbg))
847 setDebugLoc(SrcInst.getDebugLoc());
848 }
849
clone() const850 Instruction *Instruction::clone() const {
851 Instruction *New = nullptr;
852 switch (getOpcode()) {
853 default:
854 llvm_unreachable("Unhandled Opcode.");
855 #define HANDLE_INST(num, opc, clas) \
856 case Instruction::opc: \
857 New = cast<clas>(this)->cloneImpl(); \
858 break;
859 #include "llvm/IR/Instruction.def"
860 #undef HANDLE_INST
861 }
862
863 New->SubclassOptionalData = SubclassOptionalData;
864 New->copyMetadata(*this);
865 return New;
866 }
867