X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FInstruction.cpp;h=86421c4ae9ffcfd6319efde23da9c04e58d4e216;hb=7af88ec907537f9a5de343d439fbca1344f28a29;hp=42df5d71182d88f70ae09c5b80e34f40f14b72b4;hpb=0b8c9a80f20772c3793201ab5b251d3520b9cea3;p=oota-llvm.git diff --git a/lib/IR/Instruction.cpp b/lib/IR/Instruction.cpp index 42df5d71182..86421c4ae9f 100644 --- a/lib/IR/Instruction.cpp +++ b/lib/IR/Instruction.cpp @@ -12,18 +12,18 @@ //===----------------------------------------------------------------------===// #include "llvm/IR/Instruction.h" +#include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Instructions.h" +#include "llvm/IR/LeakDetector.h" #include "llvm/IR/Module.h" #include "llvm/IR/Operator.h" #include "llvm/IR/Type.h" -#include "llvm/Support/CallSite.h" -#include "llvm/Support/LeakDetector.h" using namespace llvm; Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, Instruction *InsertBefore) - : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) { // Make sure that we get added to a basicblock LeakDetector::addGarbageObject(this); @@ -35,9 +35,13 @@ Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, } } +const DataLayout *Instruction::getDataLayout() const { + return getParent()->getDataLayout(); +} + Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd) - : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) { // Make sure that we get added to a basicblock LeakDetector::addGarbageObject(this); @@ -49,7 +53,7 @@ Instruction::Instruction(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!"); + assert(!Parent && "Instruction still linked in the program!"); if (hasMetadataHashEntry()) clearMetadataHashEntries(); } @@ -141,31 +145,31 @@ void Instruction::setFastMathFlags(FastMathFlags FMF) { /// Determine whether the unsafe-algebra flag is set. bool Instruction::hasUnsafeAlgebra() const { - assert(isa(this) && "setting fast-math flag on invalid op"); + assert(isa(this) && "getting fast-math flag on invalid op"); return cast(this)->hasUnsafeAlgebra(); } /// Determine whether the no-NaNs flag is set. bool Instruction::hasNoNaNs() const { - assert(isa(this) && "setting fast-math flag on invalid op"); + assert(isa(this) && "getting fast-math flag on invalid op"); return cast(this)->hasNoNaNs(); } /// Determine whether the no-infs flag is set. bool Instruction::hasNoInfs() const { - assert(isa(this) && "setting fast-math flag on invalid op"); + assert(isa(this) && "getting fast-math flag on invalid op"); return cast(this)->hasNoInfs(); } /// Determine whether the no-signed-zeros flag is set. bool Instruction::hasNoSignedZeros() const { - assert(isa(this) && "setting fast-math flag on invalid op"); + assert(isa(this) && "getting fast-math flag on invalid op"); return cast(this)->hasNoSignedZeros(); } /// Determine whether the allow-reciprocal flag is set. bool Instruction::hasAllowReciprocal() const { - assert(isa(this) && "setting fast-math flag on invalid op"); + assert(isa(this) && "getting fast-math flag on invalid op"); return cast(this)->hasAllowReciprocal(); } @@ -173,7 +177,7 @@ bool Instruction::hasAllowReciprocal() const { /// operator which supports these flags. See LangRef.html for the meaning of /// these flats. FastMathFlags Instruction::getFastMathFlags() const { - assert(isa(this) && "setting fast-math flag on invalid op"); + assert(isa(this) && "getting fast-math flag on invalid op"); return cast(this)->getFastMathFlags(); } @@ -223,18 +227,19 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case GetElementPtr: return "getelementptr"; // Convert instructions... - case Trunc: return "trunc"; - case ZExt: return "zext"; - case SExt: return "sext"; - case FPTrunc: return "fptrunc"; - case FPExt: return "fpext"; - case FPToUI: return "fptoui"; - case FPToSI: return "fptosi"; - case UIToFP: return "uitofp"; - case SIToFP: return "sitofp"; - case IntToPtr: return "inttoptr"; - case PtrToInt: return "ptrtoint"; - case BitCast: return "bitcast"; + case Trunc: return "trunc"; + case ZExt: return "zext"; + case SExt: return "sext"; + case FPTrunc: return "fptrunc"; + case FPExt: return "fpext"; + case FPToUI: return "fptoui"; + case FPToSI: return "fptosi"; + case UIToFP: return "uitofp"; + case SIToFP: return "sitofp"; + case IntToPtr: return "inttoptr"; + case PtrToInt: return "ptrtoint"; + case BitCast: return "bitcast"; + case AddrSpaceCast: return "addrspacecast"; // Other instructions... case ICmp: return "icmp"; @@ -257,6 +262,59 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { } } +/// Return true if both instructions have the same special state +/// This must be kept in sync with lib/Transforms/IPO/MergeFunctions.cpp. +static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, + bool IgnoreAlignment = false) { + assert(I1->getOpcode() == I2->getOpcode() && + "Can not compare special state of different instructions"); + + if (const LoadInst *LI = dyn_cast(I1)) + return LI->isVolatile() == cast(I2)->isVolatile() && + (LI->getAlignment() == cast(I2)->getAlignment() || + IgnoreAlignment) && + LI->getOrdering() == cast(I2)->getOrdering() && + LI->getSynchScope() == cast(I2)->getSynchScope(); + if (const StoreInst *SI = dyn_cast(I1)) + return SI->isVolatile() == cast(I2)->isVolatile() && + (SI->getAlignment() == cast(I2)->getAlignment() || + IgnoreAlignment) && + SI->getOrdering() == cast(I2)->getOrdering() && + SI->getSynchScope() == cast(I2)->getSynchScope(); + if (const CmpInst *CI = dyn_cast(I1)) + return CI->getPredicate() == cast(I2)->getPredicate(); + if (const CallInst *CI = dyn_cast(I1)) + return CI->isTailCall() == cast(I2)->isTailCall() && + CI->getCallingConv() == cast(I2)->getCallingConv() && + CI->getAttributes() == cast(I2)->getAttributes(); + if (const InvokeInst *CI = dyn_cast(I1)) + return CI->getCallingConv() == cast(I2)->getCallingConv() && + CI->getAttributes() == + cast(I2)->getAttributes(); + if (const InsertValueInst *IVI = dyn_cast(I1)) + return IVI->getIndices() == cast(I2)->getIndices(); + if (const ExtractValueInst *EVI = dyn_cast(I1)) + return EVI->getIndices() == cast(I2)->getIndices(); + if (const FenceInst *FI = dyn_cast(I1)) + return FI->getOrdering() == cast(I2)->getOrdering() && + FI->getSynchScope() == cast(I2)->getSynchScope(); + if (const AtomicCmpXchgInst *CXI = dyn_cast(I1)) + return CXI->isVolatile() == cast(I2)->isVolatile() && + CXI->isWeak() == cast(I2)->isWeak() && + CXI->getSuccessOrdering() == + cast(I2)->getSuccessOrdering() && + CXI->getFailureOrdering() == + cast(I2)->getFailureOrdering() && + CXI->getSynchScope() == cast(I2)->getSynchScope(); + if (const AtomicRMWInst *RMWI = dyn_cast(I1)) + return RMWI->getOperation() == cast(I2)->getOperation() && + RMWI->isVolatile() == cast(I2)->isVolatile() && + RMWI->getOrdering() == cast(I2)->getOrdering() && + RMWI->getSynchScope() == cast(I2)->getSynchScope(); + + return true; +} + /// 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. @@ -274,57 +332,22 @@ bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const { getType() != I->getType()) return false; + // If both instructions have no operands, they are identical. + if (getNumOperands() == 0 && I->getNumOperands() == 0) + return haveSameSpecialState(this, I); + // We have two instructions of identical opcode and #operands. Check to see // if all operands are the same. - for (unsigned i = 0, e = getNumOperands(); i != e; ++i) - if (getOperand(i) != I->getOperand(i)) - return false; + if (!std::equal(op_begin(), op_end(), I->op_begin())) + return false; - // Check special state that is a part of some instructions. - if (const LoadInst *LI = dyn_cast(this)) - 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() && - 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() && - 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 std::equal(thisPHI->block_begin(), thisPHI->block_end(), + otherPHI->block_begin()); } - return true; + + return haveSameSpecialState(this, I); } // isSameOperationAs @@ -351,65 +374,25 @@ bool Instruction::isSameOperationAs(const Instruction *I, getOperand(i)->getType() != I->getOperand(i)->getType()) return false; - // Check special state that is a part of some instructions. - if (const LoadInst *LI = dyn_cast(this)) - return LI->isVolatile() == cast(I)->isVolatile() && - (LI->getAlignment() == cast(I)->getAlignment() || - IgnoreAlignment) && - LI->getOrdering() == cast(I)->getOrdering() && - LI->getSynchScope() == cast(I)->getSynchScope(); - if (const StoreInst *SI = dyn_cast(this)) - return SI->isVolatile() == cast(I)->isVolatile() && - (SI->getAlignment() == cast(I)->getAlignment() || - IgnoreAlignment) && - 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() && - 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; + return haveSameSpecialState(this, I, IgnoreAlignment); } /// 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) { + for (const Use &U : uses()) { // 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) + const Instruction *I = cast(U.getUser()); + const PHINode *PN = dyn_cast(I); + if (!PN) { + if (I->getParent() != BB) return true; continue; } - if (PN->getIncomingBlock(UI) != BB) + if (PN->getIncomingBlock(U) != BB) return true; } return false; @@ -455,14 +438,18 @@ bool Instruction::mayWriteToMemory() const { } } -/// 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); } +bool Instruction::mayReturn() const { + if (const CallInst *CI = dyn_cast(this)) + return !CI->doesNotReturn(); + return true; +} + /// isAssociative - Return true if the instruction is associative: /// /// Associative operators satisfy: x op (y op z) === (x op y) op z @@ -543,8 +530,8 @@ Instruction *Instruction::clone() const { // 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); + for (const auto &MD : TheMDs) + New->setMetadata(MD.first, MD.second); New->setDebugLoc(getDebugLoc()); return New;