2003-10-13 11:32:08 +08:00
|
|
|
//===-- Instruction.cpp - Implement the Instruction class -----------------===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
2013-01-02 17:10:48 +08:00
|
|
|
// This file implements the Instruction class for the IR library.
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Instruction.h"
|
2014-03-04 19:01:28 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/Operator.h"
|
|
|
|
#include "llvm/IR/Type.h"
|
2003-11-21 01:45:12 +08:00
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2011-07-18 12:54:35 +08:00
|
|
|
Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
|
2007-02-24 08:55:48 +08:00
|
|
|
Instruction *InsertBefore)
|
2014-04-09 14:08:46 +08:00
|
|
|
: User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
|
2002-09-10 23:45:53 +08:00
|
|
|
|
|
|
|
// If requested, insert this instruction into a basic block...
|
|
|
|
if (InsertBefore) {
|
|
|
|
assert(InsertBefore->getParent() &&
|
|
|
|
"Instruction to insert before is not in a basic block!");
|
|
|
|
InsertBefore->getParent()->getInstList().insert(InsertBefore, this);
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2011-07-18 12:54:35 +08:00
|
|
|
Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
|
2007-02-24 08:55:48 +08:00
|
|
|
BasicBlock *InsertAtEnd)
|
2014-04-09 14:08:46 +08:00
|
|
|
: User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
|
2004-05-27 05:41:09 +08:00
|
|
|
|
|
|
|
// append this instruction into the basic block
|
|
|
|
assert(InsertAtEnd && "Basic block to append to may not be NULL!");
|
|
|
|
InsertAtEnd->getInstList().push_back(this);
|
2007-02-13 15:54:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-22 00:53:47 +08:00
|
|
|
// Out of line virtual method, so the vtable, etc has a home.
|
2007-12-10 10:14:30 +08:00
|
|
|
Instruction::~Instruction() {
|
2014-04-15 14:32:26 +08:00
|
|
|
assert(!Parent && "Instruction still linked in the program!");
|
2010-07-21 06:25:04 +08:00
|
|
|
if (hasMetadataHashEntry())
|
|
|
|
clearMetadataHashEntries();
|
2006-06-22 00:53:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-09-07 05:33:15 +08:00
|
|
|
void Instruction::setParent(BasicBlock *P) {
|
|
|
|
Parent = P;
|
|
|
|
}
|
|
|
|
|
2015-03-04 06:01:13 +08:00
|
|
|
const Module *Instruction::getModule() const {
|
|
|
|
return getParent()->getModule();
|
|
|
|
}
|
|
|
|
|
2004-10-12 06:21:39 +08:00
|
|
|
void Instruction::removeFromParent() {
|
|
|
|
getParent()->getInstList().remove(this);
|
|
|
|
}
|
|
|
|
|
2015-04-02 08:03:07 +08:00
|
|
|
iplist<Instruction>::iterator Instruction::eraseFromParent() {
|
|
|
|
return getParent()->getInstList().erase(this);
|
2004-10-12 06:21:39 +08:00
|
|
|
}
|
2002-07-15 07:09:40 +08:00
|
|
|
|
2008-06-18 02:29:27 +08:00
|
|
|
/// 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);
|
|
|
|
}
|
|
|
|
|
2009-01-13 15:43:51 +08:00
|
|
|
/// 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);
|
|
|
|
}
|
|
|
|
|
2005-08-08 13:21:50 +08:00
|
|
|
/// moveBefore - Unlink this instruction from its current basic block and
|
|
|
|
/// insert it into the basic block that MovePos lives in, right before
|
|
|
|
/// MovePos.
|
|
|
|
void Instruction::moveBefore(Instruction *MovePos) {
|
|
|
|
MovePos->getParent()->getInstList().splice(MovePos,getParent()->getInstList(),
|
|
|
|
this);
|
|
|
|
}
|
|
|
|
|
2012-11-27 08:41:22 +08:00
|
|
|
/// Set or clear the unsafe-algebra flag on this instruction, which must be an
|
|
|
|
/// operator which supports this flag. See LangRef.html for the meaning of this
|
|
|
|
/// flag.
|
|
|
|
void Instruction::setHasUnsafeAlgebra(bool B) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->setHasUnsafeAlgebra(B);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set or clear the NoNaNs flag on this instruction, which must be an operator
|
|
|
|
/// which supports this flag. See LangRef.html for the meaning of this flag.
|
|
|
|
void Instruction::setHasNoNaNs(bool B) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->setHasNoNaNs(B);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set or clear the no-infs flag on this instruction, which must be an operator
|
|
|
|
/// which supports this flag. See LangRef.html for the meaning of this flag.
|
|
|
|
void Instruction::setHasNoInfs(bool B) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->setHasNoInfs(B);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set or clear the no-signed-zeros flag on this instruction, which must be an
|
|
|
|
/// operator which supports this flag. See LangRef.html for the meaning of this
|
|
|
|
/// flag.
|
|
|
|
void Instruction::setHasNoSignedZeros(bool B) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set or clear the allow-reciprocal flag on this instruction, which must be an
|
|
|
|
/// operator which supports this flag. See LangRef.html for the meaning of this
|
|
|
|
/// flag.
|
|
|
|
void Instruction::setHasAllowReciprocal(bool B) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Convenience function for setting all the fast-math flags on this
|
|
|
|
/// instruction, which must be an operator which supports these flags. See
|
|
|
|
/// LangRef.html for the meaning of these flats.
|
|
|
|
void Instruction::setFastMathFlags(FastMathFlags FMF) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->setFastMathFlags(FMF);
|
|
|
|
}
|
|
|
|
|
2014-09-03 04:03:00 +08:00
|
|
|
void Instruction::copyFastMathFlags(FastMathFlags FMF) {
|
|
|
|
assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op");
|
|
|
|
cast<FPMathOperator>(this)->copyFastMathFlags(FMF);
|
|
|
|
}
|
|
|
|
|
2012-11-27 08:41:22 +08:00
|
|
|
/// Determine whether the unsafe-algebra flag is set.
|
|
|
|
bool Instruction::hasUnsafeAlgebra() const {
|
2014-06-12 02:26:29 +08:00
|
|
|
assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
|
2012-11-27 08:41:22 +08:00
|
|
|
return cast<FPMathOperator>(this)->hasUnsafeAlgebra();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determine whether the no-NaNs flag is set.
|
|
|
|
bool Instruction::hasNoNaNs() const {
|
2014-06-12 02:26:29 +08:00
|
|
|
assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
|
2012-11-27 08:41:22 +08:00
|
|
|
return cast<FPMathOperator>(this)->hasNoNaNs();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determine whether the no-infs flag is set.
|
|
|
|
bool Instruction::hasNoInfs() const {
|
2014-06-12 02:26:29 +08:00
|
|
|
assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
|
2012-11-27 08:41:22 +08:00
|
|
|
return cast<FPMathOperator>(this)->hasNoInfs();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determine whether the no-signed-zeros flag is set.
|
|
|
|
bool Instruction::hasNoSignedZeros() const {
|
2014-06-12 02:26:29 +08:00
|
|
|
assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
|
2012-11-27 08:41:22 +08:00
|
|
|
return cast<FPMathOperator>(this)->hasNoSignedZeros();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determine whether the allow-reciprocal flag is set.
|
|
|
|
bool Instruction::hasAllowReciprocal() const {
|
2014-06-12 02:26:29 +08:00
|
|
|
assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
|
2012-11-27 08:41:22 +08:00
|
|
|
return cast<FPMathOperator>(this)->hasAllowReciprocal();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Convenience function for getting all the fast-math flags, which must be an
|
|
|
|
/// operator which supports these flags. See LangRef.html for the meaning of
|
2014-09-11 00:58:40 +08:00
|
|
|
/// these flags.
|
2012-11-27 08:41:22 +08:00
|
|
|
FastMathFlags Instruction::getFastMathFlags() const {
|
2014-06-12 02:26:29 +08:00
|
|
|
assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
|
2012-11-27 08:41:22 +08:00
|
|
|
return cast<FPMathOperator>(this)->getFastMathFlags();
|
|
|
|
}
|
2005-08-08 13:21:50 +08:00
|
|
|
|
2012-11-30 05:25:12 +08:00
|
|
|
/// Copy I's fast-math flags
|
|
|
|
void Instruction::copyFastMathFlags(const Instruction *I) {
|
2014-09-03 04:03:00 +08:00
|
|
|
copyFastMathFlags(I->getFastMathFlags());
|
2012-11-30 05:25:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-07-15 07:09:40 +08:00
|
|
|
const char *Instruction::getOpcodeName(unsigned OpCode) {
|
|
|
|
switch (OpCode) {
|
|
|
|
// Terminators
|
2002-08-15 02:18:02 +08:00
|
|
|
case Ret: return "ret";
|
|
|
|
case Br: return "br";
|
2002-07-15 07:09:40 +08:00
|
|
|
case Switch: return "switch";
|
2009-10-28 08:19:10 +08:00
|
|
|
case IndirectBr: return "indirectbr";
|
2002-07-15 07:09:40 +08:00
|
|
|
case Invoke: return "invoke";
|
2011-07-31 14:30:59 +08:00
|
|
|
case Resume: return "resume";
|
2004-10-17 02:08:06 +08:00
|
|
|
case Unreachable: return "unreachable";
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2002-07-15 07:09:40 +08:00
|
|
|
// Standard binary operators...
|
|
|
|
case Add: return "add";
|
2009-06-05 06:49:04 +08:00
|
|
|
case FAdd: return "fadd";
|
2002-07-15 07:09:40 +08:00
|
|
|
case Sub: return "sub";
|
2009-06-05 06:49:04 +08:00
|
|
|
case FSub: return "fsub";
|
2002-07-15 07:09:40 +08:00
|
|
|
case Mul: return "mul";
|
2009-06-05 06:49:04 +08:00
|
|
|
case FMul: return "fmul";
|
2006-10-26 14:15:43 +08:00
|
|
|
case UDiv: return "udiv";
|
|
|
|
case SDiv: return "sdiv";
|
|
|
|
case FDiv: return "fdiv";
|
2006-11-02 09:53:59 +08:00
|
|
|
case URem: return "urem";
|
|
|
|
case SRem: return "srem";
|
|
|
|
case FRem: return "frem";
|
2002-07-15 07:09:40 +08:00
|
|
|
|
|
|
|
// Logical operators...
|
|
|
|
case And: return "and";
|
|
|
|
case Or : return "or";
|
|
|
|
case Xor: return "xor";
|
|
|
|
|
|
|
|
// Memory instructions...
|
|
|
|
case Alloca: return "alloca";
|
|
|
|
case Load: return "load";
|
|
|
|
case Store: return "store";
|
2011-07-29 05:48:00 +08:00
|
|
|
case AtomicCmpXchg: return "cmpxchg";
|
|
|
|
case AtomicRMW: return "atomicrmw";
|
2011-07-26 07:16:38 +08:00
|
|
|
case Fence: return "fence";
|
2002-07-15 07:09:40 +08:00
|
|
|
case GetElementPtr: return "getelementptr";
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2006-11-27 09:05:10 +08:00
|
|
|
// Convert instructions...
|
2013-11-15 09:34:59 +08:00
|
|
|
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";
|
2006-11-27 09:05:10 +08:00
|
|
|
|
2002-07-15 07:09:40 +08:00
|
|
|
// Other instructions...
|
2006-12-03 14:27:29 +08:00
|
|
|
case ICmp: return "icmp";
|
|
|
|
case FCmp: return "fcmp";
|
2006-11-27 09:05:10 +08:00
|
|
|
case PHI: return "phi";
|
|
|
|
case Select: return "select";
|
|
|
|
case Call: return "call";
|
|
|
|
case Shl: return "shl";
|
|
|
|
case LShr: return "lshr";
|
|
|
|
case AShr: return "ashr";
|
|
|
|
case VAArg: return "va_arg";
|
2006-01-11 03:05:34 +08:00
|
|
|
case ExtractElement: return "extractelement";
|
2006-11-27 09:05:10 +08:00
|
|
|
case InsertElement: return "insertelement";
|
|
|
|
case ShuffleVector: return "shufflevector";
|
2008-05-30 18:31:54 +08:00
|
|
|
case ExtractValue: return "extractvalue";
|
|
|
|
case InsertValue: return "insertvalue";
|
2011-08-13 04:24:12 +08:00
|
|
|
case LandingPad: return "landingpad";
|
2003-05-08 10:44:12 +08:00
|
|
|
|
2002-07-15 07:09:40 +08:00
|
|
|
default: return "<Invalid operator> ";
|
|
|
|
}
|
|
|
|
}
|
2002-10-31 12:14:01 +08:00
|
|
|
|
2014-05-28 05:35:46 +08:00
|
|
|
/// 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<LoadInst>(I1))
|
|
|
|
return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
|
|
|
|
(LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
|
|
|
|
IgnoreAlignment) &&
|
|
|
|
LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
|
|
|
|
LI->getSynchScope() == cast<LoadInst>(I2)->getSynchScope();
|
|
|
|
if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
|
|
|
|
return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
|
|
|
|
(SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
|
|
|
|
IgnoreAlignment) &&
|
|
|
|
SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
|
|
|
|
SI->getSynchScope() == cast<StoreInst>(I2)->getSynchScope();
|
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
|
|
|
|
return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(I1))
|
|
|
|
return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
|
|
|
|
CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
|
|
|
|
CI->getAttributes() == cast<CallInst>(I2)->getAttributes();
|
|
|
|
if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
|
|
|
|
return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
|
|
|
|
CI->getAttributes() ==
|
|
|
|
cast<InvokeInst>(I2)->getAttributes();
|
|
|
|
if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
|
|
|
|
return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
|
|
|
|
if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
|
|
|
|
return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
|
|
|
|
if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
|
|
|
|
return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
|
|
|
|
FI->getSynchScope() == cast<FenceInst>(I2)->getSynchScope();
|
|
|
|
if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
|
|
|
|
return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
|
IR: add "cmpxchg weak" variant to support permitted failure.
This commit adds a weak variant of the cmpxchg operation, as described
in C++11. A cmpxchg instruction with this modifier is permitted to
fail to store, even if the comparison indicated it should.
As a result, cmpxchg instructions must return a flag indicating
success in addition to their original iN value loaded. Thus, for
uniformity *all* cmpxchg instructions now return "{ iN, i1 }". The
second flag is 1 when the store succeeded.
At the DAG level, a new ATOMIC_CMP_SWAP_WITH_SUCCESS node has been
added as the natural representation for the new cmpxchg instructions.
It is a strong cmpxchg.
By default this gets Expanded to the existing ATOMIC_CMP_SWAP during
Legalization, so existing backends should see no change in behaviour.
If they wish to deal with the enhanced node instead, they can call
setOperationAction on it. Beware: as a node with 2 results, it cannot
be selected from TableGen.
Currently, no use is made of the extra information provided in this
patch. Test updates are almost entirely adapting the input IR to the
new scheme.
Summary for out of tree users:
------------------------------
+ Legacy Bitcode files are upgraded during read.
+ Legacy assembly IR files will be invalid.
+ Front-ends must adapt to different type for "cmpxchg".
+ Backends should be unaffected by default.
llvm-svn: 210903
2014-06-13 22:24:07 +08:00
|
|
|
CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
|
2014-05-28 05:35:46 +08:00
|
|
|
CXI->getSuccessOrdering() ==
|
|
|
|
cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
|
|
|
|
CXI->getFailureOrdering() ==
|
|
|
|
cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
|
|
|
|
CXI->getSynchScope() == cast<AtomicCmpXchgInst>(I2)->getSynchScope();
|
|
|
|
if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
|
|
|
|
return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
|
|
|
|
RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
|
|
|
|
RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
|
|
|
|
RMWI->getSynchScope() == cast<AtomicRMWInst>(I2)->getSynchScope();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-11-30 10:51:53 +08:00
|
|
|
/// 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.
|
2008-11-27 16:39:18 +08:00
|
|
|
bool Instruction::isIdenticalTo(const Instruction *I) const {
|
2009-08-26 06:24:20 +08:00
|
|
|
return isIdenticalToWhenDefined(I) &&
|
2009-08-26 06:11:20 +08:00
|
|
|
SubclassOptionalData == I->SubclassOptionalData;
|
|
|
|
}
|
|
|
|
|
2009-08-26 06:24:20 +08:00
|
|
|
/// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it
|
2009-08-26 06:11:20 +08:00
|
|
|
/// ignores the SubclassOptionalData flags, which specify conditions
|
|
|
|
/// under which the instruction's result is undefined.
|
|
|
|
bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const {
|
2004-11-30 10:51:53 +08:00
|
|
|
if (getOpcode() != I->getOpcode() ||
|
|
|
|
getNumOperands() != I->getNumOperands() ||
|
|
|
|
getType() != I->getType())
|
|
|
|
return false;
|
|
|
|
|
2014-06-02 09:35:34 +08:00
|
|
|
// If both instructions have no operands, they are identical.
|
|
|
|
if (getNumOperands() == 0 && I->getNumOperands() == 0)
|
|
|
|
return haveSameSpecialState(this, I);
|
|
|
|
|
2004-11-30 10:51:53 +08:00
|
|
|
// We have two instructions of identical opcode and #operands. Check to see
|
|
|
|
// if all operands are the same.
|
2014-03-10 23:03:06 +08:00
|
|
|
if (!std::equal(op_begin(), op_end(), I->op_begin()))
|
|
|
|
return false;
|
2004-11-30 10:51:53 +08:00
|
|
|
|
2012-05-10 23:59:41 +08:00
|
|
|
if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
|
|
|
|
const PHINode *otherPHI = cast<PHINode>(I);
|
2014-03-10 23:03:06 +08:00
|
|
|
return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
|
|
|
|
otherPHI->block_begin());
|
2012-05-10 23:59:41 +08:00
|
|
|
}
|
2014-05-28 05:35:46 +08:00
|
|
|
|
|
|
|
return haveSameSpecialState(this, I);
|
2006-12-23 14:05:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// isSameOperationAs
|
2009-06-13 03:03:05 +08:00
|
|
|
// This should be kept in sync with isEquivalentOperation in
|
|
|
|
// lib/Transforms/IPO/MergeFunctions.cpp.
|
2012-06-28 13:42:26 +08:00
|
|
|
bool Instruction::isSameOperationAs(const Instruction *I,
|
|
|
|
unsigned flags) const {
|
|
|
|
bool IgnoreAlignment = flags & CompareIgnoringAlignment;
|
|
|
|
bool UseScalarTypes = flags & CompareUsingScalarTypes;
|
|
|
|
|
2009-06-13 03:03:05 +08:00
|
|
|
if (getOpcode() != I->getOpcode() ||
|
|
|
|
getNumOperands() != I->getNumOperands() ||
|
2012-06-28 13:42:26 +08:00
|
|
|
(UseScalarTypes ?
|
|
|
|
getType()->getScalarType() != I->getType()->getScalarType() :
|
|
|
|
getType() != I->getType()))
|
2006-12-23 14:05:41 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// We have two instructions of identical opcode and #operands. Check to see
|
|
|
|
// if all operands are the same type
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
2012-06-28 13:42:26 +08:00
|
|
|
if (UseScalarTypes ?
|
|
|
|
getOperand(i)->getType()->getScalarType() !=
|
|
|
|
I->getOperand(i)->getType()->getScalarType() :
|
|
|
|
getOperand(i)->getType() != I->getOperand(i)->getType())
|
2006-12-23 14:05:41 +08:00
|
|
|
return false;
|
|
|
|
|
2014-05-28 05:35:46 +08:00
|
|
|
return haveSameSpecialState(this, I, IgnoreAlignment);
|
2004-11-30 10:51:53 +08:00
|
|
|
}
|
|
|
|
|
2008-04-21 06:11:30 +08:00
|
|
|
/// 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 {
|
2014-03-09 11:16:01 +08:00
|
|
|
for (const Use &U : uses()) {
|
2008-04-21 06:11:30 +08:00
|
|
|
// PHI nodes uses values in the corresponding predecessor block. For other
|
|
|
|
// instructions, just check to see whether the parent of the use matches up.
|
2014-03-09 11:16:01 +08:00
|
|
|
const Instruction *I = cast<Instruction>(U.getUser());
|
|
|
|
const PHINode *PN = dyn_cast<PHINode>(I);
|
2014-04-09 14:08:46 +08:00
|
|
|
if (!PN) {
|
2014-03-09 11:16:01 +08:00
|
|
|
if (I->getParent() != BB)
|
2008-04-21 06:11:30 +08:00
|
|
|
return true;
|
|
|
|
continue;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
|
2014-03-09 11:16:01 +08:00
|
|
|
if (PN->getIncomingBlock(U) != BB)
|
2008-04-21 06:11:30 +08:00
|
|
|
return true;
|
|
|
|
}
|
2009-09-20 10:20:51 +08:00
|
|
|
return false;
|
2008-04-21 06:11:30 +08:00
|
|
|
}
|
|
|
|
|
2008-05-09 01:16:51 +08:00
|
|
|
/// mayReadFromMemory - Return true if this instruction may read memory.
|
|
|
|
///
|
|
|
|
bool Instruction::mayReadFromMemory() const {
|
|
|
|
switch (getOpcode()) {
|
|
|
|
default: return false;
|
|
|
|
case Instruction::VAArg:
|
2008-05-09 05:58:49 +08:00
|
|
|
case Instruction::Load:
|
2011-07-27 09:08:30 +08:00
|
|
|
case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory
|
2011-07-29 11:05:32 +08:00
|
|
|
case Instruction::AtomicCmpXchg:
|
|
|
|
case Instruction::AtomicRMW:
|
2008-05-09 01:16:51 +08:00
|
|
|
return true;
|
|
|
|
case Instruction::Call:
|
|
|
|
return !cast<CallInst>(this)->doesNotAccessMemory();
|
|
|
|
case Instruction::Invoke:
|
|
|
|
return !cast<InvokeInst>(this)->doesNotAccessMemory();
|
2008-05-09 05:58:49 +08:00
|
|
|
case Instruction::Store:
|
2011-08-16 05:00:18 +08:00
|
|
|
return !cast<StoreInst>(this)->isUnordered();
|
2008-05-09 01:16:51 +08:00
|
|
|
}
|
|
|
|
}
|
2008-04-21 06:11:30 +08:00
|
|
|
|
2007-02-16 07:15:00 +08:00
|
|
|
/// mayWriteToMemory - Return true if this instruction may modify memory.
|
|
|
|
///
|
|
|
|
bool Instruction::mayWriteToMemory() const {
|
|
|
|
switch (getOpcode()) {
|
|
|
|
default: return false;
|
2011-07-27 09:08:30 +08:00
|
|
|
case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory
|
2007-12-04 04:06:50 +08:00
|
|
|
case Instruction::Store:
|
2007-02-16 07:15:00 +08:00
|
|
|
case Instruction::VAArg:
|
2011-07-29 11:05:32 +08:00
|
|
|
case Instruction::AtomicCmpXchg:
|
|
|
|
case Instruction::AtomicRMW:
|
2007-02-16 07:15:00 +08:00
|
|
|
return true;
|
|
|
|
case Instruction::Call:
|
2007-12-04 04:06:50 +08:00
|
|
|
return !cast<CallInst>(this)->onlyReadsMemory();
|
2008-05-09 01:16:51 +08:00
|
|
|
case Instruction::Invoke:
|
|
|
|
return !cast<InvokeInst>(this)->onlyReadsMemory();
|
2007-02-16 07:15:00 +08:00
|
|
|
case Instruction::Load:
|
2011-08-16 05:00:18 +08:00
|
|
|
return !cast<LoadInst>(this)->isUnordered();
|
2007-02-16 07:15:00 +08:00
|
|
|
}
|
|
|
|
}
|
2002-10-31 12:14:01 +08:00
|
|
|
|
2014-09-04 05:29:59 +08:00
|
|
|
bool Instruction::isAtomic() const {
|
|
|
|
switch (getOpcode()) {
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
case Instruction::AtomicCmpXchg:
|
|
|
|
case Instruction::AtomicRMW:
|
|
|
|
case Instruction::Fence:
|
|
|
|
return true;
|
|
|
|
case Instruction::Load:
|
|
|
|
return cast<LoadInst>(this)->getOrdering() != NotAtomic;
|
|
|
|
case Instruction::Store:
|
|
|
|
return cast<StoreInst>(this)->getOrdering() != NotAtomic;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-06 14:49:50 +08:00
|
|
|
bool Instruction::mayThrow() const {
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(this))
|
|
|
|
return !CI->doesNotThrow();
|
2011-08-17 05:15:50 +08:00
|
|
|
return isa<ResumeInst>(this);
|
2009-05-06 14:49:50 +08:00
|
|
|
}
|
|
|
|
|
2013-02-20 04:02:09 +08:00
|
|
|
bool Instruction::mayReturn() const {
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(this))
|
|
|
|
return !CI->doesNotReturn();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2002-10-31 12:14:01 +08:00
|
|
|
/// isAssociative - Return true if the instruction is associative:
|
|
|
|
///
|
2009-06-05 06:49:04 +08:00
|
|
|
/// Associative operators satisfy: x op (y op z) === (x op y) op z
|
2002-10-31 12:14:01 +08:00
|
|
|
///
|
2009-06-05 06:49:04 +08:00
|
|
|
/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative.
|
2002-10-31 12:14:01 +08:00
|
|
|
///
|
2010-12-20 21:10:23 +08:00
|
|
|
bool Instruction::isAssociative(unsigned Opcode) {
|
2009-06-05 06:49:04 +08:00
|
|
|
return Opcode == And || Opcode == Or || Opcode == Xor ||
|
|
|
|
Opcode == Add || Opcode == Mul;
|
2002-10-31 12:14:01 +08:00
|
|
|
}
|
|
|
|
|
2012-11-29 09:47:31 +08:00
|
|
|
bool Instruction::isAssociative() const {
|
|
|
|
unsigned Opcode = getOpcode();
|
|
|
|
if (isAssociative(Opcode))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
switch (Opcode) {
|
|
|
|
case FMul:
|
|
|
|
case FAdd:
|
|
|
|
return cast<FPMathOperator>(this)->hasUnsafeAlgebra();
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-10-31 12:14:01 +08:00
|
|
|
/// isCommutative - Return true if the instruction is commutative:
|
|
|
|
///
|
2003-10-11 01:54:14 +08:00
|
|
|
/// Commutative operators satisfy: (x op y) === (y op x)
|
2002-10-31 12:14:01 +08:00
|
|
|
///
|
|
|
|
/// In LLVM, these are the associative operators, plus SetEQ and SetNE, when
|
|
|
|
/// applied to any type.
|
|
|
|
///
|
|
|
|
bool Instruction::isCommutative(unsigned op) {
|
|
|
|
switch (op) {
|
|
|
|
case Add:
|
2009-06-05 06:49:04 +08:00
|
|
|
case FAdd:
|
2002-10-31 12:14:01 +08:00
|
|
|
case Mul:
|
2009-06-05 06:49:04 +08:00
|
|
|
case FMul:
|
2005-04-22 07:48:37 +08:00
|
|
|
case And:
|
2002-10-31 12:14:01 +08:00
|
|
|
case Or:
|
|
|
|
case Xor:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2003-07-31 12:05:50 +08:00
|
|
|
|
Now that Reassociate's LinearizeExprTree can look through arbitrary expression
topologies, it is quite possible for a leaf node to have huge multiplicity, for
example: x0 = x*x, x1 = x0*x0, x2 = x1*x1, ... rapidly gives a value which is x
raised to a vast power (the multiplicity, or weight, of x). This patch fixes
the computation of weights by correctly computing them no matter how big they
are, rather than just overflowing and getting a wrong value. It turns out that
the weight for a value never needs more bits to represent than the value itself,
so it is enough to represent weights as APInts of the same bitwidth and do the
right overflow-avoiding dance steps when computing weights. As a side-effect it
reduces the number of multiplies needed in some cases of large powers. While
there, in view of external uses (eg by the vectorizer) I made LinearizeExprTree
static, pushing the rank computation out into users. This is progress towards
fixing PR13021.
llvm-svn: 158358
2012-06-12 22:33:56 +08:00
|
|
|
/// isIdempotent - Return true if the instruction is idempotent:
|
|
|
|
///
|
|
|
|
/// Idempotent operators satisfy: x op x === x
|
|
|
|
///
|
|
|
|
/// In LLVM, the And and Or operators are idempotent.
|
|
|
|
///
|
|
|
|
bool Instruction::isIdempotent(unsigned Opcode) {
|
|
|
|
return Opcode == And || Opcode == Or;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isNilpotent - Return true if the instruction is nilpotent:
|
|
|
|
///
|
|
|
|
/// Nilpotent operators satisfy: x op x === Id,
|
|
|
|
///
|
|
|
|
/// where Id is the identity for the operator, i.e. a constant such that
|
|
|
|
/// x op Id === x and Id op x === x for all x.
|
|
|
|
///
|
|
|
|
/// In LLVM, the Xor operator is nilpotent.
|
|
|
|
///
|
|
|
|
bool Instruction::isNilpotent(unsigned Opcode) {
|
|
|
|
return Opcode == Xor;
|
|
|
|
}
|
|
|
|
|
2009-10-28 06:16:29 +08:00
|
|
|
Instruction *Instruction::clone() const {
|
|
|
|
Instruction *New = clone_impl();
|
|
|
|
New->SubclassOptionalData = SubclassOptionalData;
|
2009-12-29 15:44:16 +08:00
|
|
|
if (!hasMetadata())
|
|
|
|
return New;
|
2012-11-16 06:34:00 +08:00
|
|
|
|
2009-12-29 15:44:16 +08:00
|
|
|
// Otherwise, enumerate and copy over metadata from the old instruction to the
|
|
|
|
// new one.
|
2014-11-12 05:30:22 +08:00
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs;
|
2011-07-15 02:57:51 +08:00
|
|
|
getAllMetadataOtherThanDebugLoc(TheMDs);
|
2014-03-10 23:03:06 +08:00
|
|
|
for (const auto &MD : TheMDs)
|
|
|
|
New->setMetadata(MD.first, MD.second);
|
2012-11-16 06:34:00 +08:00
|
|
|
|
2011-07-15 02:57:51 +08:00
|
|
|
New->setDebugLoc(getDebugLoc());
|
2009-10-28 06:16:29 +08:00
|
|
|
return New;
|
|
|
|
}
|