Move kMaxRegularHeapObjectSize into globals

src/crankshaft/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/crankshaft/hydrogen.h"
 
 #include <memory>
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
@@ skipping 2633 matching lines @@
       if_onebyte.End();
       HValue* map = Pop();
 
       // Calculate the number of bytes needed for the characters in the
       // string while observing object alignment.
       STATIC_ASSERT((SeqString::kHeaderSize & kObjectAlignmentMask) == 0);
       HValue* size = BuildObjectSizeAlignment(Pop(), SeqString::kHeaderSize);
 
       IfBuilder if_size(this);
       if_size.If<HCompareNumericAndBranch>(
-          size, Add<HConstant>(Page::kMaxRegularHeapObjectSize), Token::LT);
+          size, Add<HConstant>(kMaxRegularHeapObjectSize), Token::LT);
       if_size.Then();
       {
         // Allocate the string object. HAllocate does not care whether we pass
         // STRING_TYPE or ONE_BYTE_STRING_TYPE here, so we just use STRING_TYPE.
         HAllocate* result =
             BuildAllocate(size, HType::String(), STRING_TYPE, allocation_mode);
         Add<HStoreNamedField>(result, HObjectAccess::ForMap(), map);
 
         // Initialize the string fields.
         Add<HStoreNamedField>(result, HObjectAccess::ForStringHashField(),
@@ skipping 402 matching lines @@
   return new_capacity;
 }
 
 
 HValue* HGraphBuilder::BuildGrowElementsCapacity(HValue* object,
                                                  HValue* elements,
                                                  ElementsKind kind,
                                                  ElementsKind new_kind,
                                                  HValue* length,
                                                  HValue* new_capacity) {
-  Add<HBoundsCheck>(new_capacity, Add<HConstant>(
-          (Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) >>
-          ElementsKindToShiftSize(new_kind)));
+  Add<HBoundsCheck>(
+      new_capacity,
+      Add<HConstant>((kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) >>
+                     ElementsKindToShiftSize(new_kind)));
 
   HValue* new_elements =
       BuildAllocateAndInitializeArray(new_kind, new_capacity);
 
   BuildCopyElements(elements, kind, new_elements,
                     new_kind, length, new_capacity);
 
   Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
                         new_elements);
 
@@ skipping 6844 matching lines @@
   // objects we construct, and an int32-to-smi HChange could deopt. Accept
   // the deopt possibility now, before allocation occurs.
   length = AddUncasted<HForceRepresentation>(length, Representation::Smi());
   capacity = AddUncasted<HForceRepresentation>(capacity, Representation::Smi());
 
   // Generate size calculation code here in order to make it dominate
   // the JSArray allocation.
   HValue* elements_size = BuildCalculateElementsSize(kind, capacity);
 
   // Bail out for large objects.
-  HValue* max_size = Add<HConstant>(Page::kMaxRegularHeapObjectSize);
+  HValue* max_size = Add<HConstant>(kMaxRegularHeapObjectSize);
   Add<HBoundsCheck>(elements_size, max_size);
 
   // Allocate (dealing with failure appropriately).
   AllocationSiteMode mode = DONT_TRACK_ALLOCATION_SITE;
   HAllocate* new_object = AllocateJSArrayObject(mode);
 
   // Fill in the fields: map, properties, length.
   Handle<Map> map_constant(isolate()->get_initial_js_array_map(kind));
   HValue* map = Add<HConstant>(map_constant);
 
@@ skipping 1879 matching lines @@
   if (*top_site == *current_site) {
     // We install a dependency for pretenuring only on the outermost literal.
     top_info()->dependencies()->AssumeTenuringDecision(top_site);
   }
   top_info()->dependencies()->AssumeTransitionStable(current_site);
 
   HInstruction* object =
       Add<HAllocate>(object_size_constant, type, pretenure_flag, instance_type,
                      graph()->GetConstant0(), top_site);
 
-  // If allocation folding reaches Page::kMaxRegularHeapObjectSize the
+  // If allocation folding reaches kMaxRegularHeapObjectSize the
   // elements array may not get folded into the object. Hence, we set the
   // elements pointer to empty fixed array and let store elimination remove
   // this store in the folding case.
   HConstant* empty_fixed_array = Add<HConstant>(
       isolate()->factory()->empty_fixed_array());
   Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
       empty_fixed_array);
 
   BuildEmitObjectHeader(boilerplate_object, object);
 
@@ skipping 1539 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8