[turbofan] Refactor the InstructionSelector tests.

src/compiler/machine-node-factory.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_MACHINE_NODE_FACTORY_H_
 #define V8_COMPILER_MACHINE_NODE_FACTORY_H_
 
 #ifdef USE_SIMULATOR
 #define MACHINE_ASSEMBLER_SUPPORTS_CALL_C 0
 #else
@@ skipping 100 matching lines @@
   }
   Node* WordShl(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->WordShl(), a, b);
   }
   Node* WordShr(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->WordShr(), a, b);
   }
   Node* WordSar(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->WordSar(), a, b);
   }
+  Node* WordRor(Node* a, Node* b) {
+    if (MACHINE()->is32()) {
+      return Word32Ror(a, b);
+    } else {
+      return Word64Ror(a, b);
+    }
+  }
   Node* WordEqual(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->WordEqual(), a, b);
   }
   Node* WordNotEqual(Node* a, Node* b) {
     return WordBinaryNot(WordEqual(a, b));
   }
   Node* WordNot(Node* a) {
     if (MACHINE()->is32()) {
       return Word32Not(a);
     } else {
@@ skipping 19 matching lines @@
   }
   Node* Word32Shl(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word32Shl(), a, b);
   }
   Node* Word32Shr(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word32Shr(), a, b);
   }
   Node* Word32Sar(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word32Sar(), a, b);
   }
+  Node* Word32Ror(Node* a, Node* b) {
+    return Word32Or(Word32Shl(a, Int32Sub(Int32Constant(32), b)),
+                    Word32Shr(a, b));
+  }
   Node* Word32Equal(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word32Equal(), a, b);
   }
   Node* Word32NotEqual(Node* a, Node* b) {
     return Word32BinaryNot(Word32Equal(a, b));
   }
   Node* Word32Not(Node* a) { return Word32Xor(a, Int32Constant(-1)); }
   Node* Word32BinaryNot(Node* a) { return Word32Equal(a, Int32Constant(0)); }
 
   Node* Word64And(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64And(), a, b);
   }
   Node* Word64Or(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Or(), a, b);
   }
   Node* Word64Xor(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Xor(), a, b);
   }
   Node* Word64Shl(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Shl(), a, b);
   }
   Node* Word64Shr(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Shr(), a, b);
   }
   Node* Word64Sar(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Sar(), a, b);
   }
+  Node* Word64Ror(Node* a, Node* b) {
+    return Word64Or(Word64Shl(a, Int64Sub(Int64Constant(64), b)),
+                    Word64Shr(a, b));
+  }
   Node* Word64Equal(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Equal(), a, b);
   }
   Node* Word64NotEqual(Node* a, Node* b) {
     return Word64BinaryNot(Word64Equal(a, b));
   }
   Node* Word64Not(Node* a) { return Word64Xor(a, Int64Constant(-1)); }
   Node* Word64BinaryNot(Node* a) { return Word64Equal(a, Int64Constant(0)); }
 
   Node* Int32Add(Node* a, Node* b) {
@@ skipping 175 matching lines @@
 #undef NEW_NODE_3
 #undef MACHINE
 #undef COMMON
 #undef ZONE
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_MACHINE_NODE_FACTORY_H_