#pragma once

#ifndef MIMALLOC_TYPES_H

#define MIMALLOC_TYPES_H

#include <stddef.h> // ptrdiff_t

#include <stdint.h> // uintptr_t, uint16_t, etc

#include "atomic.h" // _Atomic

#ifdef _MSC_VER

#pragma warning(disable:4214) // bitfield is not int

#ifndef MI_MAX_ALIGN_SIZE

#define MI_MAX_ALIGN_SIZE 16 // sizeof(max_align_t)

#define MI_CACHE_LINE 64

#if defined(_MSC_VER)

#pragma warning(disable:4127) // suppress constant conditional warning (due to MI_SECURE paths)

#pragma warning(disable:26812) // unscoped enum warning

#define mi_decl_noinline __declspec(noinline)

#define mi_decl_thread __declspec(thread)

#define mi_decl_cache_align __declspec(align(MI_CACHE_LINE))

#elif (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__) // includes clang and icc

#define mi_decl_noinline __attribute__((noinline))

#define mi_decl_thread __thread

#define mi_decl_cache_align __attribute__((aligned(MI_CACHE_LINE)))

#define mi_decl_noinline

#define mi_decl_thread __thread // hope for the best :-)

#define mi_decl_cache_align

#if (MI_DEBUG)

#if defined(_MSC_VER)

#define mi_decl_noreturn __declspec(noreturn)

#elif (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__)

#define mi_decl_noreturn __attribute__((__noreturn__))

#define mi_decl_noreturn

#if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)

#define mi_decl_cold __attribute__((cold))

#define mi_decl_cold

#if (defined(__GNUC__) && defined(__THROW))

#define mi_decl_throw __THROW

#define mi_decl_throw

#if !defined(MI_SECURE)

#define MI_SECURE 0

#if !defined(MI_DEBUG)

#if !defined(NDEBUG) || defined(_DEBUG)

#define MI_DEBUG 2

#define MI_DEBUG 0

#if !defined(MI_PADDING) && (MI_SECURE>=3 || MI_DEBUG>=1 || (MI_TRACK_VALGRIND || MI_TRACK_ASAN || MI_TRACK_ETW))

#define MI_PADDING 1

#if !defined(MI_PADDING_CHECK) && MI_PADDING && (MI_SECURE>=3 || MI_DEBUG>=1)

#define MI_PADDING_CHECK 1

#if (MI_SECURE>=3 || MI_DEBUG>=1)

#define MI_ENCODE_FREELIST 1

#if INTPTR_MAX > INT64_MAX

# define MI_INTPTR_SHIFT (4) // assume 128-bit (as on arm CHERI for example)

#elif INTPTR_MAX == INT64_MAX

# define MI_INTPTR_SHIFT (3)

#elif INTPTR_MAX == INT32_MAX

# define MI_INTPTR_SHIFT (2)

#error platform pointers must be 32, 64, or 128 bits

#if SIZE_MAX == UINT64_MAX

# define MI_SIZE_SHIFT (3)

typedef int64_t mi_ssize_t;

#elif SIZE_MAX == UINT32_MAX

# define MI_SIZE_SHIFT (2)

typedef int32_t mi_ssize_t;

#error platform objects must be 32 or 64 bits

#if (SIZE_MAX/2) > LONG_MAX

# define MI_ZU(x) x##ULL

# define MI_ZI(x) x##LL

# define MI_ZU(x) x##UL

# define MI_ZI(x) x##L

#define MI_INTPTR_SIZE (1<<MI_INTPTR_SHIFT)

#define MI_INTPTR_BITS (MI_INTPTR_SIZE*8)

#define MI_SIZE_SIZE (1<<MI_SIZE_SHIFT)

#define MI_SIZE_BITS (MI_SIZE_SIZE*8)

#define MI_KiB (MI_ZU(1024))

#define MI_MiB (MI_KiB*MI_KiB)

#define MI_GiB (MI_MiB*MI_KiB)

#define MI_SEGMENT_SLICE_SHIFT (13 + MI_INTPTR_SHIFT) // 64KiB (32KiB on 32-bit)

#if MI_INTPTR_SIZE > 4

#define MI_SEGMENT_SHIFT ( 9 + MI_SEGMENT_SLICE_SHIFT) // 32MiB

#define MI_SEGMENT_SHIFT ( 7 + MI_SEGMENT_SLICE_SHIFT) // 4MiB on 32-bit

#define MI_SMALL_PAGE_SHIFT (MI_SEGMENT_SLICE_SHIFT) // 64KiB

#define MI_MEDIUM_PAGE_SHIFT ( 3 + MI_SMALL_PAGE_SHIFT) // 512KiB

#define MI_SEGMENT_SIZE (MI_ZU(1)<<MI_SEGMENT_SHIFT)

#define MI_SEGMENT_ALIGN MI_SEGMENT_SIZE

#define MI_SEGMENT_MASK ((uintptr_t)(MI_SEGMENT_ALIGN - 1))

#define MI_SEGMENT_SLICE_SIZE (MI_ZU(1)<< MI_SEGMENT_SLICE_SHIFT)

#define MI_SLICES_PER_SEGMENT (MI_SEGMENT_SIZE / MI_SEGMENT_SLICE_SIZE) // 1024

#define MI_SMALL_PAGE_SIZE (MI_ZU(1)<<MI_SMALL_PAGE_SHIFT)

#define MI_MEDIUM_PAGE_SIZE (MI_ZU(1)<<MI_MEDIUM_PAGE_SHIFT)

#define MI_SMALL_OBJ_SIZE_MAX (MI_SMALL_PAGE_SIZE/4) // 8KiB on 64-bit

#define MI_MEDIUM_OBJ_SIZE_MAX (MI_MEDIUM_PAGE_SIZE/4) // 128KiB on 64-bit

#define MI_MEDIUM_OBJ_WSIZE_MAX (MI_MEDIUM_OBJ_SIZE_MAX/MI_INTPTR_SIZE)

#define MI_LARGE_OBJ_SIZE_MAX (MI_SEGMENT_SIZE/2) // 32MiB on 64-bit

#define MI_LARGE_OBJ_WSIZE_MAX (MI_LARGE_OBJ_SIZE_MAX/MI_INTPTR_SIZE)

#define MI_BIN_HUGE (73U)

#if (MI_MEDIUM_OBJ_WSIZE_MAX >= 655360)

#error "mimalloc internal: define more bins"

#define MI_MAX_SLICE_OFFSET ((MI_ALIGNMENT_MAX / MI_SEGMENT_SLICE_SIZE) - 1)

#define MI_HUGE_BLOCK_SIZE ((uint32_t)(2*MI_GiB))

#define MI_MAX_ALIGN_GUARANTEE (8*MI_MAX_ALIGN_SIZE)

#define MI_ALIGNMENT_MAX (MI_SEGMENT_SIZE >> 1)

typedef uintptr_t mi_encoded_t;

typedef size_t mi_threadid_t;

typedef struct mi_block_s {

_Atomic(mi_encoded_t) next;

} mi_block_t;

typedef enum mi_delayed_e {

} mi_delayed_t;

#if !MI_TSAN

typedef union mi_page_flags_s {

uint8_t full_aligned;

struct {

uint8_t in_full : 1;

uint8_t has_aligned : 1;

} x;

} mi_page_flags_t;

typedef union mi_page_flags_s {

uint16_t full_aligned;

struct {

uint8_t in_full;

uint8_t has_aligned;

} x;

} mi_page_flags_t;

typedef uintptr_t mi_thread_free_t;

typedef struct mi_page_s {

} mi_page_t;

typedef enum mi_page_kind_e {

} mi_page_kind_t;

typedef enum mi_segment_kind_e {

MI_SEGMENT_NORMAL, // MI_SEGMENT_SIZE size with pages inside.

MI_SEGMENT_HUGE, // > MI_LARGE_SIZE_MAX segment with just one huge page inside.

} mi_segment_kind_t;

#define MI_MINIMAL_COMMIT_SIZE (1*MI_SEGMENT_SLICE_SIZE)

#define MI_COMMIT_SIZE (MI_SEGMENT_SLICE_SIZE) // 64KiB

#define MI_COMMIT_MASK_BITS (MI_SEGMENT_SIZE / MI_COMMIT_SIZE)

#define MI_COMMIT_MASK_FIELD_BITS MI_SIZE_BITS

#define MI_COMMIT_MASK_FIELD_COUNT (MI_COMMIT_MASK_BITS / MI_COMMIT_MASK_FIELD_BITS)

#if (MI_COMMIT_MASK_BITS != (MI_COMMIT_MASK_FIELD_COUNT * MI_COMMIT_MASK_FIELD_BITS))

#error "the segment size must be exactly divisible by the (commit size * size_t bits)"

typedef struct mi_commit_mask_s {

size_t mask[MI_COMMIT_MASK_FIELD_COUNT];

} mi_commit_mask_t;

typedef mi_page_t mi_slice_t;

typedef int64_t mi_msecs_t;

typedef enum mi_memkind_e {

} mi_memkind_t;

static inline bool mi_memkind_is_os(mi_memkind_t memkind) {

return (memkind >= MI_MEM_OS && memkind <= MI_MEM_OS_REMAP);

}

typedef struct mi_memid_os_info {

void* base; // actual base address of the block (used for offset aligned allocations)

size_t alignment; // alignment at allocation

} mi_memid_os_info_t;

typedef struct mi_memid_arena_info {

} mi_memid_arena_info_t;

typedef struct mi_memid_s {

} mi_memid_t;

typedef struct mi_segment_s {

} mi_segment_t;

typedef uintptr_t mi_tagged_segment_t;

typedef struct mi_abandoned_pool_s {

} mi_abandoned_pool_t;

typedef struct mi_tld_s mi_tld_t;

typedef struct mi_page_queue_s {

} mi_page_queue_t;

#define MI_BIN_FULL (MI_BIN_HUGE+1)

typedef struct mi_random_cxt_s {

} mi_random_ctx_t;

#if (MI_PADDING)

typedef struct mi_padding_s {

uint32_t canary; // encoded block value to check validity of the padding (in case of overflow)

uint32_t delta; // padding bytes before the block. (mi_usable_size(p) - delta == exact allocated bytes)

} mi_padding_t;

#define MI_PADDING_SIZE (sizeof(mi_padding_t))

#define MI_PADDING_WSIZE ((MI_PADDING_SIZE + MI_INTPTR_SIZE - 1) / MI_INTPTR_SIZE)

#define MI_PADDING_SIZE 0

#define MI_PADDING_WSIZE 0

#define MI_PAGES_DIRECT (MI_SMALL_WSIZE_MAX + MI_PADDING_WSIZE + 1)

struct mi_heap_s {

};

#if !defined(MI_DEBUG_UNINIT)

#define MI_DEBUG_UNINIT (0xD0)

#if !defined(MI_DEBUG_FREED)

#define MI_DEBUG_FREED (0xDF)

#if !defined(MI_DEBUG_PADDING)

#define MI_DEBUG_PADDING (0xDE)

#if (MI_DEBUG)

mi_decl_noreturn mi_decl_cold

void _mi_assert_fail(const char* assertion, const char* fname, unsigned int line, const char* func) mi_decl_throw;

#define mi_assert(expr) ((expr) ? (void)0 : _mi_assert_fail(#expr,__FILE__,__LINE__,__func__))

#define mi_assert(x)

#if (MI_DEBUG>1)

#define mi_assert_internal mi_assert

#define mi_assert_internal(x)

#if (MI_DEBUG>2)

#define mi_assert_expensive mi_assert

#define mi_assert_expensive(x)

#ifndef MI_STAT

#if (MI_DEBUG>0)

#define MI_STAT 2

#define MI_STAT 0

typedef struct mi_stat_count_s {

} mi_stat_count_t;

typedef struct mi_stat_counter_s {

int64_t total;

int64_t count;

} mi_stat_counter_t;

typedef struct mi_stats_s {

} mi_stats_t;

void _mi_stat_increase(mi_stat_count_t* stat, size_t amount);

void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount);

void _mi_stat_counter_increase(mi_stat_counter_t* stat, size_t amount);

#if (MI_STAT)

#define mi_stat_increase(stat,amount) _mi_stat_increase( &(stat), amount)

#define mi_stat_decrease(stat,amount) _mi_stat_decrease( &(stat), amount)

#define mi_stat_counter_increase(stat,amount) _mi_stat_counter_increase( &(stat), amount)

#define mi_stat_increase(stat,amount) (void)0

#define mi_stat_decrease(stat,amount) (void)0

#define mi_stat_counter_increase(stat,amount) (void)0

#define mi_heap_stat_counter_increase(heap,stat,amount) mi_stat_counter_increase( (heap)->tld->stats.stat, amount)

#define mi_heap_stat_increase(heap,stat,amount) mi_stat_increase( (heap)->tld->stats.stat, amount)

#define mi_heap_stat_decrease(heap,stat,amount) mi_stat_decrease( (heap)->tld->stats.stat, amount)

typedef struct mi_span_queue_s {

} mi_span_queue_t;

#define MI_SEGMENT_BIN_MAX (35) // 35 == mi_segment_bin(MI_SLICES_PER_SEGMENT)

typedef struct mi_os_tld_s {

size_t region_idx; // start point for next allocation

mi_stats_t* stats; // points to tld stats

} mi_os_tld_t;

typedef struct mi_segments_tld_s {

} mi_segments_tld_t;

struct mi_tld_s {

};