|
#include "gc_roots.h"
|
|
#include "gc_mark.h"
|
|
#include "../runtime.h"
|
|
#include "../fastframe.h"
|
|
#include "../nanbox.h"
|
|
|
|
void rava_gc_mark_value(RavaValue_t value) {
|
|
switch (value.type) {
|
|
case RAVA_VAL_OBJECT:
|
|
if (value.data.object_val) {
|
|
rava_gc_mark_object(&value.data.object_val->gc);
|
|
}
|
|
break;
|
|
case RAVA_VAL_ARRAY:
|
|
if (value.data.array_val) {
|
|
rava_gc_mark_object(&value.data.array_val->gc);
|
|
}
|
|
break;
|
|
case RAVA_VAL_ARRAYLIST:
|
|
if (value.data.arraylist_val) {
|
|
rava_gc_mark_object(&value.data.arraylist_val->gc);
|
|
}
|
|
break;
|
|
case RAVA_VAL_HASHMAP:
|
|
if (value.data.hashmap_val) {
|
|
rava_gc_mark_object(&value.data.hashmap_val->gc);
|
|
}
|
|
break;
|
|
case RAVA_VAL_SOCKET:
|
|
if (value.data.socket_val) {
|
|
rava_gc_mark_object(&value.data.socket_val->gc);
|
|
}
|
|
break;
|
|
case RAVA_VAL_STREAM:
|
|
if (value.data.stream_val) {
|
|
rava_gc_mark_object(&value.data.stream_val->gc);
|
|
}
|
|
break;
|
|
case RAVA_VAL_METHOD_REF:
|
|
if (value.data.method_ref_val) {
|
|
rava_gc_mark_object(&value.data.method_ref_val->gc);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void rava_gc_mark_nanbox(uint64_t v) {
|
|
if (rava_nanbox_is_object(v)) {
|
|
void *ptr = rava_nanbox_as_object(v);
|
|
if (ptr) {
|
|
RavaObject_t *obj = (RavaObject_t*)ptr;
|
|
rava_gc_mark_object(&obj->gc);
|
|
}
|
|
} else if (rava_nanbox_is_array(v)) {
|
|
void *ptr = rava_nanbox_as_array(v);
|
|
if (ptr) {
|
|
RavaArray_t *arr = (RavaArray_t*)ptr;
|
|
rava_gc_mark_object(&arr->gc);
|
|
}
|
|
}
|
|
}
|
|
|
|
void rava_gc_mark_string(const char *str) {
|
|
(void)str;
|
|
}
|
|
|
|
void rava_gc_scan_roots(RavaVM_t *vm) {
|
|
if (!vm) return;
|
|
|
|
if (vm->call_stack) {
|
|
for (size_t i = 0; i < vm->call_stack->count; i++) {
|
|
RavaCallFrame_t *frame = vm->call_stack->frames[i];
|
|
if (!frame) continue;
|
|
|
|
for (size_t j = 0; j < frame->local_count; j++) {
|
|
rava_gc_mark_value(frame->locals[j]);
|
|
}
|
|
|
|
if (frame->operand_stack) {
|
|
for (size_t j = 0; j < frame->operand_stack->top; j++) {
|
|
rava_gc_mark_value(frame->operand_stack->values[j]);
|
|
}
|
|
}
|
|
|
|
if (frame->has_this) {
|
|
rava_gc_mark_value(frame->this_ref);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern size_t rava_frame_depth;
|
|
extern FastFrame_t rava_frame_pool[];
|
|
for (size_t i = 0; i < rava_frame_depth; i++) {
|
|
FastFrame_t *frame = &rava_frame_pool[i];
|
|
|
|
for (size_t j = 0; j < RAVA_MAX_LOCALS_FIXED; j++) {
|
|
rava_gc_mark_nanbox(frame->locals[j]);
|
|
}
|
|
|
|
for (size_t j = 0; j < frame->stack_top; j++) {
|
|
rava_gc_mark_nanbox(frame->stack[j]);
|
|
}
|
|
|
|
if (frame->has_this) {
|
|
rava_gc_mark_nanbox(frame->this_ref);
|
|
}
|
|
}
|
|
|
|
if (vm->static_fields) {
|
|
for (size_t i = 0; i < vm->static_fields->count; i++) {
|
|
rava_gc_mark_value(vm->static_fields->fields[i].value);
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < RAVA_INTERN_TABLE_SIZE; i++) {
|
|
if (vm->intern_table.strings[i]) {
|
|
rava_gc_mark_string(vm->intern_table.strings[i]);
|
|
}
|
|
}
|
|
|
|
if (vm->has_exception) {
|
|
rava_gc_mark_value(vm->exception_value);
|
|
}
|
|
}
|