/**********************************************************************

gc.c -

$Author$

created at: Tue Oct 5 09:44:46 JST 1993

Copyright (C) 1993-2007 Yukihiro Matsumoto

Copyright (C) 2000 Network Applied Communication Laboratory, Inc.

Copyright (C) 2000 Information-technology Promotion Agency, Japan

**********************************************************************/

#define rb_data_object_alloc rb_data_object_alloc

#define rb_data_typed_object_alloc rb_data_typed_object_alloc

#include "ruby/internal/config.h"

#ifdef _WIN32

# include "ruby/ruby.h"

#endif

#include <signal.h>

#define sighandler_t ruby_sighandler_t

#ifndef _WIN32

#include <unistd.h>

#include <sys/mman.h>

#endif

#if defined(__wasm__) && !defined(__EMSCRIPTEN__)

# include "wasm/setjmp.h"

# include "wasm/machine.h"

#else

# include <setjmp.h>

#endif

#include <stdarg.h>

#include <stdio.h>

/* MALLOC_HEADERS_BEGIN */

#ifndef HAVE_MALLOC_USABLE_SIZE

# ifdef _WIN32

# define HAVE_MALLOC_USABLE_SIZE

# define malloc_usable_size(a) _msize(a)

# elif defined HAVE_MALLOC_SIZE

# define HAVE_MALLOC_USABLE_SIZE

# define malloc_usable_size(a) malloc_size(a)

# endif

#endif

#ifdef HAVE_MALLOC_USABLE_SIZE

# ifdef RUBY_ALTERNATIVE_MALLOC_HEADER

/* Alternative malloc header is included in ruby/missing.h */

# elif defined(HAVE_MALLOC_H)

# include <malloc.h>

# elif defined(HAVE_MALLOC_NP_H)

# include <malloc_np.h>

# elif defined(HAVE_MALLOC_MALLOC_H)

# include <malloc/malloc.h>

# endif

#endif

#if !defined(PAGE_SIZE) && defined(HAVE_SYS_USER_H)

/* LIST_HEAD conflicts with sys/queue.h on macOS */

# include <sys/user.h>

#endif

/* MALLOC_HEADERS_END */

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#endif

#ifdef HAVE_SYS_RESOURCE_H

# include <sys/resource.h>

#endif

#if defined _WIN32 || defined __CYGWIN__

# include <windows.h>

#elif defined(HAVE_POSIX_MEMALIGN)

#elif defined(HAVE_MEMALIGN)

# include <malloc.h>

#endif

#include <sys/types.h>

#ifdef __EMSCRIPTEN__

#include <emscripten.h>

#endif

#ifdef HAVE_MACH_TASK_EXCEPTION_PORTS

# include <mach/task.h>

# include <mach/mach_init.h>

# include <mach/mach_port.h>

#endif

#undef LIST_HEAD /* ccan/list conflicts with BSD-origin sys/queue.h. */

#include "constant.h"

#include "debug_counter.h"

#include "eval_intern.h"

#include "gc.h"

#include "id_table.h"

#include "internal.h"

#include "internal/class.h"

#include "internal/complex.h"

#include "internal/cont.h"

#include "internal/error.h"

#include "internal/eval.h"

#include "internal/gc.h"

#include "internal/hash.h"

#include "internal/imemo.h"

#include "internal/io.h"

#include "internal/numeric.h"

#include "internal/object.h"

#include "internal/proc.h"

#include "internal/rational.h"

#include "internal/sanitizers.h"

#include "internal/struct.h"

#include "internal/symbol.h"

#include "internal/thread.h"

#include "internal/variable.h"

#include "internal/warnings.h"

#include "mjit.h"

#include "probes.h"

#include "regint.h"

#include "ruby/debug.h"

#include "ruby/io.h"

#include "ruby/re.h"

#include "ruby/st.h"

#include "ruby/thread.h"

#include "ruby/util.h"

#include "ruby_assert.h"

#include "ruby_atomic.h"

#include "symbol.h"

#include "transient_heap.h"

#include "vm_core.h"

#include "vm_sync.h"

#include "vm_callinfo.h"

#include "ractor_core.h"

#include "builtin.h"

#include "shape.h"

#define rb_setjmp(env) RUBY_SETJMP(env)

#define rb_jmp_buf rb_jmpbuf_t

#undef rb_data_object_wrap

#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)

#define MAP_ANONYMOUS MAP_ANON

#endif

static inline struct rbimpl_size_mul_overflow_tag

size_add_overflow(size_t x, size_t y)

{

size_t z;

bool p;

#if 0

#elif __has_builtin(__builtin_add_overflow)

p = __builtin_add_overflow(x, y, &z);

#elif defined(DSIZE_T)

RB_GNUC_EXTENSION DSIZE_T dx = x;

RB_GNUC_EXTENSION DSIZE_T dy = y;

RB_GNUC_EXTENSION DSIZE_T dz = dx dy;

p = dz > SIZE_MAX;

z = (size_t)dz;

#else

z = x y;

p = z < y;

#endif

return (struct rbimpl_size_mul_overflow_tag) { p, z, };

}

static inline struct rbimpl_size_mul_overflow_tag

size_mul_add_overflow(size_t x, size_t y, size_t z) /* x * y z */

{

struct rbimpl_size_mul_overflow_tag t = rbimpl_size_mul_overflow(x, y);

struct rbimpl_size_mul_overflow_tag u = size_add_overflow(t.right, z);

return (struct rbimpl_size_mul_overflow_tag) { t.left || u.left, u.right };

}

static inline struct rbimpl_size_mul_overflow_tag

size_mul_add_mul_overflow(size_t x, size_t y, size_t z, size_t w) /* x * y z * w */

{

struct rbimpl_size_mul_overflow_tag t = rbimpl_size_mul_overflow(x, y);

struct rbimpl_size_mul_overflow_tag u = rbimpl_size_mul_overflow(z, w);

struct rbimpl_size_mul_overflow_tag v = size_add_overflow(t.right, u.right);

return (struct rbimpl_size_mul_overflow_tag) { t.left || u.left || v.left, v.right };

}

PRINTF_ARGS(NORETURN(static void gc_raise(VALUE, const char*, ...)), 2, 3);

static inline size_t

size_mul_or_raise(size_t x, size_t y, VALUE exc)

{

struct rbimpl_size_mul_overflow_tag t = rbimpl_size_mul_overflow(x, y);

if (LIKELY(!t.left)) {

return t.right;

}

else if (rb_during_gc()) {

rb_memerror(); /* or...? */

}

else {

gc_raise(

exc,

"integer overflow: %"PRIuSIZE

" * %"PRIuSIZE

" > %"PRIuSIZE,

x, y, (size_t)SIZE_MAX);

}

}

size_t

rb_size_mul_or_raise(size_t x, size_t y, VALUE exc)

{

return size_mul_or_raise(x, y, exc);

}

static inline size_t

size_mul_add_or_raise(size_t x, size_t y, size_t z, VALUE exc)

{

struct rbimpl_size_mul_overflow_tag t = size_mul_add_overflow(x, y, z);

if (LIKELY(!t.left)) {

return t.right;

}

else if (rb_during_gc()) {

rb_memerror(); /* or...? */

}

else {

gc_raise(

exc,

"integer overflow: %"PRIuSIZE

" * %"PRIuSIZE

" %"PRIuSIZE

" > %"PRIuSIZE,

x, y, z, (size_t)SIZE_MAX);

}

}

size_t

rb_size_mul_add_or_raise(size_t x, size_t y, size_t z, VALUE exc)

{

return size_mul_add_or_raise(x, y, z, exc);

}

static inline size_t

size_mul_add_mul_or_raise(size_t x, size_t y, size_t z, size_t w, VALUE exc)

{

struct rbimpl_size_mul_overflow_tag t = size_mul_add_mul_overflow(x, y, z, w);

if (LIKELY(!t.left)) {

return t.right;

}

else if (rb_during_gc()) {

rb_memerror(); /* or...? */

}

else {

gc_raise(

exc,

"integer overflow: %"PRIdSIZE

" * %"PRIdSIZE

" %"PRIdSIZE

" * %"PRIdSIZE

" > %"PRIdSIZE,

x, y, z, w, (size_t)SIZE_MAX);

}

}

#if defined(HAVE_RB_GC_GUARDED_PTR_VAL) && HAVE_RB_GC_GUARDED_PTR_VAL

/* trick the compiler into thinking a external signal handler uses this */

volatile VALUE rb_gc_guarded_val;

volatile VALUE *

rb_gc_guarded_ptr_val(volatile VALUE *ptr, VALUE val)

