lib/IR/Instruction.cpp

   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
  44 Instruction::~Instruction() {
  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
  55 const Module *Instruction::getModule() const {
  56   return getParent()->getModule();
  57 }
  58
  59 const Function *Instruction::getFunction() const {
  60   return getParent()->getParent();
  61 }
  62
  63 void Instruction::removeFromParent() {
  64   getParent()->getInstList().remove(getIterator());
  65 }
  66
  67 iplist<Instruction>::iterator Instruction::eraseFromParent() {
  68   return getParent()->getInstList().erase(getIterator());
  69 }
  70
  71 /// Insert an unlinked instruction into a basic block immediately before the
  72 /// specified instruction.
  73 void Instruction::insertBefore(Instruction *InsertPos) {
  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.
  79 void Instruction::insertAfter(Instruction *InsertPos) {
  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.
  86 void Instruction::moveBefore(Instruction *MovePos) {
  87   moveBefore(*MovePos->getParent(), MovePos->getIterator());
  88 }
  89
  90 void Instruction::moveAfter(Instruction *MovePos) {
  91   moveBefore(*MovePos->getParent(), ++MovePos->getIterator());
  92 }
  93
  94 void Instruction::moveBefore(BasicBlock &BB,
  95                              SymbolTableList<Instruction>::iterator I) {
  96   assert(I == BB.end() || I->getParent() == &BB);
  97   BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
  98 }
  99
 100 void Instruction::setHasNoUnsignedWrap(bool b) {
 101   cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b);
 102 }
 103
 104 void Instruction::setHasNoSignedWrap(bool b) {
 105   cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b);
 106 }
 107
 108 void Instruction::setIsExact(bool b) {
 109   cast<PossiblyExactOperator>(this)->setIsExact(b);
 110 }
 111
 112 bool Instruction::hasNoUnsignedWrap() const {
 113   return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap();
 114 }
 115
 116 bool Instruction::hasNoSignedWrap() const {
 117   return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
 118 }
 119
 120 void Instruction::dropPoisonGeneratingFlags() {
 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
 149 void Instruction::setFast(bool B) {
 150   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 151   cast<FPMathOperator>(this)->setFast(B);
 152 }
 153
 154 void Instruction::setHasAllowReassoc(bool B) {
 155   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 156   cast<FPMathOperator>(this)->setHasAllowReassoc(B);
 157 }
 158
 159 void Instruction::setHasNoNaNs(bool B) {
 160   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 161   cast<FPMathOperator>(this)->setHasNoNaNs(B);
 162 }
 163
 164 void Instruction::setHasNoInfs(bool B) {
 165   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 166   cast<FPMathOperator>(this)->setHasNoInfs(B);
 167 }
 168
 169 void Instruction::setHasNoSignedZeros(bool B) {
 170   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 171   cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
 172 }
 173
 174 void Instruction::setHasAllowReciprocal(bool B) {
 175   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 176   cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
 177 }
 178
 179 void Instruction::setHasApproxFunc(bool B) {
 180   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 181   cast<FPMathOperator>(this)->setHasApproxFunc(B);
 182 }
 183
 184 void Instruction::setFastMathFlags(FastMathFlags FMF) {
 185   assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
 186   cast<FPMathOperator>(this)->setFastMathFlags(FMF);
 187 }
 188
 189 void Instruction::copyFastMathFlags(FastMathFlags FMF) {
 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
 199 bool Instruction::hasAllowReassoc() const {
 200   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 201   return cast<FPMathOperator>(this)->hasAllowReassoc();
 202 }
 203
 204 bool Instruction::hasNoNaNs() const {
 205   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 206   return cast<FPMathOperator>(this)->hasNoNaNs();
 207 }
 208
 209 bool Instruction::hasNoInfs() const {
 210   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 211   return cast<FPMathOperator>(this)->hasNoInfs();
 212 }
 213
 214 bool Instruction::hasNoSignedZeros() const {
 215   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 216   return cast<FPMathOperator>(this)->hasNoSignedZeros();
 217 }
 218
 219 bool Instruction::hasAllowReciprocal() const {
 220   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 221   return cast<FPMathOperator>(this)->hasAllowReciprocal();
 222 }
 223
 224 bool Instruction::hasAllowContract() const {
 225   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 226   return cast<FPMathOperator>(this)->hasAllowContract();
 227 }
 228
 229 bool Instruction::hasApproxFunc() const {
 230   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 231   return cast<FPMathOperator>(this)->hasApproxFunc();
 232 }
 233
 234 FastMathFlags Instruction::getFastMathFlags() const {
 235   assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
 236   return cast<FPMathOperator>(this)->getFastMathFlags();
 237 }
 238
 239 void Instruction::copyFastMathFlags(const Instruction *I) {
 240   copyFastMathFlags(I->getFastMathFlags());
 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
 267 void Instruction::andIRFlags(const Value *V) {
 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)) {
 281       FastMathFlags FM = getFastMathFlags();
 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
 440 bool Instruction::isIdenticalTo(const Instruction *I) const {
 441   return isIdenticalToWhenDefined(I) &&
 442          SubclassOptionalData == I->SubclassOptionalData;
 443 }
 444
 445 bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const {
 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.
 471 bool Instruction::isSameOperationAs(const Instruction *I,
 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
 495 bool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const {
 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
 513 bool Instruction::mayReadFromMemory() const {
 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
 533 bool Instruction::mayWriteToMemory() const {
 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
 568 bool Instruction::hasAtomicLoad() const {
 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
 580 bool Instruction::hasAtomicStore() const {
 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
 602 bool Instruction::isSafeToRemove() const {
 603   return (!isa<CallInst>(this) || !this->mayHaveSideEffects()) &&
 604          !this->isTerminator();
 605 }
 606
 607 bool Instruction::isLifetimeStartOrEnd() const {
 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
 615 const Instruction *Instruction::getNextNonDebugInstruction() const {
 616   for (const Instruction *I = getNextNode(); I; I = I->getNextNode())
 617     if (!isa<DbgInfoIntrinsic>(I))
 618       return I;
 619   return nullptr;
 620 }
 621
 622 const Instruction *Instruction::getPrevNonDebugInstruction() const {
 623   for (const Instruction *I = getPrevNode(); I; I = I->getPrevNode())
 624     if (!isa<DbgInfoIntrinsic>(I))
 625       return I;
 626   return nullptr;
 627 }
 628
 629 bool Instruction::isAssociative() const {
 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
 644 unsigned Instruction::getNumSuccessors() const {
 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
 680 void Instruction::replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB) {
 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
 691 void Instruction::swapProfMetadata() {
 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
 708 void Instruction::copyMetadata(const Instruction &SrcInst,
 709                                ArrayRef<unsigned> WL) {
 710   if (!SrcInst.hasMetadata())
 711     return;
 712
 713   DenseSet<unsigned> WLS;
 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.
 719   SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs;
 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
 729 Instruction *Instruction::clone() const {
 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
 742   New->SubclassOptionalData = SubclassOptionalData;
 743   New->copyMetadata(*this);
 744   return New;
 745 }
 746
 747 void Instruction::setProfWeight(uint64_t W) {
 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 }