[heap] Prepare code for smaller large object allocation limit than max allocatable memory.

src/hydrogen.cc

 // Copyright 2013 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/hydrogen.h"
 
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
 #include "src/ast-numbering.h"
@@ skipping 1834 matching lines @@
                         done);
   STATIC_ASSERT(JSIteratorResult::kSize == 5 * kPointerSize);
   return result;
 }
 
 
 HValue* HGraphBuilder::BuildRegExpConstructResult(HValue* length,
                                                   HValue* index,
                                                   HValue* input) {
   NoObservableSideEffectsScope scope(this);
-  HConstant* max_length = Add<HConstant>(JSObject::kInitialMaxFastElementArray);
+  HConstant* max_length = Add<HConstant>(JSArray::kInitialMaxFastElementArray);
   Add<HBoundsCheck>(length, max_length);
 
   // Generate size calculation code here in order to make it dominate
   // the JSRegExpResult allocation.
   ElementsKind elements_kind = FAST_ELEMENTS;
   HValue* size = BuildCalculateElementsSize(elements_kind, length);
 
   // Allocate the JSRegExpResult and the FixedArray in one step.
   HValue* result = Add<HAllocate>(
       Add<HConstant>(JSRegExpResult::kSize), HType::JSArray(),
@@ skipping 785 matching lines @@
       return array_builder->AllocateEmptyArray();
     } else {
       return array_builder->AllocateArray(length_argument,
                                           array_length,
                                           length_argument);
     }
   }
 
   HValue* constant_zero = graph()->GetConstant0();
   HConstant* max_alloc_length =
-      Add<HConstant>(JSObject::kInitialMaxFastElementArray);
+      Add<HConstant>(JSArray::kInitialMaxFastElementArray);
   HInstruction* checked_length = Add<HBoundsCheck>(length_argument,
                                                    max_alloc_length);
   IfBuilder if_builder(this);
   if_builder.If<HCompareNumericAndBranch>(checked_length, constant_zero,
                                           Token::EQ);
   if_builder.Then();
   const int initial_capacity = JSArray::kPreallocatedArrayElements;
   HConstant* initial_capacity_node = Add<HConstant>(initial_capacity);
   Push(initial_capacity_node);  // capacity
   Push(constant_zero);          // length
@@ skipping 449 matching lines @@
   // redundant initialization of elements and length fields and at the same
   // time the object will be fully prepared for GC if it happens during
   // elements allocation.
   HValue* result = BuildCloneShallowArrayEmpty(
       boilerplate, allocation_site, mode);
 
   HAllocate* elements = BuildAllocateElements(kind, elements_size);
 
   // This function implicitly relies on the fact that the
   // FastCloneShallowArrayStub is called only for literals shorter than
-  // JSObject::kInitialMaxFastElementArray.
+  // JSArray::kInitialMaxFastElementArray.
   // Can't add HBoundsCheck here because otherwise the stub will eager a frame.
   HConstant* size_upper_bound = EstablishElementsAllocationSize(
-      kind, JSObject::kInitialMaxFastElementArray);
+      kind, JSArray::kInitialMaxFastElementArray);
   elements->set_size_upper_bound(size_upper_bound);
 
   Add<HStoreNamedField>(result, HObjectAccess::ForElementsPointer(), elements);
 
   // The allocation for the cloned array above causes register pressure on
   // machines with low register counts. Force a reload of the boilerplate
   // elements here to free up a register for the allocation to avoid unnecessary
   // spillage.
   boilerplate_elements = AddLoadElements(boilerplate);
   boilerplate_elements->SetFlag(HValue::kCantBeReplaced);
@@ skipping 10517 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8