Improve smi support in crankshaft

src/hydrogen-instructions.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3547 matching lines @@
   Representation new_rep = RepresentationFromInputs();
   UpdateRepresentation(new_rep, h_infer, "inputs");
   new_rep = RepresentationFromUses();
   UpdateRepresentation(new_rep, h_infer, "uses");
   new_rep = RepresentationFromUseRequirements();
   UpdateRepresentation(new_rep, h_infer, "use requirements");
 }
 
 
 Representation HPhi::RepresentationFromInputs() {
+  bool tagged_smi_occurred = false;

[Jakob Kummerow, 2013/05/31 16:39:40]

I don't think we should treat tagged_smi differently from just smi.

Also, as discussed offline, rewriting this method based on
Representation::generalize() sounds good.

   bool double_occurred = false;
   bool int32_occurred = false;
   bool smi_occurred = false;
   for (int i = 0; i < OperandCount(); ++i) {
     HValue* value = OperandAt(i);
     if (value->IsUnknownOSRValue()) {
       HPhi* hint_value = HUnknownOSRValue::cast(value)->incoming_value();
       if (hint_value != NULL) {
         Representation hint = hint_value->representation();
-        if (hint.IsTagged()) return hint;
-        if (hint.IsDouble()) double_occurred = true;
-        if (hint.IsInteger32()) int32_occurred = true;
-        if (hint.IsSmi()) smi_occurred = true;
+        if (hint.IsTagged()) {
+          if (!hint_value->type().IsSmi()) return hint;
+          if (double_occurred) return hint;
+          if (int32_occurred) return hint;
+          tagged_smi_occurred = true;
+        } else if (tagged_smi_occurred) {
+          if (!hint.IsSmi()) return Representation::Tagged();
+        } else {
+          if (hint.IsDouble()) double_occurred = true;
+          if (hint.IsInteger32()) int32_occurred = true;
+          if (hint.IsSmi()) smi_occurred = true;
+        }
       }
       continue;
     }
     if (value->representation().IsDouble()) double_occurred = true;
     if (value->representation().IsInteger32()) int32_occurred = true;
     if (value->representation().IsSmi()) smi_occurred = true;
     if (value->representation().IsTagged()) {
       if (value->IsConstant()) {
         HConstant* constant = HConstant::cast(value);
-        if (constant->IsConvertibleToInteger()) {
+        if (constant->HasSmiValue()) {
+          smi_occurred = true;
+        } else if (constant->IsConvertibleToInteger()) {
           int32_occurred = true;
         } else if (constant->HasNumberValue()) {
           double_occurred = true;
         } else {
           return Representation::Tagged();
         }
       } else {
         if (value->IsPhi() && !IsConvertibleToInteger()) {
-          return Representation::Tagged();
+          if (!value->type().IsSmi()) return Representation::Tagged();
+          if (double_occurred) return Representation::Tagged();
+          if (int32_occurred) return Representation::Tagged();
+          tagged_smi_occurred = true;
         }
       }
     }
   }
 
+  if (tagged_smi_occurred) return Representation::Smi();
   if (double_occurred) return Representation::Double();
   if (int32_occurred) return Representation::Integer32();
   if (smi_occurred) return Representation::Smi();
 
   return Representation::None();
 }
 
 
 Representation HPhi::RepresentationFromUseRequirements() {
   Representation all_uses_require = Representation::None();
@@ skipping 190 matching lines @@
     case kBackingStore:
       if (!name_.is_null()) stream->Add(*String::cast(*name_)->ToCString());
       stream->Add("[backing-store]");
       break;
   }
 
   stream->Add("@%d", offset());
 }
 
 } }  // namespace v8::internal