New isAssociative/isCommutative inspection methods, graciously contributed by

Casey Carter.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4459 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index 89c64098c3c279a800318b902b3ab4975e91b437..ca01e30fe54776a5ba98b5beeade4acfcf122d73 100644 (file)
--- a/include/llvm/Instruction.h
+++ b/include/llvm/Instruction.h
@@ -74,6 +74,27 @@ public:
     return iType >= BinaryOpsBegin && iType < BinaryOpsEnd;
   }
 
+  /// 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 isAssociative() const { return isAssociative(getOpcode(), getType()); }
+  static bool isAssociative(unsigned op, const Type *Ty);
+
+  /// isCommutative - Return true if the instruction is commutative:
+  ///
+  ///   Commutative operators satistify: (x op y) === (y op x)
+  ///
+  /// In LLVM, these are the associative operators, plus SetEQ and SetNE, when
+  /// applied to any type.
+  ///
+  bool isCommutative() const { return isCommutative(getOpcode()); }
+  static bool isCommutative(unsigned op);
+
+
   virtual void print(std::ostream &OS) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:

diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp
index 2084e69ede6e490f70c228bc85b771b3b57e7a5a..95267aacd02154a5bdfaefdfd0208aa44014f53b 100644 (file)
--- a/lib/VMCore/Instruction.cpp
+++ b/lib/VMCore/Instruction.cpp
@@ -97,3 +97,42 @@ const char *Instruction::getOpcodeName(unsigned OpCode) {
   
   return 0;
 }
+
+
+/// 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 == Add || Opcode == Mul ||
+      Opcode == And || Opcode == Or || Opcode == Xor) {
+    // Floating point operations do not associate!
+    return !Ty->isFloatingPoint();
+  }
+  return 0;
+}
+
+/// isCommutative - Return true if the instruction is commutative:
+///
+///   Commutative operators satistify: (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:
+  case SetEQ:
+  case SetNE:
+    return true;
+  default:
+    return false;
+  }
+}