X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FInstruction.cpp;h=c1d638775755ddad2cb79169273d83e63cde8480;hb=4e4c3408a5a1cc72b739a4b448329a281c379c55;hp=7fc6245f6da5b526251e837c7a760f317467e08c;hpb=afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5;p=oota-llvm.git diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp index 7fc6245f6da..c1d63877575 100644 --- a/lib/VMCore/Instruction.cpp +++ b/lib/VMCore/Instruction.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -11,15 +11,16 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Instruction.h" #include "llvm/Type.h" #include "llvm/Instructions.h" -#include "llvm/IntrinsicInst.h" // FIXME: remove -#include "llvm/Function.h" +#include "llvm/Constants.h" +#include "llvm/Module.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/LeakDetector.h" using namespace llvm; -Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, +Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, Instruction *InsertBefore) : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { // Make sure that we get added to a basicblock @@ -33,7 +34,7 @@ Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, } } -Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, +Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd) : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { // Make sure that we get added to a basicblock @@ -48,6 +49,8 @@ Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, // Out of line virtual method, so the vtable, etc has a home. Instruction::~Instruction() { assert(Parent == 0 && "Instruction still linked in the program!"); + if (hasMetadataHashEntry()) + clearMetadataHashEntries(); } @@ -69,6 +72,18 @@ void Instruction::eraseFromParent() { getParent()->getInstList().erase(this); } +/// insertBefore - Insert an unlinked instructions into a basic block +/// immediately before the specified instruction. +void Instruction::insertBefore(Instruction *InsertPos) { + InsertPos->getParent()->getInstList().insert(InsertPos, this); +} + +/// insertAfter - Insert an unlinked instructions into a basic block +/// immediately after the specified instruction. +void Instruction::insertAfter(Instruction *InsertPos) { + InsertPos->getParent()->getInstList().insertAfter(InsertPos, this); +} + /// moveBefore - Unlink this instruction from its current basic block and /// insert it into the basic block that MovePos lives in, right before /// MovePos. @@ -84,14 +99,18 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Ret: return "ret"; case Br: return "br"; case Switch: return "switch"; + case IndirectBr: return "indirectbr"; case Invoke: return "invoke"; - case Unwind: return "unwind"; + case Resume: return "resume"; case Unreachable: return "unreachable"; // Standard binary operators... case Add: return "add"; + case FAdd: return "fadd"; case Sub: return "sub"; + case FSub: return "fsub"; case Mul: return "mul"; + case FMul: return "fmul"; case UDiv: return "udiv"; case SDiv: return "sdiv"; case FDiv: return "fdiv"; @@ -105,11 +124,12 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Xor: return "xor"; // Memory instructions... - case Malloc: return "malloc"; - case Free: return "free"; case Alloca: return "alloca"; case Load: return "load"; case Store: return "store"; + case AtomicCmpXchg: return "cmpxchg"; + case AtomicRMW: return "atomicrmw"; + case Fence: return "fence"; case GetElementPtr: return "getelementptr"; // Convert instructions... @@ -139,17 +159,26 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case ExtractElement: return "extractelement"; case InsertElement: return "insertelement"; case ShuffleVector: return "shufflevector"; + case ExtractValue: return "extractvalue"; + case InsertValue: return "insertvalue"; + case LandingPad: return "landingpad"; default: return " "; } - - return 0; } /// isIdenticalTo - Return true if the specified instruction is exactly /// identical to the current one. This means that all operands match and any /// extra information (e.g. load is volatile) agree. -bool Instruction::isIdenticalTo(Instruction *I) const { +bool Instruction::isIdenticalTo(const Instruction *I) const { + return isIdenticalToWhenDefined(I) && + SubclassOptionalData == I->SubclassOptionalData; +} + +/// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it +/// ignores the SubclassOptionalData flags, which specify conditions +/// under which the instruction's result is undefined. +bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const { if (getOpcode() != I->getOpcode() || getNumOperands() != I->getNumOperands() || getType() != I->getType()) @@ -163,20 +192,58 @@ bool Instruction::isIdenticalTo(Instruction *I) const { // Check special state that is a part of some instructions. if (const LoadInst *LI = dyn_cast(this)) - return LI->isVolatile() == cast(I)->isVolatile(); + return LI->isVolatile() == cast(I)->isVolatile() && + LI->getAlignment() == cast(I)->getAlignment() && + LI->getOrdering() == cast(I)->getOrdering() && + LI->getSynchScope() == cast(I)->getSynchScope(); if (const StoreInst *SI = dyn_cast(this)) - return SI->isVolatile() == cast(I)->isVolatile(); + return SI->isVolatile() == cast(I)->isVolatile() && + SI->getAlignment() == cast(I)->getAlignment() && + SI->getOrdering() == cast(I)->getOrdering() && + SI->getSynchScope() == cast(I)->getSynchScope(); if (const CmpInst *CI = dyn_cast(this)) return CI->getPredicate() == cast(I)->getPredicate(); if (const CallInst *CI = dyn_cast(this)) - return CI->isTailCall() == cast(I)->isTailCall(); + return CI->isTailCall() == cast(I)->isTailCall() && + CI->getCallingConv() == cast(I)->getCallingConv() && + CI->getAttributes() == cast(I)->getAttributes(); + if (const InvokeInst *CI = dyn_cast(this)) + return CI->getCallingConv() == cast(I)->getCallingConv() && + CI->getAttributes() == cast(I)->getAttributes(); + if (const InsertValueInst *IVI = dyn_cast(this)) + return IVI->getIndices() == cast(I)->getIndices(); + if (const ExtractValueInst *EVI = dyn_cast(this)) + return EVI->getIndices() == cast(I)->getIndices(); + if (const FenceInst *FI = dyn_cast(this)) + return FI->getOrdering() == cast(FI)->getOrdering() && + FI->getSynchScope() == cast(FI)->getSynchScope(); + if (const AtomicCmpXchgInst *CXI = dyn_cast(this)) + return CXI->isVolatile() == cast(I)->isVolatile() && + CXI->getOrdering() == cast(I)->getOrdering() && + CXI->getSynchScope() == cast(I)->getSynchScope(); + if (const AtomicRMWInst *RMWI = dyn_cast(this)) + return RMWI->getOperation() == cast(I)->getOperation() && + RMWI->isVolatile() == cast(I)->isVolatile() && + RMWI->getOrdering() == cast(I)->getOrdering() && + RMWI->getSynchScope() == cast(I)->getSynchScope(); + if (const PHINode *thisPHI = dyn_cast(this)) { + const PHINode *otherPHI = cast(I); + for (unsigned i = 0, e = thisPHI->getNumOperands(); i != e; ++i) { + if (thisPHI->getIncomingBlock(i) != otherPHI->getIncomingBlock(i)) + return false; + } + return true; + } return true; } // isSameOperationAs -bool Instruction::isSameOperationAs(Instruction *I) const { - if (getOpcode() != I->getOpcode() || getType() != I->getType() || - getNumOperands() != I->getNumOperands()) +// This should be kept in sync with isEquivalentOperation in +// lib/Transforms/IPO/MergeFunctions.cpp. +bool Instruction::isSameOperationAs(const Instruction *I) const { + if (getOpcode() != I->getOpcode() || + getNumOperands() != I->getNumOperands() || + getType() != I->getType()) return false; // We have two instructions of identical opcode and #operands. Check to see @@ -187,51 +254,123 @@ bool Instruction::isSameOperationAs(Instruction *I) const { // Check special state that is a part of some instructions. if (const LoadInst *LI = dyn_cast(this)) - return LI->isVolatile() == cast(I)->isVolatile(); + return LI->isVolatile() == cast(I)->isVolatile() && + LI->getAlignment() == cast(I)->getAlignment() && + LI->getOrdering() == cast(I)->getOrdering() && + LI->getSynchScope() == cast(I)->getSynchScope(); if (const StoreInst *SI = dyn_cast(this)) - return SI->isVolatile() == cast(I)->isVolatile(); + return SI->isVolatile() == cast(I)->isVolatile() && + SI->getAlignment() == cast(I)->getAlignment() && + SI->getOrdering() == cast(I)->getOrdering() && + SI->getSynchScope() == cast(I)->getSynchScope(); if (const CmpInst *CI = dyn_cast(this)) return CI->getPredicate() == cast(I)->getPredicate(); if (const CallInst *CI = dyn_cast(this)) - return CI->isTailCall() == cast(I)->isTailCall(); + return CI->isTailCall() == cast(I)->isTailCall() && + CI->getCallingConv() == cast(I)->getCallingConv() && + CI->getAttributes() == cast(I)->getAttributes(); + if (const InvokeInst *CI = dyn_cast(this)) + return CI->getCallingConv() == cast(I)->getCallingConv() && + CI->getAttributes() == + cast(I)->getAttributes(); + if (const InsertValueInst *IVI = dyn_cast(this)) + return IVI->getIndices() == cast(I)->getIndices(); + if (const ExtractValueInst *EVI = dyn_cast(this)) + return EVI->getIndices() == cast(I)->getIndices(); + if (const FenceInst *FI = dyn_cast(this)) + return FI->getOrdering() == cast(I)->getOrdering() && + FI->getSynchScope() == cast(I)->getSynchScope(); + if (const AtomicCmpXchgInst *CXI = dyn_cast(this)) + return CXI->isVolatile() == cast(I)->isVolatile() && + CXI->getOrdering() == cast(I)->getOrdering() && + CXI->getSynchScope() == cast(I)->getSynchScope(); + if (const AtomicRMWInst *RMWI = dyn_cast(this)) + return RMWI->getOperation() == cast(I)->getOperation() && + RMWI->isVolatile() == cast(I)->isVolatile() && + RMWI->getOrdering() == cast(I)->getOrdering() && + RMWI->getSynchScope() == cast(I)->getSynchScope(); return true; } +/// isUsedOutsideOfBlock - Return true if there are any uses of I outside of the +/// specified block. Note that PHI nodes are considered to evaluate their +/// operands in the corresponding predecessor block. +bool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const { + for (const_use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) { + // PHI nodes uses values in the corresponding predecessor block. For other + // instructions, just check to see whether the parent of the use matches up. + const User *U = *UI; + const PHINode *PN = dyn_cast(U); + if (PN == 0) { + if (cast(U)->getParent() != BB) + return true; + continue; + } + + if (PN->getIncomingBlock(UI) != BB) + return true; + } + return false; +} + +/// mayReadFromMemory - Return true if this instruction may read memory. +/// +bool Instruction::mayReadFromMemory() const { + switch (getOpcode()) { + default: return false; + case Instruction::VAArg: + case Instruction::Load: + case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory + case Instruction::AtomicCmpXchg: + case Instruction::AtomicRMW: + return true; + case Instruction::Call: + return !cast(this)->doesNotAccessMemory(); + case Instruction::Invoke: + return !cast(this)->doesNotAccessMemory(); + case Instruction::Store: + return !cast(this)->isUnordered(); + } +} + /// mayWriteToMemory - Return true if this instruction may modify memory. /// bool Instruction::mayWriteToMemory() const { switch (getOpcode()) { default: return false; - case Instruction::Free: - case Instruction::Invoke: + case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory case Instruction::Store: case Instruction::VAArg: + case Instruction::AtomicCmpXchg: + case Instruction::AtomicRMW: return true; case Instruction::Call: - if (!isa(this)) - return true; // FIXME: workaround gcc bootstrap breakage return !cast(this)->onlyReadsMemory(); + case Instruction::Invoke: + return !cast(this)->onlyReadsMemory(); case Instruction::Load: - return cast(this)->isVolatile(); + return !cast(this)->isUnordered(); } } +/// mayThrow - Return true if this instruction may throw an exception. +/// +bool Instruction::mayThrow() const { + if (const CallInst *CI = dyn_cast(this)) + return !CI->doesNotThrow(); + return isa(this); +} + /// isAssociative - Return true if the instruction is associative: /// -/// Associative operators satisfy: x op (y op z) === (x op y) op z) +/// Associative operators satisfy: x op (y op z) === (x op y) op z /// -/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative, when not -/// applied to floating point types. +/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative. /// -bool Instruction::isAssociative(unsigned Opcode, const Type *Ty) { - if (Opcode == And || Opcode == Or || Opcode == Xor) - return true; - - // Add/Mul reassociate unless they are FP or FP vectors. - if (Opcode == Add || Opcode == Mul) - return !Ty->isFPOrFPVector(); - return 0; +bool Instruction::isAssociative(unsigned Opcode) { + return Opcode == And || Opcode == Or || Opcode == Xor || + Opcode == Add || Opcode == Mul; } /// isCommutative - Return true if the instruction is commutative: @@ -244,7 +383,9 @@ bool Instruction::isAssociative(unsigned Opcode, const Type *Ty) { bool Instruction::isCommutative(unsigned op) { switch (op) { case Add: + case FAdd: case Mul: + case FMul: case And: case Or: case Xor: @@ -254,22 +395,19 @@ bool Instruction::isCommutative(unsigned op) { } } -/// isTrappingInstruction - Return true if the instruction may trap. -/// -bool Instruction::isTrapping(unsigned op) { - switch(op) { - case UDiv: - case SDiv: - case FDiv: - case URem: - case SRem: - case FRem: - case Load: - case Store: - case Call: - case Invoke: - return true; - default: - return false; - } +Instruction *Instruction::clone() const { + Instruction *New = clone_impl(); + New->SubclassOptionalData = SubclassOptionalData; + if (!hasMetadata()) + return New; + + // Otherwise, enumerate and copy over metadata from the old instruction to the + // new one. + SmallVector, 4> TheMDs; + getAllMetadataOtherThanDebugLoc(TheMDs); + for (unsigned i = 0, e = TheMDs.size(); i != e; ++i) + New->setMetadata(TheMDs[i].first, TheMDs[i].second); + + New->setDebugLoc(getDebugLoc()); + return New; }