"libpas test suit is broken due to recent profile and track allocatio…

…n mode change"

https://bugs.webkit.org/show_bug.cgi?id=274554
rdar://128497967

Reviewed by Yusuke Suzuki.

libpas test build fails due to recent change (122419407).
Fixed the files to add allocation mode..

* Source/bmalloc/libpas/src/chaos/Chaos.cpp:
(std::threadMain):
* Source/bmalloc/libpas/src/libpas/hotbit_heap.c:
(hotbit_try_allocate):
(hotbit_try_allocate_with_alignment):
(hotbit_try_reallocate):
* Source/bmalloc/libpas/src/libpas/hotbit_heap.h:
* Source/bmalloc/libpas/src/libpas/hotbit_heap_inlines.h:
(hotbit_try_allocate_inline):
(hotbit_try_allocate_with_alignment_inline):
(hotbit_try_reallocate_inline):
* Source/bmalloc/libpas/src/libpas/iso_heap.c:
(iso_try_allocate_common_primitive):
(iso_try_allocate_common_primitive_with_alignment):
(iso_try_allocate_common_primitive_zeroed):
(iso_allocate_common_primitive):
(iso_allocate_common_primitive_with_alignment):
(iso_allocate_common_primitive_zeroed):
(iso_try_reallocate_common_primitive):
(iso_reallocate_common_primitive):
(iso_try_allocate_dynamic_primitive):
(iso_try_allocate_dynamic_primitive_with_alignment):
(iso_try_allocate_dynamic_primitive_zeroed):
(iso_try_reallocate_dynamic_primitive):
(iso_try_allocate):
(iso_allocate):
(iso_try_allocate_array_by_count):
(iso_allocate_array_by_count):
(iso_try_allocate_array_by_count_zeroed):
(iso_allocate_array_by_count_zeroed):
(iso_try_reallocate_array_by_count):
(iso_reallocate_array_by_count):
(iso_try_allocate_primitive):
(iso_allocate_primitive):
(iso_try_allocate_primitive_zeroed):
(iso_allocate_primitive_zeroed):
(iso_try_allocate_primitive_with_alignment):
(iso_allocate_primitive_with_alignment):
(iso_try_reallocate_primitive):
(iso_reallocate_primitive):
(iso_try_allocate_for_flex):
* Source/bmalloc/libpas/src/libpas/iso_heap.h:
* Source/bmalloc/libpas/src/libpas/iso_heap_inlines.h:
(iso_try_allocate_common_primitive_inline):
(iso_try_allocate_common_primitive_with_alignment_inline):
(iso_try_allocate_common_primitive_zeroed_inline):
(iso_allocate_common_primitive_inline):
(iso_allocate_common_primitive_with_alignment_inline):
(iso_allocate_common_primitive_zeroed_inline):
(iso_try_reallocate_common_primitive_inline):
(iso_reallocate_common_primitive_inline):
(iso_try_allocate_inline):
(iso_allocate_inline):
(iso_try_allocate_array_by_count_inline):
(iso_allocate_array_by_count_inline):
(iso_try_allocate_array_by_count_zeroed_inline):
(iso_allocate_array_by_count_zeroed_inline):
(iso_try_reallocate_array_by_count_inline):
(iso_reallocate_array_by_count_inline):
(iso_try_allocate_primitive_inline):
(iso_allocate_primitive_inline):
(iso_try_allocate_primitive_zeroed_inline):
(iso_allocate_primitive_zeroed_inline):
(iso_try_allocate_primitive_with_alignment_inline):
(iso_allocate_primitive_with_alignment_inline):
(iso_try_reallocate_primitive_inline):
(iso_reallocate_primitive_inline):
(iso_try_allocate_for_flex_inline):
* Source/bmalloc/libpas/src/libpas/iso_test_heap.c:
(iso_test_allocate_common_primitive):
(iso_test_allocate):
(iso_test_allocate_array_by_count):
* Source/bmalloc/libpas/src/libpas/iso_test_heap.h:
* Source/bmalloc/libpas/src/libpas/jit_heap.c:
(jit_heap_try_allocate):
* Source/bmalloc/libpas/src/libpas/jit_heap.h:
* Source/bmalloc/libpas/src/libpas/minalign32_heap.c:
(minalign32_allocate_common_primitive):
(minalign32_allocate):
(minalign32_allocate_array_by_count):
* Source/bmalloc/libpas/src/libpas/minalign32_heap.h:
* Source/bmalloc/libpas/src/libpas/pagesize64k_heap.c:
(pagesize64k_allocate_common_primitive):
(pagesize64k_allocate):
(pagesize64k_allocate_array_by_count):
* Source/bmalloc/libpas/src/libpas/pagesize64k_heap.h:
* Source/bmalloc/libpas/src/libpas/pas_allocation_mode.h:
* Source/bmalloc/libpas/src/libpas/thingy_heap.c:
(thingy_try_allocate_primitive):
(thingy_try_allocate_primitive_zeroed):
(thingy_try_allocate_primitive_with_alignment):
(thingy_try_reallocate_primitive):
(thingy_try_allocate):
(thingy_try_allocate_zeroed):
(thingy_try_allocate_array):
(thingy_try_allocate_zeroed_array):
(thingy_try_reallocate_array):
(thingy_utility_heap_allocate):
* Source/bmalloc/libpas/src/libpas/thingy_heap.h:
* Source/bmalloc/libpas/src/libpas/thingy_heap_prefix.h:
* Source/bmalloc/libpas/src/mbmalloc/mbmalloc_bmalloc.c:
(mbmalloc):
(mbmemalign):
(mbrealloc):
* Source/bmalloc/libpas/src/mbmalloc/mbmalloc_hotbit.c:
(mbmalloc):
(mbmemalign):
(mbrealloc):
* Source/bmalloc/libpas/src/mbmalloc/mbmalloc_iso_common_primitive.c:
(mbmalloc):
(mbmemalign):
(mbrealloc):
* Source/bmalloc/libpas/src/test/BitfitTests.cpp:
(std::testAllocateAlignedSmallerThanSizeClassAndSmallerThanLargestAvailable):
* Source/bmalloc/libpas/src/test/BmallocTests.cpp:
(std::testBmallocAllocate):
(std::testBmallocDeallocate):
* Source/bmalloc/libpas/src/test/EnumerationTests.cpp:
(std::testBasicEnumeration):
(std::testPGMEnumerationBasic):
(std::testPGMEnumerationAddAndFree):
* Source/bmalloc/libpas/src/test/ExpendableMemoryTests.cpp:
(std::testPayloadImpl):
(std::testRage):
(std::testRematerializeAfterSearchOfDecommitted):
(std::testBasicSizeClass):
* Source/bmalloc/libpas/src/test/HeapRefAllocatorIndexTests.cpp:
* Source/bmalloc/libpas/src/test/IsoDynamicPrimitiveHeapTests.cpp:
(std::allocate42):
(std::allocate42WithAlignment):
(std::allocate42Zeroed):
(std::reallocate42):
* Source/bmalloc/libpas/src/test/IsoHeapChaosTests.cpp:
(std::gigacageAllocate):
(std::testAllocationChaos):
* Source/bmalloc/libpas/src/test/IsoHeapPageSharingTests.cpp:
(std::testTakePages):
(std::testTakePagesFromCorrectHeap):
(std::testLargeHeapTakesPagesFromCorrectSmallHeap):
(std::testLargeHeapTakesPagesFromCorrectSmallHeapAllocateAfterFree):
(std::testLargeHeapTakesPagesFromCorrectSmallHeapWithFancyOrder):
(std::testLargeHeapTakesPagesFromCorrectLargeHeap):
(std::testLargeHeapTakesPagesFromCorrectLargeHeapAllocateAfterFreeOnSmallHeap):
(std::testLargeHeapTakesPagesFromCorrectLargeHeapAllocateAfterFreeOnAnotherLargeHeap):
(std::testLargeHeapTakesPagesFromCorrectLargeHeapWithFancyOrder):
(std::testSmallHeapTakesPagesFromCorrectLargeHeap):
(std::testSmallHeapTakesPagesFromCorrectLargeHeapWithFancyOrder):
(std::testSmallHeapTakesPagesFromCorrectLargeHeapAllocateAfterFreeOnSmallHeap):
(std::testSmallHeapTakesPagesFromCorrectLargeHeapAllocateAfterFreeOnAnotherLargeHeap):
(std::allocateThingiesImpl):
(std::testScavengerEventuallyReturnsMemory):
(std::testScavengerEventuallyReturnsMemoryEvenWithoutManualShrink):
* Source/bmalloc/libpas/src/test/IsoHeapPartialAndBaselineTests.cpp:
(std::testSimplePartialAllocations):
(std::testFreeAroundPrimordialStop):
(std::testFreeInterleavedAroundPrimordialStop):
(std::testMultiplePartialsFromDifferentHeapsPerShared):
(std::testMultiplePartialsFromDifferentThreadsPerShared):
(std::testTwoBaselinesEvictions):
* Source/bmalloc/libpas/src/test/IsoHeapReservedMemoryTests.cpp:
(std::testSizeProgression):
* Source/bmalloc/libpas/src/test/JITHeapTests.cpp:
(std::testAllocateShrinkAndAllocate):
(std::testAllocationSize):
* Source/bmalloc/libpas/src/test/LotsOfHeapsAndThreads.cpp:
(std::testLotsOfHeapsAndThreads):
* Source/bmalloc/libpas/src/test/MemalignTests.cpp:
* Source/bmalloc/libpas/src/test/PGMTests.cpp:
(std::testPGMSingleAlloc):
(std::testPGMMultipleAlloc):
(std::testPGMRealloc):
(std::testPGMErrors):
* Source/bmalloc/libpas/src/test/RaceTests.cpp:
(std::testLocalAllocatorStopRace):
(std::testLocalAllocatorStopRaceAgainstScavenge):
* Source/bmalloc/libpas/src/test/TLCDecommitTests.cpp:
(std::testTLCDecommit):
(std::testChaosThenDecommit):
(std::testAllocateFromStoppedBaselineImpl):
* Source/bmalloc/libpas/src/test/TSDTests.cpp:
(std::destructor):
(std::testTSD):
* Source/bmalloc/libpas/src/test/ThingyAndUtilityHeapAllocationTests.cpp:
(std::testFreeListRefillSpans):
(std::testInternalScavenge):
(std::testInternalScavengeFromCorrectDirectory):
(std::testSpuriousEligibility):
(std::testBasicSizeClassNotSet):
(std::testSmallDoubleFree):
(std::testSmallFreeInner):
(std::testSmallFreeNextWithShrink):
(std::testSmallFreeNextWithoutShrink):
(std::testSmallFreeNextBeforeShrink):
(std::testAllocationChaos):
(std::testCombinedAllocationChaos):
(std::testLargeDoubleFree):
(std::testLargeOffsetFree):
(std::testReallocatePrimitive):
(std::testReallocateArray):
* Source/bmalloc/libpas/src/test/ViewCacheTests.cpp:
(std::testDisableViewCacheUsingBoundForNoViewCache):
(std::testEnableViewCacheAtSomeBoundForNoViewCache):

Canonical link: https://commits.webkit.org/279280@main

Source/bmalloc/libpas/src/chaos/Chaos.cpp

@@ -186,9 +186,10 @@ void threadMain(uintptr_t threadIndex)
                     iso_allocate_common_primitive_with_alignment(
                         targetSize,
                         static_cast<uintptr_t>(1) << uniform_int_distribution<uintptr_t>(
-                            0, maxMemalignShift)(randomGenerator)));
+                            0, maxMemalignShift)(randomGenerator),
+                            pas_non_compact_allocation_mode));
             } else
-                ptr = static_cast<char*>(iso_allocate_common_primitive(targetSize));
+                ptr = static_cast<char*>(iso_allocate_common_primitive(targetSize, pas_non_compact_allocation_mode));
 
             for (uintptr_t i = targetSize; i--;)
                 ptr[i] = static_cast<char>(i + 42);

Source/bmalloc/libpas/src/libpas/hotbit_heap.c

@@ -47,20 +47,20 @@ pas_heap hotbit_common_primitive_heap =
 
 pas_allocator_counts hotbit_allocator_counts;
 
-void* hotbit_try_allocate(size_t size)
+void* hotbit_try_allocate(size_t size, pas_allocation_mode allocation_mode)
 {
-    return hotbit_try_allocate_inline(size);
+    return hotbit_try_allocate_inline(size, allocation_mode);
 }
 
-void* hotbit_try_allocate_with_alignment(size_t size, size_t alignment)
+void* hotbit_try_allocate_with_alignment(size_t size, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return hotbit_try_allocate_with_alignment_inline(size, alignment);
+    return hotbit_try_allocate_with_alignment_inline(size, alignment, allocation_mode);
 }
 
 void* hotbit_try_reallocate(void* old_ptr, size_t new_size,
-                             pas_reallocate_free_mode free_mode)
+                             pas_reallocate_free_mode free_mode, pas_allocation_mode allocation_mode)
 {
-    return hotbit_try_reallocate_inline(old_ptr, new_size, free_mode);
+    return hotbit_try_reallocate_inline(old_ptr, new_size, free_mode, allocation_mode);
 }
 
 void hotbit_deallocate(void* ptr)

Source/bmalloc/libpas/src/libpas/hotbit_heap.h

@@ -27,17 +27,20 @@
 #define HOTBIT_HEAP_H
 
 #include "pas_reallocate_free_mode.h"
+#include "pas_allocation_mode.h"
 
 #if PAS_ENABLE_HOTBIT
 
 PAS_BEGIN_EXTERN_C;
 
-PAS_API void* hotbit_try_allocate(size_t size);
+PAS_API void* hotbit_try_allocate(size_t size, pas_allocation_mode allocation_mode);
 PAS_API void* hotbit_try_allocate_with_alignment(size_t size,
-                                                  size_t alignment);
+                                                  size_t alignment,
+                                                  pas_allocation_mode allocation_mode);
 
 PAS_API void* hotbit_try_reallocate(void* old_ptr, size_t new_size,
-                                     pas_reallocate_free_mode free_mode);
+                                     pas_reallocate_free_mode free_mode,
+                                    pas_allocation_mode allocation_mode);
 
 PAS_API void* hotbit_reallocate(void* old_ptr, size_t new_size,
                                  pas_reallocate_free_mode free_mode);

Source/bmalloc/libpas/src/libpas/hotbit_heap_inlines.h

@@ -59,25 +59,26 @@ PAS_CREATE_TRY_ALLOCATE_INTRINSIC(
     &hotbit_common_primitive_heap_support,
     pas_intrinsic_heap_is_not_designated);
 
-static PAS_ALWAYS_INLINE void* hotbit_try_allocate_inline(size_t size)
+static PAS_ALWAYS_INLINE void* hotbit_try_allocate_inline(size_t size, pas_allocation_mode allocation_mode)
 {
-    return (void*)hotbit_try_allocate_impl(size, 1).begin;
+    return (void*)hotbit_try_allocate_impl(size, 1, allocation_mode).begin;
 }
 
 static PAS_ALWAYS_INLINE void*
-hotbit_try_allocate_with_alignment_inline(size_t size, size_t alignment)
+hotbit_try_allocate_with_alignment_inline(size_t size, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return (void*)hotbit_try_allocate_with_alignment_impl(size, alignment).begin;
+    return (void*)hotbit_try_allocate_with_alignment_impl(size, alignment, allocation_mode).begin;
 }
 
 static PAS_ALWAYS_INLINE void*
 hotbit_try_reallocate_inline(void* old_ptr, size_t new_size,
-                              pas_reallocate_free_mode free_mode)
+                              pas_reallocate_free_mode free_mode, pas_allocation_mode allocation_mode)
 {
     return (void*)pas_try_reallocate_intrinsic(
         old_ptr,
         &hotbit_common_primitive_heap,
         new_size,
+        allocation_mode,
         HOTBIT_HEAP_CONFIG,
         hotbit_try_allocate_impl_for_realloc,
         pas_reallocate_allow_heap_teleport,

Source/bmalloc/libpas/src/libpas/iso_heap.c

@@ -58,87 +58,95 @@ pas_dynamic_primitive_heap_map iso_primitive_dynamic_heap_map =
 pas_dynamic_primitive_heap_map iso_flex_dynamic_heap_map =
     PAS_DYNAMIC_PRIMITIVE_HEAP_MAP_INITIALIZER(iso_primitive_heap_ref_construct);
 
-void* iso_try_allocate_common_primitive(size_t size)
+void* iso_try_allocate_common_primitive(size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_common_primitive_inline(size);
+    return iso_try_allocate_common_primitive_inline(size, allocation_mode);
 }
 
-void* iso_try_allocate_common_primitive_with_alignment(size_t size, size_t alignment)
+void* iso_try_allocate_common_primitive_with_alignment(size_t size, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_common_primitive_with_alignment_inline(size, alignment);
+    return iso_try_allocate_common_primitive_with_alignment_inline(size, alignment, allocation_mode);
 }
 
-void* iso_try_allocate_common_primitive_zeroed(size_t size)
+void* iso_try_allocate_common_primitive_zeroed(size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_common_primitive_zeroed_inline(size);
+    return iso_try_allocate_common_primitive_zeroed_inline(size, allocation_mode);
 }
 
-void* iso_allocate_common_primitive(size_t size)
+void* iso_allocate_common_primitive(size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_common_primitive_inline(size);
+    return iso_allocate_common_primitive_inline(size, allocation_mode);
 }
 
-void* iso_allocate_common_primitive_with_alignment(size_t size, size_t alignment)
+void* iso_allocate_common_primitive_with_alignment(size_t size, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_common_primitive_with_alignment_inline(size, alignment);
+    return iso_allocate_common_primitive_with_alignment_inline(size, alignment, allocation_mode);
 }
 
-void* iso_allocate_common_primitive_zeroed(size_t size)
+void* iso_allocate_common_primitive_zeroed(size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_common_primitive_zeroed_inline(size);
+    return iso_allocate_common_primitive_zeroed_inline(size, allocation_mode);
 }
 
 void* iso_try_reallocate_common_primitive(void* old_ptr, size_t new_size,
-                                          pas_reallocate_free_mode free_mode)
+                                          pas_reallocate_free_mode free_mode,
+                                          pas_allocation_mode allocation_mode)
 {
-    return iso_try_reallocate_common_primitive_inline(old_ptr, new_size, free_mode);
+    return iso_try_reallocate_common_primitive_inline(old_ptr, new_size, free_mode, allocation_mode);
 }
 
 void* iso_reallocate_common_primitive(void* old_ptr, size_t new_size,
-                                      pas_reallocate_free_mode free_mode)
+                                      pas_reallocate_free_mode free_mode,
+                                      pas_allocation_mode allocation_mode)
 {
-    return iso_reallocate_common_primitive_inline(old_ptr, new_size, free_mode);
+    return iso_reallocate_common_primitive_inline(old_ptr, new_size, free_mode, allocation_mode);
 }
 
-void* iso_try_allocate_dynamic_primitive(const void* key, size_t size)
+void* iso_try_allocate_dynamic_primitive(const void* key, size_t size, pas_allocation_mode allocation_mode)
 {
     return iso_try_allocate_primitive(
         pas_dynamic_primitive_heap_map_find(
             &iso_primitive_dynamic_heap_map, key, size),
-        size);
+        size, allocation_mode);
 }
 
 void* iso_try_allocate_dynamic_primitive_with_alignment(const void* key,
                                                         size_t size,
-                                                        size_t alignment)
+                                                        size_t alignment,
+                                                        pas_allocation_mode allocation_mode)
 {
     return iso_try_allocate_primitive_with_alignment(
         pas_dynamic_primitive_heap_map_find(
             &iso_primitive_dynamic_heap_map, key, size),
         size,
-        alignment);
+        alignment,
+        allocation_mode);
 }
 
 void* iso_try_allocate_dynamic_primitive_zeroed(const void* key,
-                                                size_t size)
+                                                size_t size,
+                                                pas_allocation_mode allocation_mode)
 {
     return iso_try_allocate_primitive_zeroed(
         pas_dynamic_primitive_heap_map_find(
             &iso_primitive_dynamic_heap_map, key, size),
-        size);
+        size,
+        allocation_mode);
 }
 
 void* iso_try_reallocate_dynamic_primitive(void* old_ptr,
                                            const void* key,
                                            size_t new_size,
-                                           pas_reallocate_free_mode free_mode)
+                                           pas_reallocate_free_mode free_mode,
+                                           pas_allocation_mode allocation_mode)
 {
     return iso_try_reallocate_primitive(
         old_ptr,
         pas_dynamic_primitive_heap_map_find(
             &iso_primitive_dynamic_heap_map, key, new_size),
         new_size,
-        free_mode);
+        free_mode,
+        allocation_mode);
 }
 
 void iso_heap_ref_construct(pas_heap_ref* heap_ref,
@@ -149,48 +157,50 @@ void iso_heap_ref_construct(pas_heap_ref* heap_ref,
     heap_ref->allocator_index = 0;
 }
 
-void* iso_try_allocate(pas_heap_ref* heap_ref)
+void* iso_try_allocate(pas_heap_ref* heap_ref, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_inline(heap_ref);
+    return iso_try_allocate_inline(heap_ref, allocation_mode);
 }
 
-void* iso_allocate(pas_heap_ref* heap_ref)
+void* iso_allocate(pas_heap_ref* heap_ref, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_inline(heap_ref);
+    return iso_allocate_inline(heap_ref, allocation_mode);
 }
 
-void* iso_try_allocate_array_by_count(pas_heap_ref* heap_ref, size_t count, size_t alignment)
+void* iso_try_allocate_array_by_count(pas_heap_ref* heap_ref, size_t count, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_array_by_count_inline(heap_ref, count, alignment);
+    return iso_try_allocate_array_by_count_inline(heap_ref, count, alignment, allocation_mode);
 }
 
-void* iso_allocate_array_by_count(pas_heap_ref* heap_ref, size_t count, size_t alignment)
+void* iso_allocate_array_by_count(pas_heap_ref* heap_ref, size_t count, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_array_by_count_inline(heap_ref, count, alignment);
+    return iso_allocate_array_by_count_inline(heap_ref, count, alignment, allocation_mode);
 }
 
-void* iso_try_allocate_array_by_count_zeroed(pas_heap_ref* heap_ref, size_t count, size_t alignment)
+void* iso_try_allocate_array_by_count_zeroed(pas_heap_ref* heap_ref, size_t count, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_array_by_count_zeroed_inline(heap_ref, count, alignment);
+    return iso_try_allocate_array_by_count_zeroed_inline(heap_ref, count, alignment, allocation_mode);
 }
 
-void* iso_allocate_array_by_count_zeroed(pas_heap_ref* heap_ref, size_t count, size_t alignment)
+void* iso_allocate_array_by_count_zeroed(pas_heap_ref* heap_ref, size_t count, size_t alignment, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_array_by_count_zeroed_inline(heap_ref, count, alignment);
+    return iso_allocate_array_by_count_zeroed_inline(heap_ref, count, alignment, allocation_mode);
 }
 
 void* iso_try_reallocate_array_by_count(void* old_ptr, pas_heap_ref* heap_ref,
                                         size_t new_count,
-                                        pas_reallocate_free_mode free_mode)
+                                        pas_reallocate_free_mode free_mode,
+                                        pas_allocation_mode allocation_mode)
 {
-    return iso_try_reallocate_array_by_count_inline(old_ptr, heap_ref, new_count, free_mode);
+    return iso_try_reallocate_array_by_count_inline(old_ptr, heap_ref, new_count, free_mode, allocation_mode);
 }
 
 void* iso_reallocate_array_by_count(void* old_ptr, pas_heap_ref* heap_ref,
                                     size_t new_count,
-                                    pas_reallocate_free_mode free_mode)
+                                    pas_reallocate_free_mode free_mode,
+                                    pas_allocation_mode allocation_mode)
 {
-    return iso_reallocate_array_by_count_inline(old_ptr, heap_ref, new_count, free_mode);
+    return iso_reallocate_array_by_count_inline(old_ptr, heap_ref, new_count, free_mode, allocation_mode);
 }
 
 pas_heap* iso_heap_ref_get_heap(pas_heap_ref* heap_ref)
@@ -211,62 +221,68 @@ void iso_primitive_heap_ref_construct(pas_primitive_heap_ref* heap_ref,
 }
 
 void* iso_try_allocate_primitive(pas_primitive_heap_ref* heap_ref,
-                                 size_t size)
+                                 size_t size,
+                                 pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_primitive_inline(heap_ref, size);
+    return iso_try_allocate_primitive_inline(heap_ref, size, allocation_mode);
 }
 
 void* iso_allocate_primitive(pas_primitive_heap_ref* heap_ref,
-                             size_t size)
+                             size_t size,
+                             pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_primitive_inline(heap_ref, size);
+    return iso_allocate_primitive_inline(heap_ref, size, allocation_mode);
 }
 
 void* iso_try_allocate_primitive_zeroed(pas_primitive_heap_ref* heap_ref,
-                                        size_t size)
+                                        size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_primitive_zeroed_inline(heap_ref, size);
+    return iso_try_allocate_primitive_zeroed_inline(heap_ref, size, allocation_mode);
 }
 
 void* iso_allocate_primitive_zeroed(pas_primitive_heap_ref* heap_ref,
-                                    size_t size)
+                                    size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_primitive_zeroed_inline(heap_ref, size);
+    return iso_allocate_primitive_zeroed_inline(heap_ref, size, allocation_mode);
 }
 
 void* iso_try_allocate_primitive_with_alignment(pas_primitive_heap_ref* heap_ref,
                                                 size_t size,
-                                                size_t alignment)
+                                                size_t alignment,
+                                                pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_primitive_with_alignment_inline(heap_ref, size, alignment);
+    return iso_try_allocate_primitive_with_alignment_inline(heap_ref, size, alignment, allocation_mode);
 }
 
 void* iso_allocate_primitive_with_alignment(pas_primitive_heap_ref* heap_ref,
                                             size_t size,
-                                            size_t alignment)
+                                            size_t alignment,
+                                            pas_allocation_mode allocation_mode)
 {
-    return iso_allocate_primitive_with_alignment_inline(heap_ref, size, alignment);
+    return iso_allocate_primitive_with_alignment_inline(heap_ref, size, alignment, allocation_mode);
 }
 
 void* iso_try_reallocate_primitive(void* old_ptr,
                                    pas_primitive_heap_ref* heap_ref,
                                    size_t new_size,
-                                   pas_reallocate_free_mode free_mode)
+                                   pas_reallocate_free_mode free_mode,
+                                   pas_allocation_mode allocation_mode)
 {
-    return iso_try_reallocate_primitive_inline(old_ptr, heap_ref, new_size, free_mode);
+    return iso_try_reallocate_primitive_inline(old_ptr, heap_ref, new_size, free_mode, allocation_mode);
 }
 
 void* iso_reallocate_primitive(void* old_ptr,
                                pas_primitive_heap_ref* heap_ref,
                                size_t new_size,
-                               pas_reallocate_free_mode free_mode)
+                               pas_reallocate_free_mode free_mode,
+                               pas_allocation_mode allocation_mode)
 {
-    return iso_reallocate_primitive_inline(old_ptr, heap_ref, new_size, free_mode);
+    return iso_reallocate_primitive_inline(old_ptr, heap_ref, new_size, free_mode, allocation_mode);
 }
 
-void* iso_try_allocate_for_flex(const void* cls, size_t size)
+void* iso_try_allocate_for_flex(const void* cls, size_t size, pas_allocation_mode allocation_mode)
 {
-    return iso_try_allocate_for_flex_inline(cls, size);
+    return iso_try_allocate_for_flex_inline(cls, size, allocation_mode);
 }
 
 bool iso_has_object(void* ptr)