/* SPEC: PJ2026-0501 V2 kernel v0.47; typed value and object storage. */

#include "runtime_internal.h"

#include <limits.h>

#include <stdlib.h>

#include <string.h>

#if PIKA_TYPED_RUNTIME_ENABLE

#define PIKA_RUNTIME_FIELD_ASSIGNED 1u

static PikaRuntimeValue runtime_integer_value(int64_t integer) {

PikaRuntimeValue value;

memset(&value, 0, sizeof(value));

value.kind = PIKA_RUNTIME_VALUE_INTEGER;

value.as.integer = integer;

return value;

}

static void release_pointer(PikaObjectStorage* storage, void* pointer) {

if (pointer == NULL) {

return;

}

if (storage->release != NULL) {

storage->release(storage->context, pointer);

}

}

static uint16_t object_slot_limit(

const PikaObjectStorage* storage) {

return storage->slot_limit != 0u

? storage->slot_limit

: storage->capacity;

}

static uint32_t object_arena_limit(

const PikaObjectStorage* storage) {

return storage->arena_limit != 0u

? storage->arena_limit

: storage->arena_capacity;

}

static int object_arena_offset(

const PikaObjectStorage* storage,

const void* pointer,

size_t size,

uint32_t* offset) {

uintptr_t arena_address;

uintptr_t pointer_address;

uintptr_t distance;

if (storage == NULL || storage->arena == NULL ||

pointer == NULL || offset == NULL) {

return 0;

}

arena_address = (uintptr_t)storage->arena;

pointer_address = (uintptr_t)pointer;

if (pointer_address < arena_address) return 0;

distance = pointer_address - arena_address;

if (distance > storage->arena_used ||

size > (size_t)(storage->arena_used - (uint32_t)distance)) {

return 0;

}

*offset = (uint32_t)distance;

return 1;

}

static PikaStatus reserve_object_storage(

PikaObjectStorage* storage,

uint16_t slot_capacity,

uint32_t arena_capacity) {

PikaStatus status;

if (storage == NULL ||

slot_capacity > object_slot_limit(storage) ||

arena_capacity > object_arena_limit(storage)) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

if ((slot_capacity == 0u ||

(storage->slots != NULL &&

storage->capacity >= slot_capacity)) &&

(arena_capacity == 0u ||

(storage->arena != NULL &&

storage->arena_capacity >= arena_capacity))) {

return PIKA_STATUS_OK;

}

if (storage->reserve == NULL) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

status = storage->reserve(

storage->context, slot_capacity, arena_capacity);

if (status != PIKA_STATUS_OK) return status;

if ((slot_capacity > 0u &&

(storage->slots == NULL ||

storage->capacity < slot_capacity)) ||

(arena_capacity > 0u &&

(storage->arena == NULL ||

storage->arena_capacity < arena_capacity))) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

return PIKA_STATUS_OK;

}

void pika_object_storage_reset(PikaObjectStorage* storage) {

uint16_t index;

if (storage == NULL) return;

if (storage->slots != NULL) {

for (index = 0u; index < storage->count; ++index) {

PikaObjectSlot* slot = &storage->slots[index];

if (slot->active != 0u && slot->owned != 0u) {

release_pointer(storage, slot->data);

}

}

memset(storage->slots, 0,

(size_t)storage->capacity * sizeof(PikaObjectSlot));

}

storage->count = 0u;

storage->arena_used = 0u;

}

void pika_object_storage_release(PikaObjectStorage* storage) {

pika_object_storage_reset(storage);

}

static void* allocate_object_data(PikaObjectStorage* storage,

uint32_t size,

uint8_t* owned) {

uint32_t alignment = (uint32_t)sizeof(void*);

uint32_t aligned;

uint32_t required;

void* pointer = NULL;

if (storage->arena_used > UINT32_MAX - alignment + 1u) {

return NULL;

}

aligned = (storage->arena_used + alignment - 1u) /

alignment * alignment;

if (size <= UINT32_MAX - aligned) {

required = aligned + size;

if ((storage->arena == NULL ||

required > storage->arena_capacity) &&

reserve_object_storage(

storage, storage->capacity, required) ==

PIKA_STATUS_OK) {

aligned = (storage->arena_used + alignment - 1u) /

alignment * alignment;

}

}

if (storage->arena != NULL) {

if (aligned <= storage->arena_capacity &&

size <= storage->arena_capacity - aligned) {

pointer = &storage->arena[aligned];

storage->arena_used = aligned + size;

*owned = 0u;

return pointer;

}

}

if (storage->allocate != NULL && storage->release != NULL) {

pointer = storage->allocate(storage->context, size);

}

if (pointer != NULL) {

*owned = 1u;

}

return pointer;

}

static PikaStatus reserve_object_data(PikaRuntimeContext* context,

PikaObjectSlot** slot_pointer,

uint32_t required,

uint32_t element_size) {

PikaObjectStorage* storage = context->objects;

PikaObjectSlot* slot = *slot_pointer;

uint32_t capacity;

uint32_t size;

uint32_t old_size;

uint8_t owned = 0u;

void* pointer;

if (required <= slot->capacity && slot->data != NULL) {

return PIKA_STATUS_OK;

}

capacity = slot->capacity;

if (capacity == 0u) capacity = 1u;

while (capacity < required) {

if (capacity > UINT32_MAX / 2u) {

capacity = required;

break;

}

capacity *= 2u;

}

if (capacity > UINT32_MAX / element_size) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

size = capacity * element_size;

pointer = allocate_object_data(storage, size, &owned);

#if PIKA_GC_ENABLE

if (pointer == NULL && context->typed_values != NULL &&

context->object_collection_pending != 0u &&

context->gc_retry_block_depth == 0u &&

context->gc_root_active == 0u) {

uint32_t object_index =

(uint32_t)(slot - storage->slots);

memset(&context->gc_root, 0, sizeof(context->gc_root));

context->gc_root.kind =

(PikaRuntimeValueKind)slot->kind;

context->gc_root.as.object_index = object_index;

context->gc_root_active = 1u;

pika_runtime_collect_objects(context);

object_index = context->gc_root.as.object_index;

context->gc_root_active = 0u;

if (object_index < storage->count) {

slot = &storage->slots[object_index];

*slot_pointer = slot;

pointer = allocate_object_data(storage, size, &owned);

}

}

#endif

if (pointer == NULL) return PIKA_STATUS_STORAGE_TOO_SMALL;

memset(pointer, 0, size);

old_size = slot->length;

if (slot->data != NULL && old_size != 0u) {

memcpy(pointer, slot->data, old_size * element_size);

}

if (slot->owned != 0u) release_pointer(storage, slot->data);

slot->data = pointer;

slot->capacity = capacity;

slot->owned = owned;

#if PIKA_GC_ENABLE

pika_runtime_note_object_pressure(context);

#endif

if (slot->kind == PIKA_RUNTIME_VALUE_BYTEARRAY) {

((char*)slot->data)[slot->length] = '\0';

}

return PIKA_STATUS_OK;

}