{

rb_gc_guarded_val = val;

return ptr;

}

#endif

#ifndef GC_HEAP_INIT_SLOTS

#define GC_HEAP_INIT_SLOTS 10000

#endif

#ifndef GC_HEAP_FREE_SLOTS

#define GC_HEAP_FREE_SLOTS 4096

#endif

#ifndef GC_HEAP_GROWTH_FACTOR

#define GC_HEAP_GROWTH_FACTOR 1.8

#endif

#ifndef GC_HEAP_GROWTH_MAX_SLOTS

#define GC_HEAP_GROWTH_MAX_SLOTS 0 /* 0 is disable */

#endif

#ifndef GC_HEAP_OLDOBJECT_LIMIT_FACTOR

#define GC_HEAP_OLDOBJECT_LIMIT_FACTOR 2.0

#endif

#ifndef GC_HEAP_FREE_SLOTS_MIN_RATIO

#define GC_HEAP_FREE_SLOTS_MIN_RATIO 0.20

#endif

#ifndef GC_HEAP_FREE_SLOTS_GOAL_RATIO

#define GC_HEAP_FREE_SLOTS_GOAL_RATIO 0.40

#endif

#ifndef GC_HEAP_FREE_SLOTS_MAX_RATIO

#define GC_HEAP_FREE_SLOTS_MAX_RATIO 0.65

#endif

#ifndef GC_MALLOC_LIMIT_MIN

#define GC_MALLOC_LIMIT_MIN (16 * 1024 * 1024 /* 16MB */)

#endif

#ifndef GC_MALLOC_LIMIT_MAX

#define GC_MALLOC_LIMIT_MAX (32 * 1024 * 1024 /* 32MB */)

#endif

#ifndef GC_MALLOC_LIMIT_GROWTH_FACTOR

#define GC_MALLOC_LIMIT_GROWTH_FACTOR 1.4

#endif

#ifndef GC_OLDMALLOC_LIMIT_MIN

#define GC_OLDMALLOC_LIMIT_MIN (16 * 1024 * 1024 /* 16MB */)

#endif

#ifndef GC_OLDMALLOC_LIMIT_GROWTH_FACTOR

#define GC_OLDMALLOC_LIMIT_GROWTH_FACTOR 1.2

#endif

#ifndef GC_OLDMALLOC_LIMIT_MAX

#define GC_OLDMALLOC_LIMIT_MAX (128 * 1024 * 1024 /* 128MB */)

#endif

#ifndef PRINT_MEASURE_LINE

#define PRINT_MEASURE_LINE 0

#endif

#ifndef PRINT_ENTER_EXIT_TICK

#define PRINT_ENTER_EXIT_TICK 0

#endif

#ifndef PRINT_ROOT_TICKS

#define PRINT_ROOT_TICKS 0

#endif

#define USE_TICK_T (PRINT_ENTER_EXIT_TICK || PRINT_MEASURE_LINE || PRINT_ROOT_TICKS)

#define TICK_TYPE 1

typedef struct {

size_t heap_init_slots;

size_t heap_free_slots;

double growth_factor;

size_t growth_max_slots;

double heap_free_slots_min_ratio;

double heap_free_slots_goal_ratio;

double heap_free_slots_max_ratio;

double oldobject_limit_factor;

size_t malloc_limit_min;

size_t malloc_limit_max;

double malloc_limit_growth_factor;

size_t oldmalloc_limit_min;

size_t oldmalloc_limit_max;

double oldmalloc_limit_growth_factor;

VALUE gc_stress;

} ruby_gc_params_t;

static ruby_gc_params_t gc_params = {

GC_HEAP_INIT_SLOTS,

GC_HEAP_FREE_SLOTS,

GC_HEAP_GROWTH_FACTOR,

GC_HEAP_GROWTH_MAX_SLOTS,

GC_HEAP_FREE_SLOTS_MIN_RATIO,

GC_HEAP_FREE_SLOTS_GOAL_RATIO,

GC_HEAP_FREE_SLOTS_MAX_RATIO,

GC_HEAP_OLDOBJECT_LIMIT_FACTOR,

GC_MALLOC_LIMIT_MIN,

GC_MALLOC_LIMIT_MAX,

GC_MALLOC_LIMIT_GROWTH_FACTOR,

GC_OLDMALLOC_LIMIT_MIN,

GC_OLDMALLOC_LIMIT_MAX,

GC_OLDMALLOC_LIMIT_GROWTH_FACTOR,

FALSE,

};

