[turbofan] Fix the node matchers.

src/compiler/representation-change.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_REPRESENTATION_CHANGE_H_
 #define V8_COMPILER_REPRESENTATION_CHANGE_H_
 
 #include "src/base/bits.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 56 matching lines @@
   }
 
   Node* GetTaggedRepresentationFor(Node* node, MachineTypeUnion output_type) {
     // Eagerly fold representation changes for constants.
     switch (node->opcode()) {
       case IrOpcode::kNumberConstant:
       case IrOpcode::kHeapConstant:
         return node;  // No change necessary.
       case IrOpcode::kInt32Constant:
         if (output_type & kTypeUint32) {
-          uint32_t value = ValueOf<uint32_t>(node->op());
+          uint32_t value = OpParameter<uint32_t>(node);
           return jsgraph()->Constant(static_cast<double>(value));
         } else if (output_type & kTypeInt32) {
-          int32_t value = ValueOf<int32_t>(node->op());
+          int32_t value = OpParameter<int32_t>(node);
           return jsgraph()->Constant(value);
         } else if (output_type & kRepBit) {
-          return ValueOf<int32_t>(node->op()) == 0 ? jsgraph()->FalseConstant()
-                                                   : jsgraph()->TrueConstant();
+          return OpParameter<int32_t>(node) == 0 ? jsgraph()->FalseConstant()
+                                                 : jsgraph()->TrueConstant();
         } else {
           return TypeError(node, output_type, kRepTagged);
         }
       case IrOpcode::kFloat64Constant:
-        return jsgraph()->Constant(ValueOf<double>(node->op()));
+        return jsgraph()->Constant(OpParameter<double>(node));
       default:
         break;
     }
     // Select the correct X -> Tagged operator.
     Operator* op;
     if (output_type & kRepBit) {
       op = simplified()->ChangeBitToBool();
     } else if (output_type & rWord) {
       if (output_type & kTypeUint32) {
         op = simplified()->ChangeUint32ToTagged();
       } else if (output_type & kTypeInt32) {
         op = simplified()->ChangeInt32ToTagged();
       } else {
         return TypeError(node, output_type, kRepTagged);
       }
     } else if (output_type & kRepFloat64) {
       op = simplified()->ChangeFloat64ToTagged();
     } else {
       return TypeError(node, output_type, kRepTagged);
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
   Node* GetFloat64RepresentationFor(Node* node, MachineTypeUnion output_type) {
     // Eagerly fold representation changes for constants.
     switch (node->opcode()) {
       case IrOpcode::kNumberConstant:
-        return jsgraph()->Float64Constant(ValueOf<double>(node->op()));
+        return jsgraph()->Float64Constant(OpParameter<double>(node));
       case IrOpcode::kInt32Constant:
         if (output_type & kTypeUint32) {
-          uint32_t value = ValueOf<uint32_t>(node->op());
+          uint32_t value = OpParameter<uint32_t>(node);
           return jsgraph()->Float64Constant(static_cast<double>(value));
         } else {
-          int32_t value = ValueOf<int32_t>(node->op());
+          int32_t value = OpParameter<int32_t>(node);
           return jsgraph()->Float64Constant(value);
         }
       case IrOpcode::kFloat64Constant:
         return node;  // No change necessary.
       default:
         break;
     }
     // Select the correct X -> Float64 operator.
     Operator* op;
     if (output_type & kRepBit) {
@@ skipping 13 matching lines @@
   }
 
   Node* GetWord32RepresentationFor(Node* node, MachineTypeUnion output_type,
                                    bool use_unsigned) {
     // Eagerly fold representation changes for constants.
     switch (node->opcode()) {
       case IrOpcode::kInt32Constant:
         return node;  // No change necessary.
       case IrOpcode::kNumberConstant:
       case IrOpcode::kFloat64Constant: {
-        double value = ValueOf<double>(node->op());
+        double value = OpParameter<double>(node);
         if (value < 0) {
           DCHECK(IsInt32Double(value));
           int32_t iv = static_cast<int32_t>(value);
           return jsgraph()->Int32Constant(iv);
         } else {
           DCHECK(IsUint32Double(value));
           int32_t iv = static_cast<int32_t>(static_cast<uint32_t>(value));
           return jsgraph()->Int32Constant(iv);
         }
       }
@@ skipping 17 matching lines @@
     } else {
       return TypeError(node, output_type, kRepWord32);
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
   Node* GetBitRepresentationFor(Node* node, MachineTypeUnion output_type) {
     // Eagerly fold representation changes for constants.
     switch (node->opcode()) {
       case IrOpcode::kInt32Constant: {
-        int32_t value = ValueOf<int32_t>(node->op());
+        int32_t value = OpParameter<int32_t>(node);
         if (value == 0 || value == 1) return node;
         return jsgraph()->OneConstant();  // value != 0
       }
       case IrOpcode::kHeapConstant: {
-        Handle<Object> handle = ValueOf<Handle<Object> >(node->op());
+        Handle<Object> handle = OpParameter<Unique<Object> >(node).handle();
         DCHECK(*handle == isolate()->heap()->true_value() ||
                *handle == isolate()->heap()->false_value());
         return jsgraph()->Int32Constant(
             *handle == isolate()->heap()->true_value() ? 1 : 0);
       }
       default:
         break;
     }
     // Select the correct X -> Bit operator.
     Operator* op;
@@ skipping 128 matching lines @@
   JSGraph* jsgraph() { return jsgraph_; }
   Isolate* isolate() { return isolate_; }
   SimplifiedOperatorBuilder* simplified() { return simplified_; }
   MachineOperatorBuilder* machine() { return machine_; }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_