Instruction.cpp revision 296417
1//===-- Instruction.cpp - Implement the Instruction class -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Instruction class for the IR library. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/IR/Instruction.h" 15#include "llvm/IR/CallSite.h" 16#include "llvm/IR/Constants.h" 17#include "llvm/IR/Instructions.h" 18#include "llvm/IR/Module.h" 19#include "llvm/IR/Operator.h" 20#include "llvm/IR/Type.h" 21using namespace llvm; 22 23Instruction::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 35Instruction::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 45// Out of line virtual method, so the vtable, etc has a home. 46Instruction::~Instruction() { 47 assert(!Parent && "Instruction still linked in the program!"); 48 if (hasMetadataHashEntry()) 49 clearMetadataHashEntries(); 50} 51 52 53void Instruction::setParent(BasicBlock *P) { 54 Parent = P; 55} 56 57const Module *Instruction::getModule() const { 58 return getParent()->getModule(); 59} 60 61Module *Instruction::getModule() { 62 return getParent()->getModule(); 63} 64 65Function *Instruction::getFunction() { return getParent()->getParent(); } 66 67const Function *Instruction::getFunction() const { 68 return getParent()->getParent(); 69} 70 71void Instruction::removeFromParent() { 72 getParent()->getInstList().remove(getIterator()); 73} 74 75iplist<Instruction>::iterator Instruction::eraseFromParent() { 76 return getParent()->getInstList().erase(getIterator()); 77} 78 79/// Insert an unlinked instruction into a basic block immediately before the 80/// specified instruction. 81void Instruction::insertBefore(Instruction *InsertPos) { 82 InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this); 83} 84 85/// Insert an unlinked instruction into a basic block immediately after the 86/// specified instruction. 87void Instruction::insertAfter(Instruction *InsertPos) { 88 InsertPos->getParent()->getInstList().insertAfter(InsertPos->getIterator(), 89 this); 90} 91 92/// Unlink this instruction from its current basic block and insert it into the 93/// basic block that MovePos lives in, right before MovePos. 94void Instruction::moveBefore(Instruction *MovePos) { 95 MovePos->getParent()->getInstList().splice( 96 MovePos->getIterator(), getParent()->getInstList(), getIterator()); 97} 98 99/// Set or clear the unsafe-algebra flag on this instruction, which must be an 100/// operator which supports this flag. See LangRef.html for the meaning of this 101/// flag. 102void Instruction::setHasUnsafeAlgebra(bool B) { 103 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 104 cast<FPMathOperator>(this)->setHasUnsafeAlgebra(B); 105} 106 107/// Set or clear the NoNaNs flag on this instruction, which must be an operator 108/// which supports this flag. See LangRef.html for the meaning of this flag. 109void Instruction::setHasNoNaNs(bool B) { 110 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 111 cast<FPMathOperator>(this)->setHasNoNaNs(B); 112} 113 114/// Set or clear the no-infs flag on this instruction, which must be an operator 115/// which supports this flag. See LangRef.html for the meaning of this flag. 116void Instruction::setHasNoInfs(bool B) { 117 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 118 cast<FPMathOperator>(this)->setHasNoInfs(B); 119} 120 121/// Set or clear the no-signed-zeros flag on this instruction, which must be an 122/// operator which supports this flag. See LangRef.html for the meaning of this 123/// flag. 124void Instruction::setHasNoSignedZeros(bool B) { 125 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 126 cast<FPMathOperator>(this)->setHasNoSignedZeros(B); 127} 128 129/// Set or clear the allow-reciprocal flag on this instruction, which must be an 130/// operator which supports this flag. See LangRef.html for the meaning of this 131/// flag. 132void Instruction::setHasAllowReciprocal(bool B) { 133 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 134 cast<FPMathOperator>(this)->setHasAllowReciprocal(B); 135} 136 137/// Convenience function for setting all the fast-math flags on this 138/// instruction, which must be an operator which supports these flags. See 139/// LangRef.html for the meaning of these flats. 140void Instruction::setFastMathFlags(FastMathFlags FMF) { 141 assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 142 cast<FPMathOperator>(this)->setFastMathFlags(FMF); 143} 144 145void Instruction::copyFastMathFlags(FastMathFlags FMF) { 146 assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op"); 147 cast<FPMathOperator>(this)->copyFastMathFlags(FMF); 148} 149 150/// Determine whether the unsafe-algebra flag is set. 151bool Instruction::hasUnsafeAlgebra() const { 152 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 153 return cast<FPMathOperator>(this)->hasUnsafeAlgebra(); 154} 155 156/// Determine whether the no-NaNs flag is set. 157bool Instruction::hasNoNaNs() const { 158 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 159 return cast<FPMathOperator>(this)->hasNoNaNs(); 160} 161 162/// Determine whether the no-infs flag is set. 163bool Instruction::hasNoInfs() const { 164 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 165 return cast<FPMathOperator>(this)->hasNoInfs(); 166} 167 168/// Determine whether the no-signed-zeros flag is set. 169bool Instruction::hasNoSignedZeros() const { 170 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 171 return cast<FPMathOperator>(this)->hasNoSignedZeros(); 172} 173 174/// Determine whether the allow-reciprocal flag is set. 175bool Instruction::hasAllowReciprocal() const { 176 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 177 return cast<FPMathOperator>(this)->hasAllowReciprocal(); 178} 179 180/// Convenience function for getting all the fast-math flags, which must be an 181/// operator which supports these flags. See LangRef.html for the meaning of 182/// these flags. 183FastMathFlags Instruction::getFastMathFlags() const { 184 assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 185 return cast<FPMathOperator>(this)->getFastMathFlags(); 186} 187 188/// Copy I's fast-math flags 189void Instruction::copyFastMathFlags(const Instruction *I) { 190 copyFastMathFlags(I->getFastMathFlags()); 191} 192 193 194const char *Instruction::getOpcodeName(unsigned OpCode) { 195 switch (OpCode) { 196 // Terminators 197 case Ret: return "ret"; 198 case Br: return "br"; 199 case Switch: return "switch"; 200 case IndirectBr: return "indirectbr"; 201 case Invoke: return "invoke"; 202 case Resume: return "resume"; 203 case Unreachable: return "unreachable"; 204 case CleanupRet: return "cleanupret"; 205 case CatchRet: return "catchret"; 206 case CatchPad: return "catchpad"; 207 case CatchSwitch: return "catchswitch"; 208 209 // Standard binary operators... 210 case Add: return "add"; 211 case FAdd: return "fadd"; 212 case Sub: return "sub"; 213 case FSub: return "fsub"; 214 case Mul: return "mul"; 215 case FMul: return "fmul"; 216 case UDiv: return "udiv"; 217 case SDiv: return "sdiv"; 218 case FDiv: return "fdiv"; 219 case URem: return "urem"; 220 case SRem: return "srem"; 221 case FRem: return "frem"; 222 223 // Logical operators... 224 case And: return "and"; 225 case Or : return "or"; 226 case Xor: return "xor"; 227 228 // Memory instructions... 229 case Alloca: return "alloca"; 230 case Load: return "load"; 231 case Store: return "store"; 232 case AtomicCmpXchg: return "cmpxchg"; 233 case AtomicRMW: return "atomicrmw"; 234 case Fence: return "fence"; 235 case GetElementPtr: return "getelementptr"; 236 237 // Convert instructions... 238 case Trunc: return "trunc"; 239 case ZExt: return "zext"; 240 case SExt: return "sext"; 241 case FPTrunc: return "fptrunc"; 242 case FPExt: return "fpext"; 243 case FPToUI: return "fptoui"; 244 case FPToSI: return "fptosi"; 245 case UIToFP: return "uitofp"; 246 case SIToFP: return "sitofp"; 247 case IntToPtr: return "inttoptr"; 248 case PtrToInt: return "ptrtoint"; 249 case BitCast: return "bitcast"; 250 case AddrSpaceCast: return "addrspacecast"; 251 252 // Other instructions... 253 case ICmp: return "icmp"; 254 case FCmp: return "fcmp"; 255 case PHI: return "phi"; 256 case Select: return "select"; 257 case Call: return "call"; 258 case Shl: return "shl"; 259 case LShr: return "lshr"; 260 case AShr: return "ashr"; 261 case VAArg: return "va_arg"; 262 case ExtractElement: return "extractelement"; 263 case InsertElement: return "insertelement"; 264 case ShuffleVector: return "shufflevector"; 265 case ExtractValue: return "extractvalue"; 266 case InsertValue: return "insertvalue"; 267 case LandingPad: return "landingpad"; 268 case CleanupPad: return "cleanuppad"; 269 270 default: return "<Invalid operator> "; 271 } 272} 273 274/// Return true if both instructions have the same special state 275/// This must be kept in sync with lib/Transforms/IPO/MergeFunctions.cpp. 276static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, 277 bool IgnoreAlignment = false) { 278 assert(I1->getOpcode() == I2->getOpcode() && 279 "Can not compare special state of different instructions"); 280 281 if (const LoadInst *LI = dyn_cast<LoadInst>(I1)) 282 return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() && 283 (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() || 284 IgnoreAlignment) && 285 LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() && 286 LI->getSynchScope() == cast<LoadInst>(I2)->getSynchScope(); 287 if (const StoreInst *SI = dyn_cast<StoreInst>(I1)) 288 return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() && 289 (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() || 290 IgnoreAlignment) && 291 SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() && 292 SI->getSynchScope() == cast<StoreInst>(I2)->getSynchScope(); 293 if (const CmpInst *CI = dyn_cast<CmpInst>(I1)) 294 return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate(); 295 if (const CallInst *CI = dyn_cast<CallInst>(I1)) 296 return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() && 297 CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() && 298 CI->getAttributes() == cast<CallInst>(I2)->getAttributes() && 299 CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2)); 300 if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1)) 301 return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() && 302 CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() && 303 CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2)); 304 if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1)) 305 return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices(); 306 if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1)) 307 return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices(); 308 if (const FenceInst *FI = dyn_cast<FenceInst>(I1)) 309 return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() && 310 FI->getSynchScope() == cast<FenceInst>(I2)->getSynchScope(); 311 if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1)) 312 return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() && 313 CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() && 314 CXI->getSuccessOrdering() == 315 cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() && 316 CXI->getFailureOrdering() == 317 cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() && 318 CXI->getSynchScope() == cast<AtomicCmpXchgInst>(I2)->getSynchScope(); 319 if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1)) 320 return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() && 321 RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() && 322 RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() && 323 RMWI->getSynchScope() == cast<AtomicRMWInst>(I2)->getSynchScope(); 324 325 return true; 326} 327 328/// isIdenticalTo - Return true if the specified instruction is exactly 329/// identical to the current one. This means that all operands match and any 330/// extra information (e.g. load is volatile) agree. 331bool Instruction::isIdenticalTo(const Instruction *I) const { 332 return isIdenticalToWhenDefined(I) && 333 SubclassOptionalData == I->SubclassOptionalData; 334} 335 336/// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it 337/// ignores the SubclassOptionalData flags, which specify conditions 338/// under which the instruction's result is undefined. 339bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const { 340 if (getOpcode() != I->getOpcode() || 341 getNumOperands() != I->getNumOperands() || 342 getType() != I->getType()) 343 return false; 344 345 // If both instructions have no operands, they are identical. 346 if (getNumOperands() == 0 && I->getNumOperands() == 0) 347 return haveSameSpecialState(this, I); 348 349 // We have two instructions of identical opcode and #operands. Check to see 350 // if all operands are the same. 351 if (!std::equal(op_begin(), op_end(), I->op_begin())) 352 return false; 353 354 if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) { 355 const PHINode *otherPHI = cast<PHINode>(I); 356 return std::equal(thisPHI->block_begin(), thisPHI->block_end(), 357 otherPHI->block_begin()); 358 } 359 360 return haveSameSpecialState(this, I); 361} 362 363// isSameOperationAs 364// This should be kept in sync with isEquivalentOperation in 365// lib/Transforms/IPO/MergeFunctions.cpp. 366bool Instruction::isSameOperationAs(const Instruction *I, 367 unsigned flags) const { 368 bool IgnoreAlignment = flags & CompareIgnoringAlignment; 369 bool UseScalarTypes = flags & CompareUsingScalarTypes; 370 371 if (getOpcode() != I->getOpcode() || 372 getNumOperands() != I->getNumOperands() || 373 (UseScalarTypes ? 374 getType()->getScalarType() != I->getType()->getScalarType() : 375 getType() != I->getType())) 376 return false; 377 378 // We have two instructions of identical opcode and #operands. Check to see 379 // if all operands are the same type 380 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 381 if (UseScalarTypes ? 382 getOperand(i)->getType()->getScalarType() != 383 I->getOperand(i)->getType()->getScalarType() : 384 getOperand(i)->getType() != I->getOperand(i)->getType()) 385 return false; 386 387 return haveSameSpecialState(this, I, IgnoreAlignment); 388} 389 390/// isUsedOutsideOfBlock - Return true if there are any uses of I outside of the 391/// specified block. Note that PHI nodes are considered to evaluate their 392/// operands in the corresponding predecessor block. 393bool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const { 394 for (const Use &U : uses()) { 395 // PHI nodes uses values in the corresponding predecessor block. For other 396 // instructions, just check to see whether the parent of the use matches up. 397 const Instruction *I = cast<Instruction>(U.getUser()); 398 const PHINode *PN = dyn_cast<PHINode>(I); 399 if (!PN) { 400 if (I->getParent() != BB) 401 return true; 402 continue; 403 } 404 405 if (PN->getIncomingBlock(U) != BB) 406 return true; 407 } 408 return false; 409} 410 411/// mayReadFromMemory - Return true if this instruction may read memory. 412/// 413bool Instruction::mayReadFromMemory() const { 414 switch (getOpcode()) { 415 default: return false; 416 case Instruction::VAArg: 417 case Instruction::Load: 418 case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory 419 case Instruction::AtomicCmpXchg: 420 case Instruction::AtomicRMW: 421 case Instruction::CatchPad: 422 case Instruction::CatchRet: 423 return true; 424 case Instruction::Call: 425 return !cast<CallInst>(this)->doesNotAccessMemory(); 426 case Instruction::Invoke: 427 return !cast<InvokeInst>(this)->doesNotAccessMemory(); 428 case Instruction::Store: 429 return !cast<StoreInst>(this)->isUnordered(); 430 } 431} 432 433/// mayWriteToMemory - Return true if this instruction may modify memory. 434/// 435bool Instruction::mayWriteToMemory() const { 436 switch (getOpcode()) { 437 default: return false; 438 case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory 439 case Instruction::Store: 440 case Instruction::VAArg: 441 case Instruction::AtomicCmpXchg: 442 case Instruction::AtomicRMW: 443 case Instruction::CatchPad: 444 case Instruction::CatchRet: 445 return true; 446 case Instruction::Call: 447 return !cast<CallInst>(this)->onlyReadsMemory(); 448 case Instruction::Invoke: 449 return !cast<InvokeInst>(this)->onlyReadsMemory(); 450 case Instruction::Load: 451 return !cast<LoadInst>(this)->isUnordered(); 452 } 453} 454 455bool Instruction::isAtomic() const { 456 switch (getOpcode()) { 457 default: 458 return false; 459 case Instruction::AtomicCmpXchg: 460 case Instruction::AtomicRMW: 461 case Instruction::Fence: 462 return true; 463 case Instruction::Load: 464 return cast<LoadInst>(this)->getOrdering() != NotAtomic; 465 case Instruction::Store: 466 return cast<StoreInst>(this)->getOrdering() != NotAtomic; 467 } 468} 469 470bool Instruction::mayThrow() const { 471 if (const CallInst *CI = dyn_cast<CallInst>(this)) 472 return !CI->doesNotThrow(); 473 if (const auto *CRI = dyn_cast<CleanupReturnInst>(this)) 474 return CRI->unwindsToCaller(); 475 if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(this)) 476 return CatchSwitch->unwindsToCaller(); 477 return isa<ResumeInst>(this); 478} 479 480bool Instruction::mayReturn() const { 481 if (const CallInst *CI = dyn_cast<CallInst>(this)) 482 return !CI->doesNotReturn(); 483 return true; 484} 485 486/// isAssociative - Return true if the instruction is associative: 487/// 488/// Associative operators satisfy: x op (y op z) === (x op y) op z 489/// 490/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative. 491/// 492bool Instruction::isAssociative(unsigned Opcode) { 493 return Opcode == And || Opcode == Or || Opcode == Xor || 494 Opcode == Add || Opcode == Mul; 495} 496 497bool Instruction::isAssociative() const { 498 unsigned Opcode = getOpcode(); 499 if (isAssociative(Opcode)) 500 return true; 501 502 switch (Opcode) { 503 case FMul: 504 case FAdd: 505 return cast<FPMathOperator>(this)->hasUnsafeAlgebra(); 506 default: 507 return false; 508 } 509} 510 511/// isCommutative - Return true if the instruction is commutative: 512/// 513/// Commutative operators satisfy: (x op y) === (y op x) 514/// 515/// In LLVM, these are the associative operators, plus SetEQ and SetNE, when 516/// applied to any type. 517/// 518bool Instruction::isCommutative(unsigned op) { 519 switch (op) { 520 case Add: 521 case FAdd: 522 case Mul: 523 case FMul: 524 case And: 525 case Or: 526 case Xor: 527 return true; 528 default: 529 return false; 530 } 531} 532 533/// isIdempotent - Return true if the instruction is idempotent: 534/// 535/// Idempotent operators satisfy: x op x === x 536/// 537/// In LLVM, the And and Or operators are idempotent. 538/// 539bool Instruction::isIdempotent(unsigned Opcode) { 540 return Opcode == And || Opcode == Or; 541} 542 543/// isNilpotent - Return true if the instruction is nilpotent: 544/// 545/// Nilpotent operators satisfy: x op x === Id, 546/// 547/// where Id is the identity for the operator, i.e. a constant such that 548/// x op Id === x and Id op x === x for all x. 549/// 550/// In LLVM, the Xor operator is nilpotent. 551/// 552bool Instruction::isNilpotent(unsigned Opcode) { 553 return Opcode == Xor; 554} 555 556Instruction *Instruction::cloneImpl() const { 557 llvm_unreachable("Subclass of Instruction failed to implement cloneImpl"); 558} 559 560Instruction *Instruction::clone() const { 561 Instruction *New = nullptr; 562 switch (getOpcode()) { 563 default: 564 llvm_unreachable("Unhandled Opcode."); 565#define HANDLE_INST(num, opc, clas) \ 566 case Instruction::opc: \ 567 New = cast<clas>(this)->cloneImpl(); \ 568 break; 569#include "llvm/IR/Instruction.def" 570#undef HANDLE_INST 571 } 572 573 New->SubclassOptionalData = SubclassOptionalData; 574 if (!hasMetadata()) 575 return New; 576 577 // Otherwise, enumerate and copy over metadata from the old instruction to the 578 // new one. 579 SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs; 580 getAllMetadataOtherThanDebugLoc(TheMDs); 581 for (const auto &MD : TheMDs) 582 New->setMetadata(MD.first, MD.second); 583 584 New->setDebugLoc(getDebugLoc()); 585 return New; 586} 587