Assume signed for converting to word32/float64 unless use or output is explicitly unsigned.

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/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 70 matching lines @@
     }
     if ((use_type & rMask) == (output_type & rMask)) {
       // Representations are the same. That's a no-op.
       return node;
     }
     if (use_type & rTagged) {
       return GetTaggedRepresentationFor(node, output_type);
     } else if (use_type & rFloat64) {
       return GetFloat64RepresentationFor(node, output_type);
     } else if (use_type & rWord32) {
-      return GetWord32RepresentationFor(node, output_type);
+      return GetWord32RepresentationFor(node, output_type, use_type & tUint32);
     } else if (use_type & rBit) {
       return GetBitRepresentationFor(node, output_type);
     } else if (use_type & rWord64) {
       return GetWord64RepresentationFor(node, output_type);
     } else {
       return node;
     }
   }
 
   Node* GetTaggedRepresentationFor(Node* node, RepTypeUnion output_type) {
@@ skipping 56 matching lines @@
       case IrOpcode::kFloat64Constant:
         return node;  // No change necessary.
       default:
         break;
     }
     // Select the correct X -> Float64 operator.
     Operator* op;
     if (output_type & rWord32) {
       if (output_type & tUint32) {
         op = machine()->ChangeUint32ToFloat64();
-      } else if (output_type & tInt32) {
+      } else {
         op = machine()->ChangeInt32ToFloat64();
-      } else {
-        return TypeError(node, output_type, rFloat64);
       }
     } else if (output_type & rTagged) {
       op = simplified()->ChangeTaggedToFloat64();
     } else {
       return TypeError(node, output_type, rFloat64);
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
-  Node* GetWord32RepresentationFor(Node* node, RepTypeUnion output_type) {
+  Node* GetWord32RepresentationFor(Node* node, RepTypeUnion 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: {
-        if (output_type & tUint32) {
-          int32_t value = static_cast<int32_t>(
-              static_cast<uint32_t>(ValueOf<double>(node->op())));
-          return jsgraph()->Int32Constant(value);
-        } else if (output_type & tInt32) {
-          int32_t value = FastD2I(ValueOf<double>(node->op()));
-          return jsgraph()->Int32Constant(value);
+        double value = ValueOf<double>(node->op());

[Michael Starzinger, 2014/08/11 16:10:19]

Can we call DCHECK(Is[Uint|Int]32Double(value)) here?

+        if (value < 0) {
+          DCHECK(value >= kMinInt && value <= kMaxInt);
+          int32_t iv = static_cast<int32_t>(value);
+          return jsgraph()->Int32Constant(iv);
         } else {
-          return TypeError(node, output_type, rWord32);
+          DCHECK(value >= 0 && value <= kMaxUInt32);
+          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;
     if (output_type & rFloat64) {
-      if (output_type & tUint32) {
+      if (output_type & tUint32 || use_unsigned) {
         op = machine()->ChangeFloat64ToUint32();
-      } else if (output_type & tInt32) {
+      } else {
         op = machine()->ChangeFloat64ToInt32();
-      } else {
-        return TypeError(node, output_type, rWord32);
       }
     } else if (output_type & rTagged) {
-      if (output_type & tUint32) {
+      if (output_type & tUint32 || use_unsigned) {
         op = simplified()->ChangeTaggedToUint32();
-      } else if (output_type & tInt32) {
+      } else {
         op = simplified()->ChangeTaggedToInt32();
-      } else {
-        return TypeError(node, output_type, rWord32);
       }
     } else if (output_type & rBit) {
       return node;  // Sloppy comparison -> word32.
     } else {
       return TypeError(node, output_type, rWord32);
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
   Node* GetBitRepresentationFor(Node* node, RepTypeUnion output_type) {
@@ skipping 178 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_