Implementation of the new spiffy pass system

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

diff --git a/lib/VMCore/iOperators.cpp b/lib/VMCore/iOperators.cpp
index 61d5d26d2b4194033654a747ed836b4b0c834080..c2fe1bc04a1b64e0204eca16480332b9b46a71f6 100644 (file)
--- a/lib/VMCore/iOperators.cpp
+++ b/lib/VMCore/iOperators.cpp
@@ -1,14 +1,50 @@
-//===-- iBinaryOperators.cpp - Implement the BinaryOperators -----*- C++ -*--=//
+//===-- iOperators.cpp - Implement the Binary & Unary Operators --*- C++ -*--=//
 //
-// This file implements the nontrivial binary operator instructions.
+// This file implements the nontrivial binary & unary operator instructions.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/iBinary.h"
+#include "llvm/iOperators.h"
 #include "llvm/Type.h"
+#include <iostream>
+using std::cerr;
+
+//===----------------------------------------------------------------------===//
+//                              UnaryOperator Class
+//===----------------------------------------------------------------------===//
+
+UnaryOperator *UnaryOperator::create(UnaryOps Op, Value *Source) {
+  switch (Op) {
+  case Not:  return new GenericUnaryInst(Op, Source);
+  default:
+    cerr << "Don't know how to Create UnaryOperator " << Op << "\n";
+    return 0;
+  }
+}
+
+
+//===----------------------------------------------------------------------===//
+//                           GenericUnaryOperator Class
+//===----------------------------------------------------------------------===//
+
+const char *GenericUnaryInst::getOpcodeName() const {
+  switch (getOpcode()) {
+  case Not: return "not";
+  case Cast: return "cast";
+  default:
+    cerr << "Invalid unary operator type!" << getOpcode() << "\n";
+    abort();
+  }
+  return 0;
+}
+
+
+//===----------------------------------------------------------------------===//
+//                             BinaryOperator Class
+//===----------------------------------------------------------------------===//
 
 BinaryOperator *BinaryOperator::create(BinaryOps Op, Value *S1, Value *S2,
-                                      const string &Name) {
+                                      const std::string &Name) {
   switch (Op) {
   // Binary comparison operators...
   case SetLT: case SetGT: case SetLE:
@@ -20,6 +56,37 @@ BinaryOperator *BinaryOperator::create(BinaryOps Op, Value *S1, Value *S2,
   }
 }
 
+// swapOperands - Exchange the two operands to this instruction.  This
+// instruction is safe to use on any binary instruction and does not
+// modify the semantics of the instruction.  If the instruction is
+// order dependant (SetLT f.e.) the opcode is changed.
+//
+bool BinaryOperator::swapOperands() {
+  switch (getOpcode()) {
+    // Instructions that don't need opcode modification
+  case Add: case Mul:
+  case And: case Xor:
+  case Or:
+  case SetEQ: case SetNE:
+    break;
+    // Instructions that need opcode modification
+  case SetGT: iType = SetLT; break;
+  case SetLT: iType = SetGT; break;
+  case SetGE: iType = SetLE; break;
+  case SetLE: iType = SetGE; break;
+    // Error on the side of caution
+  default:
+    return true;
+  }
+  std::swap(Operands[0], Operands[1]);
+  return false;
+}
+
+
+//===----------------------------------------------------------------------===//
+//                            GenericBinaryInst Class
+//===----------------------------------------------------------------------===//
+
 const char *GenericBinaryInst::getOpcodeName() const {
   switch (getOpcode()) {
   // Standard binary operators...
@@ -34,17 +101,19 @@ const char *GenericBinaryInst::getOpcodeName() const {
   case Or : return "or";
   case Xor: return "xor";
   default:
-    cerr << "Invalid binary operator type!" << getOpcode() << endl;
-    return 0;
+    cerr << "Invalid binary operator type!" << getOpcode() << "\n";
+    abort();
   }
+  return 0;
 }
 
+
 //===----------------------------------------------------------------------===//
 //                             SetCondInst Class
 //===----------------------------------------------------------------------===//
 
 SetCondInst::SetCondInst(BinaryOps opType, Value *S1, Value *S2, 
-                         const string &Name) 
+                         const std::string &Name) 
   : BinaryOperator(opType, S1, S2, Name) {
 
   OpType = opType;