/* GC_DEBUG:

* enable to embed GC debugging information.

*/

#ifndef GC_DEBUG

#define GC_DEBUG 0

#endif

/* RGENGC_DEBUG:

* 1: basic information

* 2: remember set operation

* 3: mark

* 4:

* 5: sweep

*/

#ifndef RGENGC_DEBUG

#ifdef RUBY_DEVEL

#define RGENGC_DEBUG -1

#else

#define RGENGC_DEBUG 0

#endif

#endif

#if RGENGC_DEBUG < 0 && !defined(_MSC_VER)

# define RGENGC_DEBUG_ENABLED(level) (-(RGENGC_DEBUG) >= (level) && ruby_rgengc_debug >= (level))

#elif defined(HAVE_VA_ARGS_MACRO)

# define RGENGC_DEBUG_ENABLED(level) ((RGENGC_DEBUG) >= (level))

#else

# define RGENGC_DEBUG_ENABLED(level) 0

#endif

int ruby_rgengc_debug;

/* RGENGC_CHECK_MODE

* 0: disable all assertions

* 1: enable assertions (to debug RGenGC)

* 2: enable internal consistency check at each GC (for debugging)

* 3: enable internal consistency check at each GC steps (for debugging)

* 4: enable liveness check

* 5: show all references

*/

#ifndef RGENGC_CHECK_MODE

#define RGENGC_CHECK_MODE 0

#endif

// Note: using RUBY_ASSERT_WHEN() extend a macro in expr (info by nobu).

#define GC_ASSERT(expr) RUBY_ASSERT_MESG_WHEN(RGENGC_CHECK_MODE > 0, expr, #expr)

/* RGENGC_OLD_NEWOBJ_CHECK

* 0: disable all assertions

* >0: make a OLD object when new object creation.

*

* Make one OLD object per RGENGC_OLD_NEWOBJ_CHECK WB protected objects creation.

*/

#ifndef RGENGC_OLD_NEWOBJ_CHECK

#define RGENGC_OLD_NEWOBJ_CHECK 0

#endif

/* RGENGC_PROFILE

* 0: disable RGenGC profiling

* 1: enable profiling for basic information

* 2: enable profiling for each types

*/

#ifndef RGENGC_PROFILE

#define RGENGC_PROFILE 0

#endif

/* RGENGC_ESTIMATE_OLDMALLOC

* Enable/disable to estimate increase size of malloc'ed size by old objects.

* If estimation exceeds threshold, then will invoke full GC.

* 0: disable estimation.

* 1: enable estimation.

*/

#ifndef RGENGC_ESTIMATE_OLDMALLOC

#define RGENGC_ESTIMATE_OLDMALLOC 1

#endif

/* RGENGC_FORCE_MAJOR_GC

* Force major/full GC if this macro is not 0.

*/

#ifndef RGENGC_FORCE_MAJOR_GC

#define RGENGC_FORCE_MAJOR_GC 0

#endif

#ifndef GC_PROFILE_MORE_DETAIL

#define GC_PROFILE_MORE_DETAIL 0

#endif

#ifndef GC_PROFILE_DETAIL_MEMORY

#define GC_PROFILE_DETAIL_MEMORY 0

#endif

#ifndef GC_ENABLE_INCREMENTAL_MARK

#define GC_ENABLE_INCREMENTAL_MARK USE_RINCGC

#endif

#ifndef GC_ENABLE_LAZY_SWEEP

#define GC_ENABLE_LAZY_SWEEP 1

#endif

#ifndef CALC_EXACT_MALLOC_SIZE

#define CALC_EXACT_MALLOC_SIZE USE_GC_MALLOC_OBJ_INFO_DETAILS

#endif

#if defined(HAVE_MALLOC_USABLE_SIZE) || CALC_EXACT_MALLOC_SIZE > 0

#ifndef MALLOC_ALLOCATED_SIZE

#define MALLOC_ALLOCATED_SIZE 0

#endif

#else

#define MALLOC_ALLOCATED_SIZE 0

#endif

#ifndef MALLOC_ALLOCATED_SIZE_CHECK

#define MALLOC_ALLOCATED_SIZE_CHECK 0

#endif

#ifndef GC_DEBUG_STRESS_TO_CLASS

#define GC_DEBUG_STRESS_TO_CLASS 0

#endif

#ifndef RGENGC_OBJ_INFO

#define RGENGC_OBJ_INFO (RGENGC_DEBUG | RGENGC_CHECK_MODE)

#endif

typedef enum {

GPR_FLAG_NONE = 0x000,

/* major reason */

GPR_FLAG_MAJOR_BY_NOFREE = 0x001,

GPR_FLAG_MAJOR_BY_OLDGEN = 0x002,

GPR_FLAG_MAJOR_BY_SHADY = 0x004,

GPR_FLAG_MAJOR_BY_FORCE = 0x008,

#if RGENGC_ESTIMATE_OLDMALLOC

GPR_FLAG_MAJOR_BY_OLDMALLOC = 0x020,

#endif

GPR_FLAG_MAJOR_MASK = 0x0ff,

/* gc reason */

GPR_FLAG_NEWOBJ = 0x100,

GPR_FLAG_MALLOC = 0x200,

GPR_FLAG_METHOD = 0x400,

GPR_FLAG_CAPI = 0x800,

GPR_FLAG_STRESS = 0x1000,

/* others */

GPR_FLAG_IMMEDIATE_SWEEP = 0x2000,

GPR_FLAG_HAVE_FINALIZE = 0x4000,

GPR_FLAG_IMMEDIATE_MARK = 0x8000,

GPR_FLAG_FULL_MARK = 0x10000,

GPR_FLAG_COMPACT = 0x20000,

GPR_DEFAULT_REASON =

(GPR_FLAG_FULL_MARK | GPR_FLAG_IMMEDIATE_MARK |

GPR_FLAG_IMMEDIATE_SWEEP | GPR_FLAG_CAPI),

} gc_profile_record_flag;

typedef struct gc_profile_record {

} gc_profile_record;

struct RMoved {

};

#define RMOVED(obj) ((struct RMoved *)(obj))

typedef struct RVALUE {

} RVALUE;

#if RACTOR_CHECK_MODE

# define RVALUE_OVERHEAD (sizeof(RVALUE) - offsetof(RVALUE, _ractor_belonging_id))

#elif GC_DEBUG

# define RVALUE_OVERHEAD (sizeof(RVALUE) - offsetof(RVALUE, file))

#else

# define RVALUE_OVERHEAD 0

#endif

STATIC_ASSERT(sizeof_rvalue, sizeof(RVALUE) == (SIZEOF_VALUE * 5) RVALUE_OVERHEAD);

STATIC_ASSERT(alignof_rvalue, RUBY_ALIGNOF(RVALUE) == SIZEOF_VALUE);

typedef uintptr_t bits_t;

enum {

BITS_SIZE = sizeof(bits_t),

BITS_BITLENGTH = ( BITS_SIZE * CHAR_BIT )

};

#define popcount_bits rb_popcount_intptr

struct heap_page_header {

struct heap_page *page;

};

struct heap_page_body {

};

struct gc_list {

VALUE *varptr;

struct gc_list *next;

};

#define STACK_CHUNK_SIZE 500

typedef struct stack_chunk {

VALUE data[STACK_CHUNK_SIZE];

struct stack_chunk *next;

} stack_chunk_t;

typedef struct mark_stack {

} mark_stack_t;

#define SIZE_POOL_EDEN_HEAP(size_pool) (&(size_pool)->eden_heap)

#define SIZE_POOL_TOMB_HEAP(size_pool) (&(size_pool)->tomb_heap)

typedef struct rb_heap_struct {

} rb_heap_t;

typedef struct rb_size_pool_struct {

} rb_size_pool_t;

enum gc_mode {

};

typedef struct rb_objspace {

} rb_objspace_t;

#ifndef HEAP_PAGE_ALIGN_LOG

/* default tiny heap size: 64KiB */

#define HEAP_PAGE_ALIGN_LOG 16

#endif

#define BASE_SLOT_SIZE sizeof(RVALUE)

#define CEILDIV(i, mod) roomof(i, mod)

enum {

HEAP_PAGE_ALIGN = (1UL << HEAP_PAGE_ALIGN_LOG),

HEAP_PAGE_ALIGN_MASK = (~(~0UL << HEAP_PAGE_ALIGN_LOG)),

HEAP_PAGE_SIZE = HEAP_PAGE_ALIGN,

HEAP_PAGE_OBJ_LIMIT = (unsigned int)((HEAP_PAGE_SIZE - sizeof(struct heap_page_header)) / BASE_SLOT_SIZE),

HEAP_PAGE_BITMAP_LIMIT = CEILDIV(CEILDIV(HEAP_PAGE_SIZE, BASE_SLOT_SIZE), BITS_BITLENGTH),

HEAP_PAGE_BITMAP_SIZE = (BITS_SIZE * HEAP_PAGE_BITMAP_LIMIT),

};

#define HEAP_PAGE_ALIGN (1 << HEAP_PAGE_ALIGN_LOG)

#define HEAP_PAGE_SIZE HEAP_PAGE_ALIGN

#if GC_ENABLE_INCREMENTAL_MARK && !defined(INCREMENTAL_MARK_STEP_ALLOCATIONS)

# define INCREMENTAL_MARK_STEP_ALLOCATIONS 500

#endif

#undef INIT_HEAP_PAGE_ALLOC_USE_MMAP

/* Must define either HEAP_PAGE_ALLOC_USE_MMAP or

* INIT_HEAP_PAGE_ALLOC_USE_MMAP. */

#ifndef HAVE_MMAP

/* We can't use mmap of course, if it is not available. */

static const bool HEAP_PAGE_ALLOC_USE_MMAP = false;

#elif defined(__wasm__)

/* wasmtime does not have proper support for mmap.

* See https://github.com/bytecodealliance/wasmtime/blob/main/docs/WASI-rationale.md#why-no-mmap-and-friends

*/

static const bool HEAP_PAGE_ALLOC_USE_MMAP = false;

#elif HAVE_CONST_PAGE_SIZE

/* If we have the PAGE_SIZE and it is a constant, then we can directly use it. */

static const bool HEAP_PAGE_ALLOC_USE_MMAP = (PAGE_SIZE <= HEAP_PAGE_SIZE);

#elif defined(PAGE_MAX_SIZE) && (PAGE_MAX_SIZE <= HEAP_PAGE_SIZE)

/* If we can use the maximum page size. */

static const bool HEAP_PAGE_ALLOC_USE_MMAP = true;

#elif defined(PAGE_SIZE)

/* If the PAGE_SIZE macro can be used dynamically. */

# define INIT_HEAP_PAGE_ALLOC_USE_MMAP (PAGE_SIZE <= HEAP_PAGE_SIZE)

#elif defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)

/* If we can use sysconf to determine the page size. */

# define INIT_HEAP_PAGE_ALLOC_USE_MMAP (sysconf(_SC_PAGE_SIZE) <= HEAP_PAGE_SIZE)

#else

/* Otherwise we can't determine the system page size, so don't use mmap. */

static const bool HEAP_PAGE_ALLOC_USE_MMAP = false;

#endif

#ifdef INIT_HEAP_PAGE_ALLOC_USE_MMAP

/* We can determine the system page size at runtime. */

# define HEAP_PAGE_ALLOC_USE_MMAP (heap_page_alloc_use_mmap != false)

static bool heap_page_alloc_use_mmap;

#endif

struct heap_page {

};

/*

* When asan is enabled, this will prohibit writing to the freelist until it is unlocked

*/

static void

asan_lock_freelist(struct heap_page *page)

{

asan_poison_memory_region(&page->freelist, sizeof(RVALUE*));

}

/*

* When asan is enabled, this will enable the ability to write to the freelist

*/

static void

asan_unlock_freelist(struct heap_page *page)

{

asan_unpoison_memory_region(&page->freelist, sizeof(RVALUE*), false);

}

#define GET_PAGE_BODY(x) ((struct heap_page_body *)((bits_t)(x) & ~(HEAP_PAGE_ALIGN_MASK)))

#define GET_PAGE_HEADER(x) (&GET_PAGE_BODY(x)->header)

#define GET_HEAP_PAGE(x) (GET_PAGE_HEADER(x)->page)

#define NUM_IN_PAGE(p) (((bits_t)(p) & HEAP_PAGE_ALIGN_MASK) / BASE_SLOT_SIZE)

#define BITMAP_INDEX(p) (NUM_IN_PAGE(p) / BITS_BITLENGTH )

#define BITMAP_OFFSET(p) (NUM_IN_PAGE(p) & (BITS_BITLENGTH-1))

#define BITMAP_BIT(p) ((bits_t)1 << BITMAP_OFFSET(p))