gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-02-11 17:35:13 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
77e8a7d403
wasm-micro-runtime/core/iwasm/common/gc/gc_object.c
Liangyu Zhang b11a1d157d
GC: Add wasm_struct_obj_get_field_count API (#3236)
2024-03-18 16:26:30 +08:00

1082 lines
31 KiB
C
Raw Blame History

/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "gc_object.h"
#include "mem_alloc.h"
#include "../wasm_runtime_common.h"
#if WASM_ENABLE_INTERP != 0
#include "../interpreter/wasm_runtime.h"
#endif
#if WASM_ENABLE_AOT != 0
#include "../aot/aot_runtime.h"
#endif
#if WASM_ENABLE_STRINGREF != 0
#include "string_object.h"
#endif
WASMRttTypeRef
wasm_rtt_type_new(WASMType *defined_type, uint32 defined_type_idx,
WASMRttType **rtt_types, uint32 rtt_type_count,
korp_mutex *rtt_type_lock)
{
WASMRttType *rtt_type;
bh_assert(defined_type_idx < rtt_type_count);
os_mutex_lock(rtt_type_lock);
if (rtt_types[defined_type_idx]) {
os_mutex_unlock(rtt_type_lock);
return rtt_types[defined_type_idx];
}
if ((rtt_type = wasm_runtime_malloc(sizeof(WASMRttType)))) {
rtt_type->type_flag = defined_type->type_flag;
rtt_type->inherit_depth = defined_type->inherit_depth;
rtt_type->defined_type = defined_type;
rtt_type->root_type = defined_type->root_type;
rtt_types[defined_type_idx] = rtt_type;
}
os_mutex_unlock(rtt_type_lock);
return rtt_type;
}
static void *
gc_obj_malloc(void *heap_handle, uint64 size)
{
void *mem;
if (size >= UINT32_MAX
|| !(mem = mem_allocator_malloc_with_gc(heap_handle, (uint32)size))) {
LOG_WARNING("warning: failed to allocate memory for gc object");
return NULL;
}
memset(mem, 0, (uint32)size);
return mem;
}
static void *
get_gc_heap_handle(WASMExecEnv *exec_env)
{
void *gc_heap_handle = NULL;
WASMModuleInstanceCommon *module_inst = exec_env->module_inst;
#if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode)
gc_heap_handle =
((WASMModuleInstance *)module_inst)->e->common.gc_heap_handle;
#endif
#if WASM_ENABLE_AOT != 0
if (module_inst->module_type == Wasm_Module_AoT)
gc_heap_handle =
((AOTModuleInstanceExtra *)((AOTModuleInstance *)module_inst)->e)
->common.gc_heap_handle;
#endif
bh_assert(gc_heap_handle);
return gc_heap_handle;
}
WASMStructObjectRef
wasm_struct_obj_new_internal(void *heap_handle, WASMRttTypeRef rtt_type)
{
WASMStructObjectRef struct_obj;
WASMStructType *struct_type;
bh_assert(rtt_type->type_flag == WASM_TYPE_STRUCT);
struct_type = (WASMStructType *)rtt_type->defined_type;
if (!(struct_obj = gc_obj_malloc(heap_handle, struct_type->total_size))) {
return NULL;
}
struct_obj->header = (WASMObjectHeader)rtt_type;
return struct_obj;
}
WASMStructObjectRef
wasm_struct_obj_new(WASMExecEnv *exec_env, WASMRttTypeRef rtt_type)
{
void *heap_handle = get_gc_heap_handle(exec_env);
return wasm_struct_obj_new_internal(heap_handle, rtt_type);
}
void
wasm_struct_obj_set_field(WASMStructObjectRef struct_obj, uint32 field_idx,
const WASMValue *value)
{
WASMRttTypeRef rtt_type =
(WASMRttTypeRef)wasm_object_header((WASMObjectRef)struct_obj);
WASMStructType *struct_type = (WASMStructType *)rtt_type->defined_type;
WASMStructFieldType *field;
uint8 field_size, *field_data;
bh_assert(field_idx < struct_type->field_count);
field = struct_type->fields + field_idx;
field_data = (uint8 *)struct_obj + field->field_offset;
field_size = field->field_size;
if (field_size == 4) {
*(int32 *)field_data = value->i32;
}
else if (field_size == 8) {
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_X86_32)
*(int64 *)field_data = value->i64;
#else
PUT_I64_TO_ADDR((uint32 *)field_data, value->i64);
#endif
}
else if (field_size == 1) {
*(int8 *)field_data = (int8)value->i32;
}
else if (field_size == 2) {
*(int16 *)field_data = (int16)value->i32;
}
else {
bh_assert(0);
}
}
void
wasm_struct_obj_get_field(const WASMStructObjectRef struct_obj,
uint32 field_idx, bool sign_extend, WASMValue *value)
{
WASMRttTypeRef rtt_type =
(WASMRttTypeRef)wasm_object_header((WASMObjectRef)struct_obj);
WASMStructType *struct_type = (WASMStructType *)rtt_type->defined_type;
WASMStructFieldType *field;
uint8 *field_data, field_size;
bh_assert(field_idx < struct_type->field_count);
field = struct_type->fields + field_idx;
field_data = (uint8 *)struct_obj + field->field_offset;
field_size = field->field_size;
if (field_size == 4) {
value->i32 = *(int32 *)field_data;
}
else if (field_size == 8) {
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
|| defined(BUILD_TARGET_X86_32)
value->i64 = *(int64 *)field_data;
#else
value->i64 = GET_I64_FROM_ADDR((uint32 *)field_data);
#endif
}
else if (field_size == 1) {
if (sign_extend)
value->i32 = (int32)(*(int8 *)field_data);
else
value->u32 = (uint32)(*(uint8 *)field_data);
}
else if (field_size == 2) {
if (sign_extend)
value->i32 = (int32)(*(int16 *)field_data);
else
value->u32 = (uint32)(*(uint16 *)field_data);
}
else {
bh_assert(0);
}
}
uint32
wasm_struct_obj_get_field_count(const WASMStructObjectRef struct_obj)
{
WASMRttTypeRef rtt_type =
(WASMRttTypeRef)wasm_object_header((WASMObjectRef)struct_obj);
WASMStructType *struct_type = (WASMStructType *)rtt_type->defined_type;
return struct_type->field_count;
}
WASMArrayObjectRef
wasm_array_obj_new_internal(void *heap_handle, WASMRttTypeRef rtt_type,
uint32 length, WASMValue *init_value)
{
WASMArrayObjectRef array_obj;
WASMArrayType *array_type;
uint64 total_size;
uint32 elem_size, elem_size_log, i;
bh_assert(rtt_type->type_flag == WASM_TYPE_ARRAY);
if (length >= (1 << 29))
return NULL;
array_type = (WASMArrayType *)rtt_type->defined_type;
if (array_type->elem_type == PACKED_TYPE_I8) {
elem_size = 1;
elem_size_log = 0;
}
else if (array_type->elem_type == PACKED_TYPE_I16) {
elem_size = 2;
elem_size_log = 1;
}
else {
elem_size = wasm_value_type_size(array_type->elem_type);
elem_size_log = (elem_size == 4) ? 2 : 3;
}
total_size =
offsetof(WASMArrayObject, elem_data) + (uint64)elem_size * length;
if (!(array_obj = gc_obj_malloc(heap_handle, total_size))) {
return NULL;
}
array_obj->header = (WASMObjectHeader)rtt_type;
array_obj->length = (length << 2) | elem_size_log;
if (init_value != NULL) {
for (i = 0; i < length; i++) {
if (wasm_is_type_reftype(array_type->elem_type)) {
uint32 *elem_addr =
(uint32 *)array_obj->elem_data + REF_CELL_NUM * i;
PUT_REF_TO_ADDR(elem_addr, init_value->gc_obj);
}
else if (array_type->elem_type == VALUE_TYPE_I32
|| array_type->elem_type == VALUE_TYPE_F32) {
((int32 *)array_obj->elem_data)[i] = init_value->i32;
}
else if (array_type->elem_type == PACKED_TYPE_I8) {
((int8 *)array_obj->elem_data)[i] = (int8)init_value->i32;
}
else if (array_type->elem_type == PACKED_TYPE_I16) {
((int16 *)array_obj->elem_data)[i] = (int16)init_value->i32;
}
else {
uint32 *elem_addr = (uint32 *)array_obj->elem_data + 2 * i;
PUT_I64_TO_ADDR(elem_addr, init_value->i64);
}
}
}
return array_obj;
}
WASMArrayObjectRef
wasm_array_obj_new(WASMExecEnv *exec_env, WASMRttTypeRef rtt_type,
uint32 length, WASMValue *init_value)
{
void *heap_handle = get_gc_heap_handle(exec_env);
return wasm_array_obj_new_internal(heap_handle, rtt_type, length,
init_value);
}
void
wasm_array_obj_set_elem(WASMArrayObjectRef array_obj, uint32 elem_idx,
const WASMValue *value)
{
uint8 *elem_data = wasm_array_obj_elem_addr(array_obj, elem_idx);
uint32 elem_size = 1 << wasm_array_obj_elem_size_log(array_obj);
switch (elem_size) {
case 1:
*(int8 *)elem_data = (int8)value->i32;
break;
case 2:
*(int16 *)elem_data = (int16)value->i32;
break;
case 4:
*(int32 *)elem_data = value->i32;
break;
case 8:
PUT_I64_TO_ADDR((uint32 *)elem_data, value->i64);
break;
}
}
void
wasm_array_obj_get_elem(const WASMArrayObjectRef array_obj, uint32 elem_idx,
bool sign_extend, WASMValue *value)
{
uint8 *elem_data = wasm_array_obj_elem_addr(array_obj, elem_idx);
uint32 elem_size = 1 << wasm_array_obj_elem_size_log(array_obj);
switch (elem_size) {
case 1:
value->i32 = sign_extend ? (int32)(*(int8 *)elem_data)
: (int32)(uint32)(*(uint8 *)elem_data);
break;
case 2:
value->i32 = sign_extend ? (int32)(*(int16 *)elem_data)
: (int32)(uint32)(*(uint16 *)elem_data);
break;
case 4:
value->i32 = *(int32 *)elem_data;
break;
case 8:
value->i64 = GET_I64_FROM_ADDR((uint32 *)elem_data);
break;
}
}
void
wasm_array_obj_fill(const WASMArrayObjectRef array_obj, uint32 elem_idx,
uint32 len, WASMValue *value)
{
uint32 i;
uint8 *elem_data = wasm_array_obj_elem_addr(array_obj, elem_idx);
uint32 elem_size = 1 << wasm_array_obj_elem_size_log(array_obj);
if (elem_size == 1) {
memset(elem_data, (int8)value->i32, len);
return;
}
for (i = 0; i < len; i++) {
switch (elem_size) {
case 2:
*(int16 *)elem_data = (int16)value->i32;
break;
case 4:
*(int32 *)elem_data = value->i32;
break;
case 8:
PUT_I64_TO_ADDR((uint32 *)elem_data, value->i64);
break;
}
elem_data += elem_size;
}
}
void
wasm_array_obj_copy(WASMArrayObjectRef dst_obj, uint32 dst_idx,
WASMArrayObjectRef src_obj, uint32 src_idx, uint32 len)
{
uint8 *dst_data = wasm_array_obj_elem_addr(dst_obj, dst_idx);
uint8 *src_data = wasm_array_obj_elem_addr(src_obj, src_idx);
uint32 elem_size = 1 << wasm_array_obj_elem_size_log(dst_obj);
bh_memmove_s(dst_data, elem_size * len, src_data, elem_size * len);
}
uint32
wasm_array_obj_length(const WASMArrayObjectRef array_obj)
{
return array_obj->length >> WASM_ARRAY_LENGTH_SHIFT;
}
void *
wasm_array_obj_first_elem_addr(const WASMArrayObjectRef array_obj)
{
return array_obj->elem_data;
}
void *
wasm_array_obj_elem_addr(const WASMArrayObjectRef array_obj, uint32 elem_idx)
{
return array_obj->elem_data
+ (elem_idx << wasm_array_obj_elem_size_log(array_obj));
}
WASMFuncObjectRef
wasm_func_obj_new_internal(void *heap_handle, WASMRttTypeRef rtt_type,
uint32 func_idx_bound)
{
WASMFuncObjectRef func_obj;
uint64 total_size;
bh_assert(rtt_type->type_flag == WASM_TYPE_FUNC);
total_size = sizeof(WASMFuncObject);
if (!(func_obj = gc_obj_malloc(heap_handle, total_size))) {
return NULL;
}
func_obj->header = (WASMObjectHeader)rtt_type;
func_obj->func_idx_bound = func_idx_bound;
return func_obj;
}
WASMFuncObjectRef
wasm_func_obj_new(WASMExecEnv *exec_env, WASMRttTypeRef rtt_type,
uint32 func_idx_bound)
{
void *heap_handle = get_gc_heap_handle(exec_env);
return wasm_func_obj_new_internal(heap_handle, rtt_type, func_idx_bound);
}
uint32
wasm_func_obj_get_func_idx_bound(const WASMFuncObjectRef func_obj)
{
return func_obj->func_idx_bound;
}
WASMFuncType *
wasm_func_obj_get_func_type(const WASMFuncObjectRef func_obj)
{
WASMRttTypeRef rtt_type =
(WASMRttTypeRef)wasm_object_header((WASMObjectRef)func_obj);
bh_assert(rtt_type->type_flag == WASM_TYPE_FUNC);
return (WASMFuncType *)rtt_type->defined_type;
}
WASMExternrefObjectRef
wasm_externref_obj_new(WASMExecEnv *exec_env, const void *host_obj)
{
void *heap_handle = get_gc_heap_handle(exec_env);
WASMAnyrefObjectRef anyref_obj;
WASMExternrefObjectRef externref_obj;
WASMLocalObjectRef local_ref;
if (!(anyref_obj = gc_obj_malloc(heap_handle, sizeof(WASMAnyrefObject)))) {
return NULL;
}
anyref_obj->header = WASM_OBJ_ANYREF_OBJ_FLAG;
anyref_obj->host_obj = host_obj;
/* Lock anyref_obj in case it is reclaimed when allocating memory below */
wasm_runtime_push_local_obj_ref(exec_env, &local_ref);
local_ref.val = (WASMObjectRef)anyref_obj;
if (!(externref_obj =
gc_obj_malloc(heap_handle, sizeof(WASMExternrefObject)))) {
wasm_runtime_pop_local_obj_ref(exec_env);
return NULL;
}
externref_obj->header = WASM_OBJ_EXTERNREF_OBJ_FLAG;
externref_obj->internal_obj = (WASMObjectRef)anyref_obj;
wasm_runtime_pop_local_obj_ref(exec_env);
return externref_obj;
}
WASMAnyrefObjectRef
wasm_anyref_obj_new(WASMExecEnv *exec_env, const void *host_obj)
{
void *heap_handle = get_gc_heap_handle(exec_env);
WASMAnyrefObjectRef anyref_obj;
if (!(anyref_obj = gc_obj_malloc(heap_handle, sizeof(WASMAnyrefObject)))) {
return NULL;
}
anyref_obj->header = WASM_OBJ_ANYREF_OBJ_FLAG;
anyref_obj->host_obj = host_obj;
return anyref_obj;
}
WASMObjectRef
wasm_externref_obj_to_internal_obj(WASMExternrefObjectRef externref_obj)
{
return externref_obj->internal_obj;
}
WASMExternrefObjectRef
wasm_internal_obj_to_externref_obj(WASMExecEnv *exec_env,
WASMObjectRef internal_obj)
{
void *heap_handle = get_gc_heap_handle(exec_env);
WASMExternrefObjectRef externref_obj;
if (!(externref_obj =
gc_obj_malloc(heap_handle, sizeof(WASMExternrefObject)))) {
return NULL;
}
externref_obj->header = WASM_OBJ_EXTERNREF_OBJ_FLAG;
externref_obj->internal_obj = internal_obj;
return externref_obj;
}
const void *
wasm_anyref_obj_get_value(WASMAnyrefObjectRef anyref_obj)
{
return anyref_obj->host_obj;
}
const void *
wasm_externref_obj_get_value(const WASMExternrefObjectRef externref_obj)
{
if (wasm_obj_is_anyref_obj(externref_obj->internal_obj))
return ((WASMAnyrefObjectRef)externref_obj->internal_obj)->host_obj;
else
return externref_obj->internal_obj;
}
WASMI31ObjectRef
wasm_i31_obj_new(uint32 i31_value)
{
return (WASMI31ObjectRef)((i31_value << 1) | 1);
}
uint32
wasm_i31_obj_get_value(WASMI31ObjectRef i31_obj, bool sign_extend)
{
uint32 i31_value = (uint32)(((uintptr_t)i31_obj) >> 1);
if (sign_extend && (i31_value & 0x40000000)) /* bit 30 is 1 */
/* set bit 31 to 1 */
i31_value |= 0x80000000;
return i31_value;
}
bool
wasm_obj_is_i31_obj(WASMObjectRef obj)
{
bh_assert(obj);
return (((uintptr_t)obj) & 1) ? true : false;
}
bool
wasm_obj_is_externref_obj(WASMObjectRef obj)
{
bh_assert(obj);
return (!wasm_obj_is_i31_obj(obj)
&& (obj->header & WASM_OBJ_EXTERNREF_OBJ_FLAG))
? true
: false;
}
bool
wasm_obj_is_anyref_obj(WASMObjectRef obj)
{
bh_assert(obj);
return (!wasm_obj_is_i31_obj(obj)
&& (obj->header & WASM_OBJ_ANYREF_OBJ_FLAG))
? true
: false;
}
bool
wasm_obj_is_i31_externref_or_anyref_obj(WASMObjectRef obj)
{
bh_assert(obj);
return (wasm_obj_is_i31_obj(obj)
|| (obj->header
& (WASM_OBJ_EXTERNREF_OBJ_FLAG | WASM_OBJ_ANYREF_OBJ_FLAG)))
? true
: false;
}
bool
wasm_obj_is_struct_obj(WASMObjectRef obj)
{
WASMRttTypeRef rtt_type;
bh_assert(obj);
if (wasm_obj_is_i31_externref_or_anyref_obj(obj))
return false;
rtt_type = (WASMRttTypeRef)wasm_object_header(obj);
return rtt_type->type_flag == WASM_TYPE_STRUCT ? true : false;
}
bool
wasm_obj_is_array_obj(WASMObjectRef obj)
{
WASMRttTypeRef rtt_type;
bh_assert(obj);
if (wasm_obj_is_i31_externref_or_anyref_obj(obj))
return false;
rtt_type = (WASMRttTypeRef)wasm_object_header(obj);
return rtt_type->type_flag == WASM_TYPE_ARRAY ? true : false;
}
bool
wasm_obj_is_func_obj(WASMObjectRef obj)
{
WASMRttTypeRef rtt_type;
bh_assert(obj);
if (wasm_obj_is_i31_externref_or_anyref_obj(obj))
return false;
rtt_type = (WASMRttTypeRef)wasm_object_header(obj);
return rtt_type->type_flag == WASM_TYPE_FUNC ? true : false;
}
bool
wasm_obj_is_internal_obj(WASMObjectRef obj)
{
WASMRttTypeRef rtt_type;
bh_assert(obj);
if (wasm_obj_is_i31_obj(obj))
return true;
else if (obj->header & WASM_OBJ_ANYREF_OBJ_FLAG)
return true;
else if (obj->header & WASM_OBJ_EXTERNREF_OBJ_FLAG)
return false;
else {
rtt_type = (WASMRttTypeRef)wasm_object_header(obj);
return (rtt_type->type_flag == WASM_TYPE_STRUCT
|| rtt_type->type_flag == WASM_TYPE_ARRAY)
? true
: false;
}
}
bool
wasm_obj_is_eq_obj(WASMObjectRef obj)
{
WASMRttTypeRef rtt_type;
bh_assert(obj);
if (wasm_obj_is_i31_obj(obj))
return true;
else if ((obj->header & WASM_OBJ_ANYREF_OBJ_FLAG)
|| (obj->header & WASM_OBJ_EXTERNREF_OBJ_FLAG))
return false;
else {
rtt_type = (WASMRttTypeRef)wasm_object_header(obj);
return (rtt_type->type_flag == WASM_TYPE_STRUCT
|| rtt_type->type_flag == WASM_TYPE_ARRAY)
? true
: false;
}
}
bool
wasm_obj_is_instance_of(WASMObjectRef obj, uint32 type_idx, WASMType **types,
uint32 type_count)
{
WASMRttTypeRef rtt_type_sub;
WASMType *type_sub, *type_parent;
uint32 distance, i;
bh_assert(obj);
bh_assert(type_idx < type_count);
if (wasm_obj_is_i31_externref_or_anyref_obj(obj))
return false;
rtt_type_sub = (WASMRttTypeRef)wasm_object_header(obj);
type_parent = types[type_idx];
if (!(rtt_type_sub->root_type == type_parent->root_type
&& rtt_type_sub->inherit_depth >= type_parent->inherit_depth))
return false;
type_sub = rtt_type_sub->defined_type;
distance = type_sub->inherit_depth - type_parent->inherit_depth;
for (i = 0; i < distance; i++) {
type_sub = type_sub->parent_type;
}
return (type_sub == type_parent) ? true : false;
}
bool
wasm_obj_is_type_of(WASMObjectRef obj, int32 heap_type)
{
bh_assert(obj);
switch (heap_type) {
case HEAP_TYPE_FUNC:
return wasm_obj_is_func_obj(obj);
case HEAP_TYPE_EXTERN:
return wasm_obj_is_externref_obj(obj);
case HEAP_TYPE_ANY:
return wasm_obj_is_internal_obj(obj);
case HEAP_TYPE_EQ:
return wasm_obj_is_eq_obj(obj);
case HEAP_TYPE_I31:
return wasm_obj_is_i31_obj(obj);
case HEAP_TYPE_STRUCT:
return wasm_obj_is_struct_obj(obj);
case HEAP_TYPE_ARRAY:
return wasm_obj_is_array_obj(obj);
#if WASM_ENABLE_STRINGREF != 0
case HEAP_TYPE_STRINGREF:
return wasm_obj_is_stringref_obj(obj);
case HEAP_TYPE_STRINGVIEWWTF8:
return wasm_obj_is_stringview_wtf8_obj(obj);
case HEAP_TYPE_STRINGVIEWWTF16:
return wasm_obj_is_stringview_wtf16_obj(obj);
#endif
case HEAP_TYPE_NONE:
case HEAP_TYPE_NOFUNC:
case HEAP_TYPE_NOEXTERN:
return false;
default:
bh_assert(0);
break;
}
return false;
}
bool
wasm_obj_equal(WASMObjectRef obj1, WASMObjectRef obj2)
{
/* TODO: do we need to compare the internal details of the objects */
return obj1 == obj2 ? true : false;
}
bool
wasm_object_get_ref_list(WASMObjectRef obj, bool *p_is_compact_mode,
uint32 *p_ref_num, uint16 **p_ref_list,
uint32 *p_ref_start_offset)
{
WASMRttTypeRef rtt_type;
bh_assert(wasm_obj_is_created_from_heap(obj));
rtt_type = (WASMRttTypeRef)wasm_object_header(obj);
if (obj->header & WASM_OBJ_EXTERNREF_OBJ_FLAG) {
/* externref object */
static uint16 externref_obj_ref_list[] = { (uint16)offsetof(
WASMExternrefObject, internal_obj) };
*p_is_compact_mode = false;
*p_ref_num = 1;
*p_ref_list = externref_obj_ref_list;
return true;
}
else if (obj->header & WASM_OBJ_ANYREF_OBJ_FLAG) {
/* anyref object */
*p_is_compact_mode = false;
*p_ref_num = 0;
*p_ref_list = NULL;
return true;
}
#if WASM_ENABLE_STRINGREF != 0
else if (rtt_type->type_flag == WASM_TYPE_STRINGREF
|| rtt_type->type_flag == WASM_TYPE_STRINGVIEWWTF8
|| rtt_type->type_flag == WASM_TYPE_STRINGVIEWWTF16
|| rtt_type->type_flag == WASM_TYPE_STRINGVIEWITER) {
/* stringref/stringview_wtf8/stringview_wtf16/stringview_iter object */
*p_is_compact_mode = false;
*p_ref_num = 0;
*p_ref_list = NULL;
return true;
}
#endif /* end of WASM_ENABLE_STRINGREF != 0 */
else if (rtt_type->defined_type->type_flag == WASM_TYPE_FUNC) {
/* function object */
*p_is_compact_mode = false;
*p_ref_num = 0;
*p_ref_list = NULL;
return true;
}
else if (rtt_type->defined_type->type_flag == WASM_TYPE_STRUCT) {
/* struct object */
WASMStructType *type = (WASMStructType *)rtt_type->defined_type;
*p_is_compact_mode = false;
*p_ref_num = *type->reference_table;
*p_ref_list = type->reference_table + 1;
return true;
}
else if (rtt_type->defined_type->type_flag == WASM_TYPE_ARRAY) {
/* array object */
WASMArrayType *type = (WASMArrayType *)rtt_type->defined_type;
if (wasm_is_type_reftype(type->elem_type)) {
*p_is_compact_mode = true;
*p_ref_num = wasm_array_obj_length((WASMArrayObjectRef)obj);
*p_ref_start_offset = (uint16)offsetof(WASMArrayObject, elem_data);
}
else {
*p_is_compact_mode = false;
*p_ref_num = 0;
*p_ref_list = NULL;
}
return true;
}
else {
bh_assert(0);
return false;
}
}
bool
wasm_obj_set_gc_finalizer(wasm_exec_env_t exec_env, const wasm_obj_t obj,
wasm_obj_finalizer_t cb, void *data)
{
void *heap_handle = get_gc_heap_handle(exec_env);
return mem_allocator_set_gc_finalizer(heap_handle, obj, (gc_finalizer_t)cb,
data);
}
void
wasm_obj_unset_gc_finalizer(wasm_exec_env_t exec_env, void *obj)
{
void *heap_handle = get_gc_heap_handle(exec_env);
mem_allocator_unset_gc_finalizer(heap_handle, obj);
}
#if WASM_ENABLE_STRINGREF != 0
WASMRttTypeRef
wasm_stringref_rtt_type_new(uint16 type_flag, WASMRttType **rtt_types,
korp_mutex *rtt_type_lock)
{
WASMRttType *rtt_type;
uint32 index;
bh_assert(type_flag >= WASM_TYPE_STRINGREF
&& type_flag <= WASM_TYPE_STRINGVIEWITER);
index = type_flag - WASM_TYPE_STRINGREF;
os_mutex_lock(rtt_type_lock);
if (rtt_types[index]) {
os_mutex_unlock(rtt_type_lock);
return rtt_types[index];
}
if ((rtt_type = wasm_runtime_malloc(sizeof(WASMRttType)))) {
memset(rtt_type, 0, sizeof(WASMRttType));
rtt_type->type_flag = type_flag;
rtt_types[index] = rtt_type;
}
os_mutex_unlock(rtt_type_lock);
return rtt_type;
}
static void
wasm_stringref_obj_finalizer(WASMStringrefObjectRef stringref_obj, void *data)
{
wasm_string_destroy(
(WASMString)wasm_stringref_obj_get_value(stringref_obj));
}
static void
wasm_stringview_wtf8_obj_finalizer(WASMStringviewWTF8ObjectRef stringref_obj,
void *data)
{
wasm_string_destroy(
(WASMString)wasm_stringview_wtf8_obj_get_value(stringref_obj));
}
static void
wasm_stringview_wtf16_obj_finalizer(WASMStringviewWTF16ObjectRef stringref_obj,
void *data)
{
wasm_string_destroy(
(WASMString)wasm_stringview_wtf16_obj_get_value(stringref_obj));
}
static void
wasm_stringview_iter_obj_finalizer(WASMStringviewIterObjectRef stringref_obj,
void *data)
{
wasm_string_destroy(
(WASMString)wasm_stringview_iter_obj_get_value(stringref_obj));
}
static WASMObjectRef
stringref_obj_new(WASMExecEnv *exec_env, uint32 type, const void *str_obj,
int32 pos)
{
WASMObjectRef stringref_obj = NULL;
void *heap_handle = get_gc_heap_handle(exec_env);
WASMModuleInstanceCommon *module_inst =
wasm_runtime_get_module_inst(exec_env);
WASMRttTypeRef rtt_type = NULL;
#if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) {
WASMModule *module = ((WASMModuleInstance *)module_inst)->module;
rtt_type = wasm_stringref_rtt_type_new(type, module->stringref_rtts,
&module->rtt_type_lock);
}
#endif
#if WASM_ENABLE_AOT != 0
if (module_inst->module_type == Wasm_Module_AoT) {
AOTModule *module =
(AOTModule *)((AOTModuleInstance *)module_inst)->module;
rtt_type = wasm_stringref_rtt_type_new(type, module->stringref_rtts,
&module->rtt_type_lock);
}
#endif
if (!rtt_type) {
return NULL;
}
if (type == WASM_TYPE_STRINGREF) {
if (!(stringref_obj =
gc_obj_malloc(heap_handle, sizeof(WASMStringrefObject)))) {
return NULL;
}
((WASMStringrefObjectRef)stringref_obj)->header =
(WASMObjectHeader)rtt_type;
((WASMStringrefObjectRef)stringref_obj)->str_obj = str_obj;
wasm_obj_set_gc_finalizer(
exec_env, (wasm_obj_t)stringref_obj,
(wasm_obj_finalizer_t)wasm_stringref_obj_finalizer, NULL);
}
else if (type == WASM_TYPE_STRINGVIEWWTF8) {
if (!(stringref_obj = gc_obj_malloc(
heap_handle, sizeof(WASMStringviewWTF8Object)))) {
return NULL;
}
((WASMStringviewWTF8ObjectRef)stringref_obj)->header =
(WASMObjectHeader)rtt_type;
((WASMStringviewWTF8ObjectRef)stringref_obj)->str_obj = str_obj;
wasm_obj_set_gc_finalizer(
exec_env, (wasm_obj_t)stringref_obj,
(wasm_obj_finalizer_t)wasm_stringview_wtf8_obj_finalizer, NULL);
}
else if (type == WASM_TYPE_STRINGVIEWWTF16) {
if (!(stringref_obj = gc_obj_malloc(
heap_handle, sizeof(WASMStringviewWTF16Object)))) {
return NULL;
}
((WASMStringviewWTF16ObjectRef)stringref_obj)->header =
(WASMObjectHeader)rtt_type;
((WASMStringviewWTF16ObjectRef)stringref_obj)->str_obj = str_obj;
wasm_obj_set_gc_finalizer(
exec_env, (wasm_obj_t)stringref_obj,
(wasm_obj_finalizer_t)wasm_stringview_wtf16_obj_finalizer, NULL);
}
else if (type == WASM_TYPE_STRINGVIEWITER) {
if (!(stringref_obj = gc_obj_malloc(
heap_handle, sizeof(WASMStringviewIterObject)))) {
return NULL;
}
((WASMStringviewIterObjectRef)stringref_obj)->header =
(WASMObjectHeader)rtt_type;
((WASMStringviewIterObjectRef)stringref_obj)->str_obj = str_obj;
((WASMStringviewIterObjectRef)stringref_obj)->pos = pos;
wasm_obj_set_gc_finalizer(
exec_env, (wasm_obj_t)stringref_obj,
(wasm_obj_finalizer_t)wasm_stringview_iter_obj_finalizer, NULL);
}
return stringref_obj;
}
WASMStringrefObjectRef
wasm_stringref_obj_new(WASMExecEnv *exec_env, const void *str_obj)
{
WASMStringrefObjectRef stringref_obj;
stringref_obj = (WASMStringrefObjectRef)stringref_obj_new(
exec_env, WASM_TYPE_STRINGREF, str_obj, 0);
return stringref_obj;
}
WASMStringviewWTF8ObjectRef
wasm_stringview_wtf8_obj_new(WASMExecEnv *exec_env, const void *str_obj)
{
WASMStringviewWTF8ObjectRef stringview_wtf8_obj;
stringview_wtf8_obj = (WASMStringviewWTF8ObjectRef)stringref_obj_new(
exec_env, WASM_TYPE_STRINGVIEWWTF8, str_obj, 0);
return stringview_wtf8_obj;
}
WASMStringviewWTF16ObjectRef
wasm_stringview_wtf16_obj_new(WASMExecEnv *exec_env, const void *str_obj)
{
WASMStringviewWTF16ObjectRef stringview_wtf16_obj;
stringview_wtf16_obj = (WASMStringviewWTF16ObjectRef)stringref_obj_new(
exec_env, WASM_TYPE_STRINGVIEWWTF16, str_obj, 0);
return stringview_wtf16_obj;
}
WASMStringviewIterObjectRef
wasm_stringview_iter_obj_new(WASMExecEnv *exec_env, const void *str_obj,
int32 pos)
{
WASMStringviewIterObjectRef stringview_iter_obj;
stringview_iter_obj = (WASMStringviewIterObjectRef)stringref_obj_new(
exec_env, WASM_TYPE_STRINGVIEWITER, str_obj, pos);
return stringview_iter_obj;
}
const void *
wasm_stringref_obj_get_value(WASMStringrefObjectRef stringref_obj)
{
return stringref_obj->str_obj;
}
const void *
wasm_stringview_wtf8_obj_get_value(
WASMStringviewWTF8ObjectRef stringview_wtf8_obj)
{
return stringview_wtf8_obj->str_obj;
}
const void *
wasm_stringview_wtf16_obj_get_value(
WASMStringviewWTF16ObjectRef stringview_wtf16_obj)
{
return stringview_wtf16_obj->str_obj;
}
const void *
wasm_stringview_iter_obj_get_value(
WASMStringviewIterObjectRef stringview_iter_obj)
{
return stringview_iter_obj->str_obj;
}
int32
wasm_stringview_iter_obj_get_pos(
WASMStringviewIterObjectRef stringview_iter_obj)
{
return stringview_iter_obj->pos;
}
void
wasm_stringview_iter_obj_update_pos(
WASMStringviewIterObjectRef stringview_iter_obj, int32 pos)
{
stringview_iter_obj->pos = pos;
}
#define WASM_OBJ_IS_STRINGREF_IMPL(flag) \
WASMRttTypeRef rtt_type; \
\
bh_assert(obj); \
\
if (wasm_obj_is_i31_externref_or_anyref_obj(obj)) \
return false; \
\
rtt_type = (WASMRttTypeRef)wasm_object_header(obj); \
return rtt_type->type_flag == flag ? true : false
bool
wasm_obj_is_stringref_obj(WASMObjectRef obj)
{
WASM_OBJ_IS_STRINGREF_IMPL(WASM_TYPE_STRINGREF);
}
bool
wasm_obj_is_stringview_wtf8_obj(WASMObjectRef obj)
{
WASM_OBJ_IS_STRINGREF_IMPL(WASM_TYPE_STRINGVIEWWTF8);
}
bool
wasm_obj_is_stringview_wtf16_obj(WASMObjectRef obj)
{
WASM_OBJ_IS_STRINGREF_IMPL(WASM_TYPE_STRINGVIEWWTF16);
}
#undef WASM_OBJ_IS_STRINGREF_IMPL
#endif /* end of WASM_ENABLE_STRINGREF != 0 */
Reference in New Issue View Git Blame Copy Permalink