Generate the TransitionElementsStub using 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 2105 matching lines @@
     stream->Add(" ");
     dependency()->PrintNameTo(stream);
   }
 
   if (RequiresHoleCheck()) {
     stream->Add(" check_hole");
   }
 }
 
 
+bool HLoadKeyed::CanReturnHole() const {

[Michael Starzinger, 2013/02/01 13:15:08]

This name is kind of disambiguate, it took me a while to figure out that it's
used by the use-sites of this value. As discussed offline we should rename this
to something like "UsesMustHandleHole()".

[danno, 2013/02/02 17:56:21]

Done.

+  if (IsFastPackedElementsKind(elements_kind())) {
+    return false;
+  }
+
+  if (hole_mode() == ALLOW_RETURN_HOLE) return true;
+
+  if (IsFastDoubleElementsKind(elements_kind())) {
+    return false;
+  }
+
+  for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
+    HValue* use = it.value();
+    if (!use->IsChange()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
 bool HLoadKeyed::RequiresHoleCheck() const {
   if (IsFastPackedElementsKind(elements_kind())) {
     return false;
   }
 
-  if (IsFastDoubleElementsKind(elements_kind())) {
-    return true;
-  }
-
-  for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
-    HValue* use = it.value();
-    if (!use->IsChange()) {
-      return true;
-    }
-  }
-
-  return false;
+  return !CanReturnHole();
 }
 
 
 void HLoadKeyedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add("[");
   key()->PrintNameTo(stream);
   stream->Add("]");
 }
 
@@ skipping 253 matching lines @@
 HType HStringCharFromCode::CalculateInferredType() {
   return HType::String();
 }
 
 
 HType HAllocateObject::CalculateInferredType() {
   return HType::JSObject();
 }
 
 
+HType HAllocate::CalculateInferredType() {
+  return type_;
+}
+
+
 HType HFastLiteral::CalculateInferredType() {
   // TODO(mstarzinger): Be smarter, could also be JSArray here.
   return HType::JSObject();
 }
 
 
 HType HArrayLiteral::CalculateInferredType() {
   return HType::JSArray();
 }
 
@@ skipping 101 matching lines @@
   // Propagate to the left argument. If the left argument cannot be -0, then
   // the result of the sub operation cannot be either.
   if (range() == NULL || range()->CanBeMinusZero()) {
     return left();
   }
   return NULL;
 }
 
 
 bool HStoreKeyed::NeedsCanonicalization() {
-  // If value is an integer or comes from the result of a keyed load
-  // then it will be a non-hole value: no need for canonicalization.
-  if (value()->IsLoadKeyed() ||
-      (value()->IsChange() && HChange::cast(value())->from().IsInteger32())) {
+  // If value is an integer or smi or comes from the result of a keyed load or
+  // constant then it is either be a non-hole value or in the case of a constant
+  // the hole is only being stored explicitly: no need for canonicalization.
+  if (value()->IsLoadKeyed() || value()->IsConstant()) {
     return false;
   }
+
+  if (value()->IsChange()) {
+    if (HChange::cast(value())->from().IsInteger32()) {
+      return false;
+    }
+    if (HChange::cast(value())->value()->type().IsSmi()) {
+      return false;
+    }
+  }
   return true;
 }
 
 
 #define H_CONSTANT_INT32(val)                                                  \
 new(zone) HConstant(FACTORY->NewNumberFromInt(val, TENURED),                   \
                     Representation::Integer32())
 #define H_CONSTANT_DOUBLE(val)                                                 \
 new(zone) HConstant(FACTORY->NewNumber(val, TENURED),                          \
                     Representation::Double())
@@ skipping 308 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal