[heap] Make Heap::MaxRegularHeapObjectSize an inlineable constexpr

Bug: v8:11263
Change-Id: Ia86ae814434aed9795f98d80e987a1ed10fa9a1f
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2821540Reviewed-by: Michael Stanton <mvstanton@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: Camillo Bruni <cbruni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#73991}

src/compiler/allocation-builder-inl.h

@@ -7,6 +7,7 @@
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/allocation-builder.h"
+#include "src/heap/heap-inl.h"
 #include "src/objects/arguments-inl.h"
 #include "src/objects/map-inl.h"
 
@@ -14,6 +15,16 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
+void AllocationBuilder::Allocate(int size, AllocationType allocation,
+                                 Type type) {
+  DCHECK_LE(size, Heap::MaxRegularHeapObjectSize(allocation));
+  effect_ = graph()->NewNode(
+      common()->BeginRegion(RegionObservability::kNotObservable), effect_);
+  allocation_ = graph()->NewNode(simplified()->Allocate(type, allocation),
+                                 jsgraph()->Constant(size), effect_, control_);
+  effect_ = allocation_;
+}
+
 void AllocationBuilder::AllocateContext(int variadic_part_length, MapRef map) {
   DCHECK(base::IsInRange(map.instance_type(), FIRST_CONTEXT_TYPE,
                          LAST_CONTEXT_TYPE));

src/compiler/allocation-builder.h

@@ -25,16 +25,9 @@ class AllocationBuilder final {
         control_(control) {}
 
   // Primitive allocation of static size.
-  void Allocate(int size, AllocationType allocation = AllocationType::kYoung,
-                Type type = Type::Any()) {
-    DCHECK_LE(size, Heap::MaxRegularHeapObjectSize(allocation));
-    effect_ = graph()->NewNode(
-        common()->BeginRegion(RegionObservability::kNotObservable), effect_);
-    allocation_ =
-        graph()->NewNode(simplified()->Allocate(type, allocation),
-                         jsgraph()->Constant(size), effect_, control_);
-    effect_ = allocation_;
-  }
+  inline void Allocate(int size,
+                       AllocationType allocation = AllocationType::kYoung,
+                       Type type = Type::Any());
 
   // Primitive store into a field.
   void Store(const FieldAccess& access, Node* value) {

src/heap/heap-inl.h

@@ -85,6 +85,15 @@ BytecodeFlushMode Heap::GetBytecodeFlushMode(Isolate* isolate) {
   return BytecodeFlushMode::kDoNotFlushBytecode;
 }
 
+// static
+constexpr int Heap::MaxRegularHeapObjectSize(AllocationType allocation) {
+  if (!V8_ENABLE_THIRD_PARTY_HEAP_BOOL &&
+      (allocation == AllocationType::kCode)) {
+    return MemoryChunkLayout::MaxRegularCodeObjectSize();
+  }
+  return kMaxRegularHeapObjectSize;
+}
+
 Isolate* Heap::isolate() {
   return reinterpret_cast<Isolate*>(
       reinterpret_cast<intptr_t>(this) -

src/heap/heap.cc

@@ -4851,15 +4851,6 @@ bool Heap::AllocationLimitOvershotByLargeMargin() {
   return v8_overshoot >= v8_margin || global_overshoot >= global_margin;
 }
 
-// static
-int Heap::MaxRegularHeapObjectSize(AllocationType allocation) {
-  if (!V8_ENABLE_THIRD_PARTY_HEAP_BOOL &&
-      (allocation == AllocationType::kCode)) {
-    return MemoryChunkLayout::MaxRegularCodeObjectSize();
-  }
-  return kMaxRegularHeapObjectSize;
-}
-
 bool Heap::ShouldOptimizeForLoadTime() {
   return isolate()->rail_mode() == PERFORMANCE_LOAD &&
          !AllocationLimitOvershotByLargeMargin() &&

src/heap/heap.h

@@ -1390,7 +1390,7 @@ class Heap {
   // which the size of the allocatable space per V8 page may depend on the OS
   // page size at runtime. You may use kMaxRegularHeapObjectSize as a constant
   // instead if you know the allocation isn't in the code spaces.
-  V8_EXPORT_PRIVATE static int MaxRegularHeapObjectSize(
+  V8_EXPORT_PRIVATE static constexpr int MaxRegularHeapObjectSize(
       AllocationType allocation);
 
   // ===========================================================================