Add some missing node names

[oota-llvm.git] / lib / VMCore / Instruction.cpp

diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp
index b009c01eecb7cae95c16657e458b950949cad58f..a44b5e4b11ae410e338c5493c6b98fddcd64cacc 100644 (file)
--- a/lib/VMCore/Instruction.cpp
+++ b/lib/VMCore/Instruction.cpp
@@ -1,28 +1,26 @@
 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
-// 
+//
 //                     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 implements the Instruction class for the VMCore library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Instructions.h"
 #include "llvm/Function.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/Type.h"
-#include "Support/LeakDetector.h"
+#include "llvm/Support/LeakDetector.h"
 using namespace llvm;
 
-Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
-                         Instruction *InsertBefore)
-  : User(ty, Value::InstructionVal, Name) {
-  Parent = 0;
-  iType = it;
-
+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) {
   // Make sure that we get added to a basicblock
   LeakDetector::addGarbageObject(this);
 
@@ -34,6 +32,21 @@ Instruction::Instruction(const Type *ty, unsigned it, const std::string &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) {
+  // 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);
+}
+
+void Instruction::setOpcode(unsigned opc) {
+  setValueType(Value::InstructionVal + opc);
+}
+
 void Instruction::setParent(BasicBlock *P) {
   if (getParent()) {
     if (!P) LeakDetector::addGarbageObject(this);
@@ -44,16 +57,20 @@ void Instruction::setParent(BasicBlock *P) {
   Parent = P;
 }
 
-// Specialize setName to take care of symbol table majik
-void Instruction::setName(const std::string &name, SymbolTable *ST) {
-  BasicBlock *P = 0; Function *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->getSymbolTable().insert(this);
+void Instruction::removeFromParent() {
+  getParent()->getInstList().remove(this);
+}
+
+void Instruction::eraseFromParent() {
+  getParent()->getInstList().erase(this);
+}
+
+/// 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);
 }
 
 
@@ -65,7 +82,8 @@ const char *Instruction::getOpcodeName(unsigned OpCode) {
   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";
@@ -85,7 +103,7 @@ const char *Instruction::getOpcodeName(unsigned OpCode) {
   case SetGT:  return "setgt";
   case SetEQ:  return "seteq";
   case SetNE:  return "setne";
-    
+
   // Memory instructions...
   case Malloc:        return "malloc";
   case Free:          return "free";
@@ -93,22 +111,49 @@ const char *Instruction::getOpcodeName(unsigned OpCode) {
   case Load:          return "load";
   case Store:         return "store";
   case GetElementPtr: return "getelementptr";
-    
+
   // Other instructions...
   case PHI:     return "phi";
   case Cast:    return "cast";
+  case Select:  return "select";
   case Call:    return "call";
   case Shl:     return "shl";
   case Shr:     return "shr";
-  case VANext:  return "vanext";
-  case VAArg:   return "vaarg";
+  case VAArg:   return "va_arg";
+  case ExtractElement: return "extractelement";
+  case InsertElement: return "insertelement";
 
   default: return "<Invalid operator> ";
   }
-  
+
   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<LoadInst>(this))
+    return LI->isVolatile() == cast<LoadInst>(I)->isVolatile();
+  if (const StoreInst *SI = dyn_cast<StoreInst>(this))
+    return SI->isVolatile() == cast<StoreInst>(I)->isVolatile();
+  if (const CallInst *CI = dyn_cast<CallInst>(this))
+    return CI->isTailCall() == cast<CallInst>(I)->isTailCall();
+  return true;
+}
+
 
 /// isAssociative - Return true if the instruction is associative:
 ///
@@ -137,7 +182,7 @@ bool Instruction::isCommutative(unsigned op) {
   switch (op) {
   case Add:
   case Mul:
-  case And: 
+  case And:
   case Or:
   case Xor:
   case SetEQ: