LLVM  10.0.0svn
Instruction.cpp
Go to the documentation of this file.
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/IR/IntrinsicInst.h"
15 #include "llvm/ADT/DenseSet.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Instructions.h"
18 #include "llvm/IR/MDBuilder.h"
19 #include "llvm/IR/Operator.h"
20 #include "llvm/IR/Type.h"
21 using namespace llvm;
22 
23 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
24  Instruction *InsertBefore)
25  : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
26 
27  // If requested, insert this instruction into a basic block...
28  if (InsertBefore) {
29  BasicBlock *BB = InsertBefore->getParent();
30  assert(BB && "Instruction to insert before is not in a basic block!");
31  BB->getInstList().insert(InsertBefore->getIterator(), this);
32  }
33 }
34 
35 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
36  BasicBlock *InsertAtEnd)
37  : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
38 
39  // append this instruction into the basic block
40  assert(InsertAtEnd && "Basic block to append to may not be NULL!");
41  InsertAtEnd->getInstList().push_back(this);
42 }
43 
45  assert(!Parent && "Instruction still linked in the program!");
46  if (hasMetadataHashEntry())
47  clearMetadataHashEntries();
48 }
49 
50 
51 void Instruction::setParent(BasicBlock *P) {
52  Parent = P;
53 }
54 
56  return getParent()->getModule();
57 }
58 
60  return getParent()->getParent();
61 }
62 
65 }
66 
68  return getParent()->getInstList().erase(getIterator());
69 }
70 
71 /// Insert an unlinked instruction into a basic block immediately before the
72 /// specified instruction.
74  InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this);
75 }
76 
77 /// Insert an unlinked instruction into a basic block immediately after the
78 /// specified instruction.
80  InsertPos->getParent()->getInstList().insertAfter(InsertPos->getIterator(),
81  this);
82 }
83 
84 /// Unlink this instruction from its current basic block and insert it into the
85 /// basic block that MovePos lives in, right before MovePos.
87  moveBefore(*MovePos->getParent(), MovePos->getIterator());
88 }
89 
91  moveBefore(*MovePos->getParent(), ++MovePos->getIterator());
92 }
93 
96  assert(I == BB.end() || I->getParent() == &BB);
97  BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
98 }
99 
101  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b);
102 }
103 
105  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b);
106 }
107 
109  cast<PossiblyExactOperator>(this)->setIsExact(b);
110 }
111 
113  return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap();
114 }
115 
117  return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
118 }
119 
121  switch (getOpcode()) {
122  case Instruction::Add:
123  case Instruction::Sub:
124  case Instruction::Mul:
125  case Instruction::Shl:
126  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(false);
127  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(false);
128  break;
129 
130  case Instruction::UDiv:
131  case Instruction::SDiv:
132  case Instruction::AShr:
133  case Instruction::LShr:
134  cast<PossiblyExactOperator>(this)->setIsExact(false);
135  break;
136 
137  case Instruction::GetElementPtr:
138  cast<GetElementPtrInst>(this)->setIsInBounds(false);
139  break;
140  }
141  // TODO: FastMathFlags!
142 }
143 
144 
145 bool Instruction::isExact() const {
146  return cast<PossiblyExactOperator>(this)->isExact();
147 }
148 
150  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
151  cast<FPMathOperator>(this)->setFast(B);
152 }
153 
155  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
156  cast<FPMathOperator>(this)->setHasAllowReassoc(B);
157 }
158 
160  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
161  cast<FPMathOperator>(this)->setHasNoNaNs(B);
162 }
163 
165  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
166  cast<FPMathOperator>(this)->setHasNoInfs(B);
167 }
168 
170  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
171  cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
172 }
173 
175  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
176  cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
177 }
178 
180  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
181  cast<FPMathOperator>(this)->setHasApproxFunc(B);
182 }
183 
185  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
186  cast<FPMathOperator>(this)->setFastMathFlags(FMF);
187 }
188 
190  assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op");
191  cast<FPMathOperator>(this)->copyFastMathFlags(FMF);
192 }
193 
194 bool Instruction::isFast() const {
195  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
196  return cast<FPMathOperator>(this)->isFast();
197 }
198 
200  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
201  return cast<FPMathOperator>(this)->hasAllowReassoc();
202 }
203 
205  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
206  return cast<FPMathOperator>(this)->hasNoNaNs();
207 }
208 
210  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
211  return cast<FPMathOperator>(this)->hasNoInfs();
212 }
213 
215  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
216  return cast<FPMathOperator>(this)->hasNoSignedZeros();
217 }
218 
220  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
221  return cast<FPMathOperator>(this)->hasAllowReciprocal();
222 }
223 
225  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
226  return cast<FPMathOperator>(this)->hasAllowContract();
227 }
228 
230  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
231  return cast<FPMathOperator>(this)->hasApproxFunc();
232 }
233 
235  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
236  return cast<FPMathOperator>(this)->getFastMathFlags();
237 }
238 
241 }
242 
243 void Instruction::copyIRFlags(const Value *V, bool IncludeWrapFlags) {
244  // Copy the wrapping flags.
245  if (IncludeWrapFlags && isa<OverflowingBinaryOperator>(this)) {
246  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
247  setHasNoSignedWrap(OB->hasNoSignedWrap());
248  setHasNoUnsignedWrap(OB->hasNoUnsignedWrap());
249  }
250  }
251 
252  // Copy the exact flag.
253  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
254  if (isa<PossiblyExactOperator>(this))
255  setIsExact(PE->isExact());
256 
257  // Copy the fast-math flags.
258  if (auto *FP = dyn_cast<FPMathOperator>(V))
259  if (isa<FPMathOperator>(this))
260  copyFastMathFlags(FP->getFastMathFlags());
261 
262  if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
263  if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
264  DestGEP->setIsInBounds(SrcGEP->isInBounds() | DestGEP->isInBounds());
265 }
266 
268  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
269  if (isa<OverflowingBinaryOperator>(this)) {
270  setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap());
271  setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap());
272  }
273  }
274 
275  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
276  if (isa<PossiblyExactOperator>(this))
277  setIsExact(isExact() & PE->isExact());
278 
279  if (auto *FP = dyn_cast<FPMathOperator>(V)) {
280  if (isa<FPMathOperator>(this)) {
282  FM &= FP->getFastMathFlags();
283  copyFastMathFlags(FM);
284  }
285  }
286 
287  if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
288  if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
289  DestGEP->setIsInBounds(SrcGEP->isInBounds() & DestGEP->isInBounds());
290 }
291 
292 const char *Instruction::getOpcodeName(unsigned OpCode) {
293  switch (OpCode) {
294  // Terminators
295  case Ret: return "ret";
296  case Br: return "br";
297  case Switch: return "switch";
298  case IndirectBr: return "indirectbr";
299  case Invoke: return "invoke";
300  case Resume: return "resume";
301  case Unreachable: return "unreachable";
302  case CleanupRet: return "cleanupret";
303  case CatchRet: return "catchret";
304  case CatchPad: return "catchpad";
305  case CatchSwitch: return "catchswitch";
306  case CallBr: return "callbr";
307 
308  // Standard unary operators...
309  case FNeg: return "fneg";
310 
311  // Standard binary operators...
312  case Add: return "add";
313  case FAdd: return "fadd";
314  case Sub: return "sub";
315  case FSub: return "fsub";
316  case Mul: return "mul";
317  case FMul: return "fmul";
318  case UDiv: return "udiv";
319  case SDiv: return "sdiv";
320  case FDiv: return "fdiv";
321  case URem: return "urem";
322  case SRem: return "srem";
323  case FRem: return "frem";
324 
325  // Logical operators...
326  case And: return "and";
327  case Or : return "or";
328  case Xor: return "xor";
329 
330  // Memory instructions...
331  case Alloca: return "alloca";
332  case Load: return "load";
333  case Store: return "store";
334  case AtomicCmpXchg: return "cmpxchg";
335  case AtomicRMW: return "atomicrmw";
336  case Fence: return "fence";
337  case GetElementPtr: return "getelementptr";
338 
339  // Convert instructions...
340  case Trunc: return "trunc";
341  case ZExt: return "zext";
342  case SExt: return "sext";
343  case FPTrunc: return "fptrunc";
344  case FPExt: return "fpext";
345  case FPToUI: return "fptoui";
346  case FPToSI: return "fptosi";
347  case UIToFP: return "uitofp";
348  case SIToFP: return "sitofp";
349  case IntToPtr: return "inttoptr";
350  case PtrToInt: return "ptrtoint";
351  case BitCast: return "bitcast";
352  case AddrSpaceCast: return "addrspacecast";
353 
354  // Other instructions...
355  case ICmp: return "icmp";
356  case FCmp: return "fcmp";
357  case PHI: return "phi";
358  case Select: return "select";
359  case Call: return "call";
360  case Shl: return "shl";
361  case LShr: return "lshr";
362  case AShr: return "ashr";
363  case VAArg: return "va_arg";
364  case ExtractElement: return "extractelement";
365  case InsertElement: return "insertelement";
366  case ShuffleVector: return "shufflevector";
367  case ExtractValue: return "extractvalue";
368  case InsertValue: return "insertvalue";
369  case LandingPad: return "landingpad";
370  case CleanupPad: return "cleanuppad";
371 
372  default: return "<Invalid operator> ";
373  }
374 }
375 
376 /// Return true if both instructions have the same special state. This must be
377 /// kept in sync with FunctionComparator::cmpOperations in
378 /// lib/Transforms/IPO/MergeFunctions.cpp.
379 static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2,
380  bool IgnoreAlignment = false) {
381  assert(I1->getOpcode() == I2->getOpcode() &&
382  "Can not compare special state of different instructions");
383 
384  if (const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
385  return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
386  (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
387  IgnoreAlignment);
388  if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
389  return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
390  (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
391  IgnoreAlignment) &&
392  LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
393  LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
394  if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
395  return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
396  (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
397  IgnoreAlignment) &&
398  SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
399  SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
400  if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
401  return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
402  if (const CallInst *CI = dyn_cast<CallInst>(I1))
403  return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
404  CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
405  CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
406  CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
407  if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
408  return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
409  CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
410  CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
411  if (const CallBrInst *CI = dyn_cast<CallBrInst>(I1))
412  return CI->getCallingConv() == cast<CallBrInst>(I2)->getCallingConv() &&
413  CI->getAttributes() == cast<CallBrInst>(I2)->getAttributes() &&
414  CI->hasIdenticalOperandBundleSchema(*cast<CallBrInst>(I2));
415  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
416  return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
417  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
418  return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
419  if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
420  return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
421  FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
422  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
423  return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
424  CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
425  CXI->getSuccessOrdering() ==
426  cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
427  CXI->getFailureOrdering() ==
428  cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
429  CXI->getSyncScopeID() ==
430  cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
431  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
432  return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
433  RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
434  RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
435  RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
436 
437  return true;
438 }
439 
441  return isIdenticalToWhenDefined(I) &&
443 }
444 
446  if (getOpcode() != I->getOpcode() ||
447  getNumOperands() != I->getNumOperands() ||
448  getType() != I->getType())
449  return false;
450 
451  // If both instructions have no operands, they are identical.
452  if (getNumOperands() == 0 && I->getNumOperands() == 0)
453  return haveSameSpecialState(this, I);
454 
455  // We have two instructions of identical opcode and #operands. Check to see
456  // if all operands are the same.
457  if (!std::equal(op_begin(), op_end(), I->op_begin()))
458  return false;
459 
460  if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
461  const PHINode *otherPHI = cast<PHINode>(I);
462  return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
463  otherPHI->block_begin());
464  }
465 
466  return haveSameSpecialState(this, I);
467 }
468 
469 // Keep this in sync with FunctionComparator::cmpOperations in
470 // lib/Transforms/IPO/MergeFunctions.cpp.
472  unsigned flags) const {
473  bool IgnoreAlignment = flags & CompareIgnoringAlignment;
474  bool UseScalarTypes = flags & CompareUsingScalarTypes;
475 
476  if (getOpcode() != I->getOpcode() ||
477  getNumOperands() != I->getNumOperands() ||
478  (UseScalarTypes ?
479  getType()->getScalarType() != I->getType()->getScalarType() :
480  getType() != I->getType()))
481  return false;
482 
483  // We have two instructions of identical opcode and #operands. Check to see
484  // if all operands are the same type
485  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
486  if (UseScalarTypes ?
487  getOperand(i)->getType()->getScalarType() !=
488  I->getOperand(i)->getType()->getScalarType() :
489  getOperand(i)->getType() != I->getOperand(i)->getType())
490  return false;
491 
492  return haveSameSpecialState(this, I, IgnoreAlignment);
493 }
494 
496  for (const Use &U : uses()) {
497  // PHI nodes uses values in the corresponding predecessor block. For other
498  // instructions, just check to see whether the parent of the use matches up.
499  const Instruction *I = cast<Instruction>(U.getUser());
500  const PHINode *PN = dyn_cast<PHINode>(I);
501  if (!PN) {
502  if (I->getParent() != BB)
503  return true;
504  continue;
505  }
506 
507  if (PN->getIncomingBlock(U) != BB)
508  return true;
509  }
510  return false;
511 }
512 
514  switch (getOpcode()) {
515  default: return false;
516  case Instruction::VAArg:
517  case Instruction::Load:
518  case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory
519  case Instruction::AtomicCmpXchg:
520  case Instruction::AtomicRMW:
521  case Instruction::CatchPad:
522  case Instruction::CatchRet:
523  return true;
524  case Instruction::Call:
525  case Instruction::Invoke:
526  case Instruction::CallBr:
527  return !cast<CallBase>(this)->doesNotReadMemory();
528  case Instruction::Store:
529  return !cast<StoreInst>(this)->isUnordered();
530  }
531 }
532 
534  switch (getOpcode()) {
535  default: return false;
536  case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory
537  case Instruction::Store:
538  case Instruction::VAArg:
539  case Instruction::AtomicCmpXchg:
540  case Instruction::AtomicRMW:
541  case Instruction::CatchPad:
542  case Instruction::CatchRet:
543  return true;
544  case Instruction::Call:
545  case Instruction::Invoke:
546  case Instruction::CallBr:
547  return !cast<CallBase>(this)->onlyReadsMemory();
548  case Instruction::Load:
549  return !cast<LoadInst>(this)->isUnordered();
550  }
551 }
552 
553 bool Instruction::isAtomic() const {
554  switch (getOpcode()) {
555  default:
556  return false;
557  case Instruction::AtomicCmpXchg:
558  case Instruction::AtomicRMW:
559  case Instruction::Fence:
560  return true;
561  case Instruction::Load:
562  return cast<LoadInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
563  case Instruction::Store:
564  return cast<StoreInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
565  }
566 }
567 
569  assert(isAtomic());
570  switch (getOpcode()) {
571  default:
572  return false;
573  case Instruction::AtomicCmpXchg:
574  case Instruction::AtomicRMW:
575  case Instruction::Load:
576  return true;
577  }
578 }
579 
581  assert(isAtomic());
582  switch (getOpcode()) {
583  default:
584  return false;
585  case Instruction::AtomicCmpXchg:
586  case Instruction::AtomicRMW:
587  case Instruction::Store:
588  return true;
589  }
590 }
591 
592 bool Instruction::mayThrow() const {
593  if (const CallInst *CI = dyn_cast<CallInst>(this))
594  return !CI->doesNotThrow();
595  if (const auto *CRI = dyn_cast<CleanupReturnInst>(this))
596  return CRI->unwindsToCaller();
597  if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(this))
598  return CatchSwitch->unwindsToCaller();
599  return isa<ResumeInst>(this);
600 }
601 
603  return (!isa<CallInst>(this) || !this->mayHaveSideEffects()) &&
604  !this->isTerminator();
605 }
606 
608  auto II = dyn_cast<IntrinsicInst>(this);
609  if (!II)
610  return false;
611  Intrinsic::ID ID = II->getIntrinsicID();
612  return ID == Intrinsic::lifetime_start || ID == Intrinsic::lifetime_end;
613 }
614 
616  for (const Instruction *I = getNextNode(); I; I = I->getNextNode())
617  if (!isa<DbgInfoIntrinsic>(I))
618  return I;
619  return nullptr;
620 }
621 
623  for (const Instruction *I = getPrevNode(); I; I = I->getPrevNode())
624  if (!isa<DbgInfoIntrinsic>(I))
625  return I;
626  return nullptr;
627 }
628 
630  unsigned Opcode = getOpcode();
631  if (isAssociative(Opcode))
632  return true;
633 
634  switch (Opcode) {
635  case FMul:
636  case FAdd:
637  return cast<FPMathOperator>(this)->hasAllowReassoc() &&
638  cast<FPMathOperator>(this)->hasNoSignedZeros();
639  default:
640  return false;
641  }
642 }
643 
645  switch (getOpcode()) {
646 #define HANDLE_TERM_INST(N, OPC, CLASS) \
647  case Instruction::OPC: \
648  return static_cast<const CLASS *>(this)->getNumSuccessors();
649 #include "llvm/IR/Instruction.def"
650  default:
651  break;
652  }
653  llvm_unreachable("not a terminator");
654 }
655 
656 BasicBlock *Instruction::getSuccessor(unsigned idx) const {
657  switch (getOpcode()) {
658 #define HANDLE_TERM_INST(N, OPC, CLASS) \
659  case Instruction::OPC: \
660  return static_cast<const CLASS *>(this)->getSuccessor(idx);
661 #include "llvm/IR/Instruction.def"
662  default:
663  break;
664  }
665  llvm_unreachable("not a terminator");
666 }
667 
668 void Instruction::setSuccessor(unsigned idx, BasicBlock *B) {
669  switch (getOpcode()) {
670 #define HANDLE_TERM_INST(N, OPC, CLASS) \
671  case Instruction::OPC: \
672  return static_cast<CLASS *>(this)->setSuccessor(idx, B);
673 #include "llvm/IR/Instruction.def"
674  default:
675  break;
676  }
677  llvm_unreachable("not a terminator");
678 }
679 
681  for (unsigned Idx = 0, NumSuccessors = Instruction::getNumSuccessors();
682  Idx != NumSuccessors; ++Idx)
683  if (getSuccessor(Idx) == OldBB)
684  setSuccessor(Idx, NewBB);
685 }
686 
687 Instruction *Instruction::cloneImpl() const {
688  llvm_unreachable("Subclass of Instruction failed to implement cloneImpl");
689 }
690 
692  MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
693  if (!ProfileData || ProfileData->getNumOperands() != 3 ||
694  !isa<MDString>(ProfileData->getOperand(0)))
695  return;
696 
697  MDString *MDName = cast<MDString>(ProfileData->getOperand(0));
698  if (MDName->getString() != "branch_weights")
699  return;
700 
701  // The first operand is the name. Fetch them backwards and build a new one.
702  Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
703  ProfileData->getOperand(1)};
704  setMetadata(LLVMContext::MD_prof,
705  MDNode::get(ProfileData->getContext(), Ops));
706 }
707 
709  ArrayRef<unsigned> WL) {
710  if (!SrcInst.hasMetadata())
711  return;
712 
714  for (unsigned M : WL)
715  WLS.insert(M);
716 
717  // Otherwise, enumerate and copy over metadata from the old instruction to the
718  // new one.
720  SrcInst.getAllMetadataOtherThanDebugLoc(TheMDs);
721  for (const auto &MD : TheMDs) {
722  if (WL.empty() || WLS.count(MD.first))
723  setMetadata(MD.first, MD.second);
724  }
725  if (WL.empty() || WLS.count(LLVMContext::MD_dbg))
726  setDebugLoc(SrcInst.getDebugLoc());
727 }
728 
730  Instruction *New = nullptr;
731  switch (getOpcode()) {
732  default:
733  llvm_unreachable("Unhandled Opcode.");
734 #define HANDLE_INST(num, opc, clas) \
735  case Instruction::opc: \
736  New = cast<clas>(this)->cloneImpl(); \
737  break;
738 #include "llvm/IR/Instruction.def"
739 #undef HANDLE_INST
740  }
741 
743  New->copyMetadata(*this);
744  return New;
745 }
746 
748  assert(isa<CallBase>(this) &&
749  "Can only set weights for call like instructions");
750  SmallVector<uint32_t, 1> Weights;
751  Weights.push_back(W);
752  MDBuilder MDB(getContext());
753  setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
754 }
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
This does the same thing as getAllMetadata, except that it filters out the debug location.
Definition: Instruction.h:267
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:67
bool hasNoInfs() const
Determine whether the no-infs flag is set.
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction, which must be an operator which supports these flags.
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:722
const Instruction * getPrevNonDebugInstruction() const
Return a pointer to the previous non-debug instruction in the same basic block as &#39;this&#39;...
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
iterator_range< use_iterator > uses()
Definition: Value.h:375
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
This instruction extracts a struct member or array element value from an aggregate value...
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const
This function determines if the specified instruction executes the same operation as the current one...
Instruction * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:288
iterator erase(iterator where)
Definition: ilist.h:265
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool isAtomic() const
Return true if this instruction has an AtomicOrdering of unordered or higher.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
BasicBlock * getSuccessor(unsigned Idx) const
Return the specified successor. This instruction must be a terminator.
An instruction for ordering other memory operations.
Definition: Instructions.h:462
An instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:538
bool isSafeToRemove() const
Return true if the instruction can be removed if the result is unused.
void setProfWeight(uint64_t W)
Sets the branch_weights metadata to W for CallInst.
This class represents a function call, abstracting a target machine&#39;s calling convention.
void setHasNoNaNs(bool B)
Set or clear the no-nans flag on this instruction, which must be an operator which supports this flag...
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB)
Replace specified successor OldBB to point at the provided block.
bool hasAtomicLoad() const
Return true if this atomic instruction loads from memory.
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:743
bool isTerminator() const
Definition: Instruction.h:128
Metadata node.
Definition: Metadata.h:863
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1068
An instruction for reading from memory.
Definition: Instructions.h:169
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:701
void setSuccessor(unsigned Idx, BasicBlock *BB)
Update the specified successor to point at the provided block.
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
op_iterator op_begin()
Definition: User.h:229
bool isIdenticalTo(const Instruction *I) const
Return true if the specified instruction is exactly identical to the current one. ...
bool hasAllowContract() const
Determine whether the allow-contract flag is set.
void setHasApproxFunc(bool B)
Set or clear the approximate-math-functions flag on this instruction, which must be an operator which...
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
Definition: BasicBlock.cpp:140
static uint32_t getAlignment(const MCSectionCOFF &Sec)
bool hasAllowReciprocal() const
Determine whether the allow-reciprocal flag is set.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs...
bool hasApproxFunc() const
Determine whether the approximate-math-functions flag is set.
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
Definition: Instruction.h:224
Check for equivalence ignoring load/store alignment.
Definition: Instruction.h:646
block_iterator block_begin()
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
Instruction * clone() const
Create a copy of &#39;this&#39; instruction that is identical in all ways except the following: ...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:246
Check for equivalence treating a type and a vector of that type as equivalent.
Definition: Instruction.h:649
LLVMContext & getContext() const
Definition: Metadata.h:923
void andIRFlags(const Value *V)
Logical &#39;and&#39; of any supported wrapping, exact, and fast-math flags of V and this instruction...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:244
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:125
An instruction for storing to memory.
Definition: Instructions.h:325
unsigned getNumSuccessors() const
Return the number of successors that this instruction has.
Value * getOperand(unsigned i) const
Definition: User.h:169
void setFast(bool B)
Set or clear all fast-math-flags on this instruction, which must be an operator which supports this f...
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return &#39;this&#39;.
Definition: Type.h:307
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
StringRef getString() const
Definition: Metadata.cpp:463
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1165
#define P(N)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:328
bool isIdenticalToWhenDefined(const Instruction *I) const
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags, which may specify conditions under which the instruction&#39;s result is undefined.
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction...
Definition: Instruction.cpp:73
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
const char * getOpcodeName() const
Definition: Instruction.h:127
static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, bool IgnoreAlignment=false)
Return true if both instructions have the same special state.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:187
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:582
bool mayThrow() const
Return true if this instruction may throw an exception.
const Instruction * getNextNonDebugInstruction() const
Return a pointer to the next non-debug instruction in the same basic block as &#39;this&#39;, or nullptr if no such instruction exists.
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
op_iterator op_end()
Definition: User.h:231
bool isLifetimeStartOrEnd() const
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:327
bool isFast() const
Determine whether all fast-math-flags are set.
constexpr double e
Definition: MathExtras.h:57
self_iterator getIterator()
Definition: ilist_node.h:81
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:59
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
Return metadata containing two branch weights.
Definition: MDBuilder.cpp:37
bool isExact() const
Determine whether the exact flag is set.
void swapProfMetadata()
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1222
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:92
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:338
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
Definition: PPCPredicates.h:87
Iterator for intrusive lists based on ilist_node.
unsigned getNumOperands() const
Definition: User.h:191
void setHasAllowReassoc(bool B)
Set or clear the reassociation flag on this instruction, which must be an operator which supports thi...
iterator end()
Definition: BasicBlock.h:275
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
bool isUsedOutsideOfBlock(const BasicBlock *BB) const
Return true if there are any uses of this instruction in blocks other than the specified block...
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:55
void push_back(pointer val)
Definition: ilist.h:311
static bool isWeak(const MCSymbolELF &Sym)
void removeFromParent()
This method unlinks &#39;this&#39; from the containing basic block, but does not delete it.
Definition: Instruction.cpp:63
pointer remove(iterator &IT)
Definition: ilist.h:249
List that automatically updates parent links and symbol tables.
iterator insert(iterator where, pointer New)
Definition: ilist.h:226
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:331
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:79
#define I(x, y, z)
Definition: MD5.cpp:58
bool mayReadFromMemory() const
Return true if this instruction may read memory.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
Instruction(const Instruction &)=delete
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag...
bool hasAtomicStore() const
Return true if this atomic instruction stores to memory.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void moveAfter(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:90
LLVM Value Representation.
Definition: Value.h:74
bool hasAllowReassoc() const
Determine whether the allow-reassociation flag is set.
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:86
Invoke instruction.
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:159
A single uniqued string.
Definition: Metadata.h:603
static bool isVolatile(Instruction *Inst)
void setHasNoSignedZeros(bool B)
Set or clear the no-signed-zeros flag on this instruction, which must be an operator which supports t...
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1074
iterator insertAfter(iterator where, pointer New)
Definition: ilist.h:235
Root of the metadata hierarchy.
Definition: Metadata.h:57
void setHasAllowReciprocal(bool B)
Set or clear the allow-reciprocal flag on this instruction, which must be an operator which supports ...
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:43
const BasicBlock * getParent() const
Definition: Instruction.h:66
an instruction to allocate memory on the stack
Definition: Instructions.h:59
This instruction inserts a struct field of array element value into an aggregate value.