[turbofan] Next step towards shared operators.

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 73 matching lines @@
                                                  : jsgraph()->TrueConstant();
         } else {
           return TypeError(node, output_type, kRepTagged);
         }
       case IrOpcode::kFloat64Constant:
         return jsgraph()->Constant(OpParameter<double>(node));
       default:
         break;
     }
     // Select the correct X -> Tagged operator.
-    Operator* op;
+    const 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);
       }
@@ skipping 17 matching lines @@
         } else {
           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;
+    const Operator* op;
     if (output_type & kRepBit) {
       return TypeError(node, output_type, kRepFloat64);
     } else if (output_type & rWord) {
       if (output_type & kTypeUint32) {
         op = machine()->ChangeUint32ToFloat64();
       } else {
         op = machine()->ChangeInt32ToFloat64();
       }
     } else if (output_type & kRepTagged) {
       op = simplified()->ChangeTaggedToFloat64();
@@ skipping 19 matching lines @@
         } else {
           DCHECK(IsUint32Double(value));
           int32_t iv = static_cast<int32_t>(static_cast<uint32_t>(value));
           return jsgraph()->Int32Constant(iv);
         }
       }
       default:
         break;
     }
     // Select the correct X -> Word32 operator.
-    Operator* op = NULL;
+    const Operator* op = NULL;
     if (output_type & kRepFloat64) {
       if (output_type & kTypeUint32 || use_unsigned) {
         op = machine()->ChangeFloat64ToUint32();
       } else {
         op = machine()->ChangeFloat64ToInt32();
       }
     } else if (output_type & kRepTagged) {
       if (output_type & kTypeUint32 || use_unsigned) {
         op = simplified()->ChangeTaggedToUint32();
       } else {
@@ skipping 17 matching lines @@
         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;
+    const Operator* op;
     if (output_type & rWord) {
       return node;  // No change necessary.
     } else if (output_type & kRepWord64) {
       return node;  // TODO(titzer): No change necessary, on 64-bit.
     } else if (output_type & kRepTagged) {
       op = simplified()->ChangeBoolToBit();
     } else {
       return TypeError(node, output_type, kRepBit);
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
   Node* GetWord64RepresentationFor(Node* node, MachineTypeUnion output_type) {
     if (output_type & kRepBit) {
       return node;  // Sloppy comparison -> word64
     }
     // Can't really convert Word64 to anything else. Purported to be internal.
     return TypeError(node, output_type, kRepWord64);
   }
 
-  Operator* Int32OperatorFor(IrOpcode::Value opcode) {
+  const Operator* Int32OperatorFor(IrOpcode::Value opcode) {
     switch (opcode) {
       case IrOpcode::kNumberAdd:
         return machine()->Int32Add();
       case IrOpcode::kNumberSubtract:
         return machine()->Int32Sub();
       case IrOpcode::kNumberEqual:
         return machine()->Word32Equal();
       case IrOpcode::kNumberLessThan:
         return machine()->Int32LessThan();
       case IrOpcode::kNumberLessThanOrEqual:
         return machine()->Int32LessThanOrEqual();
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 
-  Operator* Uint32OperatorFor(IrOpcode::Value opcode) {
+  const Operator* Uint32OperatorFor(IrOpcode::Value opcode) {
     switch (opcode) {
       case IrOpcode::kNumberAdd:
         return machine()->Int32Add();
       case IrOpcode::kNumberSubtract:
         return machine()->Int32Sub();
       case IrOpcode::kNumberEqual:
         return machine()->Word32Equal();
       case IrOpcode::kNumberLessThan:
         return machine()->Uint32LessThan();
       case IrOpcode::kNumberLessThanOrEqual:
         return machine()->Uint32LessThanOrEqual();
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 
-  Operator* Float64OperatorFor(IrOpcode::Value opcode) {
+  const Operator* Float64OperatorFor(IrOpcode::Value opcode) {
     switch (opcode) {
       case IrOpcode::kNumberAdd:
         return machine()->Float64Add();
       case IrOpcode::kNumberSubtract:
         return machine()->Float64Sub();
       case IrOpcode::kNumberMultiply:
         return machine()->Float64Mul();
       case IrOpcode::kNumberDivide:
         return machine()->Float64Div();
       case IrOpcode::kNumberModulus:
@@ skipping 61 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_