X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FInstruction.cpp;h=48c73a08400c076316c5247ac002c6ca8fd396fe;hb=fadb3f773e5ab171315761d151c1416921d25614;hp=70b375902dc63e60fd8707109faf79f634f724a8;hpb=3822ff5c71478c7c90a50ca57045fb676fcb5005;p=oota-llvm.git diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp index 70b375902dc..48c73a08400 100644 --- a/lib/VMCore/Instruction.cpp +++ b/lib/VMCore/Instruction.cpp @@ -11,16 +11,16 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Type.h" #include "llvm/Instructions.h" +#include "llvm/IntrinsicInst.h" #include "llvm/Function.h" -#include "llvm/SymbolTable.h" -#include "llvm/Type.h" #include "llvm/Support/LeakDetector.h" using namespace llvm; Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, const std::string &Name, Instruction *InsertBefore) - : User(ty, Value::InstructionVal + it, Ops, NumOps, Name), Parent(0) { + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { // Make sure that we get added to a basicblock LeakDetector::addGarbageObject(this); @@ -30,29 +30,55 @@ Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, "Instruction to insert before is not in a basic block!"); InsertBefore->getParent()->getInstList().insert(InsertBefore, this); } + setName(Name); } Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, const std::string &Name, BasicBlock *InsertAtEnd) - : User(ty, Value::InstructionVal + it, Ops, NumOps, Name), Parent(0) { + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { // Make sure that we get added to a basicblock LeakDetector::addGarbageObject(this); // append this instruction into the basic block assert(InsertAtEnd && "Basic block to append to may not be NULL!"); InsertAtEnd->getInstList().push_back(this); + setName(Name); } +Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, + const char *Name, Instruction *InsertBefore) + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { + // Make sure that we get added to a basicblock + LeakDetector::addGarbageObject(this); + + // 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); + } + if (Name && *Name) setName(Name); +} + +Instruction::Instruction(const Type *ty, unsigned it, Use *Ops, unsigned NumOps, + const char *Name, BasicBlock *InsertAtEnd) + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { + // Make sure that we get added to a basicblock + LeakDetector::addGarbageObject(this); + + // append this instruction into the basic block + assert(InsertAtEnd && "Basic block to append to may not be NULL!"); + InsertAtEnd->getInstList().push_back(this); + if (Name && *Name) setName(Name); +} + + // Out of line virtual method, so the vtable, etc has a home. Instruction::~Instruction() { assert(Parent == 0 && "Instruction still linked in the program!"); } -void Instruction::setOpcode(unsigned opc) { - setValueType(Value::InstructionVal + opc); -} - void Instruction::setParent(BasicBlock *P) { if (getParent()) { if (!P) LeakDetector::addGarbageObject(this); @@ -106,14 +132,6 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Or : return "or"; case Xor: return "xor"; - // SetCC operators... - case SetLE: return "setle"; - case SetGE: return "setge"; - case SetLT: return "setlt"; - case SetGT: return "setgt"; - case SetEQ: return "seteq"; - case SetNE: return "setne"; - // Memory instructions... case Malloc: return "malloc"; case Free: return "free"; @@ -122,18 +140,33 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Store: return "store"; 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"; + // Other instructions... - case PHI: return "phi"; - case Cast: return "cast"; - 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"; + case ICmp: return "icmp"; + case FCmp: return "fcmp"; + 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"; case ExtractElement: return "extractelement"; - case InsertElement: return "insertelement"; - case ShuffleVector: return "shufflevector"; + case InsertElement: return "insertelement"; + case ShuffleVector: return "shufflevector"; default: return " "; } @@ -161,11 +194,57 @@ bool Instruction::isIdenticalTo(Instruction *I) const { return LI->isVolatile() == cast(I)->isVolatile(); if (const StoreInst *SI = dyn_cast(this)) return SI->isVolatile() == cast(I)->isVolatile(); + 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 true; +} + +// isSameOperationAs +bool Instruction::isSameOperationAs(Instruction *I) const { + if (getOpcode() != I->getOpcode() || getType() != I->getType() || + getNumOperands() != I->getNumOperands()) + 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) + if (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(); + if (const StoreInst *SI = dyn_cast(this)) + return SI->isVolatile() == cast(I)->isVolatile(); + 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 true; } +/// mayWriteToMemory - Return true if this instruction may modify memory. +/// +bool Instruction::mayWriteToMemory() const { + switch (getOpcode()) { + default: return false; + case Instruction::Free: + case Instruction::Store: + case Instruction::Invoke: + case Instruction::VAArg: + return true; + case Instruction::Call: + if (const IntrinsicInst *II = dyn_cast(this)) { + // If the intrinsic doesn't write memory, it is safe. + } + return true; + case Instruction::Load: + return cast(this)->isVolatile(); + } +} /// isAssociative - Return true if the instruction is associative: /// @@ -198,31 +277,12 @@ bool Instruction::isCommutative(unsigned op) { case And: case Or: case Xor: - case SetEQ: - case SetNE: return true; default: return false; } } -/// isComparison - Return true if the instruction is a Set* instruction: -/// -bool Instruction::isComparison(unsigned op) { - switch (op) { - case SetEQ: - case SetNE: - case SetLT: - case SetGT: - case SetLE: - case SetGE: - return true; - } - return false; -} - - - /// isTrappingInstruction - Return true if the instruction may trap. /// bool Instruction::isTrapping(unsigned op) {