X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FInstruction.cpp;h=5107b74417a549afffc88446b30971db7622a386;hb=e6be34a53ecbe8c2ff9f0793b13d847e94c0de91;hp=aa3beb3f52fe0783330db873ea1adde8145f95ff;hpb=699a7bfd6b0c789e7e04c0e182d7518b34b514b0;p=oota-llvm.git diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp index aa3beb3f52f..5107b74417a 100644 --- a/lib/VMCore/Instruction.cpp +++ b/lib/VMCore/Instruction.cpp @@ -1,54 +1,273 @@ -//===-- Instruction.cpp - Implement the Instruction class --------*- C++ -*--=// +//===-- Instruction.cpp - Implement the Instruction class -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // This file implements the Instruction class for the VMCore library. // //===----------------------------------------------------------------------===// -#include "llvm/Instruction.h" -#include "llvm/Method.h" -#include "llvm/SymbolTable.h" -#include "llvm/CodeGen/MachineInstr.h" +#include "llvm/Type.h" +#include "llvm/Instructions.h" +#include "llvm/Function.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 *InsertBefore) + : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { + // Make sure that we get added to a basicblock + LeakDetector::addGarbageObject(this); -Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name) - : User(ty, Value::InstructionVal, Name), - machineInstrVec(new MachineCodeForVMInstr) { - Parent = 0; - iType = it; + // 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); + } } +Instruction::Instruction(const 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 + 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); +} + + +// Out of line virtual method, so the vtable, etc has a home. Instruction::~Instruction() { - assert(getParent() == 0 && "Instruction still embedded in basic block!"); - delete machineInstrVec; + assert(Parent == 0 && "Instruction still linked in the program!"); +} + + +void Instruction::setParent(BasicBlock *P) { + if (getParent()) { + if (!P) LeakDetector::addGarbageObject(this); + } else { + if (P) LeakDetector::removeGarbageObject(this); + } + + Parent = P; +} + +void Instruction::removeFromParent() { + getParent()->getInstList().remove(this); } -// Specialize setName to take care of symbol table majik -void Instruction::setName(const std::string &name, SymbolTable *ST) { - BasicBlock *P = 0; Method *PP = 0; - assert((ST == 0 || !getParent() || !getParent()->getParent() || - ST == getParent()->getParent()->getSymbolTable()) && - "Invalid symtab argument!"); - if ((P = getParent()) && (PP = P->getParent()) && hasName()) - PP->getSymbolTable()->remove(this); - Value::setName(name); - if (PP && hasName()) PP->getSymbolTableSure()->insert(this); +void Instruction::eraseFromParent() { + getParent()->getInstList().erase(this); } -void Instruction::addMachineInstruction(MachineInstr* minstr) { - machineInstrVec->push_back(minstr); +/// 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); +} + + +const char *Instruction::getOpcodeName(unsigned OpCode) { + switch (OpCode) { + // Terminators + case Ret: return "ret"; + case Br: return "br"; + case Switch: return "switch"; + case Invoke: return "invoke"; + case Unwind: return "unwind"; + case Unreachable: return "unreachable"; + + // Standard binary operators... + case Add: return "add"; + case Sub: return "sub"; + case Mul: return "mul"; + case UDiv: return "udiv"; + case SDiv: return "sdiv"; + case FDiv: return "fdiv"; + case URem: return "urem"; + case SRem: return "srem"; + case FRem: return "frem"; + + // Logical operators... + case And: return "and"; + case Or : return "or"; + 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 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 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 GetResult: return "getresult"; + + 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 { + if (getOpcode() != I->getOpcode() || + getNumOperands() != I->getNumOperands() || + getType() != I->getType()) + return false; + + // 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; + + // 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; +} + +// 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::Invoke: + case Instruction::Store: + case Instruction::VAArg: + return true; + case Instruction::Call: + return !cast(this)->onlyReadsMemory(); + case Instruction::Load: + return cast(this)->isVolatile(); + } +} + +/// isAssociative - Return true if the instruction is associative: +/// +/// 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. +/// +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; } -#if 0 -// Dont make this inline because you would need to include -// MachineInstr.h in Instruction.h, which creates a circular -// sequence of forward declarations. Trying to fix that will -// cause a serious circularity in link order. -// -const std::vector &Instruction::getTempValuesForMachineCode() const { - return machineInstrVec->getTempValues(); +/// isCommutative - Return true if the instruction is commutative: +/// +/// Commutative operators satisfy: (x op y) === (y op x) +/// +/// 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: + case Mul: + case And: + case Or: + case Xor: + return true; + default: + return false; + } } -#endif -void Instruction::dropAllReferences() { - machineInstrVec->dropAllReferences(); - User::dropAllReferences(); +/// 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; + } }