[turbofan] Machine operators are globally shared singletons.

src/compiler/raw-machine-assembler.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_RAW_MACHINE_ASSEMBLER_H_
 #define V8_COMPILER_RAW_MACHINE_ASSEMBLER_H_
 
 #ifdef USE_SIMULATOR
 #define MACHINE_ASSEMBLER_SUPPORTS_CALL_C 0
 #else
@@ skipping 90 matching lines @@
   Node* Load(MachineType rep, Node* base) {
     return Load(rep, base, Int32Constant(0));
   }
   Node* Load(MachineType rep, Node* base, Node* index) {
     return NewNode(machine()->Load(rep), base, index);
   }
   void Store(MachineType rep, Node* base, Node* value) {
     Store(rep, base, Int32Constant(0), value);
   }
   void Store(MachineType rep, Node* base, Node* index, Node* value) {
-    NewNode(machine()->Store(rep, kNoWriteBarrier), base, index, value);
+    NewNode(machine()->Store(StoreRepresentation(rep, kNoWriteBarrier)), base,
+            index, value);
   }
   // Arithmetic Operations.
   Node* WordAnd(Node* a, Node* b) {
     return NewNode(machine()->WordAnd(), a, b);
   }
   Node* WordOr(Node* a, Node* b) { return NewNode(machine()->WordOr(), a, b); }
   Node* WordXor(Node* a, Node* b) {
     return NewNode(machine()->WordXor(), a, b);
   }
   Node* WordShl(Node* a, Node* b) {
     return NewNode(machine()->WordShl(), a, b);
   }
   Node* WordShr(Node* a, Node* b) {
     return NewNode(machine()->WordShr(), a, b);
   }
   Node* WordSar(Node* a, Node* b) {
     return NewNode(machine()->WordSar(), a, b);
   }
   Node* WordRor(Node* a, Node* b) {
     return NewNode(machine()->WordRor(), a, b);
   }
   Node* WordEqual(Node* a, Node* b) {
     return NewNode(machine()->WordEqual(), a, b);
   }
   Node* WordNotEqual(Node* a, Node* b) {
     return WordBinaryNot(WordEqual(a, b));
   }
   Node* WordNot(Node* a) {
-    if (machine()->is32()) {
+    if (machine()->Is32()) {
       return Word32Not(a);
     } else {
       return Word64Not(a);
     }
   }
   Node* WordBinaryNot(Node* a) {
-    if (machine()->is32()) {
+    if (machine()->Is32()) {
       return Word32BinaryNot(a);
     } else {
       return Word64BinaryNot(a);
     }
   }
 
   Node* Word32And(Node* a, Node* b) {
     return NewNode(machine()->Word32And(), a, b);
   }
   Node* Word32Or(Node* a, Node* b) {
@@ skipping 290 matching lines @@
   BasicBlock* current_block_;
 
   DISALLOW_COPY_AND_ASSIGN(RawMachineAssembler);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_RAW_MACHINE_ASSEMBLER_H_