SYMBOL INDEX (1145 symbols across 46 files)

FILE: doc/mimalloc-doc.h
  type mi_heap_s (line 458) | struct mi_heap_s
  type mi_heap_t (line 465) | typedef struct mi_heap_s mi_heap_t;
  type mi_heap_area_t (line 627) | typedef struct mi_heap_area_s {
  type mi_arena_id_t (line 694) | typedef int mi_arena_id_t;
  type mi_stats_s (line 1029) | struct mi_stats_s {
  type mi_stats_t (line 1037) | typedef struct mi_stats_s mi_stats_t;
  type mi_option_t (line 1190) | typedef enum mi_option_e {
  type mi_theap_s (line 1279) | struct mi_theap_s
  type mi_theap_t (line 1282) | typedef struct mi_theap_s mi_theap_t;

FILE: include/mimalloc-new-delete.h
  function delete (line 34) | void operator delete(void* p) noexcept              { mi_free(p); }
  function noexcept (line 35) | void operator delete[](void* p) noexcept            { mi_free(p); }
  function operator (line 37) | void operator delete  (void* p, const std::nothrow_t&) noexcept { mi_fre...
  function noexcept (line 38) | void operator delete[](void* p, const std::nothrow_t&) noexcept { mi_fre...
  function operator (line 47) | void operator delete  (void* p, std::size_t n) noexcept { mi_free_size(p...
  function noexcept (line 48) | void operator delete[](void* p, std::size_t n) noexcept { mi_free_size(p...
  function operator (line 52) | void operator delete  (void* p, std::align_val_t al) noexcept { mi_free_...
  function noexcept (line 53) | void operator delete[](void* p, std::align_val_t al) noexcept { mi_free_...
  function operator (line 54) | void operator delete  (void* p, std::size_t n, std::align_val_t al) noex...
  function noexcept (line 55) | void operator delete[](void* p, std::size_t n, std::align_val_t al) noex...
  function operator (line 56) | void operator delete  (void* p, std::align_val_t al, const std::nothrow_...
  function noexcept (line 57) | void operator delete[](void* p, std::align_val_t al, const std::nothrow_...

FILE: include/mimalloc-stats.h
  type mi_stat_count_t (line 17) | typedef struct mi_stat_count_s {
  type mi_stat_counter_t (line 24) | typedef struct mi_stat_counter_s {
  function MI_STAT_COUNT (line 30) | MI_STAT_COUNT(reserved)                   /* reserved memory bytes */ \

FILE: include/mimalloc.h
  type mi_heap_s (line 208) | struct mi_heap_s
  type mi_heap_t (line 209) | typedef struct mi_heap_s mi_heap_t;
  type mi_heap_area_t (line 276) | typedef struct mi_heap_area_s {
  type mi_arena_id_t (line 304) | typedef int mi_arena_id_t;
  type mi_option_t (line 370) | typedef enum mi_option_e {
  type T (line 498) | typedef T                 value_type;
  type std (line 499) | typedef std::size_t       size_type;
  type std (line 500) | typedef std::ptrdiff_t    difference_type;
  type value_type (line 501) | typedef value_type&       reference;
  type value_type (line 502) | typedef value_type const& const_reference;
  type value_type (line 503) | typedef value_type*       pointer;
  type value_type (line 504) | typedef value_type const* const_pointer;
  function construct (line 513) | void construct(pointer p, value_type const& val) { ::new(p) value_type(v...
  function destroy (line 514) | void destroy(pointer p) { p->~value_type(); }
  function pointer (line 518) | pointer       address(reference x) const        { return &x; }
  function const_pointer (line 519) | const_pointer address(const_reference x) const  { return &x; }
  type mi_stl_allocator (line 526) | typedef mi_stl_allocator<U> other;
  function mi_decl_nodiscard (line 564) | mi_decl_nodiscard T* allocate(size_type count) { return static_cast<T*>(...
  function mi_decl_nodiscard (line 565) | mi_decl_nodiscard T* allocate(size_type count, const void*) { return all...
  function collect (line 574) | void collect(bool force) { mi_heap_collect(this->heap.get(), force); }
  type _mi_heap_stl_allocator_common (line 579) | struct _mi_heap_stl_allocator_common
  function heap (line 585) | _mi_heap_stl_allocator_common(const _mi_heap_stl_allocator_common& x) mi...
  function heap_destroy (line 590) | static void heap_destroy(mi_heap_t* hp) { if (hp != NULL) { mi_heap_dest...
  type mi_heap_stl_allocator (line 602) | typedef mi_heap_stl_allocator<U> other;
  type mi_heap_destroy_stl_allocator (line 619) | typedef mi_heap_destroy_stl_allocator<U> other;

FILE: include/mimalloc/atomic.h
  function mi_atomic_addi64_relaxed (line 131) | static inline int64_t mi_atomic_addi64_relaxed(volatile int64_t* p, int6...
  function mi_atomic_void_addi64_relaxed (line 134) | static inline void mi_atomic_void_addi64_relaxed(volatile int64_t* p, co...
  function mi_atomic_maxi64_relaxed (line 140) | static inline void mi_atomic_maxi64_relaxed(volatile int64_t* p, int64_t...
  type LONG64 (line 160) | typedef LONG64   msc_intptr_t;
  type LONG (line 163) | typedef LONG     msc_intptr_t;
  type mi_memory_order (line 167) | typedef enum mi_memory_order_e {
  function mi_atomic_fetch_add_explicit (line 176) | static inline uintptr_t mi_atomic_fetch_add_explicit(_Atomic(uintptr_t)*...
  function mi_atomic_fetch_sub_explicit (line 180) | static inline uintptr_t mi_atomic_fetch_sub_explicit(_Atomic(uintptr_t)*...
  function mi_atomic_fetch_and_explicit (line 184) | static inline uintptr_t mi_atomic_fetch_and_explicit(_Atomic(uintptr_t)*...
  function mi_atomic_fetch_or_explicit (line 188) | static inline uintptr_t mi_atomic_fetch_or_explicit(_Atomic(uintptr_t)*p...
  function mi_atomic_compare_exchange_strong_explicit (line 192) | static inline bool mi_atomic_compare_exchange_strong_explicit(_Atomic(ui...
  function mi_atomic_compare_exchange_weak_explicit (line 203) | static inline bool mi_atomic_compare_exchange_weak_explicit(_Atomic(uint...
  function mi_atomic_exchange_explicit (line 206) | static inline uintptr_t mi_atomic_exchange_explicit(_Atomic(uintptr_t)*p...
  function mi_atomic_thread_fence (line 210) | static inline void mi_atomic_thread_fence(mi_memory_order mo) {
  function mi_atomic_load_explicit (line 215) | static inline uintptr_t mi_atomic_load_explicit(_Atomic(uintptr_t) const...
  function mi_atomic_store_explicit (line 227) | static inline void mi_atomic_store_explicit(_Atomic(uintptr_t)*p, uintpt...
  function mi_atomic_loadi64_explicit (line 235) | static inline int64_t mi_atomic_loadi64_explicit(_Atomic(int64_t)*p, mi_...
  function mi_atomic_storei64_explicit (line 248) | static inline void mi_atomic_storei64_explicit(_Atomic(int64_t)*p, int64...
  function mi_atomic_addi64_relaxed (line 258) | static inline int64_t mi_atomic_addi64_relaxed(volatile _Atomic(int64_t)...
  function mi_atomic_void_addi64_relaxed (line 271) | static inline void mi_atomic_void_addi64_relaxed(volatile int64_t* p, co...
  function mi_atomic_maxi64_relaxed (line 278) | static inline void mi_atomic_maxi64_relaxed(volatile _Atomic(int64_t)*p,...
  function mi_atomic_addi64_acq_rel (line 285) | static inline void mi_atomic_addi64_acq_rel(volatile _Atomic(int64_t*)p,...
  function mi_atomic_casi64_strong_acq_rel (line 289) | static inline bool mi_atomic_casi64_strong_acq_rel(volatile _Atomic(int6...
  function mi_atomic_addi (line 323) | static inline intptr_t mi_atomic_addi(_Atomic(intptr_t)*p, intptr_t add) {
  function mi_atomic_subi (line 328) | static inline intptr_t mi_atomic_subi(_Atomic(intptr_t)*p, intptr_t sub) {
  type mi_atomic_once_t (line 337) | typedef _Atomic(uintptr_t) mi_atomic_once_t;
  function mi_atomic_once (line 340) | static inline bool mi_atomic_once( mi_atomic_once_t* once ) {
  type mi_atomic_guard_t (line 346) | typedef _Atomic(uintptr_t) mi_atomic_guard_t;
  function mi_atomic_yield (line 363) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 367) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 372) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 380) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 384) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 389) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 393) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 399) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 403) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 411) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 416) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 421) | static inline void mi_atomic_yield(void) {
  function mi_lock_try_acquire (line 444) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 447) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 450) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 453) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 456) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 463) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 466) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 469) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 472) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 475) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 487) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 490) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 496) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 499) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 502) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 511) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 514) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 517) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 520) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 523) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 534) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 538) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 544) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 547) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 550) | static inline void mi_lock_done(mi_lock_t* lock) {

FILE: include/mimalloc/internal.h
  type mi_arena_field_cursor_t (line 203) | typedef struct mi_arena_field_cursor_s { // abstract struct
  function _mi_is_power_of_two (line 374) | static inline bool _mi_is_power_of_two(uintptr_t x) {
  function _mi_is_aligned (line 379) | static inline bool _mi_is_aligned(void* p, size_t alignment) {
  function _mi_align_up (line 385) | static inline uintptr_t _mi_align_up(uintptr_t sz, size_t alignment) {
  function _mi_align_down (line 397) | static inline uintptr_t _mi_align_down(uintptr_t sz, size_t alignment) {
  function _mi_divide_up (line 420) | static inline uintptr_t _mi_divide_up(uintptr_t size, size_t divider) {
  function _mi_clamp (line 427) | static inline size_t _mi_clamp(size_t sz, size_t min, size_t max) {
  function mi_mem_is_zero (line 434) | static inline bool mi_mem_is_zero(const void* p, size_t size) {
  function _mi_wsize_from_size (line 444) | static inline size_t _mi_wsize_from_size(size_t size) {
  function mi_mul_overflow (line 455) | static inline bool mi_mul_overflow(size_t count, size_t size, size_t* to...
  function mi_mul_overflow (line 465) | static inline bool mi_mul_overflow(size_t count, size_t size, size_t* to...
  function mi_count_size_overflow (line 474) | static inline bool mi_count_size_overflow(size_t count, size_t size, siz...
  function mi_heap_is_backing (line 496) | static inline bool mi_heap_is_backing(const mi_heap_t* heap) {
  function mi_heap_is_initialized (line 500) | static inline bool mi_heap_is_initialized(mi_heap_t* heap) {
  function _mi_ptr_cookie (line 505) | static inline uintptr_t _mi_ptr_cookie(const void* p) {
  function mi_page_t (line 515) | static inline mi_page_t* _mi_heap_get_free_small_page(mi_heap_t* heap, s...
  function mi_segment_t (line 527) | static inline mi_segment_t* _mi_ptr_segment(const void* p) {
  function mi_page_t (line 536) | static inline mi_page_t* mi_slice_to_page(mi_slice_t* s) {
  function mi_slice_t (line 541) | static inline mi_slice_t* mi_page_to_slice(mi_page_t* p) {
  function mi_segment_t (line 547) | static inline mi_segment_t* _mi_page_segment(const mi_page_t* page) {
  function mi_slice_t (line 554) | static inline mi_slice_t* mi_slice_first(const mi_slice_t* slice) {
  function mi_page_t (line 563) | static inline mi_page_t* _mi_segment_page_of(const mi_segment_t* segment...
  function mi_page_t (line 584) | static inline mi_page_t* _mi_ptr_page(void* p) {
  function mi_page_block_size (line 590) | static inline size_t mi_page_block_size(const mi_page_t* page) {
  function mi_page_is_huge (line 595) | static inline bool mi_page_is_huge(const mi_page_t* page) {
  function mi_page_usable_block_size (line 603) | static inline size_t mi_page_usable_block_size(const mi_page_t* page) {
  function mi_segment_size (line 608) | static inline size_t mi_segment_size(mi_segment_t* segment) {
  function mi_block_t (line 617) | static inline mi_block_t* mi_page_thread_free(const mi_page_t* page) {
  function mi_delayed_t (line 621) | static inline mi_delayed_t mi_page_thread_free_flag(const mi_page_t* pag...
  function mi_heap_t (line 626) | static inline mi_heap_t* mi_page_heap(const mi_page_t* page) {
  function mi_page_set_heap (line 630) | static inline void mi_page_set_heap(mi_page_t* page, mi_heap_t* heap) {
  function mi_block_t (line 637) | static inline mi_block_t* mi_tf_block(mi_thread_free_t tf) {
  function mi_delayed_t (line 640) | static inline mi_delayed_t mi_tf_delayed(mi_thread_free_t tf) {
  function mi_thread_free_t (line 643) | static inline mi_thread_free_t mi_tf_make(mi_block_t* block, mi_delayed_...
  function mi_thread_free_t (line 646) | static inline mi_thread_free_t mi_tf_set_delayed(mi_thread_free_t tf, mi...
  function mi_thread_free_t (line 649) | static inline mi_thread_free_t mi_tf_set_block(mi_thread_free_t tf, mi_b...
  function mi_page_all_free (line 655) | static inline bool mi_page_all_free(const mi_page_t* page) {
  function mi_page_has_any_available (line 661) | static inline bool mi_page_has_any_available(const mi_page_t* page) {
  function mi_page_immediate_available (line 667) | static inline bool mi_page_immediate_available(const mi_page_t* page) {
  function mi_page_is_mostly_used (line 673) | static inline bool mi_page_is_mostly_used(const mi_page_t* page) {
  function mi_page_queue_t (line 679) | static inline mi_page_queue_t* mi_page_queue(const mi_heap_t* heap, size...
  function mi_page_is_in_full (line 688) | static inline bool mi_page_is_in_full(const mi_page_t* page) {
  function mi_page_set_in_full (line 692) | static inline void mi_page_set_in_full(mi_page_t* page, bool in_full) {
  function mi_page_has_aligned (line 696) | static inline bool mi_page_has_aligned(const mi_page_t* page) {
  function mi_page_set_has_aligned (line 700) | static inline void mi_page_set_has_aligned(mi_page_t* page, bool has_ali...
  function mi_block_ptr_is_guarded (line 708) | static inline bool mi_block_ptr_is_guarded(const mi_block_t* block, cons...
  function mi_heap_malloc_use_guarded (line 713) | static inline bool mi_heap_malloc_use_guarded(mi_heap_t* heap, size_t si...
  function mi_is_in_same_segment (line 763) | static inline bool mi_is_in_same_segment(const void* p, const void* q) {
  function mi_is_in_same_page (line 767) | static inline bool mi_is_in_same_page(const void* p, const void* q) {
  function mi_rotl (line 777) | static inline uintptr_t mi_rotl(uintptr_t x, uintptr_t shift) {
  function mi_rotr (line 781) | static inline uintptr_t mi_rotr(uintptr_t x, uintptr_t shift) {
  function mi_encoded_t (line 791) | static inline mi_encoded_t mi_ptr_encode(const void* null, const void* p...
  function mi_ptr_encode_canary (line 796) | static inline uint32_t mi_ptr_encode_canary(const void* null, const void...
  function mi_block_t (line 806) | static inline mi_block_t* mi_block_nextx( const void* null, const mi_blo...
  function mi_block_set_nextx (line 819) | static inline void mi_block_set_nextx(const void* null, mi_block_t* bloc...
  function mi_block_t (line 830) | static inline mi_block_t* mi_block_next(const mi_page_t* page, const mi_...
  function mi_block_set_next (line 846) | static inline void mi_block_set_next(const mi_page_t* page, mi_block_t* ...
  function mi_commit_mask_create_empty (line 860) | static inline void mi_commit_mask_create_empty(mi_commit_mask_t* cm) {
  function mi_commit_mask_create_full (line 866) | static inline void mi_commit_mask_create_full(mi_commit_mask_t* cm) {
  function mi_commit_mask_is_empty (line 872) | static inline bool mi_commit_mask_is_empty(const mi_commit_mask_t* cm) {
  function mi_commit_mask_is_full (line 879) | static inline bool mi_commit_mask_is_full(const mi_commit_mask_t* cm) {
  function mi_memid_t (line 904) | static inline mi_memid_t _mi_memid_create(mi_memkind_t memkind) {
  function mi_memid_t (line 911) | static inline mi_memid_t _mi_memid_none(void) {
  function mi_memid_t (line 915) | static inline mi_memid_t _mi_memid_create_os(void* base, size_t size, bo...
  function _mi_random_shuffle (line 930) | static inline uintptr_t _mi_random_shuffle(uintptr_t x) {
  function mi_clz (line 960) | static inline size_t mi_clz(size_t x) {
  function mi_ctz (line 968) | static inline size_t mi_ctz(size_t x) {
  function mi_clz (line 982) | static inline size_t mi_clz(size_t x) {
  function mi_ctz (line 992) | static inline size_t mi_ctz(size_t x) {
  function mi_ctz_generic32 (line 1005) | static inline size_t mi_ctz_generic32(uint32_t x) {
  function mi_clz_generic32 (line 1015) | static inline size_t mi_clz_generic32(uint32_t x) {
  function mi_ctz (line 1030) | static inline size_t mi_ctz(size_t x) {
  function mi_clz (line 1045) | static inline size_t mi_clz(size_t x) {
  function mi_bsr (line 1063) | static inline size_t mi_bsr(size_t x) {
  function mi_popcount (line 1069) | static inline size_t mi_popcount(size_t x) {
  function _mi_memcpy (line 1095) | static inline void _mi_memcpy(void* dst, const void* src, size_t n) {
  function _mi_memzero (line 1103) | static inline void _mi_memzero(void* dst, size_t n) {
  function _mi_memcpy (line 1112) | static inline void _mi_memcpy(void* dst, const void* src, size_t n) {
  function _mi_memzero (line 1115) | static inline void _mi_memzero(void* dst, size_t n) {
  function _mi_memcpy_aligned (line 1127) | static inline void _mi_memcpy_aligned(void* dst, const void* src, size_t...
  function _mi_memzero_aligned (line 1134) | static inline void _mi_memzero_aligned(void* dst, size_t n) {
  function _mi_memcpy_aligned (line 1141) | static inline void _mi_memcpy_aligned(void* dst, const void* src, size_t...
  function _mi_memzero_aligned (line 1146) | static inline void _mi_memzero_aligned(void* dst, size_t n) {

FILE: include/mimalloc/prim.h
  type mi_os_mem_config_t (line 24) | typedef struct mi_os_mem_config_s {
  type mi_process_info_t (line 90) | typedef struct mi_process_info_s {
  function mi_prim_tls_slot_set (line 182) | static inline void mi_prim_tls_slot_set(size_t slot, void* value) mi_att...
  function mi_prim_tls_slot_set (line 237) | static inline void mi_prim_tls_slot_set(size_t slot, void* value) mi_att...
  function mi_threadid_t (line 282) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 288) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 295) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 302) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 318) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_heap_t (line 370) | static inline mi_heap_t* mi_prim_get_default_heap(void) {
  function mi_heap_t (line 385) | static inline mi_heap_t** mi_prim_tls_pthread_heap_slot(void) {
  function mi_heap_t (line 393) | static inline mi_heap_t* mi_prim_get_default_heap(void) {
  function mi_heap_t (line 404) | static inline mi_heap_t* mi_prim_get_default_heap(void) {
  function mi_heap_t (line 411) | static inline mi_heap_t* mi_prim_get_default_heap(void) {

FILE: include/mimalloc/types.h
  type mi_ssize_t (line 140) | typedef int64_t  mi_ssize_t;
  type mi_ssize_t (line 143) | typedef int32_t  mi_ssize_t;
  type mi_encoded_t (line 241) | typedef uintptr_t  mi_encoded_t;
  type mi_threadid_t (line 244) | typedef size_t     mi_threadid_t;
  type mi_block_t (line 247) | typedef struct mi_block_s {
  type mi_delayed_t (line 260) | typedef enum mi_delayed_e {
  type mi_page_flags_t (line 271) | typedef union mi_page_flags_s {
  type mi_page_flags_t (line 280) | typedef union mi_page_flags_s {
  type mi_thread_free_t (line 291) | typedef uintptr_t mi_thread_free_t;
  type mi_page_t (line 321) | typedef struct mi_page_s {
  type mi_page_kind_t (line 365) | typedef enum mi_page_kind_e {
  type mi_segment_kind_t (line 373) | typedef enum mi_segment_kind_e {
  type mi_commit_mask_t (line 400) | typedef struct mi_commit_mask_s {
  type mi_page_t (line 404) | typedef mi_page_t  mi_slice_t;
  type mi_msecs_t (line 405) | typedef int64_t    mi_msecs_t;
  type mi_memkind_t (line 413) | typedef enum mi_memkind_e {
  function mi_memkind_is_os (line 423) | static inline bool mi_memkind_is_os(mi_memkind_t memkind) {
  type mi_memid_os_info_t (line 427) | typedef struct mi_memid_os_info {
  type mi_memid_arena_info_t (line 432) | typedef struct mi_memid_arena_info {
  type mi_memid_t (line 438) | typedef struct mi_memid_s {
  type mi_subproc_t (line 464) | typedef struct mi_subproc_s mi_subproc_t;
  type mi_segment_t (line 466) | typedef struct mi_segment_s {
  type mi_tld_t (line 519) | typedef struct mi_tld_s mi_tld_t;
  type mi_page_queue_t (line 522) | typedef struct mi_page_queue_s {
  type mi_random_ctx_t (line 531) | typedef struct mi_random_cxt_s {
  type mi_padding_t (line 541) | typedef struct mi_padding_s {
  type mi_heap_s (line 556) | struct mi_heap_s {
  type mi_subproc_s (line 589) | struct mi_subproc_s {
  type mi_span_queue_t (line 606) | typedef struct mi_span_queue_s {
  type mi_segments_tld_t (line 615) | typedef struct mi_segments_tld_s {
  type mi_tld_s (line 627) | struct mi_tld_s {

FILE: src/alloc-aligned.c
  function mi_malloc_is_naturally_aligned (line 18) | static bool mi_malloc_is_naturally_aligned( size_t size, size_t alignmen...
  function mi_decl_restrict (line 28) | static mi_decl_restrict void* mi_heap_malloc_guarded_aligned(mi_heap_t* ...
  function mi_decl_noinline (line 55) | static mi_decl_noinline void* mi_heap_malloc_zero_aligned_at_overalloc(m...
  function mi_decl_noinline (line 135) | static mi_decl_noinline void* mi_heap_malloc_zero_aligned_at_generic(mi_...
  function mi_likely (line 153) | mi_likely(is_aligned_or_null) {
  function mi_likely (line 194) | mi_likely(is_aligned)
  function mi_decl_nodiscard (line 319) | mi_decl_nodiscard void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void...
  function mi_decl_nodiscard (line 323) | mi_decl_nodiscard void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p...
  function mi_decl_nodiscard (line 327) | mi_decl_nodiscard void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, voi...
  function mi_decl_nodiscard (line 331) | mi_decl_nodiscard void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* ...
  function mi_decl_nodiscard (line 335) | mi_decl_nodiscard void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, voi...
  function mi_decl_nodiscard (line 341) | mi_decl_nodiscard void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* ...
  function mi_decl_nodiscard (line 347) | mi_decl_nodiscard void* mi_realloc_aligned_at(void* p, size_t newsize, s...
  function mi_decl_nodiscard (line 351) | mi_decl_nodiscard void* mi_realloc_aligned(void* p, size_t newsize, size...
  function mi_decl_nodiscard (line 355) | mi_decl_nodiscard void* mi_rezalloc_aligned_at(void* p, size_t newsize, ...
  function mi_decl_nodiscard (line 359) | mi_decl_nodiscard void* mi_rezalloc_aligned(void* p, size_t newsize, siz...
  function mi_decl_nodiscard (line 363) | mi_decl_nodiscard void* mi_recalloc_aligned_at(void* p, size_t newcount,...
  function mi_decl_nodiscard (line 367) | mi_decl_nodiscard void* mi_recalloc_aligned(void* p, size_t newcount, si...

FILE: src/alloc-override.c
  function mi_decl_externc (line 60) | mi_decl_externc size_t mi_malloc_size_checked(void *p) {
  type mi_interpose_s (line 67) | struct mi_interpose_s {
  type mi_interpose_s (line 119) | struct mi_interpose_s
  function void (line 167) | void operator delete(void* p) noexcept              MI_FORWARD0(mi_free,p)
  function operator (line 183) | void operator delete  (void* p, std::align_val_t al) noexcept { mi_free_...
  function noexcept (line 184) | void operator delete[](void* p, std::align_val_t al) noexcept { mi_free_...
  function operator (line 185) | void operator delete  (void* p, std::size_t n, std::align_val_t al) noex...
  function noexcept (line 186) | void operator delete[](void* p, std::size_t n, std::align_val_t al) noex...
  function operator (line 187) | void operator delete  (void* p, std::align_val_t al, const std::nothrow_...
  function noexcept (line 188) | void operator delete[](void* p, std::align_val_t al, const std::nothrow_...
  function _ZdlPv (line 203) | void _ZdlPv(void* p)            MI_FORWARD0(mi_free,p) // delete
  function _ZdaPvSt11align_val_t (line 209) | void _ZdaPvSt11align_val_t(void* p, size_t al)            { mi_free_alig...
  function _ZdlPvmSt11align_val_t (line 210) | void _ZdlPvmSt11align_val_t(void* p, size_t n, size_t al) { mi_free_size...
  function _ZdaPvmSt11align_val_t (line 211) | void _ZdaPvmSt11align_val_t(void* p, size_t n, size_t al) { mi_free_size...
  function _ZdlPvRKSt9nothrow_t (line 213) | void _ZdlPvRKSt9nothrow_t(void* p, mi_nothrow_t tag)      { MI_UNUSED(ta...
  function _ZdaPvRKSt9nothrow_t (line 214) | void _ZdaPvRKSt9nothrow_t(void* p, mi_nothrow_t tag)      { MI_UNUSED(ta...
  function _ZdlPvSt11align_val_tRKSt9nothrow_t (line 215) | void _ZdlPvSt11align_val_tRKSt9nothrow_t(void* p, size_t al, mi_nothrow_...
  function _ZdaPvSt11align_val_tRKSt9nothrow_t (line 216) | void _ZdaPvSt11align_val_tRKSt9nothrow_t(void* p, size_t al, mi_nothrow_...
  function vfree (line 261) | void   vfree(void* p)                    { mi_free(p); }
  function malloc_good_size (line 262) | size_t malloc_good_size(size_t size)     { return mi_malloc_good_size(si...
  function posix_memalign (line 263) | int    posix_memalign(void** p, size_t alignment, size_t size) { return ...
  function cfree (line 278) | void  cfree(void* p)                                    { mi_free(p); }
  function mi_decl_weak (line 284) | mi_decl_weak int reallocarr(void* p, size_t count, size_t size)    { ret...
  function __posix_memalign (line 305) | int   __posix_memalign(void** p, size_t alignment, size_t size) { return...

FILE: src/alloc-posix.c
  function mi_decl_nodiscard (line 35) | mi_decl_nodiscard size_t mi_malloc_size(const void* p) mi_attr_noexcept {
  function mi_decl_nodiscard (line 40) | mi_decl_nodiscard size_t mi_malloc_usable_size(const void *p) mi_attr_no...
  function mi_decl_nodiscard (line 45) | mi_decl_nodiscard size_t mi_malloc_good_size(size_t size) mi_attr_noexce...
  function mi_cfree (line 49) | void mi_cfree(void* p) mi_attr_noexcept {
  function mi_posix_memalign (line 55) | int mi_posix_memalign(void** p, size_t alignment, size_t size) mi_attr_n...
  function mi_decl_nodiscard (line 102) | mi_decl_nodiscard void* mi_reallocarray( void* p, size_t count, size_t s...
  function mi_decl_nodiscard (line 108) | mi_decl_nodiscard int mi_reallocarr( void* p, size_t count, size_t size ...
  function mi_dupenv_s (line 143) | int mi_dupenv_s(char** buf, size_t* size, const char* name) mi_attr_noex...
  function mi_wdupenv_s (line 158) | int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned shor...
  function mi_decl_nodiscard (line 179) | mi_decl_nodiscard void* mi_aligned_offset_recalloc(void* p, size_t newco...
  function mi_decl_nodiscard (line 183) | mi_decl_nodiscard void* mi_aligned_recalloc(void* p, size_t newcount, si...

FILE: src/alloc.c
  function mi_unlikely (line 61) | mi_unlikely(zero) {
  function mi_decl_restrict (line 129) | static inline mi_decl_restrict void* mi_heap_malloc_small_zero(mi_heap_t...
  function else (line 175) | else if (huge_alignment==0 && mi_heap_malloc_use_guarded(heap,size)) {
  function mi_decl_nodiscard (line 324) | mi_decl_nodiscard void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t...
  function mi_decl_nodiscard (line 328) | mi_decl_nodiscard void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 336) | mi_decl_nodiscard void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 342) | mi_decl_nodiscard void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 346) | mi_decl_nodiscard void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 353) | mi_decl_nodiscard void* mi_realloc(void* p, size_t newsize) mi_attr_noex...
  function mi_decl_nodiscard (line 357) | mi_decl_nodiscard void* mi_reallocn(void* p, size_t count, size_t size) ...
  function mi_decl_nodiscard (line 361) | mi_decl_nodiscard void* mi_urealloc(void* p, size_t newsize, size_t* usa...
  function mi_decl_nodiscard (line 366) | mi_decl_nodiscard void* mi_reallocf(void* p, size_t newsize) mi_attr_noe...
  function mi_decl_nodiscard (line 370) | mi_decl_nodiscard void* mi_rezalloc(void* p, size_t newsize) mi_attr_noe...
  function mi_decl_nodiscard (line 374) | mi_decl_nodiscard void* mi_recalloc(void* p, size_t count, size_t size) ...
  function mi_try_new_handler (line 496) | static bool mi_try_new_handler(bool nothrow) {
  function std_new_handler_t (line 523) | std_new_handler_t __attribute__((weak)) _ZSt15get_new_handlerv(void) {
  function std_new_handler_t (line 526) | static std_new_handler_t mi_get_new_handler(void) {
  function std_new_handler_t (line 531) | static std_new_handler_t mi_get_new_handler(void) {
  function mi_try_new_handler (line 536) | static bool mi_try_new_handler(bool nothrow) {
  function mi_decl_noinline (line 560) | static mi_decl_noinline void* mi_try_new(size_t size, bool nothrow) {
  function mi_decl_nodiscard (line 616) | mi_decl_nodiscard void* mi_new_realloc(void* p, size_t newsize) {
  function mi_decl_nodiscard (line 624) | mi_decl_nodiscard void* mi_new_reallocn(void* p, size_t newcount, size_t...
  function mi_decl_restrict (line 681) | mi_decl_restrict void* _mi_heap_malloc_guarded(mi_heap_t* heap, size_t s...

FILE: src/arena-abandon.c
  function mi_arena_segment_os_clear_abandoned (line 51) | static bool mi_arena_segment_os_clear_abandoned(mi_segment_t* segment, b...
  function _mi_arena_segment_clear_abandoned (line 94) | bool _mi_arena_segment_clear_abandoned(mi_segment_t* segment) {
  function mi_arena_segment_os_mark_abandoned (line 119) | static void mi_arena_segment_os_mark_abandoned(mi_segment_t* segment) {
  function _mi_arena_segment_mark_abandoned (line 143) | void _mi_arena_segment_mark_abandoned(mi_segment_t* segment)
  function _mi_arena_field_cursor_init (line 172) | void _mi_arena_field_cursor_init(mi_heap_t* heap, mi_subproc_t* subproc,...
  function _mi_arena_field_cursor_done (line 202) | void _mi_arena_field_cursor_done(mi_arena_field_cursor_t* current) {
  function mi_segment_t (line 209) | static mi_segment_t* mi_arena_segment_clear_abandoned_at(mi_arena_t* are...
  function mi_segment_t (line 232) | static mi_segment_t* mi_arena_segment_clear_abandoned_next_field(mi_aren...
  function mi_segment_t (line 282) | static mi_segment_t* mi_arena_segment_clear_abandoned_next_list(mi_arena...
  function mi_segment_t (line 317) | mi_segment_t* _mi_arena_segment_clear_abandoned_next(mi_arena_field_curs...
  function mi_abandoned_visit_blocks (line 329) | bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag,...

FILE: src/arena.c
  type mi_arena_t (line 33) | typedef struct mi_arena_s {
  function mi_arena_id_index (line 75) | size_t mi_arena_id_index(mi_arena_id_t id) {
  function mi_arena_id_t (line 79) | static mi_arena_id_t mi_arena_id_create(size_t arena_index) {
  function mi_arena_id_t (line 84) | mi_arena_id_t _mi_arena_id_none(void) {
  function mi_arena_id_is_suitable (line 88) | static bool mi_arena_id_is_suitable(mi_arena_id_t arena_id, bool arena_i...
  function _mi_arena_memid_is_suitable (line 93) | bool _mi_arena_memid_is_suitable(mi_memid_t memid, mi_arena_id_t request...
  function _mi_arena_memid_is_os_allocated (line 102) | bool _mi_arena_memid_is_os_allocated(mi_memid_t memid) {
  function mi_arena_get_count (line 106) | size_t mi_arena_get_count(void) {
  function mi_arena_t (line 110) | mi_arena_t* mi_arena_from_index(size_t idx) {
  function mi_block_count_of_size (line 121) | static size_t mi_block_count_of_size(size_t size) {
  function mi_arena_block_size (line 125) | static size_t mi_arena_block_size(size_t bcount) {
  function mi_arena_size (line 129) | static size_t mi_arena_size(mi_arena_t* arena) {
  function mi_memid_t (line 133) | static mi_memid_t mi_memid_create_arena(mi_arena_id_t id, bool is_exclus...
  function mi_arena_memid_indices (line 141) | bool mi_arena_memid_indices(mi_memid_t memid, size_t* arena_index, mi_bi...
  function _mi_arena_meta_free (line 201) | void _mi_arena_meta_free(void* p, mi_memid_t memid, size_t size) {
  function mi_arena_try_claim (line 220) | static bool mi_arena_try_claim(mi_arena_t* arena, size_t blocks, mi_bitm...
  function mi_decl_noinline (line 235) | static mi_decl_noinline void* mi_arena_try_alloc_at(mi_arena_t* arena, s...
  function mi_decl_noinline (line 333) | static mi_decl_noinline void* mi_arena_try_alloc(int numa_node, size_t s...
  function mi_arena_reserve (line 368) | static bool mi_arena_reserve(size_t req_size, bool allow_large, mi_arena...
  function mi_arena_purge_delay (line 467) | static long mi_arena_purge_delay(void) {
  function mi_arena_purge (line 474) | static void mi_arena_purge(mi_arena_t* arena, size_t bitmap_idx, size_t ...
  function mi_arena_schedule_purge (line 506) | static void mi_arena_schedule_purge(mi_arena_t* arena, size_t bitmap_idx...
  function mi_arena_purge_range (line 534) | static bool mi_arena_purge_range(mi_arena_t* arena, size_t idx, size_t s...
  function mi_arena_try_purge (line 558) | static bool mi_arena_try_purge(mi_arena_t* arena, mi_msecs_t now, bool f...
  function mi_arenas_try_purge (line 617) | static void mi_arenas_try_purge( bool force, bool visit_all )
  function _mi_arena_free (line 661) | void _mi_arena_free(void* p, size_t size, size_t committed_size, mi_memi...
  function mi_arenas_unsafe_destroy (line 744) | static void mi_arenas_unsafe_destroy(void) {
  function _mi_arenas_collect (line 768) | void _mi_arenas_collect(bool force_purge) {
  function _mi_arena_unsafe_destroy_all (line 774) | void _mi_arena_unsafe_destroy_all(void) {
  function _mi_arena_contains (line 780) | bool _mi_arena_contains(const void* p) {
  function mi_arena_add (line 795) | static bool mi_arena_add(mi_arena_t* arena, mi_arena_id_t* arena_id, mi_...
  function mi_manage_os_memory_ex2 (line 815) | static bool mi_manage_os_memory_ex2(void* start, size_t size, bool is_la...
  function mi_manage_os_memory_ex (line 881) | bool mi_manage_os_memory_ex(void* start, size_t size, bool is_committed,...
  function mi_reserve_os_memory_ex (line 890) | int mi_reserve_os_memory_ex(size_t size, bool commit, bool allow_large, ...
  function mi_manage_os_memory (line 908) | bool mi_manage_os_memory(void* start, size_t size, bool is_committed, bo...
  function mi_reserve_os_memory (line 913) | int mi_reserve_os_memory(size_t size, bool commit, bool allow_large) mi_...
  function mi_debug_show_bitmap (line 922) | static size_t mi_debug_show_bitmap(const char* prefix, const char* heade...
  function mi_debug_show_arenas (line 946) | void mi_debug_show_arenas(void) mi_attr_noexcept {
  function mi_arenas_print (line 975) | void mi_arenas_print(void) mi_attr_noexcept {
  function mi_reserve_huge_os_pages_at_ex (line 984) | int mi_reserve_huge_os_pages_at_ex(size_t pages, int numa_node, size_t t...
  function mi_reserve_huge_os_pages_at (line 1006) | int mi_reserve_huge_os_pages_at(size_t pages, int numa_node, size_t time...
  function mi_reserve_huge_os_pages_interleave (line 1011) | int mi_reserve_huge_os_pages_interleave(size_t pages, size_t numa_nodes,...
  function mi_reserve_huge_os_pages (line 1038) | int mi_reserve_huge_os_pages(size_t pages, double max_secs, size_t* page...

FILE: src/bitmap.c
  function mi_bitmap_mask_ (line 28) | static inline size_t mi_bitmap_mask_(size_t count, size_t bitidx) {
  function _mi_bitmap_try_find_claim_field (line 43) | inline bool _mi_bitmap_try_find_claim_field(mi_bitmap_t bitmap, size_t i...
  function _mi_bitmap_try_find_from_claim (line 100) | bool _mi_bitmap_try_find_from_claim(mi_bitmap_t bitmap, const size_t bit...
  function _mi_bitmap_try_find_from_claim_pred (line 112) | bool _mi_bitmap_try_find_from_claim_pred(mi_bitmap_t bitmap, const size_...
  function _mi_bitmap_unclaim (line 132) | bool _mi_bitmap_unclaim(mi_bitmap_t bitmap, size_t bitmap_fields, size_t...
  function _mi_bitmap_claim (line 145) | bool _mi_bitmap_claim(mi_bitmap_t bitmap, size_t bitmap_fields, size_t c...
  function mi_bitmap_is_claimedx (line 157) | static bool mi_bitmap_is_claimedx(mi_bitmap_t bitmap, size_t bitmap_fiel...
  function _mi_bitmap_try_claim (line 169) | bool _mi_bitmap_try_claim(mi_bitmap_t bitmap, size_t bitmap_fields, size...
  function _mi_bitmap_is_claimed (line 184) | bool _mi_bitmap_is_claimed(mi_bitmap_t bitmap, size_t bitmap_fields, siz...
  function _mi_bitmap_is_any_claimed (line 188) | bool _mi_bitmap_is_any_claimed(mi_bitmap_t bitmap, size_t bitmap_fields,...
  function mi_bitmap_try_find_claim_field_across (line 203) | static bool mi_bitmap_try_find_claim_field_across(mi_bitmap_t bitmap, si...
  function _mi_bitmap_try_find_from_claim_across (line 295) | bool _mi_bitmap_try_find_from_claim_across(mi_bitmap_t bitmap, const siz...
  function mi_bitmap_mask_across (line 323) | static size_t mi_bitmap_mask_across(mi_bitmap_index_t bitmap_idx, size_t...
  function _mi_bitmap_unclaim_across (line 349) | bool _mi_bitmap_unclaim_across(mi_bitmap_t bitmap, size_t bitmap_fields,...
  function _mi_bitmap_claim_across (line 372) | bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, s...
  function mi_bitmap_is_claimedx_across (line 404) | static bool mi_bitmap_is_claimedx_across(mi_bitmap_t bitmap, size_t bitm...
  function _mi_bitmap_is_claimed_across (line 433) | bool _mi_bitmap_is_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fiel...
  function _mi_bitmap_is_any_claimed_across (line 437) | bool _mi_bitmap_is_any_claimed_across(mi_bitmap_t bitmap, size_t bitmap_...

FILE: src/bitmap.h
  type mi_bitmap_field_t (line 31) | typedef _Atomic(size_t)  mi_bitmap_field_t;
  type mi_bitmap_field_t (line 32) | typedef mi_bitmap_field_t*  mi_bitmap_t;
  type mi_bitmap_index_t (line 35) | typedef size_t mi_bitmap_index_t;
  function mi_bitmap_index_t (line 38) | static inline mi_bitmap_index_t mi_bitmap_index_create_ex(size_t idx, si...
  function mi_bitmap_index_t (line 42) | static inline mi_bitmap_index_t mi_bitmap_index_create(size_t idx, size_...
  function mi_bitmap_index_t (line 48) | static inline mi_bitmap_index_t mi_bitmap_index_create_from_bit(size_t f...
  function mi_bitmap_index_field (line 53) | static inline size_t mi_bitmap_index_field(mi_bitmap_index_t bitmap_idx) {
  function mi_bitmap_index_bit_in_field (line 58) | static inline size_t mi_bitmap_index_bit_in_field(mi_bitmap_index_t bitm...
  function mi_bitmap_index_bit (line 63) | static inline size_t mi_bitmap_index_bit(mi_bitmap_index_t bitmap_idx) {

FILE: src/free.c
  function mi_free_block_local (line 31) | static inline void mi_free_block_local(mi_page_t* page, mi_block_t* bloc...
  function mi_block_t (line 59) | mi_block_t* _mi_page_ptr_unalign(const mi_page_t* page, const void* p) {
  function mi_block_check_unguard (line 77) | static inline void mi_block_check_unguard(mi_page_t* page, mi_block_t* b...
  function mi_block_check_unguard (line 81) | static inline void mi_block_check_unguard(mi_page_t* page, mi_block_t* b...
  function mi_free_generic_local (line 87) | static void mi_decl_noinline mi_free_generic_local(mi_page_t* page, mi_s...
  function mi_free_generic_mt (line 95) | static void mi_decl_noinline mi_free_generic_mt(mi_page_t* page, mi_segm...
  function _mi_free_generic (line 102) | void mi_decl_noinline _mi_free_generic(mi_segment_t* segment, mi_page_t*...
  function mi_free_ex (line 151) | static inline void mi_free_ex(void* p, size_t* usable) mi_attr_noexcept
  function mi_free (line 177) | void mi_free(void* p) mi_attr_noexcept {
  function mi_ufree (line 181) | void mi_ufree(void* p, size_t* usable) mi_attr_noexcept {
  function _mi_free_delayed_block (line 186) | bool _mi_free_delayed_block(mi_block_t* block) {
  function mi_free_block_delayed_mt (line 218) | static void mi_decl_noinline mi_free_block_delayed_mt( mi_page_t* page, ...
  function mi_free_block_mt (line 262) | static void mi_decl_noinline mi_free_block_mt(mi_page_t* page, mi_segmen...
  function mi_page_usable_aligned_size_of (line 321) | static size_t mi_decl_noinline mi_page_usable_aligned_size_of(const mi_p...
  function mi_page_t (line 335) | static inline mi_page_t* mi_validate_ptr_page(const void* p, const char*...
  function _mi_usable_size (line 342) | static inline size_t _mi_usable_size(const void* p, const mi_page_t* pag...
  function mi_decl_nodiscard (line 354) | mi_decl_nodiscard size_t mi_usable_size(const void* p) mi_attr_noexcept {
  function mi_free_size (line 364) | void mi_free_size(void* p, size_t size) mi_attr_noexcept {
  function mi_free_size_aligned (line 374) | void mi_free_size_aligned(void* p, size_t size, size_t alignment) mi_att...
  function mi_free_aligned (line 380) | void mi_free_aligned(void* p, size_t alignment) mi_attr_noexcept {
  function mi_list_contains (line 394) | static bool mi_list_contains(const mi_page_t* page, const mi_block_t* li...
  function mi_decl_noinline (line 402) | static mi_decl_noinline bool mi_check_is_double_freex(const mi_page_t* p...
  function mi_check_is_double_free (line 417) | static inline bool mi_check_is_double_free(const mi_page_t* page, const ...
  function mi_check_is_double_free (line 430) | static inline bool mi_check_is_double_free(const mi_page_t* page, const ...
  function mi_page_decode_padding (line 443) | static bool mi_page_decode_padding(const mi_page_t* page, const mi_block...
  function mi_page_usable_size_of (line 458) | static size_t mi_page_usable_size_of(const mi_page_t* page, const mi_blo...
  function _mi_padding_shrink (line 470) | void _mi_padding_shrink(const mi_page_t* page, const mi_block_t* block, ...
  function mi_page_usable_size_of (line 486) | static size_t mi_page_usable_size_of(const mi_page_t* page, const mi_blo...
  function _mi_padding_shrink (line 491) | void _mi_padding_shrink(const mi_page_t* page, const mi_block_t* block, ...
  function mi_verify_padding (line 500) | static bool mi_verify_padding(const mi_page_t* page, const mi_block_t* b...
  function mi_check_padding (line 524) | static void mi_check_padding(const mi_page_t* page, const mi_block_t* bl...
  function mi_check_padding (line 534) | static void mi_check_padding(const mi_page_t* page, const mi_block_t* bl...
  function mi_stat_free (line 543) | static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) {
  function mi_stat_free (line 565) | static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) {
  function mi_block_unguard (line 573) | static void mi_block_unguard(mi_page_t* page, mi_block_t* block, void* p) {

FILE: src/heap.c
  function mi_heap_visit_pages (line 27) | static bool mi_heap_visit_pages(mi_heap_t* heap, heap_page_visitor_fun* ...
  function mi_heap_page_is_valid (line 56) | static bool mi_heap_page_is_valid(mi_heap_t* heap, mi_page_queue_t* pq, ...
  function mi_heap_is_valid (line 68) | static bool mi_heap_is_valid(mi_heap_t* heap) {
  type mi_collect_t (line 85) | typedef enum mi_collect_e {
  function mi_heap_page_collect (line 92) | static bool mi_heap_page_collect(mi_heap_t* heap, mi_page_queue_t* pq, m...
  function mi_heap_page_never_delayed_free (line 115) | static bool mi_heap_page_never_delayed_free(mi_heap_t* heap, mi_page_que...
  function mi_heap_collect_ex (line 124) | static void mi_heap_collect_ex(mi_heap_t* heap, mi_collect_t collect)
  function _mi_heap_collect_abandon (line 182) | void _mi_heap_collect_abandon(mi_heap_t* heap) {
  function mi_heap_collect (line 186) | void mi_heap_collect(mi_heap_t* heap, bool force) mi_attr_noexcept {
  function mi_collect (line 190) | void mi_collect(bool force) mi_attr_noexcept {
  function mi_heap_t (line 199) | mi_heap_t* mi_heap_get_default(void) {
  function mi_heap_is_default (line 204) | static bool mi_heap_is_default(const mi_heap_t* heap) {
  function mi_heap_t (line 209) | mi_heap_t* mi_heap_get_backing(void) {
  function _mi_heap_init (line 218) | void _mi_heap_init(mi_heap_t* heap, mi_tld_t* tld, mi_arena_id_t arena_i...
  function mi_decl_nodiscard (line 244) | mi_decl_nodiscard mi_heap_t* mi_heap_new_ex(int heap_tag, bool allow_des...
  function mi_decl_nodiscard (line 253) | mi_decl_nodiscard mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id) {
  function mi_decl_nodiscard (line 257) | mi_decl_nodiscard mi_heap_t* mi_heap_new(void) {
  function _mi_heap_memid_is_suitable (line 262) | bool _mi_heap_memid_is_suitable(mi_heap_t* heap, mi_memid_t memid) {
  function _mi_heap_random_next (line 266) | uintptr_t _mi_heap_random_next(mi_heap_t* heap) {
  function mi_heap_reset_pages (line 271) | static void mi_heap_reset_pages(mi_heap_t* heap) {
  function mi_heap_free (line 282) | static void mi_heap_free(mi_heap_t* heap) {
  function mi_heap_t (line 313) | mi_heap_t* _mi_heap_by_tag(mi_heap_t* heap, uint8_t tag) {
  function _mi_heap_page_destroy (line 329) | static bool _mi_heap_page_destroy(mi_heap_t* heap, mi_page_queue_t* pq, ...
  function _mi_heap_destroy_pages (line 374) | void _mi_heap_destroy_pages(mi_heap_t* heap) {
  function mi_heap_track_block_free (line 380) | static bool mi_cdecl mi_heap_track_block_free(const mi_heap_t* heap, con...
  function mi_heap_destroy (line 387) | void mi_heap_destroy(mi_heap_t* heap) {
  function _mi_heap_unsafe_destroy_all (line 416) | void _mi_heap_unsafe_destroy_all(mi_heap_t* heap) {
  function mi_heap_absorb (line 437) | static void mi_heap_absorb(mi_heap_t* heap, mi_heap_t* from) {
  function mi_heaps_are_compatible (line 471) | static bool mi_heaps_are_compatible(mi_heap_t* heap1, mi_heap_t* heap2) {
  function mi_heap_delete (line 477) | void mi_heap_delete(mi_heap_t* heap)
  function mi_heap_t (line 497) | mi_heap_t* mi_heap_set_default(mi_heap_t* heap) {
  function mi_heap_t (line 515) | static mi_heap_t* mi_heap_of_block(const void* p) {
  function mi_heap_contains_block (line 524) | bool mi_heap_contains_block(mi_heap_t* heap, const void* p) {
  function mi_heap_page_check_owned (line 531) | static bool mi_heap_page_check_owned(mi_heap_t* heap, mi_page_queue_t* p...
  function mi_heap_check_owned (line 541) | bool mi_heap_check_owned(mi_heap_t* heap, const void* p) {
  function mi_check_owned (line 550) | bool mi_check_owned(const void* p) {
  function _mi_heap_area_init (line 560) | void _mi_heap_area_init(mi_heap_area_t* area, mi_page_t* page) {
  function mi_get_fast_divisor (line 573) | static void mi_get_fast_divisor(size_t divisor, uint64_t* magic, size_t*...
  function mi_fast_divide (line 579) | static size_t mi_fast_divide(size_t n, uint64_t magic, size_t shift) {
  function _mi_heap_area_visit_blocks (line 585) | bool _mi_heap_area_visit_blocks(const mi_heap_area_t* area, mi_page_t* p...
  type mi_heap_area_ex_t (line 692) | typedef struct mi_heap_area_ex_s {
  function mi_heap_visit_areas_page (line 699) | static bool mi_heap_visit_areas_page(mi_heap_t* heap, mi_page_queue_t* p...
  function mi_heap_visit_areas (line 710) | static bool mi_heap_visit_areas(const mi_heap_t* heap, mi_heap_area_visi...
  type mi_visit_blocks_args_t (line 716) | typedef struct mi_visit_blocks_args_s {
  function mi_heap_area_visitor (line 722) | static bool mi_heap_area_visitor(const mi_heap_t* heap, const mi_heap_ar...
  function mi_heap_visit_blocks (line 734) | bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_blocks, mi_b...

FILE: src/init.c
  function mi_threadid_t (line 145) | mi_threadid_t _mi_thread_id(void) mi_attr_noexcept {
  function mi_decl_export (line 187) | mi_decl_export void mi_heap_guarded_set_sample_rate(mi_heap_t* heap, siz...
  function mi_decl_export (line 198) | mi_decl_export void mi_heap_guarded_set_size_bound(mi_heap_t* heap, size...
  function _mi_heap_guarded_init (line 203) | void _mi_heap_guarded_init(mi_heap_t* heap) {
  function mi_decl_export (line 212) | mi_decl_export void mi_heap_guarded_set_sample_rate(mi_heap_t* heap, siz...
  function mi_decl_export (line 216) | mi_decl_export void mi_heap_guarded_set_size_bound(mi_heap_t* heap, size...
  function _mi_heap_guarded_init (line 219) | void _mi_heap_guarded_init(mi_heap_t* heap) {
  function mi_heap_main_init (line 225) | static void mi_heap_main_init(void) {
  function mi_heap_t (line 243) | mi_heap_t* _mi_heap_main_get(void) {
  function mi_subproc_id_t (line 252) | mi_subproc_id_t mi_subproc_main(void) {
  function mi_subproc_id_t (line 256) | mi_subproc_id_t mi_subproc_new(void) {
  function mi_subproc_t (line 267) | mi_subproc_t* _mi_subproc_from_id(mi_subproc_id_t subproc_id) {
  function mi_subproc_delete (line 271) | void mi_subproc_delete(mi_subproc_id_t subproc_id) {
  function mi_subproc_add_current_thread (line 289) | void mi_subproc_add_current_thread(mi_subproc_id_t subproc_id) {
  type mi_thread_data_t (line 304) | typedef struct mi_thread_data_s {
  function mi_thread_data_t (line 319) | static mi_thread_data_t* mi_thread_data_zalloc(void) {
  function mi_thread_data_free (line 350) | static void mi_thread_data_free( mi_thread_data_t* tdfree ) {
  function _mi_thread_data_collect (line 365) | void _mi_thread_data_collect(void) {
  function _mi_thread_heap_init (line 379) | static bool _mi_thread_heap_init(void) {
  function _mi_tld_init (line 403) | void _mi_tld_init(mi_tld_t* tld, mi_heap_t* bheap) {
  function _mi_thread_heap_done (line 412) | static bool _mi_thread_heap_done(mi_heap_t* heap) {
  function mi_process_setup_auto_thread_done (line 481) | static void mi_process_setup_auto_thread_done(void) {
  function _mi_is_main_thread (line 490) | bool _mi_is_main_thread(void) {
  function _mi_current_thread_count (line 496) | size_t  _mi_current_thread_count(void) {
  function mi_thread_init (line 501) | void mi_thread_init(void) mi_attr_noexcept
  function mi_thread_done (line 516) | void mi_thread_done(void) mi_attr_noexcept {
  function _mi_thread_done (line 520) | void _mi_thread_done(mi_heap_t* heap)
  function _mi_heap_set_default_direct (line 544) | void _mi_heap_set_default_direct(mi_heap_t* heap)  {
  function mi_thread_set_in_threadpool (line 561) | void mi_thread_set_in_threadpool(void) mi_attr_noexcept {
  function _mi_preloading (line 571) | _mi_preloading(void) {
  function mi_decl_nodiscard (line 576) | mi_decl_nodiscard bool mi_is_redirected(void) mi_attr_noexcept {
  function _mi_auto_process_init (line 581) | void _mi_auto_process_init(void) {
  function mi_detect_cpu_features (line 610) | static void mi_detect_cpu_features(void) {
  function mi_detect_cpu_features (line 619) | static void mi_detect_cpu_features(void) {
  function mi_process_init (line 625) | void mi_process_init(void) mi_attr_noexcept {
  function mi_process_done (line 669) | void mi_cdecl mi_process_done(void) mi_attr_noexcept {
  function _mi_auto_process_done (line 712) | void mi_cdecl _mi_auto_process_done(void) mi_attr_noexcept {

FILE: src/libc.c
  function _mi_toupper (line 19) | char _mi_toupper(char c) {
  function _mi_strnicmp (line 24) | int _mi_strnicmp(const char* s, const char* t, size_t n) {
  function _mi_strlcpy (line 32) | void _mi_strlcpy(char* dest, const char* src, size_t dest_size) {
  function _mi_strlcat (line 43) | void _mi_strlcat(char* dest, const char* src, size_t dest_size) {
  function _mi_strlen (line 54) | size_t _mi_strlen(const char* s) {
  function _mi_strnlen (line 61) | size_t _mi_strnlen(const char* s, size_t max_len) {
  function _mi_getenv (line 69) | bool _mi_getenv(const char* name, char* result, size_t result_size) {
  function _mi_getenv (line 76) | bool _mi_getenv(const char* name, char* result, size_t result_size) {
  function mi_outc (line 95) | static void mi_outc(char c, char** out, char* end) {
  function mi_outs (line 102) | static void mi_outs(const char* s, char** out, char* end) {
  function mi_out_fill (line 111) | static void mi_out_fill(char fill, size_t len, char** out, char* end) {
  function mi_out_alignright (line 119) | static void mi_out_alignright(char fill, char* start, size_t len, size_t...
  function mi_out_num (line 133) | static void mi_out_num(uintmax_t x, size_t base, char prefix, char** out...
  function _mi_vsnprintf (line 163) | int _mi_vsnprintf(char* buf, size_t bufsize, const char* fmt, va_list ar...
  function _mi_snprintf (line 271) | int _mi_snprintf(char* buf, size_t buflen, const char* fmt, ...) {
  function mi_byte_sum32 (line 286) | static size_t mi_byte_sum32(uint32_t x) {
  function mi_popcount_generic32 (line 293) | static size_t mi_popcount_generic32(uint32_t x) {
  function mi_decl_noinline (line 306) | mi_decl_noinline size_t _mi_popcount_generic(size_t x) {
  function mi_byte_sum64 (line 316) | static size_t mi_byte_sum64(uint64_t x) {
  function mi_popcount_generic64 (line 323) | static size_t mi_popcount_generic64(uint64_t x) {
  function mi_decl_noinline (line 330) | mi_decl_noinline size_t _mi_popcount_generic(size_t x) {

FILE: src/options.c
  function mi_version (line 22) | int mi_version(void) mi_attr_noexcept {
  type mi_init_t (line 33) | typedef enum mi_init_e {
  type mi_option_desc_t (line 39) | typedef struct mi_option_desc_s {
  function mi_option_has_size_in_kib (line 177) | static bool mi_option_has_size_in_kib(mi_option_t option) {
  function _mi_options_init (line 181) | void _mi_options_init(void) {
  function mi_options_print (line 204) | void mi_options_print(void) mi_attr_noexcept
  function _mi_option_get_fast (line 244) | long _mi_option_get_fast(mi_option_t option) {
  function mi_option_get (line 253) | mi_decl_nodiscard long mi_option_get(mi_option_t option) {
  function mi_option_get_clamp (line 264) | mi_decl_nodiscard long mi_option_get_clamp(mi_option_t option, long min,...
  function mi_decl_nodiscard (line 269) | mi_decl_nodiscard size_t mi_option_get_size(mi_option_t option) {
  function mi_option_set (line 278) | void mi_option_set(mi_option_t option, long value) {
  function mi_option_set_default (line 294) | void mi_option_set_default(mi_option_t option, long value) {
  function mi_decl_nodiscard (line 303) | mi_decl_nodiscard bool mi_option_is_enabled(mi_option_t option) {
  function mi_option_set_enabled (line 307) | void mi_option_set_enabled(mi_option_t option, bool enable) {
  function mi_option_set_enabled_default (line 311) | void mi_option_set_enabled_default(mi_option_t option, bool enable) {
  function mi_option_enable (line 315) | void mi_option_enable(mi_option_t option) {
  function mi_option_disable (line 319) | void mi_option_disable(mi_option_t option) {
  function mi_out_stderr (line 323) | static void mi_cdecl mi_out_stderr(const char* msg, void* arg) {
  function mi_out_buf (line 340) | static void mi_cdecl mi_out_buf(const char* msg, void* arg) {
  function mi_out_buf_flush (line 356) | static void mi_out_buf_flush(mi_output_fun* out, bool no_more_buf, void*...
  function mi_out_buf_stderr (line 372) | static void mi_cdecl mi_out_buf_stderr(const char* msg, void* arg) {
  function mi_output_fun (line 388) | static mi_output_fun* mi_out_get_default(void** parg) {
  function mi_register_output (line 394) | void mi_register_output(mi_output_fun* out, void* arg) mi_attr_noexcept {
  function mi_add_stderr_output (line 401) | static void mi_add_stderr_output(void) {
  function mi_decl_noinline (line 424) | static mi_decl_noinline bool mi_recurse_enter_prim(void) {
  function mi_decl_noinline (line 430) | static mi_decl_noinline void mi_recurse_exit_prim(void) {
  function mi_recurse_enter (line 434) | static bool mi_recurse_enter(void) {
  function mi_recurse_exit (line 441) | static void mi_recurse_exit(void) {
  function _mi_fputs (line 448) | void _mi_fputs(mi_output_fun* out, void* arg, const char* prefix, const ...
  function mi_vfprintf (line 464) | static void mi_vfprintf( mi_output_fun* out, void* arg, const char* pref...
  function _mi_fprintf (line 473) | void _mi_fprintf( mi_output_fun* out, void* arg, const char* fmt, ... ) {
  function mi_vfprintf_thread (line 480) | static void mi_vfprintf_thread(mi_output_fun* out, void* arg, const char...
  function _mi_message (line 491) | void _mi_message(const char* fmt, ...) {
  function _mi_trace_message (line 498) | void _mi_trace_message(const char* fmt, ...) {
  function _mi_verbose_message (line 506) | void _mi_verbose_message(const char* fmt, ...) {
  function mi_show_error_message (line 514) | static void mi_show_error_message(const char* fmt, va_list args) {
  function _mi_warning_message (line 522) | void _mi_warning_message(const char* fmt, ...) {
  function _mi_assert_fail (line 535) | void _mi_assert_fail(const char* assertion, const char* fname, unsigned ...
  function mi_error_default (line 548) | static void mi_error_default(int err) {
  function mi_register_error (line 570) | void mi_register_error(mi_error_fun* fun, void* arg) {
  function _mi_error_message (line 575) | void _mi_error_message(int err, const char* fmt, ...) {
  function mi_option_init (line 599) | static void mi_option_init(mi_option_desc_t* desc) {

FILE: src/os.c
  function _mi_os_has_overcommit (line 46) | bool _mi_os_has_overcommit(void) {
  function _mi_os_has_virtual_reserve (line 50) | bool _mi_os_has_virtual_reserve(void) {
  function _mi_os_page_size (line 56) | size_t _mi_os_page_size(void) {
  function _mi_os_large_page_size (line 61) | size_t _mi_os_large_page_size(void) {
  function _mi_os_canuse_large_page (line 65) | bool _mi_os_canuse_large_page(size_t size, size_t alignment) {
  function _mi_os_good_alloc_size (line 72) | size_t _mi_os_good_alloc_size(size_t size) {
  function _mi_os_init (line 83) | void _mi_os_init(void) {
  function mi_os_prim_free (line 153) | static void mi_os_prim_free(void* addr, size_t size, size_t commit_size) {
  function _mi_os_free_ex (line 166) | void _mi_os_free_ex(void* addr, size_t size, bool still_committed, mi_me...
  function _mi_os_free (line 200) | void  _mi_os_free(void* p, size_t size, mi_memid_t memid) {
  function mi_decl_nodiscard (line 363) | mi_decl_nodiscard static void* mi_os_ensure_zero(void* p, size_t size, m...
  function _mi_os_commit_ex (line 449) | bool _mi_os_commit_ex(void* addr, size_t size, bool* is_zero, size_t sta...
  function _mi_os_commit (line 478) | bool _mi_os_commit(void* addr, size_t size, bool* is_zero) {
  function mi_os_decommit_ex (line 482) | static bool mi_os_decommit_ex(void* addr, size_t size, bool* needs_recom...
  function _mi_os_decommit (line 501) | bool _mi_os_decommit(void* addr, size_t size) {
  function _mi_os_reset (line 511) | bool _mi_os_reset(void* addr, size_t size) {
  function _mi_os_reuse (line 531) | void _mi_os_reuse( void* addr, size_t size ) {
  function _mi_os_purge_ex (line 544) | bool _mi_os_purge_ex(void* p, size_t size, bool allow_reset, size_t stat...
  function _mi_os_purge (line 567) | bool _mi_os_purge(void* p, size_t size) {
  function mi_os_protectx (line 572) | static  bool mi_os_protectx(void* addr, size_t size, bool protect) {
  function _mi_os_protect (line 589) | bool _mi_os_protect(void* addr, size_t size) {
  function _mi_os_unprotect (line 593) | bool _mi_os_unprotect(void* addr, size_t size) {
  function mi_os_free_huge_os_pages (line 717) | static void mi_os_free_huge_os_pages(void* p, size_t size) {
  function _mi_os_numa_node_count (line 734) | int _mi_os_numa_node_count(void) {
  function mi_os_numa_node_get (line 753) | static int mi_os_numa_node_get(void) {
  function _mi_os_numa_node (line 763) | int _mi_os_numa_node(void) {

FILE: src/page-queue.c
  function mi_page_queue_is_huge (line 40) | static inline bool mi_page_queue_is_huge(const mi_page_queue_t* pq) {
  function mi_page_queue_is_full (line 44) | static inline bool mi_page_queue_is_full(const mi_page_queue_t* pq) {
  function mi_page_queue_is_special (line 48) | static inline bool mi_page_queue_is_special(const mi_page_queue_t* pq) {
  function mi_bin (line 60) | static inline size_t mi_bin(size_t size) {
  function _mi_bin (line 100) | size_t _mi_bin(size_t size) {
  function _mi_bin_size (line 104) | size_t _mi_bin_size(size_t bin) {
  function mi_good_size (line 109) | size_t mi_good_size(size_t size) mi_attr_noexcept {
  function mi_page_queue_contains (line 119) | static bool mi_page_queue_contains(mi_page_queue_t* queue, const mi_page...
  function mi_heap_contains_queue (line 134) | static bool mi_heap_contains_queue(const mi_heap_t* heap, const mi_page_...
  function mi_page_is_large_or_huge (line 139) | static inline bool mi_page_is_large_or_huge(const mi_page_t* page) {
  function mi_page_bin (line 143) | static size_t mi_page_bin(const mi_page_t* page) {
  function _mi_page_stats_bin (line 150) | size_t _mi_page_stats_bin(const mi_page_t* page) {
  function mi_page_queue_t (line 156) | static mi_page_queue_t* mi_heap_page_queue_of(mi_heap_t* heap, const mi_...
  function mi_page_queue_t (line 166) | static mi_page_queue_t* mi_page_queue_of(const mi_page_t* page) {
  function mi_heap_queue_first_update (line 178) | static inline void mi_heap_queue_first_update(mi_heap_t* heap, const mi_...
  function mi_page_queue_remove (line 221) | static void mi_page_queue_remove(mi_page_queue_t* queue, mi_page_t* page) {
  function mi_page_queue_push (line 246) | static void mi_page_queue_push(mi_heap_t* heap, mi_page_queue_t* queue, ...
  function mi_page_queue_move_to_front (line 274) | static void mi_page_queue_move_to_front(mi_heap_t* heap, mi_page_queue_t...
  function mi_page_queue_enqueue_from_ex (line 283) | static void mi_page_queue_enqueue_from_ex(mi_page_queue_t* to, mi_page_q...
  function mi_page_queue_enqueue_from (line 352) | static void mi_page_queue_enqueue_from(mi_page_queue_t* to, mi_page_queu...
  function mi_page_queue_enqueue_from_full (line 356) | static void mi_page_queue_enqueue_from_full(mi_page_queue_t* to, mi_page...
  function _mi_page_queue_append (line 362) | size_t _mi_page_queue_append(mi_heap_t* heap, mi_page_queue_t* pq, mi_pa...

FILE: src/page.c
  function mi_block_t (line 32) | static inline mi_block_t* mi_page_block_at(const mi_page_t* page, void* ...
  function mi_page_list_count (line 43) | static size_t mi_page_list_count(mi_page_t* page, mi_block_t* head) {
  function mi_page_list_is_valid (line 60) | static bool mi_page_list_is_valid(mi_page_t* page, mi_block_t* p) {
  function mi_page_is_valid_init (line 80) | static bool mi_page_is_valid_init(mi_page_t* page) {
  function _mi_page_is_valid (line 117) | bool _mi_page_is_valid(mi_page_t* page) {
  function _mi_page_use_delayed_free (line 140) | void _mi_page_use_delayed_free(mi_page_t* page, mi_delayed_t delay, bool...
  function _mi_page_try_use_delayed_free (line 146) | bool _mi_page_try_use_delayed_free(mi_page_t* page, mi_delayed_t delay, ...
  function _mi_page_thread_free_collect (line 181) | static void _mi_page_thread_free_collect(mi_page_t* page)
  function _mi_page_free_collect (line 217) | void _mi_page_free_collect(mi_page_t* page, bool force) {
  function _mi_page_reclaim (line 257) | void _mi_page_reclaim(mi_heap_t* heap, mi_page_t* page) {
  function mi_page_t (line 273) | static mi_page_t* mi_page_fresh_alloc(mi_heap_t* heap, mi_page_queue_t* ...
  function mi_page_t (line 301) | static mi_page_t* mi_page_fresh(mi_heap_t* heap, mi_page_queue_t* pq) {
  function _mi_heap_delayed_free_all (line 314) | void _mi_heap_delayed_free_all(mi_heap_t* heap) {
  function _mi_heap_delayed_free_partial (line 321) | bool _mi_heap_delayed_free_partial(mi_heap_t* heap) {
  function _mi_page_unfull (line 351) | void _mi_page_unfull(mi_page_t* page) {
  function mi_page_to_full (line 365) | static void mi_page_to_full(mi_page_t* page, mi_page_queue_t* pq) {
  function _mi_page_abandon (line 380) | void _mi_page_abandon(mi_page_t* page, mi_page_queue_t* pq) {
  function _mi_page_force_abandon (line 409) | void _mi_page_force_abandon(mi_page_t* page) {
  function _mi_page_free (line 432) | void _mi_page_free(mi_page_t* page, mi_page_queue_t* pq, bool force) {
  function _mi_page_retire (line 462) | void _mi_page_retire(mi_page_t* page) mi_attr_noexcept {
  function _mi_heap_collect_retired (line 498) | void _mi_heap_collect_retired(mi_heap_t* heap, bool force) {
  function mi_page_free_list_extend_secure (line 536) | static void mi_page_free_list_extend_secure(mi_heap_t* const heap, mi_pa...
  function mi_decl_noinline (line 593) | static mi_decl_noinline void mi_page_free_list_extend( mi_page_t* const ...
  function mi_page_extend_free (line 635) | static bool mi_page_extend_free(mi_heap_t* heap, mi_page_t* page, mi_tld...
  function mi_page_init (line 679) | static void mi_page_init(mi_heap_t* heap, mi_page_t* page, size_t block_...
  function mi_page_is_expandable (line 745) | static bool mi_page_is_expandable(const mi_page_t* page) {
  function mi_page_t (line 753) | static mi_page_t* mi_page_queue_find_free_ex(mi_heap_t* heap, mi_page_qu...
  function mi_page_t (line 859) | static inline mi_page_t* mi_find_free_page(mi_heap_t* heap, size_t size) {
  function _mi_deferred_free (line 896) | void _mi_deferred_free(mi_heap_t* heap, bool force) {
  function mi_register_deferred_free (line 905) | void mi_register_deferred_free(mi_deferred_free_fun* fn, void* arg) mi_a...
  function mi_page_t (line 919) | static mi_page_t* mi_large_huge_page_alloc(mi_heap_t* heap, size_t size,...
  function mi_page_t (line 963) | static mi_page_t* mi_find_page(mi_heap_t* heap, size_t size, size_t huge...

FILE: src/prim/emscripten/prim.c
  function _mi_prim_mem_init (line 50) | void _mi_prim_mem_init( mi_os_mem_config_t* config) {
  function _mi_prim_free (line 60) | int _mi_prim_free(void* addr, size_t size) {
  function _mi_prim_alloc (line 74) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function _mi_prim_commit (line 99) | int _mi_prim_commit(void* addr, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 106) | int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 112) | int _mi_prim_reset(void* addr, size_t size) {
  function _mi_prim_reuse (line 117) | int _mi_prim_reuse(void* addr, size_t size) {
  function _mi_prim_protect (line 122) | int _mi_prim_protect(void* addr, size_t size, bool protect) {
  function _mi_prim_alloc_huge_os_pages (line 132) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 139) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 143) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 154) | mi_msecs_t _mi_prim_clock_now(void) {
  function _mi_prim_process_info (line 163) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 176) | void _mi_prim_out_stderr( const char* msg) {
  function _mi_prim_getenv (line 185) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 198) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function mi_pthread_done (line 214) | static void mi_pthread_done(void* value) {
  function _mi_prim_thread_init_auto_done (line 220) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 225) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 229) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function _mi_prim_thread_init_auto_done (line 237) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 241) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 245) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {

FILE: src/prim/osx/alloc-override-zone.c
  function zone_size (line 44) | static size_t zone_size(malloc_zone_t* zone, const void* p) {
  function zone_free (line 65) | static void zone_free(malloc_zone_t* zone, void* p) {
  function zone_destroy (line 80) | static void zone_destroy(malloc_zone_t* zone) {
  function zone_batch_malloc (line 85) | static unsigned zone_batch_malloc(malloc_zone_t* zone, size_t size, void...
  function zone_batch_free (line 94) | static void zone_batch_free(malloc_zone_t* zone, void** ps, unsigned cou...
  function zone_pressure_relief (line 101) | static size_t zone_pressure_relief(malloc_zone_t* zone, size_t size) {
  function zone_free_definite_size (line 107) | static void zone_free_definite_size(malloc_zone_t* zone, void* p, size_t...
  function boolean_t (line 112) | static boolean_t zone_claimed_address(malloc_zone_t* zone, void* p) {
  function kern_return_t (line 122) | static kern_return_t intro_enumerator(task_t task, void* p,
  function intro_good_size (line 133) | static size_t intro_good_size(malloc_zone_t* zone, size_t size) {
  function boolean_t (line 138) | static boolean_t intro_check(malloc_zone_t* zone) {
  function intro_print (line 143) | static void intro_print(malloc_zone_t* zone, boolean_t verbose) {
  function intro_log (line 148) | static void intro_log(malloc_zone_t* zone, void* p) {
  function intro_force_lock (line 153) | static void intro_force_lock(malloc_zone_t* zone) {
  function intro_force_unlock (line 158) | static void intro_force_unlock(malloc_zone_t* zone) {
  function intro_statistics (line 163) | static void intro_statistics(malloc_zone_t* zone, malloc_statistics_t* s...
  function boolean_t (line 172) | static boolean_t intro_zone_locked(malloc_zone_t* zone) {
  function malloc_zone_t (line 256) | static inline malloc_zone_t* mi_get_default_zone(void)
  function malloc_zone_t (line 272) | static malloc_zone_t* mi_malloc_create_zone(vm_size_t size, unsigned fla...
  function malloc_zone_t (line 277) | static malloc_zone_t* mi_malloc_default_zone (void) {
  function malloc_zone_t (line 281) | static malloc_zone_t* mi_malloc_default_purgeable_zone(void) {
  function mi_malloc_destroy_zone (line 285) | static void mi_malloc_destroy_zone(malloc_zone_t* zone) {
  function kern_return_t (line 290) | static kern_return_t mi_malloc_get_all_zones (task_t task, memory_reader...
  function mi_malloc_set_zone_name (line 301) | static void mi_malloc_set_zone_name(malloc_zone_t* zone, const char* nam...
  function mi_malloc_jumpstart (line 305) | static int mi_malloc_jumpstart(uintptr_t cookie) {
  function mi__malloc_fork_prepare (line 310) | static void mi__malloc_fork_prepare(void) {
  function mi__malloc_fork_parent (line 313) | static void mi__malloc_fork_parent(void) {
  function mi__malloc_fork_child (line 316) | static void mi__malloc_fork_child(void) {
  function mi_malloc_printf (line 320) | static void mi_malloc_printf(const char* fmt, ...) {
  function zone_check (line 324) | static bool zone_check(malloc_zone_t* zone) {
  function malloc_zone_t (line 329) | static malloc_zone_t* zone_from_ptr(const void* p) {
  function zone_log (line 334) | static void zone_log(malloc_zone_t* zone, void* p) {
  function zone_print (line 338) | static void zone_print(malloc_zone_t* zone, bool b) {
  function zone_print_ptr_info (line 342) | static void zone_print_ptr_info(void* p) {
  function zone_register (line 346) | static void zone_register(malloc_zone_t* zone) {
  function zone_unregister (line 350) | static void zone_unregister(malloc_zone_t* zone) {
  type mi_interpose_s (line 356) | struct mi_interpose_s {
  type mi_interpose_s (line 363) | struct mi_interpose_s
  function malloc_zone_t (line 405) | static inline malloc_zone_t* mi_get_default_zone(void)
  function _mi_macos_override_malloc (line 421) | __attribute__((constructor(101))) // highest priority

FILE: src/prim/prim.c
  function mi_process_attach (line 41) | mi_process_attach(void) {
  function mi_process_detach (line 44) | mi_process_detach(void) {
  function mi_init_done_t (line 50) | struct mi_init_done_t {
  function _mi_is_redirected (line 66) | bool _mi_is_redirected(void) {
  function _mi_allocator_init (line 69) | bool _mi_allocator_init(const char** message) {
  function _mi_allocator_done (line 73) | void _mi_allocator_done(void) {

FILE: src/prim/unix/prim.c
  function mi_prim_open (line 86) | static inline int mi_prim_open(const char* fpath, int open_flags) {
  function mi_prim_read (line 89) | static inline ssize_t mi_prim_read(int fd, void* buf, size_t bufsize) {
  function mi_prim_close (line 92) | static inline int mi_prim_close(int fd) {
  function mi_prim_access (line 95) | static inline int mi_prim_access(const char *fpath, int mode) {
  function mi_prim_open (line 101) | static inline int mi_prim_open(const char* fpath, int open_flags) {
  function mi_prim_read (line 104) | static inline ssize_t mi_prim_read(int fd, void* buf, size_t bufsize) {
  function mi_prim_close (line 107) | static inline int mi_prim_close(int fd) {
  function mi_prim_access (line 110) | static inline int mi_prim_access(const char *fpath, int mode) {
  function unix_detect_overcommit (line 122) | static bool unix_detect_overcommit(void) {
  function unix_detect_physical_memory (line 149) | static void unix_detect_physical_memory( size_t page_size, size_t* physi...
  function _mi_prim_mem_init (line 182) | void _mi_prim_mem_init( mi_os_mem_config_t* config )
  function _mi_prim_free (line 219) | int _mi_prim_free(void* addr, size_t size ) {
  function unix_madvise (line 230) | static int unix_madvise(void* addr, size_t size, int advice) {
  function unix_mmap_fd (line 300) | static int unix_mmap_fd(void) {
  type memcntl_mha (line 400) | struct memcntl_mha
  function _mi_prim_alloc (line 414) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function unix_mprotect_hint (line 433) | static void unix_mprotect_hint(int err) {
  function _mi_prim_commit (line 445) | int _mi_prim_commit(void* start, size_t size, bool* is_zero) {
  function _mi_prim_reuse (line 460) | int _mi_prim_reuse(void* start, size_t size) {
  function _mi_prim_decommit (line 468) | int _mi_prim_decommit(void* start, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 494) | int _mi_prim_reset(void* start, size_t size) {
  function _mi_prim_protect (line 523) | int _mi_prim_protect(void* start, size_t size, bool protect) {
  function mi_prim_mbind (line 543) | static long mi_prim_mbind(void* start, unsigned long len, unsigned long ...
  function mi_prim_mbind (line 547) | static long mi_prim_mbind(void* start, unsigned long len, unsigned long ...
  function _mi_prim_alloc_huge_os_pages (line 553) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_alloc_huge_os_pages (line 573) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 588) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 600) | size_t _mi_prim_numa_node_count(void) {
  function _mi_prim_numa_node (line 613) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 624) | size_t _mi_prim_numa_node_count(void) {
  function _mi_prim_numa_node (line 633) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 638) | size_t _mi_prim_numa_node_count(void) {
  function _mi_prim_numa_node (line 648) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 652) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 666) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 679) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 711) | static mi_msecs_t timeval_secs(const struct timeval* tv) {
  function _mi_prim_process_info (line 715) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_process_info (line 763) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 776) | void _mi_prim_out_stderr( const char* msg ) {
  function _mi_prim_getenv (line 799) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_getenv (line 818) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 847) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_random_buf (line 858) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_random_buf (line 869) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_random_buf (line 908) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function mi_pthread_done (line 925) | static void mi_pthread_done(void* value) {
  function _mi_prim_thread_init_auto_done (line 931) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 936) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 942) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function _mi_prim_thread_init_auto_done (line 950) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 954) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 958) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {

FILE: src/prim/wasi/prim.c
  function _mi_prim_mem_init (line 21) | void _mi_prim_mem_init( mi_os_mem_config_t* config ) {
  function _mi_prim_free (line 33) | int _mi_prim_free(void* addr, size_t size ) {
  function _mi_prim_alloc (line 122) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function _mi_prim_commit (line 135) | int _mi_prim_commit(void* addr, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 141) | int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 147) | int _mi_prim_reset(void* addr, size_t size) {
  function _mi_prim_reuse (line 152) | int _mi_prim_reuse(void* addr, size_t size) {
  function _mi_prim_protect (line 157) | int _mi_prim_protect(void* addr, size_t size, bool protect) {
  function _mi_prim_alloc_huge_os_pages (line 167) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 174) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 178) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 191) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 204) | mi_msecs_t _mi_prim_clock_now(void) {
  function _mi_prim_process_info (line 221) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 232) | void _mi_prim_out_stderr( const char* msg ) {
  function _mi_prim_getenv (line 241) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 265) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_thread_init_auto_done (line 274) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 278) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 282) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {

FILE: src/prim/windows/etw.h
  type MCGEN_TRACE_CONTEXT (line 243) | typedef struct _MCGEN_TRACE_CONTEXT
  function FORCEINLINE (line 268) | FORCEINLINE
  function FORCEINLINE (line 308) | FORCEINLINE
  function DECLSPEC_NOINLINE (line 323) | DECLSPEC_NOINLINE __inline
  type _mcgen_PASTE2 (line 457) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 460) | struct _mcgen_PASTE2
  type MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTREGISTER (line 464) | typedef void MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_...
  type _mcgen_PASTE2 (line 470) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 473) | struct _mcgen_PASTE2
  type MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTUNREGISTER (line 477) | typedef void MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGE...
  type _mcgen_PASTE2 (line 483) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 486) | struct _mcgen_PASTE2
  type MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_MCGEN_EVENTSETINFORMATION (line 490) | typedef void MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_...
  type _mcgen_PASTE2 (line 496) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 499) | struct _mcgen_PASTE2
  type MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_MCGEN_EVENTWRITETRANSFER (line 503) | typedef void MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_M...
  function DECLSPEC_NOINLINE (line 513) | DECLSPEC_NOINLINE __inline
  function DECLSPEC_NOINLINE (line 559) | DECLSPEC_NOINLINE __inline
  function DECLSPEC_NOINLINE (line 611) | DECLSPEC_NOINLINE __inline
  type McGenContext_microsoft_windows_mimalloc (line 766) | typedef struct tagMcGenContext_microsoft_windows_mimalloc {
  function ULONG (line 785) | __inline
  function McGenContext_microsoft_windows_mimalloc (line 807) | McGenContext_microsoft_windows_mimalloc*
  function ETW_INLINE (line 880) | ETW_INLINE

FILE: src/prim/windows/prim.c
  type MI_MEM_EXTENDED_PARAMETER_TYPE (line 28) | typedef enum MI_MEM_EXTENDED_PARAMETER_TYPE_E {
  type DECLSPEC_ALIGN (line 38) | struct DECLSPEC_ALIGN
  type MI_MEM_ADDRESS_REQUIREMENTS (line 43) | typedef struct MI_MEM_ADDRESS_REQUIREMENTS_S {
  type PVOID (line 52) | typedef PVOID (__stdcall *PVirtualAlloc2)(HANDLE, PVOID, SIZE_T, ULONG, ...
  type LONG (line 53) | typedef LONG  (__stdcall *PNtAllocateVirtualMemoryEx)(HANDLE, PVOID*, SI...
  type MI_PROCESSOR_NUMBER (line 58) | typedef struct MI_PROCESSOR_NUMBER_S { WORD Group; BYTE Number; BYTE Res...
  type VOID (line 60) | typedef VOID (__stdcall *PGetCurrentProcessorNumberEx)(MI_PROCESSOR_NUMB...
  type BOOL (line 61) | typedef BOOL (__stdcall *PGetNumaProcessorNodeEx)(MI_PROCESSOR_NUMBER* P...
  type BOOL (line 62) | typedef BOOL (__stdcall* PGetNumaNodeProcessorMaskEx)(USHORT Node, PGROU...
  type BOOL (line 63) | typedef BOOL (__stdcall *PGetNumaProcessorNode)(UCHAR Processor, PUCHAR ...
  type BOOL (line 64) | typedef BOOL (__stdcall* PGetNumaNodeProcessorMask)(UCHAR Node, PULONGLO...
  type BOOL (line 65) | typedef BOOL (__stdcall* PGetNumaHighestNodeNumber)(PULONG Node);
  type SIZE_T (line 74) | typedef SIZE_T(__stdcall* PGetLargePageMinimum)(VOID);
  type BOOL (line 78) | typedef BOOL (__stdcall *PGetPhysicallyInstalledSystemMemory)( PULONGLON...
  function win_enable_large_os_pages (line 84) | static bool win_enable_large_os_pages(size_t* large_page_size)
  function _mi_prim_mem_init (line 127) | void _mi_prim_mem_init( mi_os_mem_config_t* config )
  function _mi_prim_free (line 191) | int _mi_prim_free(void* addr, size_t size ) {
  function win_is_out_of_memory_error (line 245) | static bool win_is_out_of_memory_error(DWORD err) {
  function _mi_prim_alloc (line 319) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function _mi_prim_commit (line 338) | int _mi_prim_commit(void* addr, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 355) | int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 361) | int _mi_prim_reset(void* addr, size_t size) {
  function _mi_prim_reuse (line 372) | int _mi_prim_reuse(void* addr, size_t size) {
  function _mi_prim_protect (line 377) | int _mi_prim_protect(void* addr, size_t size, bool protect) {
  function _mi_prim_alloc_huge_os_pages (line 429) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 440) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 460) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 494) | static mi_msecs_t mi_to_msecs(LARGE_INTEGER t) {
  function mi_msecs_t (line 505) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 518) | static mi_msecs_t filetime_msecs(const FILETIME* ftime) {
  type PPROCESS_MEMORY_COUNTERS (line 526) | typedef BOOL (WINAPI *PGetProcessMemoryInfo)(HANDLE, PPROCESS_MEMORY_COU...
  function _mi_prim_process_info (line 529) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 563) | void _mi_prim_out_stderr( const char* msg )
  function _mi_prim_getenv (line 607) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 628) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  type PUCHAR (line 638) | typedef LONG (NTAPI *PBCryptGenRandom)(HANDLE, PUCHAR, ULONG, ULONG);
  function _mi_prim_random_buf (line 641) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function mi_win_tls_init (line 669) | static void mi_win_tls_init(DWORD reason) {
  function mi_win_main (line 692) | static void NTAPI mi_win_main(PVOID module, DWORD reason, LPVOID reserve...
  function BOOL (line 712) | BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved) {
  function _mi_prim_thread_init_auto_done (line 718) | void _mi_prim_thread_init_auto_done(void) { }
  function _mi_prim_thread_done_auto_done (line 719) | void _mi_prim_thread_done_auto_done(void) { }
  function _mi_prim_thread_associate_default_heap (line 720) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function mi_win_main_attach (line 727) | static void NTAPI mi_win_main_attach(PVOID module, DWORD reason, LPVOID ...
  function mi_win_main_detach (line 732) | static void NTAPI mi_win_main_detach(PVOID module, DWORD reason, LPVOID ...
  function _mi_prim_thread_init_auto_done (line 775) | void _mi_prim_thread_init_auto_done(void) { }
  function _mi_prim_thread_done_auto_done (line 776) | void _mi_prim_thread_done_auto_done(void) { }
  function _mi_prim_thread_associate_default_heap (line 777) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function mi_process_attach (line 788) | static int mi_process_attach(void) {
  function mi_fls_done (line 816) | static void NTAPI mi_fls_done(PVOID value) {
  function _mi_prim_thread_init_auto_done (line 824) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 828) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 834) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function _mi_is_redirected (line 848) | bool _mi_is_redirected(void) {
  function mi_decl_export (line 855) | mi_decl_export void _mi_redirect_entry(DWORD reason) {
  function _mi_allocator_init (line 873) | bool _mi_allocator_init(const char** message) {
  function _mi_allocator_done (line 876) | void _mi_allocator_done(void) {

FILE: src/random.c
  function rotl (line 36) | static inline uint32_t rotl(uint32_t x, uint32_t shift) {
  function qround (line 40) | static inline void qround(uint32_t x[16], size_t a, size_t b, size_t c, ...
  function chacha_block (line 47) | static void chacha_block(mi_random_ctx_t* ctx)
  function chacha_next32 (line 81) | static uint32_t chacha_next32(mi_random_ctx_t* ctx) {
  function read32 (line 92) | static inline uint32_t read32(const uint8_t* p, size_t idx32) {
  function chacha_init (line 97) | static void chacha_init(mi_random_ctx_t* ctx, const uint8_t key[32], uin...
  function chacha_split (line 116) | static void chacha_split(mi_random_ctx_t* ctx, uint64_t nonce, mi_random...
  function mi_random_is_initialized (line 133) | static bool mi_random_is_initialized(mi_random_ctx_t* ctx) {
  function _mi_random_split (line 138) | void _mi_random_split(mi_random_ctx_t* ctx, mi_random_ctx_t* ctx_new) {
  function _mi_random_next (line 144) | uintptr_t _mi_random_next(mi_random_ctx_t* ctx) {
  function _mi_os_random_weak (line 165) | uintptr_t _mi_os_random_weak(uintptr_t extra_seed) {
  function mi_random_init_ex (line 177) | static void mi_random_init_ex(mi_random_ctx_t* ctx, bool use_weak) {
  function _mi_random_init (line 198) | void _mi_random_init(mi_random_ctx_t* ctx) {
  function _mi_random_init_weak (line 202) | void _mi_random_init_weak(mi_random_ctx_t * ctx) {
  function _mi_random_reinit_if_weak (line 206) | void _mi_random_reinit_if_weak(mi_random_ctx_t * ctx) {

FILE: src/segment-map.c
  type mi_segmap_part_t (line 42) | typedef struct mi_segmap_part_s {
  function mi_segmap_part_t (line 50) | static mi_segmap_part_t* mi_segment_map_index_of(const mi_segment_t* seg...
  function _mi_segment_map_allocated_at (line 82) | void _mi_segment_map_allocated_at(const mi_segment_t* segment) {
  function _mi_segment_map_freed_at (line 95) | void _mi_segment_map_freed_at(const mi_segment_t* segment) {
  function mi_segment_t (line 109) | static mi_segment_t* _mi_segment_of(const void* p) {
  function mi_is_valid_pointer (line 126) | static bool mi_is_valid_pointer(const void* p) {
  function mi_is_in_heap_region (line 131) | bool mi_is_in_heap_region(const void* p) mi_attr_noexcept {
  function _mi_segment_map_unsafe_destroy (line 135) | void _mi_segment_map_unsafe_destroy(void) {

FILE: src/segment.c
  function mi_commit_mask_all_set (line 27) | static bool mi_commit_mask_all_set(const mi_commit_mask_t* commit, const...
  function mi_commit_mask_any_set (line 34) | static bool mi_commit_mask_any_set(const mi_commit_mask_t* commit, const...
  function mi_commit_mask_create_intersect (line 41) | static void mi_commit_mask_create_intersect(const mi_commit_mask_t* comm...
  function mi_commit_mask_clear (line 47) | static void mi_commit_mask_clear(mi_commit_mask_t* res, const mi_commit_...
  function mi_commit_mask_set (line 53) | static void mi_commit_mask_set(mi_commit_mask_t* res, const mi_commit_ma...
  function mi_commit_mask_create (line 59) | static void mi_commit_mask_create(size_t bitidx, size_t bitcount, mi_com...
  function _mi_commit_mask_committed_size (line 86) | size_t _mi_commit_mask_committed_size(const mi_commit_mask_t* cm, size_t...
  function _mi_commit_mask_next_run (line 105) | size_t _mi_commit_mask_next_run(const mi_commit_mask_t* cm, size_t* idx) {
  function mi_slice_t (line 178) | static const mi_slice_t* mi_segment_slices_end(const mi_segment_t* segme...
  function mi_slice_bin8 (line 194) | static inline size_t mi_slice_bin8(size_t slice_count) {
  function mi_slice_bin (line 204) | static inline size_t mi_slice_bin(size_t slice_count) {
  function mi_slice_index (line 212) | static inline size_t mi_slice_index(const mi_slice_t* slice) {
  function mi_span_queue_push (line 224) | static void mi_span_queue_push(mi_span_queue_t* sq, mi_slice_t* slice) {
  function mi_span_queue_t (line 235) | static mi_span_queue_t* mi_span_queue_for(size_t slice_count, mi_segment...
  function mi_span_queue_delete (line 242) | static void mi_span_queue_delete(mi_span_queue_t* sq, mi_slice_t* slice) {
  function mi_slice_is_used (line 259) | static bool mi_slice_is_used(const mi_slice_t* slice) {
  function mi_span_queue_contains (line 265) | static bool mi_span_queue_contains(mi_span_queue_t* sq, mi_slice_t* slic...
  function mi_segment_is_valid (line 272) | static bool mi_segment_is_valid(mi_segment_t* segment, mi_segments_tld_t...
  function mi_segment_info_size (line 328) | static size_t mi_segment_info_size(mi_segment_t* segment) {
  function mi_segment_calculate_slices (line 370) | static size_t mi_segment_calculate_slices(size_t required, size_t* info_...
  function mi_segments_track_size (line 398) | static void mi_segments_track_size(long segment_size, mi_segments_tld_t*...
  function mi_segment_os_free (line 407) | static void mi_segment_os_free(mi_segment_t* segment, mi_segments_tld_t*...
  function mi_segment_commit_mask (line 437) | static void mi_segment_commit_mask(mi_segment_t* segment, bool conservat...
  function mi_segment_commit (line 487) | static bool mi_segment_commit(mi_segment_t* segment, uint8_t* p, size_t ...
  function mi_segment_ensure_committed (line 517) | static bool mi_segment_ensure_committed(mi_segment_t* segment, uint8_t* ...
  function mi_segment_purge (line 525) | static bool mi_segment_purge(mi_segment_t* segment, uint8_t* p, size_t s...
  function mi_segment_schedule_purge (line 554) | static void mi_segment_schedule_purge(mi_segment_t* segment, uint8_t* p,...
  function mi_segment_try_purge (line 594) | static void mi_segment_try_purge(mi_segment_t* segment, bool force) {
  function _mi_segment_collect (line 619) | void _mi_segment_collect(mi_segment_t* segment, bool force) {
  function mi_segment_is_abandoned (line 627) | static bool mi_segment_is_abandoned(mi_segment_t* segment) {
  function mi_segment_span_free (line 632) | static void mi_segment_span_free(mi_segment_t* segment, size_t slice_ind...
  function mi_segment_span_remove_from_queue (line 673) | static void mi_segment_span_remove_from_queue(mi_slice_t* slice, mi_segm...
  function mi_slice_t (line 681) | static mi_slice_t* mi_segment_span_free_coalesce(mi_slice_t* slice, mi_s...
  function mi_page_t (line 732) | static mi_page_t* mi_segment_span_allocate(mi_segment_t* segment, size_t...
  function mi_segment_slice_split (line 782) | static void mi_segment_slice_split(mi_segment_t* segment, mi_slice_t* sl...
  function mi_page_t (line 794) | static mi_page_t* mi_segments_page_find_and_allocate(size_t slice_count,...
  function mi_segment_t (line 833) | static mi_segment_t* mi_segment_os_alloc( size_t required, size_t page_a...
  function mi_segment_t (line 896) | static mi_segment_t* mi_segment_alloc(size_t required, size_t page_align...
  function mi_segment_free (line 975) | static void mi_segment_free(mi_segment_t* segment, bool force, mi_segmen...
  function mi_slice_t (line 1019) | static mi_slice_t* mi_segment_page_clear(mi_page_t* page, mi_segments_tl...
  function _mi_segment_page_free (line 1055) | void _mi_segment_page_free(mi_page_t* page, bool force, mi_segments_tld_...
  function mi_segment_abandon (line 1102) | static void mi_segment_abandon(mi_segment_t* segment, mi_segments_tld_t*...
  function _mi_segment_page_abandon (line 1139) | void _mi_segment_page_abandon(mi_page_t* page, mi_segments_tld_t* tld) {
  function mi_slice_t (line 1160) | static mi_slice_t* mi_slices_start_iterate(mi_segment_t* segment, const ...
  function mi_segment_check_free (line 1169) | static bool mi_segment_check_free(mi_segment_t* segment, size_t slices_n...
  function mi_segment_t (line 1213) | static mi_segment_t* mi_segment_reclaim(mi_segment_t* segment, mi_heap_t...
  function _mi_segment_attempt_reclaim (line 1285) | bool _mi_segment_attempt_reclaim(mi_heap_t* heap, mi_segment_t* segment) {
  function _mi_abandoned_reclaim_all (line 1306) | void _mi_abandoned_reclaim_all(mi_heap_t* heap, mi_segments_tld_t* tld) {
  function segment_count_is_within_target (line 1317) | static bool segment_count_is_within_target(mi_segments_tld_t* tld, size_...
  function mi_segment_get_reclaim_tries (line 1323) | static long mi_segment_get_reclaim_tries(mi_segments_tld_t* tld) {
  function mi_segment_t (line 1335) | static mi_segment_t* mi_segment_try_reclaim(mi_heap_t* heap, size_t need...
  function _mi_abandoned_collect (line 1385) | void _mi_abandoned_collect(mi_heap_t* heap, bool force, mi_segments_tld_...
  function mi_segment_force_abandon (line 1413) | static void mi_segment_force_abandon(mi_segment_t* segment, mi_segments_...
  function mi_segments_try_abandon_to_target (line 1467) | static void mi_segments_try_abandon_to_target(mi_heap_t* heap, size_t ta...
  function mi_segments_try_abandon (line 1487) | static void mi_segments_try_abandon(mi_heap_t* heap, mi_segments_tld_t* ...
  function mi_collect_reduce (line 1494) | void mi_collect_reduce(size_t target_size) mi_attr_noexcept {
  function mi_segment_t (line 1509) | static mi_segment_t* mi_segment_reclaim_or_alloc(mi_heap_t* heap, size_t...
  function mi_page_t (line 1537) | static mi_page_t* mi_segments_page_alloc(mi_heap_t* heap, mi_page_kind_t...
  function mi_page_t (line 1569) | static mi_page_t* mi_segment_huge_page_alloc(size_t size, size_t page_al...
  function _mi_segment_huge_page_free (line 1602) | void _mi_segment_huge_page_free(mi_segment_t* segment, mi_page_t* page, ...
  function _mi_segment_huge_page_reset (line 1630) | void _mi_segment_huge_page_reset(mi_segment_t* segment, mi_page_t* page,...
  function mi_page_t (line 1650) | mi_page_t* _mi_segment_page_alloc(mi_heap_t* heap, size_t block_size, si...
  function else (line 1658) | else if (block_size <= MI_SMALL_OBJ_SIZE_MAX) {
  function else (line 1661) | else if (block_size <= MI_MEDIUM_OBJ_SIZE_MAX) {
  function else (line 1664) | else if (block_size <= MI_LARGE_OBJ_SIZE_MAX) {
  function mi_segment_visit_page (line 1681) | static bool mi_segment_visit_page(mi_page_t* page, bool visit_blocks, mi...
  function _mi_segment_visit_blocks (line 1693) | bool _mi_segment_visit_blocks(mi_segment_t* segment, int heap_tag, bool ...

FILE: src/stats.c
  function mi_is_in_main (line 22) | static bool mi_is_in_main(void* stat) {
  function mi_stat_update (line 27) | static void mi_stat_update(mi_stat_count_t* stat, int64_t amount) {
  function _mi_stat_counter_increase (line 47) | void _mi_stat_counter_increase(mi_stat_counter_t* stat, size_t amount) {
  function _mi_stat_increase (line 56) | void _mi_stat_increase(mi_stat_count_t* stat, size_t amount) {
  function _mi_stat_decrease (line 60) | void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount) {
  function mi_stat_adjust (line 65) | static void mi_stat_adjust(mi_stat_count_t* stat, int64_t amount) {
  function _mi_stat_adjust_decrease (line 80) | void _mi_stat_adjust_decrease(mi_stat_count_t* stat, size_t amount) {
  function mi_stat_count_add_mt (line 86) | static void mi_stat_count_add_mt(mi_stat_count_t* stat, const mi_stat_co...
  function mi_stat_counter_add_mt (line 100) | static void mi_stat_counter_add_mt(mi_stat_counter_t* stat, const mi_sta...
  function mi_stats_add (line 109) | static void mi_stats_add(mi_stats_t* stats, const mi_stats_t* src) {
  function mi_printf_amount (line 135) | static void mi_printf_amount(int64_t n, int64_t unit, mi_output_fun* out...
  function mi_print_amount (line 164) | static void mi_print_amount(int64_t n, int64_t unit, mi_output_fun* out,...
  function mi_print_count (line 168) | static void mi_print_count(int64_t n, int64_t unit, mi_output_fun* out, ...
  function mi_stat_print_ex (line 173) | static void mi_stat_print_ex(const mi_stat_count_t* stat, const char* ms...
  function mi_stat_print (line 215) | static void mi_stat_print(const mi_stat_count_t* stat, const char* msg, ...
  function mi_stat_total_print (line 220) | static void mi_stat_total_print(const mi_stat_count_t* stat, const char*...
  function mi_stat_counter_print (line 228) | static void mi_stat_counter_print(const mi_stat_counter_t* stat, const c...
  function mi_stat_average_print (line 235) | static void mi_stat_average_print(size_t count, size_t total, const char...
  function mi_print_header (line 243) | static void mi_print_header(mi_output_fun* out, void* arg ) {
  function mi_stats_print_bins (line 248) | static void mi_stats_print_bins(const mi_stat_count_t* bins, size_t max,...
  type buffered_t (line 272) | typedef struct buffered_s {
  function mi_buffered_flush (line 280) | static void mi_buffered_flush(buffered_t* buf) {
  function mi_buffered_out (line 286) | static void mi_cdecl mi_buffered_out(const char* msg, void* arg) {
  function _mi_stats_print (line 302) | static void _mi_stats_print(mi_stats_t* stats, mi_output_fun* out0, void...
  function mi_stats_t (line 375) | static mi_stats_t* mi_stats_get_default(void) {
  function mi_stats_merge_from (line 380) | static void mi_stats_merge_from(mi_stats_t* stats) {
  function mi_stats_reset (line 387) | void mi_stats_reset(void) mi_attr_noexcept {
  function mi_stats_merge (line 394) | void mi_stats_merge(void) mi_attr_noexcept {
  function _mi_stats_merge_thread (line 398) | void _mi_stats_merge_thread(mi_tld_t* tld) {
  function _mi_stats_done (line 402) | void _mi_stats_done(mi_stats_t* stats) {  // called from `mi_thread_done`
  function mi_stats_print_out (line 406) | void mi_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept {
  function mi_stats_print (line 411) | void mi_stats_print(void* out) mi_attr_noexcept {
  function mi_thread_stats_print_out (line 416) | void mi_thread_stats_print_out(mi_output_fun* out, void* arg) mi_attr_no...
  function mi_msecs_t (line 427) | mi_msecs_t _mi_clock_now(void) {
  function mi_msecs_t (line 431) | mi_msecs_t _mi_clock_start(void) {
  function mi_msecs_t (line 439) | mi_msecs_t _mi_clock_end(mi_msecs_t start) {
  function mi_decl_export (line 449) | mi_decl_export void mi_process_info(size_t* elapsed_msecs, size_t* user_...
  function mi_stats_get (line 479) | bool mi_stats_get(mi_stats_t* stats) mi_attr_noexcept {
  type mi_heap_buf_t (line 491) | typedef struct mi_heap_buf_s {
  function mi_heap_buf_expand (line 498) | static bool mi_heap_buf_expand(mi_heap_buf_t* hbuf) {
  function mi_heap_buf_print (line 512) | static void mi_heap_buf_print(mi_heap_buf_t* hbuf, const char* msg) {
  function mi_heap_buf_print_count_bin (line 527) | static void mi_heap_buf_print_count_bin(mi_heap_buf_t* hbuf, const char*...
  function mi_heap_buf_print_count (line 543) | static void mi_heap_buf_print_count(mi_heap_buf_t* hbuf, const char* pre...
  function mi_heap_buf_print_count_value (line 550) | static void mi_heap_buf_print_count_value(mi_heap_buf_t* hbuf, const cha...
  function mi_heap_buf_print_value (line 558) | static void mi_heap_buf_print_value(mi_heap_buf_t* hbuf, const char* nam...
  function mi_heap_buf_print_size (line 565) | static void mi_heap_buf_print_size(mi_heap_buf_t* hbuf, const char* name...
  function mi_heap_buf_print_counter_value (line 572) | static void mi_heap_buf_print_counter_value(mi_heap_buf_t* hbuf, const c...

FILE: test/main-override-dep.cpp
  class Static (line 20) | class Static {
    method Static (line 24) | Static() {
  function BOOL (line 41) | BOOL WINAPI DllMain(HINSTANCE module, DWORD reason, LPVOID reserved) {

FILE: test/main-override-dep.h
  function class (line 7) | class TestAllocInDll

FILE: test/main-override-static.c
  function main (line 32) | int main() {
  function test_align (line 87) | static void test_align() {
  function invalid_free (line 94) | static void invalid_free() {
  function block_overflow1 (line 99) | static void block_overflow1() {
  function block_overflow2 (line 105) | static void block_overflow2() {
  function double_free1 (line 114) | static void double_free1() {
  function double_free2 (line 130) | static void double_free2() {
  function corrupt_free (line 153) | static void corrupt_free() {
  function test_aslr (line 177) | static void test_aslr(void) {
  function test_process_info (line 184) | static void test_process_info(void) {
  function test_reserved (line 201) | static void test_reserved(void) {
  function negative_stat (line 219) | static void negative_stat(void) {
  function alloc_huge (line 227) | static void alloc_huge(void) {
  function test_visit (line 232) | static bool test_visit(const mi_heap_t* heap, const mi_heap_area_t* area...
  function test_heap_walk (line 242) | static void test_heap_walk(void) {
  function test_heap_arena (line 251) | static void test_heap_arena(void) {
  function test_canary_leak (line 265) | static void test_canary_leak(void) {
  function test_manage_os_memory (line 275) | static void test_manage_os_memory(void) {
  function test_manage_os_memory (line 297) | static void test_manage_os_memory(void) {
  function test_large_pages (line 310) | static void test_large_pages(void) {
  function mi_bsr32 (line 357) | static inline uint8_t mi_bsr32(uint32_t x) {
  function mi_bsr32 (line 363) | static inline uint8_t mi_bsr32(uint32_t x) {
  function mi_bsr32 (line 367) | static inline uint8_t mi_bsr32(uint32_t x) {
  function _mi_bsr (line 385) | uint8_t _mi_bsr(uintptr_t x) {
  function _mi_wsize_from_size (line 399) | static inline size_t _mi_wsize_from_size(size_t size) {
  function mi_bin (line 409) | static inline size_t mi_bin(size_t wsize) {
  function _mi_bin4 (line 449) | static inline uint8_t _mi_bin4(size_t size) {
  function _mi_binx4 (line 478) | static size_t _mi_binx4(size_t wsize) {
  function _mi_binx8 (line 495) | static size_t _mi_binx8(size_t bsize) {
  function mi_binx (line 504) | static inline size_t mi_binx(size_t wsize) {
  function mi_bins (line 526) | static void mi_bins(void) {

FILE: test/main-override.c
  function main (line 8) | int main() {

FILE: test/main-override.cpp
  function msleep (line 20) | static void msleep(unsigned long msecs) { Sleep(msecs); }
  function msleep (line 23) | static void msleep(unsigned long msecs) { usleep(msecs * 1000UL); }
  function main (line 58) | int main() {
  function free_p (line 96) | void free_p() {
  class Test (line 101) | class Test {
    method Test (line 105) | Test(int x) { i = x; }
  function various_tests (line 110) | static void various_tests() {
  class Static (line 140) | class Static {
    method Static (line 144) | Static() {
  function test_stl_allocator1 (line 157) | static bool test_stl_allocator1() {
  type some_struct (line 164) | struct some_struct { int i; int j; double z; }
  function test_dep (line 168) | static void test_dep()
  function test_stl_allocator2 (line 177) | static bool test_stl_allocator2() {
  function test_stl_allocator3 (line 185) | static bool test_stl_allocator3() {
  function test_stl_allocator4 (line 192) | static bool test_stl_allocator4() {
  function test_stl_allocator5 (line 199) | static bool test_stl_allocator5() {
  function test_stl_allocator6 (line 206) | static bool test_stl_allocator6() {
  function test_stl_allocators (line 214) | static void test_stl_allocators() {
  function test_mixed0 (line 233) | static void test_mixed0() {
  function asd (line 263) | void asd() {
  function test_mixed1 (line 267) | static void test_mixed1() {
  function test_large_migrate (line 290) | static void test_large_migrate(void) {
  function strdup_test (line 309) | static void strdup_test() {
  function heap_no_delete_worker (line 321) | static void heap_no_delete_worker() {
  function heap_no_delete (line 327) | static void heap_no_delete() {
  function test_std_string (line 334) | static void test_std_string() {
  function t1main (line 343) | static void t1main() {
  function heap_late_free (line 349) | static void heap_late_free() {
  function alloc0 (line 361) | static void alloc0(/* void* arg */)
  function padding_shrink (line 366) | static void padding_shrink(void)
  function heap_thread_free_large_worker (line 375) | static void heap_thread_free_large_worker() {
  function heap_thread_free_large (line 379) | static void heap_thread_free_large() {
  function heap_thread_free_huge_worker (line 387) | static void heap_thread_free_huge_worker() {
  function heap_thread_free_huge (line 391) | static void heap_thread_free_huge() {
  function local_alloc (line 402) | static void local_alloc() {
  function test_thread_leak (line 416) | static void test_thread_leak(void) {
  function test_mt_shutdown (line 427) | static void test_mt_shutdown()
  function large_alloc (line 454) | void large_alloc(void)
  function fail_aslr (line 464) | static void fail_aslr() {
  function dummy_worker (line 472) | static void dummy_worker() {
  function tsan_numa_test (line 477) | static void tsan_numa_test() {
  function bench_alloc_large (line 488) | static void bench_alloc_large(void) {
  class MTest (line 514) | class MTest
    method MTest (line 518) | MTest() { data = (char*)malloc(1024); }
  function threadFun (line 524) | void threadFun( int i )
  function test_thread_local (line 530) | void test_thread_local()
  function test_perf_local_alloc (line 548) | static void test_perf_local_alloc()
  function test_perf_run (line 566) | static void test_perf_run()
  function test_perf (line 580) | void test_perf(void)
  function escape (line 588) | static void escape(uint8_t* p, size_t n) {
  function test_perf2 (line 594) | void test_perf2(void) {
  function test_perf3 (line 603) | void test_perf3(void) {
  function local_alloc4 (line 613) | static void local_alloc4() {
  function test_perf4 (line 624) | static void test_perf4(void) {
  function escape5 (line 635) | void escape5(uint8_t* p, size_t n) {
  function local_alloc5 (line 646) | static void local_alloc5() {
  function test_perf5 (line 660) | static void test_perf5(void) {

FILE: test/main.c
  function test_heap (line 5) | void test_heap(void* p_out) {
  function test_large (line 14) | void test_large() {
  function main (line 25) | int main() {

FILE: test/test-api-fill.c
  function main (line 24) | int main(void) {
  function check_zero_init (line 301) | bool check_zero_init(uint8_t* p, size_t size) {
  function check_debug_fill_uninit (line 312) | bool check_debug_fill_uninit(uint8_t* p, size_t size) {
  function check_debug_fill_freed (line 328) | bool check_debug_fill_freed(uint8_t* p, size_t size) {

FILE: test/test-api.c
  function mem_is_zero (line 54) | bool mem_is_zero(uint8_t* p, size_t size) {
  function main (line 65) | int main(void) {
  function test_heap1 (line 385) | bool test_heap1(void) {
  function test_heap2 (line 394) | bool test_heap2(void) {
  function test_stl_allocator1 (line 405) | bool test_stl_allocator1(void) {
  type some_struct (line 416) | struct some_struct  { int i; int j; double z; }
  function test_stl_allocator2 (line 418) | bool test_stl_allocator2(void) {
  function test_stl_heap_allocator1 (line 429) | bool test_stl_heap_allocator1(void) {
  function test_stl_heap_allocator2 (line 440) | bool test_stl_heap_allocator2(void) {
  function test_stl_heap_allocator3 (line 451) | bool test_stl_heap_allocator3(void) {
  function test_stl_heap_allocator4 (line 469) | bool test_stl_heap_allocator4(void) {

FILE: test/test-stress.c
  function pick (line 89) | static uintptr_t pick(random_t r) {
  function chance (line 110) | static bool chance(size_t perc, random_t r) {
  function free_items (line 133) | static void free_items(void* p) {
  function visit_blocks (line 148) | static bool visit_blocks(const mi_heap_t* heap, const mi_heap_area_t* ar...
  function stress (line 158) | static void stress(intptr_t tid) {
  function test_stress (line 222) | static void test_stress(void) {
  function leak (line 251) | static void leak(intptr_t tid) {
  function test_leak (line 261) | static void test_leak(void) {
  function main (line 279) | int main(int argc, char** argv) {
  function DWORD (line 360) | static DWORD WINAPI thread_entry(LPVOID param) {
  function run_os_threads (line 365) | static void run_os_threads(size_t nthreads, void (*fun)(intptr_t)) {
  function run_os_threads (line 400) | static void run_os_threads(size_t nthreads, void (*fun)(intptr_t)) {

FILE: test/test-wrong.c
  function main (line 55) | int main(int argc, char** argv) {

FILE: test/testhelper.h
  function check_result (line 20) | static bool check_result(bool result, const char* testname, const char* ...
  function print_test_summary (line 41) | static inline int print_test_summary(void)