Hydrogen array constructor cleanup and improvements

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 1737 matching lines @@
       HConstant(Context::ARRAY_FUNCTION_INDEX));
 
   return AddInstruction(new (zone())
       HLoadKeyed(native_context, index, NULL, FAST_ELEMENTS));
 }
 
 
 HGraphBuilder::JSArrayBuilder::JSArrayBuilder(HGraphBuilder* builder,
                                               ElementsKind kind,
                                               HValue* allocation_site_payload,
+                                              HValue* constructor_function,
                                               bool disable_allocation_sites) :
         builder_(builder),
         kind_(kind),
         allocation_site_payload_(allocation_site_payload),
-        constructor_function_(NULL) {
+        constructor_function_(constructor_function) {
   mode_ = disable_allocation_sites
       ? DONT_TRACK_ALLOCATION_SITE
       : AllocationSiteInfo::GetMode(kind);
 }
 
 
 HGraphBuilder::JSArrayBuilder::JSArrayBuilder(HGraphBuilder* builder,
                                               ElementsKind kind,
                                               HValue* constructor_function) :
     builder_(builder),
     kind_(kind),
     mode_(DONT_TRACK_ALLOCATION_SITE),
     allocation_site_payload_(NULL),
     constructor_function_(constructor_function) {
 }
 
 
 HValue* HGraphBuilder::JSArrayBuilder::EmitMapCode(HValue* context) {
+  if (kind_ == FAST_SMI_ELEMENTS) {
+    // Optimization: the initial Array map is for FAST_SMI_ELEMENTS.
+    // No need for a context lookup in this case.

[danno, 2013/06/27 08:53:04]

Why not? What is special about smi elements?

[mvstanton, 2013/06/27 15:33:29]

Because the initial map on the constructor is setup for smi elements. I added an
assert in bootstrapper.cc to protect this (the assert can't live here because
this code is called before the global object is fully set up). I also changed
the code to check against GetInitialFastElementsKind() instead of
FAST_SMI_ELEMENTS.

+    HObjectAccess access = HObjectAccess::ForPrototypeOrInitialMap();
+    return AddInstruction(
+        builder()->BuildLoadNamedField(constructor_function_,
+                                       access,
+                                       Representation::Tagged()));
+  }
+
   HInstruction* native_context = builder()->BuildGetNativeContext(context);
-
   HInstruction* index = builder()->AddInstruction(new(zone())
       HConstant(Context::JS_ARRAY_MAPS_INDEX));
-
   HInstruction* map_array = builder()->AddInstruction(new(zone())
       HLoadKeyed(native_context, index, NULL, FAST_ELEMENTS));
-
   HInstruction* kind_index = builder()->AddInstruction(new(zone())
-      HConstant(kind_));
-
+                                                       HConstant(kind_));
   return builder()->AddInstruction(new(zone())
       HLoadKeyed(map_array, kind_index, NULL, FAST_ELEMENTS));
 }
 
 
 HValue* HGraphBuilder::JSArrayBuilder::EmitInternalMapCode() {
   // Find the map near the constructor function
   HObjectAccess access = HObjectAccess::ForPrototypeOrInitialMap();
   return AddInstruction(
       builder()->BuildLoadNamedField(constructor_function_,
@@ skipping 76 matching lines @@
   HValue* context = builder()->environment()->LookupContext();
 
   // Allocate (dealing with failure appropriately)
   HAllocate::Flags flags = HAllocate::DefaultFlags(kind_);
   HAllocate* new_object = new(zone()) HAllocate(context, size_in_bytes,
                                                 HType::JSArray(), flags);
   AddInstruction(new_object);
 
   // Fill in the fields: map, properties, length
   HValue* map;
-  if (constructor_function_ != NULL) {
+  if (allocation_site_payload_ == NULL) {
     map = EmitInternalMapCode();
   } else {
     map = EmitMapCode(context);
   }
   elements_location_ = builder()->BuildJSArrayHeader(new_object,
                                                      map,
                                                      mode_,
                                                      allocation_site_payload_,
                                                      length_field);
 
@@ skipping 9655 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal