[turbofan] Improve representation selection for Smi checking.

src/compiler/representation-change.cc

 // Copyright 2015 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.
 
 #include "src/compiler/representation-change.h"
 
 #include <sstream>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 124 matching lines @@
       // Both are words less than or equal to 32-bits.
       // Since loads of integers from memory implicitly sign or zero extend the
       // value to the full machine word size and stores implicitly truncate,
       // no representation change is necessary.
       return node;
     }
   }
 
   switch (use_info.representation()) {
     case MachineRepresentation::kTaggedSigned:
-      DCHECK(use_info.type_check() == TypeCheckKind::kNone);
-      return GetTaggedSignedRepresentationFor(node, output_rep, output_type);
+      DCHECK(use_info.type_check() == TypeCheckKind::kNone ||
+             use_info.type_check() == TypeCheckKind::kSignedSmall);
+      return GetTaggedSignedRepresentationFor(node, output_rep, output_type,
+                                              use_node, use_info);
     case MachineRepresentation::kTaggedPointer:
       DCHECK(use_info.type_check() == TypeCheckKind::kNone);
       return GetTaggedPointerRepresentationFor(node, output_rep, output_type);
     case MachineRepresentation::kTagged:
       DCHECK(use_info.type_check() == TypeCheckKind::kNone);
       return GetTaggedRepresentationFor(node, output_rep, output_type,
                                         use_info.truncation());
     case MachineRepresentation::kFloat32:
       DCHECK(use_info.type_check() == TypeCheckKind::kNone);
       return GetFloat32RepresentationFor(node, output_rep, output_type,
@@ skipping 16 matching lines @@
       // TODO(bbudge) Handle conversions between tagged and untagged.
       break;
     case MachineRepresentation::kNone:
       return node;
   }
   UNREACHABLE();
   return nullptr;
 }
 
 Node* RepresentationChanger::GetTaggedSignedRepresentationFor(
-    Node* node, MachineRepresentation output_rep, Type* output_type) {
+    Node* node, MachineRepresentation output_rep, Type* output_type,
+    Node* use_node, UseInfo use_info) {
   // Eagerly fold representation changes for constants.
   switch (node->opcode()) {
-    case IrOpcode::kNumberConstant: {
-      int32_t value = OpParameter<int32_t>(node);
-      if (Smi::IsValid(value)) {
-        return jsgraph()->Constant(value);
+    case IrOpcode::kNumberConstant:
+      if (output_type->Is(Type::SignedSmall())) {

[Jarin, 2016/09/23 08:31:54]

Note: At some point we should compile away NumberConstant during representation
selection...

[Benedikt Meurer, 2016/09/23 08:39:38]

Acknowledged.

+        return node;
       }
-      return TypeError(node, output_rep, output_type,
-                       MachineRepresentation::kTaggedSigned);
-    }
-    case IrOpcode::kHeapConstant:
-      return TypeError(node, output_rep, output_type,
-                       MachineRepresentation::kTaggedSigned);
-    case IrOpcode::kInt32Constant:
-      if (output_type->Is(Type::SignedSmall())) {
-        int32_t value = OpParameter<int32_t>(node);
-        return jsgraph()->Constant(value);
-      } else {
-        return TypeError(node, output_rep, output_type,
-                         MachineRepresentation::kTaggedSigned);
-      }
-    case IrOpcode::kFloat64Constant:
-    case IrOpcode::kFloat32Constant:
-      return TypeError(node, output_rep, output_type,
-                       MachineRepresentation::kTaggedSigned);
+      break;
     default:
       break;
   }
   // Select the correct X -> Tagged operator.
   const Operator* op;
   if (Type::Semantic(output_type, jsgraph()->zone())->Is(Type::None())) {
     // This is an impossible value; it should not be used at runtime.
     // We just provide a dummy value here.
     return jsgraph()->Constant(0);
   } else if (IsWord(output_rep)) {
     if (output_type->Is(Type::Signed31())) {
       op = simplified()->ChangeInt31ToTaggedSigned();
-    } else if (machine()->Is64() && output_type->Is(Type::Signed32())) {
-      op = simplified()->ChangeInt32ToTagged();
+    } else if (output_type->Is(Type::Signed32())) {
+      if (SmiValuesAre32Bits()) {
+        op = simplified()->ChangeInt32ToTagged();
+      } else {

[Jarin, 2016/09/23 08:31:54]

How about 

else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
  op = simplified()->CheckedUint32ToTaggedSigned();
} else {
  TypeError(...);
}

(Here and below.)

[Benedikt Meurer, 2016/09/23 08:39:38]

Done.

+        DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+        op = simplified()->CheckedInt32ToTaggedSigned();
+      }
+    } else if (output_type->Is(Type::Unsigned32())) {
+      DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+      op = simplified()->CheckedUint32ToTaggedSigned();
     } else {
       return TypeError(node, output_rep, output_type,
                        MachineRepresentation::kTaggedSigned);
     }
+  } else if (output_rep == MachineRepresentation::kFloat64) {
+    if (output_type->Is(Type::Signed31())) {
+      // float64 -> int32 -> tagged signed
+      node = InsertChangeFloat64ToInt32(node);
+      op = simplified()->ChangeInt31ToTaggedSigned();
+    } else if (output_type->Is(Type::Signed32())) {
+      // float64 -> int32 -> tagged signed
+      node = InsertChangeFloat64ToInt32(node);
+      if (SmiValuesAre32Bits()) {
+        op = simplified()->ChangeInt32ToTagged();
+      } else {
+        DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+        op = simplified()->CheckedInt32ToTaggedSigned();
+      }
+    } else if (output_type->Is(Type::Unsigned32())) {
+      // float64 -> uint32 -> tagged signed
+      DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+      node = InsertChangeFloat64ToUint32(node);
+      op = simplified()->CheckedUint32ToTaggedSigned();
+    } else {
+      DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+      op = simplified()->CheckedFloat64ToInt32(
+          output_type->Maybe(Type::MinusZero())
+              ? CheckForMinusZeroMode::kCheckForMinusZero
+              : CheckForMinusZeroMode::kDontCheckForMinusZero);
+      node = InsertConversion(node, op, use_node);
+      if (SmiValuesAre32Bits()) {
+        op = simplified()->ChangeInt32ToTagged();
+      } else {
+        op = simplified()->CheckedInt32ToTaggedSigned();
+      }
+    }
+  } else if (CanBeTaggedPointer(output_rep)) {
+    DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+    op = simplified()->CheckedTaggedToTaggedSigned();
+  } else if (output_rep == MachineRepresentation::kBit) {
+    // TODO(turbofan): Consider adding a Bailout operator that just deopts.
+    // Also use that for MachineRepresentation::kPointer case above.
+    DCHECK_EQ(TypeCheckKind::kSignedSmall, use_info.type_check());
+    node = InsertChangeBitToTagged(node);
+    op = simplified()->CheckedTaggedToTaggedSigned();
   } else {
     return TypeError(node, output_rep, output_type,
                      MachineRepresentation::kTaggedSigned);
   }
-  return jsgraph()->graph()->NewNode(op, node);
+  return InsertConversion(node, op, use_node);
 }
 
 Node* RepresentationChanger::GetTaggedPointerRepresentationFor(
     Node* node, MachineRepresentation output_rep, Type* output_type) {
   // Eagerly fold representation changes for constants.
   switch (node->opcode()) {
     case IrOpcode::kHeapConstant:
       return node;  // No change necessary.
     case IrOpcode::kInt32Constant:
       if (output_type->Is(Type::Boolean())) {
@@ skipping 684 matching lines @@
 
     V8_Fatal(__FILE__, __LINE__,
              "RepresentationChangerError: node #%d:%s of "
              "%s cannot be changed to %s",
              node->id(), node->op()->mnemonic(), out_str.str().c_str(),
              use_str.str().c_str());
   }
   return node;
 }
 
+Node* RepresentationChanger::InsertChangeBitToTagged(Node* node) {
+  return jsgraph()->graph()->NewNode(simplified()->ChangeBitToTagged(), node);
+}
 
 Node* RepresentationChanger::InsertChangeFloat32ToFloat64(Node* node) {
   return jsgraph()->graph()->NewNode(machine()->ChangeFloat32ToFloat64(), node);
 }
 
 Node* RepresentationChanger::InsertChangeFloat64ToUint32(Node* node) {
   return jsgraph()->graph()->NewNode(machine()->ChangeFloat64ToUint32(), node);
 }
 
 Node* RepresentationChanger::InsertChangeFloat64ToInt32(Node* node) {
   return jsgraph()->graph()->NewNode(machine()->ChangeFloat64ToInt32(), node);
 }
 
 Node* RepresentationChanger::InsertChangeTaggedSignedToInt32(Node* node) {
   return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(),
                                      node);
 }
 
 Node* RepresentationChanger::InsertChangeTaggedToFloat64(Node* node) {
   return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
                                      node);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8