PikaStatus pika_runtime_create_object(

PikaRuntimeContext* context,

PikaRuntimeValueKind kind,

uint32_t length,

uint32_t element_size,

uint32_t* object_index,

void** data) {

PikaObjectStorage* storage;

PikaObjectSlot* slot;

uint8_t owned = 0u;

uint32_t size;

void* pointer = NULL;

#if PIKA_GC_ENABLE

int collected = 0;

#endif

if (context == NULL || context->objects == NULL ||

object_index == NULL || data == NULL) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

storage = context->objects;

if ((storage->slots == NULL && storage->reserve == NULL) ||

(element_size != 0u &&

length > UINT32_MAX / element_size)) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

#if PIKA_GC_ENABLE

retry:

#endif

if (storage->count >= storage->capacity) {

#if PIKA_GC_ENABLE

if (!collected && context->typed_values != NULL &&

context->object_collection_pending != 0u &&

context->gc_retry_block_depth == 0u) {

collected = 1;

pika_runtime_collect_objects(context);

goto retry;

}

#endif

if (storage->count == UINT16_MAX ||

reserve_object_storage(

storage,

(uint16_t)(storage->count + 1u),

storage->arena_used) != PIKA_STATUS_OK) {

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

}

size = length * element_size;

if (size != 0u) {

pointer = allocate_object_data(storage, size, &owned);

if (pointer == NULL) {

#if PIKA_GC_ENABLE

if (!collected && context->typed_values != NULL &&

context->object_collection_pending != 0u &&

context->gc_retry_block_depth == 0u) {

collected = 1;

pika_runtime_collect_objects(context);

goto retry;

}

#endif

return PIKA_STATUS_STORAGE_TOO_SMALL;

}

memset(pointer, 0, size);

}

*object_index = storage->count;

slot = &storage->slots[storage->count++];

slot->kind = (uint8_t)kind;

slot->active = 1u;

slot->owned = owned;

slot->length = length;

slot->capacity = length;

slot->data = pointer;

*data = pointer;

if (context->metrics != NULL &&

storage->count > context->metrics->object_peak) {

context->metrics->object_peak = storage->count;

}

#if PIKA_GC_ENABLE

pika_runtime_note_object_pressure(context);

#endif

return PIKA_STATUS_OK;

}

PikaObjectSlot* pika_runtime_object(

PikaRuntimeContext* context,

PikaRuntimeValue value) {

if (context == NULL || context->objects == NULL ||

context->objects->slots == NULL ||

value.as.object_index >= context->objects->count) {

return NULL;

}

if (context->objects->slots[value.as.object_index].active == 0u) {

return NULL;

}

return &context->objects->slots[value.as.object_index];

}

PikaRuntimeValue pika_runtime_read_value(

const PikaRuntimeContext* context,

uint32_t index) {

PikaRuntimeValue value;

memset(&value, 0, sizeof(value));

if (context == NULL) {

return value;

}

if (context->typed_values != NULL) {

return context->typed_values[index];

}

value.kind = PIKA_RUNTIME_VALUE_INTEGER;

value.as.integer = context->values[index];

return value;

}

PikaStatus pika_runtime_write_value(

PikaRuntimeContext* context,

uint32_t index,

PikaRuntimeValue value) {

if (context == NULL) {

return PIKA_STATUS_INVALID_ARGUMENT;

}

if (context->typed_values != NULL) {

context->typed_values[index] = value;

return PIKA_STATUS_OK;

}

if (value.kind == PIKA_RUNTIME_VALUE_INTEGER ||

value.kind == PIKA_RUNTIME_VALUE_BOOLEAN ||

value.kind == PIKA_RUNTIME_VALUE_NONE) {

context->values[index] =

value.kind == PIKA_RUNTIME_VALUE_INTEGER

? value.as.integer

: value.kind == PIKA_RUNTIME_VALUE_BOOLEAN

? (value.as.integer != 0 ? 1 : 0)

: 0;

return PIKA_STATUS_OK;

}

return PIKA_STATUS_TYPE_MISMATCH;

}

int pika_runtime_value_truthy(

const PikaRuntimeContext* context,

PikaRuntimeValue value) {

PikaObjectSlot* slot;

if (value.kind == PIKA_RUNTIME_VALUE_NONE) {

return 0;

}

if (value.kind == PIKA_RUNTIME_VALUE_BOOLEAN ||

value.kind == PIKA_RUNTIME_VALUE_INTEGER) {

return value.as.integer != 0;

}

if (value.kind == PIKA_RUNTIME_VALUE_FLOAT) {

return value.as.floating != 0.0;

}

if (value.kind == PIKA_RUNTIME_VALUE_RANGE) {

uint32_t length = 0u;

return pika_runtime_range_length(

(PikaRuntimeContext*)context, value, &length) ==

PIKA_STATUS_OK &&

length != 0u;

}

if (value.kind == PIKA_RUNTIME_VALUE_INSTANCE ||

value.kind == PIKA_RUNTIME_VALUE_NATIVE_OBJECT) {

return 1;

}

slot = pika_runtime_object((PikaRuntimeContext*)context, value);

return slot != NULL && slot->length != 0u;

}

static int is_value_sequence(PikaRuntimeValueKind kind) {

return kind == PIKA_RUNTIME_VALUE_LIST ||

kind == PIKA_RUNTIME_VALUE_TUPLE ||

kind == PIKA_RUNTIME_VALUE_SET;

}

static int is_byte_sequence(PikaRuntimeValueKind kind) {

return kind == PIKA_RUNTIME_VALUE_BYTES ||

kind == PIKA_RUNTIME_VALUE_BYTEARRAY;

}

#if PIKA_GC_ENABLE

typedef void (*PikaRuntimeValueVisitor)(

PikaRuntimeValue* value,

void* context);

typedef struct {

uint32_t source;

uint32_t destination;

} PikaObjectIndexRemap;

static int is_object_value_kind(PikaRuntimeValueKind kind) {

return is_value_sequence(kind) ||

is_byte_sequence(kind) ||

kind == PIKA_RUNTIME_VALUE_STRING ||

kind == PIKA_RUNTIME_VALUE_DICT ||

kind == PIKA_RUNTIME_VALUE_RANGE ||

kind == PIKA_RUNTIME_VALUE_ITERATOR ||

kind == PIKA_RUNTIME_VALUE_SLICE ||

kind == PIKA_RUNTIME_VALUE_TYPE ||

kind == PIKA_RUNTIME_VALUE_MODULE ||

#if PIKA_CAPABILITY_EXCEPTION_BASIC_ENABLE

kind == PIKA_RUNTIME_VALUE_INSTANCE ||

kind == PIKA_RUNTIME_VALUE_EXCEPTION;

#else

kind == PIKA_RUNTIME_VALUE_INSTANCE;

#endif

}

static int object_slot_payload_size(

const PikaObjectSlot* slot,

uint32_t* size) {

uint32_t element_size;

switch ((PikaRuntimeValueKind)slot->kind) {

case PIKA_RUNTIME_VALUE_STRING:

case PIKA_RUNTIME_VALUE_BYTES:

case PIKA_RUNTIME_VALUE_BYTEARRAY:

case PIKA_RUNTIME_VALUE_TYPE:

case PIKA_RUNTIME_VALUE_MODULE:

element_size = 1u;

break;

case PIKA_RUNTIME_VALUE_LIST:

case PIKA_RUNTIME_VALUE_TUPLE:

case PIKA_RUNTIME_VALUE_SET:

case PIKA_RUNTIME_VALUE_INSTANCE:

element_size = (uint32_t)sizeof(PikaRuntimeValue);

break;

case PIKA_RUNTIME_VALUE_DICT:

element_size = (uint32_t)sizeof(PikaMapEntry);

break;

case PIKA_RUNTIME_VALUE_RANGE:

element_size = (uint32_t)sizeof(PikaRangeData);

break;

case PIKA_RUNTIME_VALUE_ITERATOR:

element_size = (uint32_t)sizeof(PikaIteratorData);

break;

case PIKA_RUNTIME_VALUE_SLICE:

element_size = (uint32_t)sizeof(PikaSliceData);

break;

default:

return 0;

}

if (slot->capacity > UINT32_MAX / element_size) {

return 0;

}

*size = slot->capacity * element_size;

return 1;

}

static void visit_object_values(

PikaObjectSlot* slot,

PikaRuntimeValueVisitor visitor,

void* visitor_context) {

uint32_t index;

if (slot->data == NULL || slot->length > slot->capacity) {

return;

}

if (slot->kind == PIKA_RUNTIME_VALUE_LIST ||

slot->kind == PIKA_RUNTIME_VALUE_TUPLE ||

slot->kind == PIKA_RUNTIME_VALUE_SET ||

slot->kind == PIKA_RUNTIME_VALUE_INSTANCE) {

PikaRuntimeValue* values =

(PikaRuntimeValue*)slot->data;

for (index = 0u; index < slot->length; ++index) {

visitor(&values[index], visitor_context);

}

return;

}

if (slot->kind == PIKA_RUNTIME_VALUE_DICT) {

PikaMapEntry* entries = (PikaMapEntry*)slot->data;

for (index = 0u; index < slot->length; ++index) {

visitor(&entries[index].key, visitor_context);

visitor(&entries[index].value, visitor_context);

}

return;

}

if (slot->kind == PIKA_RUNTIME_VALUE_SLICE &&

slot->length > 0u) {

PikaSliceData* slice = (PikaSliceData*)slot->data;

visitor(&slice->start, visitor_context);

visitor(&slice->stop, visitor_context);

visitor(&slice->step, visitor_context);

}

}

static void mark_object_value(

PikaRuntimeValue* value,

void* context) {

PikaObjectStorage* storage = (PikaObjectStorage*)context;

uint32_t index;

if (!is_object_value_kind(value->kind)) {

return;

}

index = value->as.object_index;

if (index < storage->count &&

storage->slots[index].active == 1u) {

storage->slots[index].active = 2u;

}

}

static void remap_object_value(

PikaRuntimeValue* value,

void* context) {

const PikaObjectIndexRemap* remap =

(const PikaObjectIndexRemap*)context;

if (is_object_value_kind(value->kind) &&

value->as.object_index == remap->source) {

value->as.object_index = remap->destination;

}

}

static void visit_runtime_roots(

PikaRuntimeContext* context,

PikaRuntimeValueVisitor visitor,

void* visitor_context) {

uint32_t depth;

if (context->frames != NULL &&

context->typed_values != NULL) {

for (depth = 0u; depth <= context->depth; ++depth) {

const PikaRuntimeFrame* frame =

&context->frames[depth];

uint32_t count = frame->slot_count;

uint32_t index;

if (count > context->max_slots) {

count = context->max_slots;

}

for (index = 0u; index < count; ++index) {

visitor(

&context->typed_values[

frame->value_base + index],

visitor_context);

}

}

}

if (context->result != NULL) {

visitor(

&context->result->typed_value,

visitor_context);

}

if (context->gc_root_active != 0u) {

visitor(&context->gc_root, visitor_context);

}

#if PIKA_CAPABILITY_EXCEPTION_BASIC_ENABLE

if (context->has_pending_exception != 0u) {

visitor(

&context->pending_exception,

visitor_context);

}

#endif

}

static void mark_object_graph(PikaRuntimeContext* context) {

PikaObjectStorage* storage = context->objects;

uint32_t index;

int pending;

for (index = 0u; index < storage->count; ++index) {

if (storage->slots[index].active != 0u) {

storage->slots[index].active = 1u;

}

}

visit_runtime_roots(

context, mark_object_value, storage);

do {

pending = 0;

for (index = 0u; index < storage->count; ++index) {

PikaObjectSlot* slot = &storage->slots[index];

if (slot->active != 2u) {

continue;

}

slot->active = 3u;

pending = 1;

visit_object_values(

slot, mark_object_value, storage);

if (slot->kind ==

PIKA_RUNTIME_VALUE_ITERATOR &&

slot->data != NULL &&

slot->length > 0u &&

slot->length <= slot->capacity) {

PikaIteratorData* iterator =

(PikaIteratorData*)slot->data;

if (iterator->source_index <

storage->count &&

storage->slots[

iterator->source_index]

.active == 1u) {

storage->slots[

iterator->source_index]

.active = 2u;

}

}

}

} while (pending != 0);

}

static void remap_object_graph(

PikaRuntimeContext* context,

uint32_t source,

uint32_t destination) {

PikaObjectStorage* storage = context->objects;

PikaObjectIndexRemap remap = {source, destination};

uint32_t index;

visit_runtime_roots(

context, remap_object_value, &remap);

for (index = 0u; index < storage->count; ++index) {

PikaObjectSlot* slot = &storage->slots[index];

if (slot->active == 0u) {

continue;

}

visit_object_values(

slot, remap_object_value, &remap);

if (slot->kind ==

PIKA_RUNTIME_VALUE_ITERATOR &&

slot->data != NULL &&

slot->length > 0u &&

slot->length <= slot->capacity) {

PikaIteratorData* iterator =

(PikaIteratorData*)slot->data;

if (iterator->source_index == source) {

iterator->source_index = destination;

}

}

}

}

static void compact_object_slots(

PikaRuntimeContext* context) {

PikaObjectStorage* storage = context->objects;

uint32_t old_count = storage->count;

uint32_t destination = 0u;

uint32_t source;

for (source = 0u; source < old_count; ++source) {

PikaObjectSlot* slot = &storage->slots[source];

if (slot->active == 1u) {

if (slot->owned != 0u) {

release_pointer(storage, slot->data);

}

memset(slot, 0, sizeof(*slot));

}

}

for (source = 0u; source < old_count; ++source) {

PikaObjectSlot* slot = &storage->slots[source];

if (slot->active != 3u) {

continue;

}

if (destination != source) {

storage->slots[destination] = *slot;

storage->slots[destination].active = 1u;

memset(slot, 0, sizeof(*slot));

remap_object_graph(

context, source, destination);

} else {

slot->active = 1u;

}

++destination;

}

if (destination < old_count) {

memset(

&storage->slots[destination], 0,

(old_count - destination) *

sizeof(PikaObjectSlot));

}

storage->count = (uint16_t)destination;

}

#if PIKA_BINDING_RUNTIME_ENABLE

static void visit_reachable_values(

PikaRuntimeContext* context,

PikaRuntimeValueVisitor visitor,

void* visitor_context) {

uint32_t index;

visit_runtime_roots(

context, visitor, visitor_context);

if (context->objects == NULL ||

context->objects->slots == NULL) {

return;

}

for (index = 0u;

index < context->objects->count;

++index) {

PikaObjectSlot* slot =

&context->objects->slots[index];

if (slot->active != 0u) {

visit_object_values(

slot, visitor, visitor_context);

}

}

}

static void mark_binding_value(

PikaRuntimeValue* value,

void* context) {

PikaRuntimeContext* runtime =

(PikaRuntimeContext*)context;

uint32_t index;

if (value->kind !=

PIKA_RUNTIME_VALUE_NATIVE_OBJECT) {

return;

}

index = value->as.object_index;

if (index < runtime->binding_object_count &&

runtime->binding_storage

->objects[index]

.active == 1u) {

runtime->binding_storage

->objects[index]

.active = 2u;

}

}

static void invalidate_released_binding_value(

PikaRuntimeValue* value,

void* context) {

PikaRuntimeContext* runtime =

(PikaRuntimeContext*)context;

uint32_t index;

if (value->kind !=

PIKA_RUNTIME_VALUE_NATIVE_OBJECT) {

return;

}

index = value->as.object_index;

if (index < runtime->binding_object_count &&

runtime->binding_storage->objects[index].active == 0u) {

memset(value, 0, sizeof(*value));

value->kind = PIKA_RUNTIME_VALUE_NONE;

}

}

static void remap_binding_value(

PikaRuntimeValue* value,

void* context) {

const PikaObjectIndexRemap* remap =

(const PikaObjectIndexRemap*)context;

if (value->kind ==

PIKA_RUNTIME_VALUE_NATIVE_OBJECT &&

value->as.object_index == remap->source) {

value->as.object_index = remap->destination;

}

}

static void invalidate_released_binding_storage_values(

PikaRuntimeContext* context,

uint32_t object_count) {

uint32_t depth;

PikaBindingObject* objects =

context->binding_storage->objects;

if (context->binding_storage->values == NULL ||

context->frames == NULL) {

return;

}

for (depth = 0u; depth <= context->depth; ++depth) {

const PikaRuntimeFrame* frame =

&context->frames[depth];

uint32_t count = frame->slot_count;

uint32_t index;

if (frame->value_base >=

context->binding_storage->value_capacity) {

continue;

}

if (count > context->max_slots) {

count = context->max_slots;

}

if (count >

context->binding_storage->value_capacity -

frame->value_base) {

count =

context->binding_storage->value_capacity -

frame->value_base;

}

for (index = 0u; index < count; ++index) {

PikaBindingValue* value =

&context->binding_storage->values[

frame->value_base + index];

uint32_t object_index;

if (value->kind !=

PIKA_BINDING_VALUE_OPAQUE) {

continue;

}

for (object_index = 0u;

object_index < object_count;

++object_index) {

if (objects[object_index].active == 0u &&

value->as.opaque ==

&objects[object_index]) {

memset(value, 0, sizeof(*value));

value->kind = PIKA_BINDING_VALUE_NONE;

break;

}

}

}

}

}

static void remap_binding_storage_values(

PikaRuntimeContext* context,

uint32_t source,

uint32_t destination) {

uint32_t depth;

PikaBindingObject* objects =

context->binding_storage->objects;

if (context->binding_storage->values == NULL ||

context->frames == NULL) {

return;

}

for (depth = 0u; depth <= context->depth; ++depth) {

const PikaRuntimeFrame* frame =

&context->frames[depth];

uint32_t count = frame->slot_count;

uint32_t index;

if (frame->value_base >=

context->binding_storage->value_capacity) {

continue;

}

if (count > context->max_slots) {

count = context->max_slots;

}

if (count >

context->binding_storage->value_capacity -

frame->value_base) {

count =

context->binding_storage->value_capacity -

frame->value_base;

}

for (index = 0u; index < count; ++index) {

PikaBindingValue* value =

&context->binding_storage->values[

frame->value_base + index];

if (value->kind ==

PIKA_BINDING_VALUE_OPAQUE &&

value->as.opaque ==

&objects[source]) {

value->as.opaque =

&objects[destination];

}

}

}

}

static void compact_binding_objects(

PikaRuntimeContext* context) {

PikaBindingObject* objects;

uint32_t old_count;

uint32_t destination = 0u;

uint32_t source;

if (context->binding_storage == NULL ||

context->binding_storage->objects == NULL ||

context->binding_object_count == 0u) {

return;

}

if (context->binding_object_count >

context->binding_storage->object_capacity) {

return;

}

objects = context->binding_storage->objects;

old_count = context->binding_object_count;

for (source = 0u; source < old_count; ++source) {

if (objects[source].active != 0u) {

objects[source].active = 1u;

}

}

visit_reachable_values(

context, invalidate_released_binding_value, context);

invalidate_released_binding_storage_values(

context, old_count);

visit_reachable_values(

context, mark_binding_value, context);

for (source = 0u; source < old_count; ++source) {

if (objects[source].active == 1u) {

pika_binding_object_release(

&objects[source]);

}

}

for (source = 0u; source < old_count; ++source) {

PikaObjectIndexRemap remap;

if (objects[source].active != 2u) {

continue;

}

if (source != destination) {

objects[destination] = objects[source];

objects[destination].active = 1u;

memset(

&objects[source], 0,

sizeof(PikaBindingObject));

remap.source = source;

remap.destination = destination;

visit_reachable_values(

context, remap_binding_value,

&remap);

remap_binding_storage_values(

context, source, destination);

} else {

objects[source].active = 1u;

}

++destination;

}

if (destination < old_count) {

memset(

&objects[destination], 0,

(old_count - destination) *

sizeof(PikaBindingObject));

}

context->binding_object_count =

(uint16_t)destination;

}

#endif

static void compact_object_arena(

PikaObjectStorage* storage) {

uintptr_t begin;

uintptr_t end;

uintptr_t previous_pointer = 0u;

uintptr_t previous_end = 0u;

uint32_t index;

uint32_t destination = 0u;

uint32_t previous_index = 0u;

uint32_t alignment = (uint32_t)sizeof(void*);

int have_previous = 0;

if (storage->slots == NULL ||

storage->arena == NULL ||

storage->arena_capacity == 0u) {

return;

}

begin = (uintptr_t)storage->arena;

end = begin + storage->arena_capacity;

if (end < begin ||

storage->arena_used >

storage->arena_capacity) {

return;

}

for (index = 0u; index < storage->count; ++index) {

PikaObjectSlot* slot = &storage->slots[index];

uint32_t size;

uintptr_t pointer;

if (slot->active == 0u ||

slot->owned != 0u ||

slot->data == NULL) {

continue;

}

if (!object_slot_payload_size(slot, &size)) {

return;

}

pointer = (uintptr_t)slot->data;

if (pointer < begin || pointer > end ||

size > end - pointer) {

return;

}

}

for (;;) {

uint32_t selected = UINT32_MAX;

uintptr_t selected_pointer = UINTPTR_MAX;

uint32_t selected_size = 0u;

uint64_t aligned;

for (index = 0u; index < storage->count; ++index) {

PikaObjectSlot* slot = &storage->slots[index];

uintptr_t pointer;

uint32_t size;

if (slot->active != 1u ||

slot->owned != 0u ||

slot->data == NULL ||

!object_slot_payload_size(slot, &size) ||

size == 0u) {

continue;

}

pointer = (uintptr_t)slot->data;

if (have_previous != 0 &&

(pointer < previous_pointer ||

(pointer == previous_pointer &&

index <= previous_index))) {

continue;

}