Tag smi-constants as smi. This also fixes code that copies holes into arrays.

src/hydrogen.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 585 matching lines @@
   if (!pointer->is_set()) {
     HConstant* constant =
         new(zone()) HConstant(value, Representation::Integer32());
     constant->InsertAfter(GetConstantUndefined());
     pointer->set(constant);
   }
   return pointer->get();
 }
 
 
-HConstant* HGraph::GetConstantSmi(SetOncePointer<HConstant>* pointer,
-                                  int32_t value) {
-  if (!pointer->is_set()) {
-    HConstant* constant =
-        new(zone()) HConstant(Handle<Object>(Smi::FromInt(value), isolate()),
-                              Representation::Tagged());
-    constant->InsertAfter(GetConstantUndefined());
-    pointer->set(constant);
-  }
-  return pointer->get();
-}
-
-
 HConstant* HGraph::GetConstant0() {
   return GetConstantInt32(&constant_0_, 0);
 }
 
 
 HConstant* HGraph::GetConstant1() {
   return GetConstantInt32(&constant_1_, 1);
 }
 
 
@@ skipping 19 matching lines @@
   return constant_##name##_.get();                                             \
 }
 
 
 DEFINE_GET_CONSTANT(True, true, HType::Boolean(), true)
 DEFINE_GET_CONSTANT(False, false, HType::Boolean(), false)
 DEFINE_GET_CONSTANT(Hole, the_hole, HType::Tagged(), false)
 DEFINE_GET_CONSTANT(Null, null, HType::Tagged(), false)
 
 
-HConstant* HGraph::GetConstantSmi0() {
-  return GetConstantSmi(&constant_smi_0_, 0);
-}
-
-
-HConstant* HGraph::GetConstantSmi1() {
-  return GetConstantSmi(&constant_smi_1_, 1);
-}
-
-
 #undef DEFINE_GET_CONSTANT
 
 
 HConstant* HGraph::GetInvalidContext() {
   return GetConstantInt32(&constant_invalid_context_, 0xFFFFC0C7);
 }
 
 
 HGraphBuilder::IfBuilder::IfBuilder(HGraphBuilder* builder, int position)
     : builder_(builder),
@@ skipping 877 matching lines @@
     HConstant* constant_to = HConstant::cast(to);
 
     if (constant_from->HasInteger32Value() &&
         constant_from->Integer32Value() == 0 &&
         constant_to->HasInteger32Value() &&
         constant_to->Integer32Value() == initial_capacity) {
       unfold_loop = true;
     }
   }
 
+  // Since we're about to store a hole value, the store instruction below must
+  // assume an elements kind that supports heap object values.
+  if (IsFastSmiOrObjectElementsKind(elements_kind)) {
+    elements_kind = FAST_HOLEY_ELEMENTS;
+  }
+
   if (unfold_loop) {
     for (int i = 0; i < initial_capacity; i++) {
       HInstruction* key = AddInstruction(new(zone)
                              HConstant(i, Representation::Integer32()));
       AddInstruction(new(zone) HStoreKeyed(elements, key, hole, elements_kind));
     }
   } else {
     LoopBuilder builder(this, context, LoopBuilder::kPostIncrement);
 
     HValue* key = builder.BeginBody(from, to, Token::LT);
@@ skipping 26 matching lines @@
 
   LoopBuilder builder(this, context, LoopBuilder::kPostIncrement);
 
   HValue* key = builder.BeginBody(graph()->GetConstant0(), length, Token::LT);
 
   HValue* element =
       AddInstruction(new(zone()) HLoadKeyed(from_elements, key, NULL,
                                             from_elements_kind,
                                             ALLOW_RETURN_HOLE));
 
-  AddInstruction(new(zone()) HStoreKeyed(to_elements, key, element,
-                                         to_elements_kind));
+  ElementsKind holey_kind = IsFastSmiElementsKind(to_elements_kind)
+      ? FAST_HOLEY_ELEMENTS : to_elements_kind;
+  HInstruction* holey_store = AddInstruction(
+      new(zone()) HStoreKeyed(to_elements, key, element, holey_kind));
+  holey_store->ClearFlag(HValue::kDeoptimizeOnUndefined);
 
   builder.EndBody();
 
   if (!pre_fill_with_holes && length != capacity) {
     // Fill unused capacity with the hole.
     BuildFillElementsWithHole(context, to_elements, to_elements_kind,
                               key, capacity);
   }
 }
 
@@ skipping 10734 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal