Merge pull request #159 from devnexen/using_flatten_cpp

struct · web-flow · commit 59ac28589268 · 2022-12-03T11:57:53.000-05:00
using flatten attribute on most of public interface.
diff --git a/src/iso_alloc.cpp b/src/iso_alloc.cpp
@@ -26,43 +26,43 @@ extern "C" __attribute__((constructor(FIRST_CTOR + 1))) void iso_cpp(void) {
 // These hooks override the basic new/delete
 // operators to use the iso_alloc API
 
-EXTERNAL_API void *operator new(size_t size) NEW_EXCEPT {
+EXTERNAL_API FLATTEN void *operator new(size_t size) NEW_EXCEPT {
     return iso_alloc(size);
 }
 
-EXTERNAL_API void operator delete(void *p) noexcept {
+EXTERNAL_API FLATTEN void operator delete(void *p) noexcept {
     iso_free(p);
 }
 
-EXTERNAL_API void *operator new[](size_t size) NEW_EXCEPT {
+EXTERNAL_API FLATTEN void *operator new[](size_t size) NEW_EXCEPT {
     return iso_alloc(size);
 }
 
-EXTERNAL_API void operator delete[](void *p) noexcept {
+EXTERNAL_API FLATTEN void operator delete[](void *p) noexcept {
     iso_free(p);
 }
 
-EXTERNAL_API void *operator new(size_t size, const std::nothrow_t &) noexcept {
+EXTERNAL_API FLATTEN void *operator new(size_t size, const std::nothrow_t &) noexcept {
     return iso_alloc(size);
 }
 
-EXTERNAL_API void *operator new[](size_t size, const std::nothrow_t &) noexcept {
+EXTERNAL_API FLATTEN void *operator new[](size_t size, const std::nothrow_t &) noexcept {
     return iso_alloc(size);
 }
 
-void operator delete(void *ptr, size_t size) noexcept {
+FLATTEN void operator delete(void *ptr, size_t size) noexcept {
     return iso_free_size(ptr, size);
 }
 
-void operator delete[](void *ptr, size_t size) noexcept {
+FLATTEN void operator delete[](void *ptr, size_t size) noexcept {
     return iso_free_size(ptr, size);
 }
 
-EXTERNAL_API void operator delete(void *ptr, const std::nothrow_t &) noexcept {
+EXTERNAL_API FLATTEN void operator delete(void *ptr, const std::nothrow_t &) noexcept {
     return iso_free(ptr);
 }
 
-EXTERNAL_API void operator delete[](void *ptr, const std::nothrow_t &) noexcept {
+EXTERNAL_API FLATTEN void operator delete[](void *ptr, const std::nothrow_t &) noexcept {
     return iso_free(ptr);
 }
 
diff --git a/src/iso_alloc_interfaces.c b/src/iso_alloc_interfaces.c
@@ -10,49 +10,49 @@
 #include "iso_alloc_profiler.h"
 #endif
 
-EXTERNAL_API void iso_alloc_initialize(void) {
+EXTERNAL_API FLATTEN void iso_alloc_initialize(void) {
     _iso_alloc_initialize();
 }
 
-EXTERNAL_API void iso_alloc_destroy(void) {
+EXTERNAL_API FLATTEN void iso_alloc_destroy(void) {
     _iso_alloc_destroy();
 }
 
-EXTERNAL_API NO_DISCARD MALLOC_ATTR ALLOC_SIZE ASSUME_ALIGNED void *iso_alloc(size_t size) {
+EXTERNAL_API NO_DISCARD FLATTEN MALLOC_ATTR ALLOC_SIZE ASSUME_ALIGNED void *iso_alloc(size_t size) {
     return _iso_alloc(NULL, size);
 }
 
-EXTERNAL_API NO_DISCARD MALLOC_ATTR CALLOC_SIZE ASSUME_ALIGNED void *iso_calloc(size_t nmemb, size_t size) {
+EXTERNAL_API NO_DISCARD FLATTEN MALLOC_ATTR CALLOC_SIZE ASSUME_ALIGNED void *iso_calloc(size_t nmemb, size_t size) {
     return _iso_calloc(nmemb, size);
 }
 
-EXTERNAL_API void iso_free(void *p) {
+EXTERNAL_API FLATTEN void iso_free(void *p) {
     _iso_free(p, false);
 }
 
-EXTERNAL_API void iso_free_size(void *p, size_t size) {
+EXTERNAL_API FLATTEN void iso_free_size(void *p, size_t size) {
     _iso_free_size(p, size);
 }
 
-EXTERNAL_API void iso_free_from_zone(void *p, iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN void iso_free_from_zone(void *p, iso_alloc_zone_handle *zone) {
     UNMASK_ZONE_HANDLE(zone);
     _iso_free_from_zone(p, zone, false);
 }
 
-EXTERNAL_API void iso_free_from_zone_permanently(void *p, iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN void iso_free_from_zone_permanently(void *p, iso_alloc_zone_handle *zone) {
     UNMASK_ZONE_HANDLE(zone);
     _iso_free_from_zone(p, zone, true);
 }
 
-EXTERNAL_API void iso_free_permanently(void *p) {
+EXTERNAL_API FLATTEN void iso_free_permanently(void *p) {
     _iso_free(p, true);
 }
 
-EXTERNAL_API size_t iso_chunksz(void *p) {
+EXTERNAL_API FLATTEN size_t iso_chunksz(void *p) {
     return _iso_chunk_size(p);
 }
 
-EXTERNAL_API NO_DISCARD size_t iso_zone_chunk_count(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN NO_DISCARD size_t iso_zone_chunk_count(iso_alloc_zone_handle *zone) {
     UNMASK_ZONE_HANDLE(zone);
     iso_alloc_zone_t *_zone = (iso_alloc_zone_t *) zone;
     size_t canaries = 0;
@@ -63,7 +63,7 @@ EXTERNAL_API NO_DISCARD size_t iso_zone_chunk_count(iso_alloc_zone_handle *zone)
     return (_zone->chunk_count - canaries);
 }
 
-EXTERNAL_API NO_DISCARD REALLOC_SIZE ASSUME_ALIGNED void *iso_realloc(void *p, size_t size) {
+EXTERNAL_API FLATTEN NO_DISCARD REALLOC_SIZE ASSUME_ALIGNED void *iso_realloc(void *p, size_t size) {
     if(size == 0) {
         iso_free(p);
         return NULL;
@@ -94,7 +94,7 @@ EXTERNAL_API NO_DISCARD REALLOC_SIZE ASSUME_ALIGNED void *iso_realloc(void *p, s
     return r;
 }
 
-EXTERNAL_API NO_DISCARD MALLOC_ATTR REALLOC_SIZE ASSUME_ALIGNED void *iso_reallocarray(void *p, size_t nmemb, size_t size) {
+EXTERNAL_API FLATTEN NO_DISCARD MALLOC_ATTR REALLOC_SIZE ASSUME_ALIGNED void *iso_reallocarray(void *p, size_t nmemb, size_t size) {
     unsigned int res;
 
     if(__builtin_umul_overflow(nmemb, size, &res)) {
@@ -104,11 +104,11 @@ EXTERNAL_API NO_DISCARD MALLOC_ATTR REALLOC_SIZE ASSUME_ALIGNED void *iso_reallo
     return iso_realloc(p, nmemb * size);
 }
 
-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strdup(const char *str) {
+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char *iso_strdup(const char *str) {
     return iso_strdup_from_zone(NULL, str);
 }
 
-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strdup_from_zone(iso_alloc_zone_handle *zone, const char *str) {
+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char *iso_strdup_from_zone(iso_alloc_zone_handle *zone, const char *str) {
     if(str == NULL) {
         return NULL;
     }
@@ -129,11 +129,11 @@ EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strdup_from_zone(iso_alloc_zone
     return p;
 }
 
-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strndup(const char *str, size_t n) {
+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char *iso_strndup(const char *str, size_t n) {
     return iso_strndup_from_zone(NULL, str, n);
 }
 
-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strndup_from_zone(iso_alloc_zone_handle *zone, const char *str, size_t n) {
+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char *iso_strndup_from_zone(iso_alloc_zone_handle *zone, const char *str, size_t n) {
     if(str == NULL) {
         return NULL;
     }
@@ -160,7 +160,7 @@ EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strndup_from_zone(iso_alloc_zon
     return p;
 }
 
-EXTERNAL_API NO_DISCARD MALLOC_ATTR ASSUME_ALIGNED void *iso_alloc_from_zone(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN NO_DISCARD MALLOC_ATTR ASSUME_ALIGNED void *iso_alloc_from_zone(iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return NULL;
     }
@@ -171,7 +171,7 @@ EXTERNAL_API NO_DISCARD MALLOC_ATTR ASSUME_ALIGNED void *iso_alloc_from_zone(iso
     return _iso_alloc(zone, _zone->chunk_size);
 }
 
-EXTERNAL_API NO_DISCARD MALLOC_ATTR void *iso_alloc_from_zone_tagged(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN NO_DISCARD MALLOC_ATTR void *iso_alloc_from_zone_tagged(iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return NULL;
     }
@@ -183,7 +183,7 @@ EXTERNAL_API NO_DISCARD MALLOC_ATTR void *iso_alloc_from_zone_tagged(iso_alloc_z
     return _tag_ptr(p, zone);
 }
 
-EXTERNAL_API NO_DISCARD void *iso_alloc_tag_ptr(void *p, iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN NO_DISCARD void *iso_alloc_tag_ptr(void *p, iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return NULL;
     }
@@ -192,7 +192,7 @@ EXTERNAL_API NO_DISCARD void *iso_alloc_tag_ptr(void *p, iso_alloc_zone_handle *
     return _tag_ptr(p, zone);
 }
 
-EXTERNAL_API NO_DISCARD void *iso_alloc_untag_ptr(void *p, iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN NO_DISCARD void *iso_alloc_untag_ptr(void *p, iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return NULL;
     }
@@ -201,7 +201,7 @@ EXTERNAL_API NO_DISCARD void *iso_alloc_untag_ptr(void *p, iso_alloc_zone_handle
     return _untag_ptr(p, zone);
 }
 
-EXTERNAL_API void iso_alloc_verify_ptr_tag(void *p, iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN void iso_alloc_verify_ptr_tag(void *p, iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return;
     }
@@ -211,7 +211,7 @@ EXTERNAL_API void iso_alloc_verify_ptr_tag(void *p, iso_alloc_zone_handle *zone)
     return;
 }
 
-EXTERNAL_API NO_DISCARD uint8_t iso_alloc_get_mem_tag(void *p, iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN NO_DISCARD uint8_t iso_alloc_get_mem_tag(void *p, iso_alloc_zone_handle *zone) {
     if(zone == NULL || p == NULL) {
         return 0;
     }
@@ -220,7 +220,7 @@ EXTERNAL_API NO_DISCARD uint8_t iso_alloc_get_mem_tag(void *p, iso_alloc_zone_ha
     return _iso_alloc_get_mem_tag(p, zone);
 }
 
-EXTERNAL_API void iso_alloc_destroy_zone(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN void iso_alloc_destroy_zone(iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return;
     }
@@ -229,13 +229,13 @@ EXTERNAL_API void iso_alloc_destroy_zone(iso_alloc_zone_handle *zone) {
     _iso_alloc_destroy_zone(zone);
 }
 
-EXTERNAL_API NO_DISCARD iso_alloc_zone_handle *iso_alloc_new_zone(size_t size) {
+EXTERNAL_API FLATTEN NO_DISCARD iso_alloc_zone_handle *iso_alloc_new_zone(size_t size) {
     iso_alloc_zone_handle *zone = (iso_alloc_zone_handle *) iso_new_zone(size, false);
     UNMASK_ZONE_HANDLE(zone);
     return zone;
 }
 
-EXTERNAL_API int32_t iso_alloc_name_zone(iso_alloc_zone_handle *zone, char *name) {
+EXTERNAL_API FLATTEN int32_t iso_alloc_name_zone(iso_alloc_zone_handle *zone, char *name) {
     if(zone == NULL) {
         return 0;
     } else {
@@ -246,15 +246,15 @@ EXTERNAL_API int32_t iso_alloc_name_zone(iso_alloc_zone_handle *zone, char *name
     return name_mapping(_zone->user_pages_start, ZONE_USER_SIZE, name);
 }
 
-EXTERNAL_API void iso_alloc_protect_root(void) {
+EXTERNAL_API FLATTEN void iso_alloc_protect_root(void) {
     _iso_alloc_protect_root();
 }
 
-EXTERNAL_API void iso_alloc_unprotect_root(void) {
+EXTERNAL_API FLATTEN void iso_alloc_unprotect_root(void) {
     _iso_alloc_unprotect_root();
 }
 
-EXTERNAL_API uint64_t iso_alloc_detect_zone_leaks(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN uint64_t iso_alloc_detect_zone_leaks(iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return 0;
     } else {
@@ -264,11 +264,11 @@ EXTERNAL_API uint64_t iso_alloc_detect_zone_leaks(iso_alloc_zone_handle *zone) {
     return _iso_alloc_detect_leaks_in_zone(zone);
 }
 
-EXTERNAL_API uint64_t iso_alloc_detect_leaks(void) {
+EXTERNAL_API FLATTEN uint64_t iso_alloc_detect_leaks(void) {
     return _iso_alloc_detect_leaks();
 }
 
-EXTERNAL_API uint64_t iso_alloc_zone_mem_usage(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN uint64_t iso_alloc_zone_mem_usage(iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return 0;
     } else {
@@ -278,15 +278,15 @@ EXTERNAL_API uint64_t iso_alloc_zone_mem_usage(iso_alloc_zone_handle *zone) {
     return _iso_alloc_zone_mem_usage(zone);
 }
 
-EXTERNAL_API uint64_t iso_alloc_mem_usage(void) {
+EXTERNAL_API FLATTEN uint64_t iso_alloc_mem_usage(void) {
     return _iso_alloc_mem_usage();
 }
 
-EXTERNAL_API void iso_verify_zones(void) {
+EXTERNAL_API FLATTEN void iso_verify_zones(void) {
     verify_all_zones();
 }
 
-EXTERNAL_API void iso_verify_zone(iso_alloc_zone_handle *zone) {
+EXTERNAL_API FLATTEN void iso_verify_zone(iso_alloc_zone_handle *zone) {
     if(zone == NULL) {
         return;
     } else {
@@ -296,26 +296,26 @@ EXTERNAL_API void iso_verify_zone(iso_alloc_zone_handle *zone) {
     verify_zone(zone);
 }
 
-EXTERNAL_API void iso_flush_caches(void) {
+EXTERNAL_API FLATTEN void iso_flush_caches(void) {
     flush_caches();
 }
 
 #if HEAP_PROFILER
-EXTERNAL_API size_t iso_get_alloc_traces(iso_alloc_traces_t *traces_out) {
+EXTERNAL_API FLATTEN size_t iso_get_alloc_traces(iso_alloc_traces_t *traces_out) {
     return _iso_get_alloc_traces(traces_out);
 }
 
-EXTERNAL_API size_t iso_get_free_traces(iso_free_traces_t *traces_out) {
+EXTERNAL_API FLATTEN size_t iso_get_free_traces(iso_free_traces_t *traces_out) {
     return _iso_get_free_traces(traces_out);
 }
 
-EXTERNAL_API void iso_alloc_reset_traces(void) {
+EXTERNAL_API FLATTEN void iso_alloc_reset_traces(void) {
     _iso_alloc_reset_traces();
 }
 #endif
 
 #if EXPERIMENTAL
-EXTERNAL_API void iso_alloc_search_stack(void *p) {
+EXTERNAL_API FLATTEN void iso_alloc_search_stack(void *p) {
     _iso_alloc_search_stack(p);
 }
 #endif

Original file line number	Diff line number	Diff line change
`@@ -26,43 +26,43 @@ extern "C" __attribute__((constructor(FIRST_CTOR + 1))) void iso_cpp(void) {`
`26`	`26`	`// These hooks override the basic new/delete`
`27`	`27`	`// operators to use the iso_alloc API`
`28`	`28`
`29`		`-EXTERNAL_API void *operator new(size_t size) NEW_EXCEPT {`
	`29`	`+EXTERNAL_API FLATTEN void *operator new(size_t size) NEW_EXCEPT {`
`30`	`30`	`return iso_alloc(size);`
`31`	`31`	`}`
`32`	`32`
`33`		`-EXTERNAL_API void operator delete(void *p) noexcept {`
	`33`	`+EXTERNAL_API FLATTEN void operator delete(void *p) noexcept {`
`34`	`34`	`iso_free(p);`
`35`	`35`	`}`
`36`	`36`
`37`		`-EXTERNAL_API void *operator new[](size_t size) NEW_EXCEPT {`
	`37`	`+EXTERNAL_API FLATTEN void *operator new[](size_t size) NEW_EXCEPT {`
`38`	`38`	`return iso_alloc(size);`
`39`	`39`	`}`
`40`	`40`
`41`		`-EXTERNAL_API void operator delete[](void *p) noexcept {`
	`41`	`+EXTERNAL_API FLATTEN void operator delete[](void *p) noexcept {`
`42`	`42`	`iso_free(p);`
`43`	`43`	`}`
`44`	`44`
`45`		`-EXTERNAL_API void *operator new(size_t size, const std::nothrow_t &) noexcept {`
	`45`	`+EXTERNAL_API FLATTEN void *operator new(size_t size, const std::nothrow_t &) noexcept {`
`46`	`46`	`return iso_alloc(size);`
`47`	`47`	`}`
`48`	`48`
`49`		`-EXTERNAL_API void *operator new[](size_t size, const std::nothrow_t &) noexcept {`
	`49`	`+EXTERNAL_API FLATTEN void *operator new[](size_t size, const std::nothrow_t &) noexcept {`
`50`	`50`	`return iso_alloc(size);`
`51`	`51`	`}`
`52`	`52`
`53`		`-void operator delete(void *ptr, size_t size) noexcept {`
	`53`	`+FLATTEN void operator delete(void *ptr, size_t size) noexcept {`
`54`	`54`	`return iso_free_size(ptr, size);`
`55`	`55`	`}`
`56`	`56`
`57`		`-void operator delete[](void *ptr, size_t size) noexcept {`
	`57`	`+FLATTEN void operator delete[](void *ptr, size_t size) noexcept {`
`58`	`58`	`return iso_free_size(ptr, size);`
`59`	`59`	`}`
`60`	`60`
`61`		`-EXTERNAL_API void operator delete(void *ptr, const std::nothrow_t &) noexcept {`
	`61`	`+EXTERNAL_API FLATTEN void operator delete(void *ptr, const std::nothrow_t &) noexcept {`
`62`	`62`	`return iso_free(ptr);`
`63`	`63`	`}`
`64`	`64`
`65`		`-EXTERNAL_API void operator delete[](void *ptr, const std::nothrow_t &) noexcept {`
	`65`	`+EXTERNAL_API FLATTEN void operator delete[](void *ptr, const std::nothrow_t &) noexcept {`
`66`	`66`	`return iso_free(ptr);`
`67`	`67`	`}`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -10,49 +10,49 @@`
`10`	`10`	`#include "iso_alloc_profiler.h"`
`11`	`11`	`#endif`
`12`	`12`
`13`		`-EXTERNAL_API void iso_alloc_initialize(void) {`
	`13`	`+EXTERNAL_API FLATTEN void iso_alloc_initialize(void) {`
`14`	`14`	`_iso_alloc_initialize();`
`15`	`15`	`}`
`16`	`16`
`17`		`-EXTERNAL_API void iso_alloc_destroy(void) {`
	`17`	`+EXTERNAL_API FLATTEN void iso_alloc_destroy(void) {`
`18`	`18`	`_iso_alloc_destroy();`
`19`	`19`	`}`
`20`	`20`
`21`		`-EXTERNAL_API NO_DISCARD MALLOC_ATTR ALLOC_SIZE ASSUME_ALIGNED void *iso_alloc(size_t size) {`
	`21`	`+EXTERNAL_API NO_DISCARD FLATTEN MALLOC_ATTR ALLOC_SIZE ASSUME_ALIGNED void *iso_alloc(size_t size) {`
`22`	`22`	`return _iso_alloc(NULL, size);`
`23`	`23`	`}`
`24`	`24`
`25`		`-EXTERNAL_API NO_DISCARD MALLOC_ATTR CALLOC_SIZE ASSUME_ALIGNED void *iso_calloc(size_t nmemb, size_t size) {`
	`25`	`+EXTERNAL_API NO_DISCARD FLATTEN MALLOC_ATTR CALLOC_SIZE ASSUME_ALIGNED void *iso_calloc(size_t nmemb, size_t size) {`
`26`	`26`	`return _iso_calloc(nmemb, size);`
`27`	`27`	`}`
`28`	`28`
`29`		`-EXTERNAL_API void iso_free(void *p) {`
	`29`	`+EXTERNAL_API FLATTEN void iso_free(void *p) {`
`30`	`30`	`_iso_free(p, false);`
`31`	`31`	`}`
`32`	`32`
`33`		`-EXTERNAL_API void iso_free_size(void *p, size_t size) {`
	`33`	`+EXTERNAL_API FLATTEN void iso_free_size(void *p, size_t size) {`
`34`	`34`	`_iso_free_size(p, size);`
`35`	`35`	`}`
`36`	`36`
`37`		`-EXTERNAL_API void iso_free_from_zone(void p, iso_alloc_zone_handle zone) {`
	`37`	`+EXTERNAL_API FLATTEN void iso_free_from_zone(void p, iso_alloc_zone_handle zone) {`
`38`	`38`	`UNMASK_ZONE_HANDLE(zone);`
`39`	`39`	`_iso_free_from_zone(p, zone, false);`
`40`	`40`	`}`
`41`	`41`
`42`		`-EXTERNAL_API void iso_free_from_zone_permanently(void p, iso_alloc_zone_handle zone) {`
	`42`	`+EXTERNAL_API FLATTEN void iso_free_from_zone_permanently(void p, iso_alloc_zone_handle zone) {`
`43`	`43`	`UNMASK_ZONE_HANDLE(zone);`
`44`	`44`	`_iso_free_from_zone(p, zone, true);`
`45`	`45`	`}`
`46`	`46`
`47`		`-EXTERNAL_API void iso_free_permanently(void *p) {`
	`47`	`+EXTERNAL_API FLATTEN void iso_free_permanently(void *p) {`
`48`	`48`	`_iso_free(p, true);`
`49`	`49`	`}`
`50`	`50`
`51`		`-EXTERNAL_API size_t iso_chunksz(void *p) {`
	`51`	`+EXTERNAL_API FLATTEN size_t iso_chunksz(void *p) {`
`52`	`52`	`return _iso_chunk_size(p);`
`53`	`53`	`}`
`54`	`54`
`55`		`-EXTERNAL_API NO_DISCARD size_t iso_zone_chunk_count(iso_alloc_zone_handle *zone) {`
	`55`	`+EXTERNAL_API FLATTEN NO_DISCARD size_t iso_zone_chunk_count(iso_alloc_zone_handle *zone) {`
`56`	`56`	`UNMASK_ZONE_HANDLE(zone);`
`57`	`57`	`iso_alloc_zone_t _zone = (iso_alloc_zone_t ) zone;`
`58`	`58`	`size_t canaries = 0;`
`@@ -63,7 +63,7 @@ EXTERNAL_API NO_DISCARD size_t iso_zone_chunk_count(iso_alloc_zone_handle *zone)`
`63`	`63`	`return (_zone->chunk_count - canaries);`
`64`	`64`	`}`
`65`	`65`
`66`		`-EXTERNAL_API NO_DISCARD REALLOC_SIZE ASSUME_ALIGNED void iso_realloc(void p, size_t size) {`
	`66`	`+EXTERNAL_API FLATTEN NO_DISCARD REALLOC_SIZE ASSUME_ALIGNED void iso_realloc(void p, size_t size) {`
`67`	`67`	`if(size == 0) {`
`68`	`68`	`iso_free(p);`
`69`	`69`	`return NULL;`
`@@ -94,7 +94,7 @@ EXTERNAL_API NO_DISCARD REALLOC_SIZE ASSUME_ALIGNED void iso_realloc(void p, s`
`94`	`94`	`return r;`
`95`	`95`	`}`
`96`	`96`
`97`		`-EXTERNAL_API NO_DISCARD MALLOC_ATTR REALLOC_SIZE ASSUME_ALIGNED void iso_reallocarray(void p, size_t nmemb, size_t size) {`
	`97`	`+EXTERNAL_API FLATTEN NO_DISCARD MALLOC_ATTR REALLOC_SIZE ASSUME_ALIGNED void iso_reallocarray(void p, size_t nmemb, size_t size) {`
`98`	`98`	`unsigned int res;`
`99`	`99`
`100`	`100`	`if(__builtin_umul_overflow(nmemb, size, &res)) {`
`@@ -104,11 +104,11 @@ EXTERNAL_API NO_DISCARD MALLOC_ATTR REALLOC_SIZE ASSUME_ALIGNED void *iso_reallo`
`104`	`104`	`return iso_realloc(p, nmemb * size);`
`105`	`105`	`}`
`106`	`106`
`107`		`-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char iso_strdup(const char str) {`
	`107`	`+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char iso_strdup(const char str) {`
`108`	`108`	`return iso_strdup_from_zone(NULL, str);`
`109`	`109`	`}`
`110`	`110`
`111`		`-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char iso_strdup_from_zone(iso_alloc_zone_handle zone, const char *str) {`
	`111`	`+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char iso_strdup_from_zone(iso_alloc_zone_handle zone, const char *str) {`
`112`	`112`	`if(str == NULL) {`
`113`	`113`	`return NULL;`
`114`	`114`	`}`
`@@ -129,11 +129,11 @@ EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strdup_from_zone(iso_alloc_zone`
`129`	`129`	`return p;`
`130`	`130`	`}`
`131`	`131`
`132`		`-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char iso_strndup(const char str, size_t n) {`
	`132`	`+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char iso_strndup(const char str, size_t n) {`
`133`	`133`	`return iso_strndup_from_zone(NULL, str, n);`
`134`	`134`	`}`
`135`	`135`
`136`		`-EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char iso_strndup_from_zone(iso_alloc_zone_handle zone, const char *str, size_t n) {`
	`136`	`+EXTERNAL_API FLATTEN NO_DISCARD ASSUME_ALIGNED char iso_strndup_from_zone(iso_alloc_zone_handle zone, const char *str, size_t n) {`
`137`	`137`	`if(str == NULL) {`
`138`	`138`	`return NULL;`
`139`	`139`	`}`
`@@ -160,7 +160,7 @@ EXTERNAL_API NO_DISCARD ASSUME_ALIGNED char *iso_strndup_from_zone(iso_alloc_zon`
`160`	`160`	`return p;`
`161`	`161`	`}`
`162`	`162`
`163`		`-EXTERNAL_API NO_DISCARD MALLOC_ATTR ASSUME_ALIGNED void iso_alloc_from_zone(iso_alloc_zone_handle zone) {`
	`163`	`+EXTERNAL_API FLATTEN NO_DISCARD MALLOC_ATTR ASSUME_ALIGNED void iso_alloc_from_zone(iso_alloc_zone_handle zone) {`
`164`	`164`	`if(zone == NULL) {`
`165`	`165`	`return NULL;`
`166`	`166`	`}`
`@@ -171,7 +171,7 @@ EXTERNAL_API NO_DISCARD MALLOC_ATTR ASSUME_ALIGNED void *iso_alloc_from_zone(iso`
`171`	`171`	`return _iso_alloc(zone, _zone->chunk_size);`
`172`	`172`	`}`
`173`	`173`
`174`		`-EXTERNAL_API NO_DISCARD MALLOC_ATTR void iso_alloc_from_zone_tagged(iso_alloc_zone_handle zone) {`
	`174`	`+EXTERNAL_API FLATTEN NO_DISCARD MALLOC_ATTR void iso_alloc_from_zone_tagged(iso_alloc_zone_handle zone) {`
`175`	`175`	`if(zone == NULL) {`
`176`	`176`	`return NULL;`
`177`	`177`	`}`
`@@ -183,7 +183,7 @@ EXTERNAL_API NO_DISCARD MALLOC_ATTR void *iso_alloc_from_zone_tagged(iso_alloc_z`
`183`	`183`	`return _tag_ptr(p, zone);`
`184`	`184`	`}`
`185`	`185`
`186`		`-EXTERNAL_API NO_DISCARD void iso_alloc_tag_ptr(void p, iso_alloc_zone_handle *zone) {`
	`186`	`+EXTERNAL_API FLATTEN NO_DISCARD void iso_alloc_tag_ptr(void p, iso_alloc_zone_handle *zone) {`
`187`	`187`	`if(zone == NULL) {`
`188`	`188`	`return NULL;`
`189`	`189`	`}`
`@@ -192,7 +192,7 @@ EXTERNAL_API NO_DISCARD void iso_alloc_tag_ptr(void p, iso_alloc_zone_handle *`
`192`	`192`	`return _tag_ptr(p, zone);`
`193`	`193`	`}`
`194`	`194`
`195`		`-EXTERNAL_API NO_DISCARD void iso_alloc_untag_ptr(void p, iso_alloc_zone_handle *zone) {`
	`195`	`+EXTERNAL_API FLATTEN NO_DISCARD void iso_alloc_untag_ptr(void p, iso_alloc_zone_handle *zone) {`
`196`	`196`	`if(zone == NULL) {`
`197`	`197`	`return NULL;`
`198`	`198`	`}`
`@@ -201,7 +201,7 @@ EXTERNAL_API NO_DISCARD void iso_alloc_untag_ptr(void p, iso_alloc_zone_handle`
`201`	`201`	`return _untag_ptr(p, zone);`
`202`	`202`	`}`
`203`	`203`
`204`		`-EXTERNAL_API void iso_alloc_verify_ptr_tag(void p, iso_alloc_zone_handle zone) {`
	`204`	`+EXTERNAL_API FLATTEN void iso_alloc_verify_ptr_tag(void p, iso_alloc_zone_handle zone) {`
`205`	`205`	`if(zone == NULL) {`
`206`	`206`	`return;`
`207`	`207`	`}`
`@@ -211,7 +211,7 @@ EXTERNAL_API void iso_alloc_verify_ptr_tag(void p, iso_alloc_zone_handle zone)`
`211`	`211`	`return;`
`212`	`212`	`}`
`213`	`213`
`214`		`-EXTERNAL_API NO_DISCARD uint8_t iso_alloc_get_mem_tag(void p, iso_alloc_zone_handle zone) {`
	`214`	`+EXTERNAL_API FLATTEN NO_DISCARD uint8_t iso_alloc_get_mem_tag(void p, iso_alloc_zone_handle zone) {`
`215`	`215`	`if(zone == NULL \|\| p == NULL) {`
`216`	`216`	`return 0;`
`217`	`217`	`}`
`@@ -220,7 +220,7 @@ EXTERNAL_API NO_DISCARD uint8_t iso_alloc_get_mem_tag(void *p, iso_alloc_zone_ha`
`220`	`220`	`return _iso_alloc_get_mem_tag(p, zone);`
`221`	`221`	`}`
`222`	`222`
`223`		`-EXTERNAL_API void iso_alloc_destroy_zone(iso_alloc_zone_handle *zone) {`
	`223`	`+EXTERNAL_API FLATTEN void iso_alloc_destroy_zone(iso_alloc_zone_handle *zone) {`
`224`	`224`	`if(zone == NULL) {`
`225`	`225`	`return;`
`226`	`226`	`}`
`@@ -229,13 +229,13 @@ EXTERNAL_API void iso_alloc_destroy_zone(iso_alloc_zone_handle *zone) {`
`229`	`229`	`_iso_alloc_destroy_zone(zone);`
`230`	`230`	`}`
`231`	`231`
`232`		`-EXTERNAL_API NO_DISCARD iso_alloc_zone_handle *iso_alloc_new_zone(size_t size) {`
	`232`	`+EXTERNAL_API FLATTEN NO_DISCARD iso_alloc_zone_handle *iso_alloc_new_zone(size_t size) {`
`233`	`233`	`iso_alloc_zone_handle zone = (iso_alloc_zone_handle ) iso_new_zone(size, false);`
`234`	`234`	`UNMASK_ZONE_HANDLE(zone);`
`235`	`235`	`return zone;`
`236`	`236`	`}`
`237`	`237`
`238`		`-EXTERNAL_API int32_t iso_alloc_name_zone(iso_alloc_zone_handle zone, char name) {`
	`238`	`+EXTERNAL_API FLATTEN int32_t iso_alloc_name_zone(iso_alloc_zone_handle zone, char name) {`
`239`	`239`	`if(zone == NULL) {`
`240`	`240`	`return 0;`
`241`	`241`	`} else {`
`@@ -246,15 +246,15 @@ EXTERNAL_API int32_t iso_alloc_name_zone(iso_alloc_zone_handle zone, char name`
`246`	`246`	`return name_mapping(_zone->user_pages_start, ZONE_USER_SIZE, name);`
`247`	`247`	`}`
`248`	`248`
`249`		`-EXTERNAL_API void iso_alloc_protect_root(void) {`
	`249`	`+EXTERNAL_API FLATTEN void iso_alloc_protect_root(void) {`
`250`	`250`	`_iso_alloc_protect_root();`
`251`	`251`	`}`
`252`	`252`
`253`		`-EXTERNAL_API void iso_alloc_unprotect_root(void) {`
	`253`	`+EXTERNAL_API FLATTEN void iso_alloc_unprotect_root(void) {`
`254`	`254`	`_iso_alloc_unprotect_root();`
`255`	`255`	`}`
`256`	`256`
`257`		`-EXTERNAL_API uint64_t iso_alloc_detect_zone_leaks(iso_alloc_zone_handle *zone) {`
	`257`	`+EXTERNAL_API FLATTEN uint64_t iso_alloc_detect_zone_leaks(iso_alloc_zone_handle *zone) {`
`258`	`258`	`if(zone == NULL) {`
`259`	`259`	`return 0;`
`260`	`260`	`} else {`
`@@ -264,11 +264,11 @@ EXTERNAL_API uint64_t iso_alloc_detect_zone_leaks(iso_alloc_zone_handle *zone) {`
`264`	`264`	`return _iso_alloc_detect_leaks_in_zone(zone);`
`265`	`265`	`}`
`266`	`266`
`267`		`-EXTERNAL_API uint64_t iso_alloc_detect_leaks(void) {`
	`267`	`+EXTERNAL_API FLATTEN uint64_t iso_alloc_detect_leaks(void) {`
`268`	`268`	`return _iso_alloc_detect_leaks();`
`269`	`269`	`}`
`270`	`270`
`271`		`-EXTERNAL_API uint64_t iso_alloc_zone_mem_usage(iso_alloc_zone_handle *zone) {`
	`271`	`+EXTERNAL_API FLATTEN uint64_t iso_alloc_zone_mem_usage(iso_alloc_zone_handle *zone) {`
`272`	`272`	`if(zone == NULL) {`
`273`	`273`	`return 0;`
`274`	`274`	`} else {`
`@@ -278,15 +278,15 @@ EXTERNAL_API uint64_t iso_alloc_zone_mem_usage(iso_alloc_zone_handle *zone) {`
`278`	`278`	`return _iso_alloc_zone_mem_usage(zone);`
`279`	`279`	`}`
`280`	`280`
`281`		`-EXTERNAL_API uint64_t iso_alloc_mem_usage(void) {`
	`281`	`+EXTERNAL_API FLATTEN uint64_t iso_alloc_mem_usage(void) {`
`282`	`282`	`return _iso_alloc_mem_usage();`
`283`	`283`	`}`
`284`	`284`
`285`		`-EXTERNAL_API void iso_verify_zones(void) {`
	`285`	`+EXTERNAL_API FLATTEN void iso_verify_zones(void) {`
`286`	`286`	`verify_all_zones();`
`287`	`287`	`}`
`288`	`288`
`289`		`-EXTERNAL_API void iso_verify_zone(iso_alloc_zone_handle *zone) {`
	`289`	`+EXTERNAL_API FLATTEN void iso_verify_zone(iso_alloc_zone_handle *zone) {`
`290`	`290`	`if(zone == NULL) {`
`291`	`291`	`return;`
`292`	`292`	`} else {`
`@@ -296,26 +296,26 @@ EXTERNAL_API void iso_verify_zone(iso_alloc_zone_handle *zone) {`
`296`	`296`	`verify_zone(zone);`
`297`	`297`	`}`
`298`	`298`
`299`		`-EXTERNAL_API void iso_flush_caches(void) {`
	`299`	`+EXTERNAL_API FLATTEN void iso_flush_caches(void) {`
`300`	`300`	`flush_caches();`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`#if HEAP_PROFILER`
`304`		`-EXTERNAL_API size_t iso_get_alloc_traces(iso_alloc_traces_t *traces_out) {`
	`304`	`+EXTERNAL_API FLATTEN size_t iso_get_alloc_traces(iso_alloc_traces_t *traces_out) {`
`305`	`305`	`return _iso_get_alloc_traces(traces_out);`
`306`	`306`	`}`
`307`	`307`
`308`		`-EXTERNAL_API size_t iso_get_free_traces(iso_free_traces_t *traces_out) {`
	`308`	`+EXTERNAL_API FLATTEN size_t iso_get_free_traces(iso_free_traces_t *traces_out) {`
`309`	`309`	`return _iso_get_free_traces(traces_out);`
`310`	`310`	`}`
`311`	`311`
`312`		`-EXTERNAL_API void iso_alloc_reset_traces(void) {`
	`312`	`+EXTERNAL_API FLATTEN void iso_alloc_reset_traces(void) {`
`313`	`313`	`_iso_alloc_reset_traces();`
`314`	`314`	`}`
`315`	`315`	`#endif`
`316`	`316`
`317`	`317`	`#if EXPERIMENTAL`
`318`		`-EXTERNAL_API void iso_alloc_search_stack(void *p) {`
	`318`	`+EXTERNAL_API FLATTEN void iso_alloc_search_stack(void *p) {`
`319`	`319`	`_iso_alloc_search_stack(p);`
`320`	`320`	`}`
`321`	`321`	`#endif`