[turbofan] Use range types to type and lower arithmetic ops.

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 <sstream>
 
 #include "src/base/bits.h"
@@ skipping 198 matching lines @@
       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);
     }
   }
 
+  Node* GetTruncatedWord32For(Node* node, MachineTypeUnion output_type) {
+    // Eagerly fold truncations for constants.
+    switch (node->opcode()) {
+      case IrOpcode::kInt32Constant:
+        return node;  // No change necessary.
+      case IrOpcode::kFloat32Constant:
+        return jsgraph()->Int32Constant(
+            DoubleToInt32(OpParameter<float>(node)));
+      case IrOpcode::kNumberConstant:
+      case IrOpcode::kFloat64Constant:
+        return jsgraph()->Int32Constant(
+            DoubleToInt32(OpParameter<double>(node)));
+      default:
+        break;
+    }
+    // Select the correct X -> Word32 truncation operator.
+    const Operator* op = NULL;
+    if (output_type & kRepFloat64) {
+      op = machine()->TruncateFloat64ToInt32();

[Benedikt Meurer, 2014/10/23 10:33:26]

The op is always the same in the end, probably no need to assign it inside the
conditional blocks.

[Jarin, 2014/10/23 11:14:52]

While that's true, I would prefer to keep this separate.

+    } else if (output_type & kRepFloat32) {
+      node = InsertChangeFloat32ToFloat64(node);
+      op = machine()->TruncateFloat64ToInt32();
+    } else if (output_type & kRepTagged) {
+      node = InsertChangeTaggedToFloat64(node);
+      op = machine()->TruncateFloat64ToInt32();
+    } else {
+      return TypeError(node, output_type, kRepWord32);
+    }
+    return jsgraph()->graph()->NewNode(op, node);
+  }
+
   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::kFloat32Constant:
         return MakeInt32Constant(OpParameter<float>(node));
       case IrOpcode::kNumberConstant:
       case IrOpcode::kFloat64Constant:
@@ skipping 185 matching lines @@
                use_str.str().c_str());
     }
     return node;
   }
 
   Node* InsertChangeFloat32ToFloat64(Node* node) {
     return jsgraph()->graph()->NewNode(machine()->ChangeFloat32ToFloat64(),
                                        node);
   }
 
+  Node* InsertChangeTaggedToFloat64(Node* node) {
+    return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
+                                       node);
+  }
+
   JSGraph* jsgraph() { return jsgraph_; }
   Isolate* isolate() { return isolate_; }
   SimplifiedOperatorBuilder* simplified() { return simplified_; }
   MachineOperatorBuilder* machine() { return jsgraph()->machine(); }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_