feat: interface to value

Author: weiwenhao

runtime/collector.c

@@ -350,8 +350,14 @@ static void scan_stack(n_processor_t *p, coroutine_t *co) {
     }
 
 
-    if (co->error) {
-        insert_gc_worklist(worklist, co->error);
+    if (co->has_error) {
+        if (co->error.value.ptr_value && span_of((addr_t) co->error.value.ptr_value)) {
+            insert_gc_worklist(worklist, co->error.value.ptr_value);
+        }
+
+        if (co->error.methods && span_of((addr_t) co->error.methods)) {
+            insert_gc_worklist(worklist, co->error.methods);
+        }
     }
 
     if (co->traces.data && span_of((addr_t) co->traces.data)) {

runtime/nutils/errort.h

@@ -26,15 +26,16 @@ static inline n_string_t rti_error_msg(n_interface_t *error) {
  * @param has
  * @return
  */
-static inline n_interface_t *n_error_new(n_string_t msg, uint8_t panic) {
+static inline n_interface_t n_error_new(n_string_t msg, uint8_t panic) {
     n_errort *errort = rti_gc_malloc(errort_rtype.gc_heap_size, &errort_rtype);
     errort->msg = msg;
     errort->panic = panic;
     DEBUGF("[runtime.n_error_new] errort=%p, msg=%p, panic=%d", errort, msg, panic);
 
     // interface casting, error to interface union
     int64_t methods[1] = {(int64_t) errort_msg};
-    n_interface_t *result = interface_casting(errort_rtype.hash, errort, 1, methods);
+    n_interface_t result = {0};
+    interface_casting(&result, errort_rtype.hash, errort, 1, methods);
 
     return result;
 }

runtime/nutils/fs.c

@@ -125,7 +125,7 @@ fs_context_t *rt_uv_fs_open(n_string_t path, int64_t flags, int64_t mode) {
 
     global_waiting_send(uv_async_fs_open, ctx, rt_string_ref(&path), 0);
     if (co->has_error) {
-        n_string_t msg = rti_error_msg(co->error);
+        n_string_t msg = rti_error_msg(&co->error);
         DEBUGF("[fs_open] open file failed: %s", (char *) rt_string_ref(&msg));
         return NULL;
     } else {
@@ -165,7 +165,7 @@ n_int_t rt_uv_fs_read_at(fs_context_t *ctx, n_vec_t buf, int offset) {
     global_waiting_send(uv_async_fs_read_at, ctx, (void *) offset, 0);
 
     if (co->has_error) {
-        n_string_t msg = rti_error_msg(co->error);
+        n_string_t msg = rti_error_msg(&co->error);
         DEBUGF("[rt_uv_fs_read] read file failed: %s", (char *) rt_string_ref(&msg));
         return 0;
     } else {
@@ -200,7 +200,7 @@ n_int_t rt_uv_fs_write_at(fs_context_t *ctx, n_vec_t buf, int offset) {
     global_waiting_send(uv_async_fs_write_at, ctx, &buf, (void *) (int64_t) offset);
 
     if (co->has_error) {
-        n_string_t msg = rti_error_msg(co->error);
+        n_string_t msg = rti_error_msg(&co->error);
         DEBUGF("[fs_write_at] write file failed: %s", (char *) rt_string_ref(&msg));
     } else {
         DEBUGF("[fs_write_at] write file success");
@@ -288,7 +288,7 @@ uv_stat_t rt_uv_fs_stat(fs_context_t *ctx) {
     global_waiting_send(uv_async_fs_stat, ctx, co, 0);
 
     if (co->has_error) {
-        n_string_t msg = rti_error_msg(co->error);
+        n_string_t msg = rti_error_msg(&co->error);
         DEBUGF("[rt_uv_fs_stat] stat file failed: %s", (char *) rt_string_ref(&msg));
     } else {
         DEBUGF("[rt_uv_fs_stat] stat file success");

runtime/nutils/nutils.c

@@ -126,61 +126,60 @@ bool interface_is(n_interface_t *mu, int64_t target_rtype_hash) {
 }
 
 /**
- * union 参考 env 中的 upvalue 处理超过 8byte 的数据
+ * interface 参考 any 处理 storage_ind 类型
+ * @param out
  * @param input_rtype_hash
- * @param value
- * @return
+ * @param value_ref
+ * @param method_count
+ * @param methods
  */
-n_interface_t *interface_casting(uint64_t input_rtype_hash, void *value_ref, int64_t method_count, int64_t *methods) {
+void interface_casting(n_interface_t *out, uint64_t input_rtype_hash, void *value_ref, int64_t method_count, int64_t *methods) {
+    assert(out && "interface_casting out is null");
     // - 根据 input_rtype_hash 找到对应的
     rtype_t *rtype = rt_find_rtype(input_rtype_hash);
     assert(rtype && "cannot find rtype by hash");
 
     ASSERT_ADDR(value_ref);
 
-    TRACEF("[union_casting] input_kind=%s", type_kind_str[rtype->kind]);
-
-
-    rtype_t interface_rtype = GC_RTYPE(TYPE_INTERFACE, 4, TYPE_GC_SCAN, TYPE_GC_SCAN, TYPE_GC_NOSCAN, TYPE_GC_NOSCAN);
-
-    // any_t 在 element_rtype list 中是可以预注册的，因为其 gc_bits 不会变来变去的，都是恒定不变的！
-    n_interface_t *mu = rti_gc_malloc(sizeof(n_interface_t), &interface_rtype);
+    TRACEF("[interface_casting] input_kind=%s", type_kind_str[rtype->kind]);
 
     if (method_count > 0) {
-        mu->method_count = method_count;
-        mu->methods = (int64_t *) rti_array_new(&uint64_rtype, method_count);
+        out->method_count = method_count;
+        out->methods = (int64_t *) rti_array_new(&uint64_rtype, method_count);
         // 进行数据 copy TODO write barrier
-        memmove(mu->methods, methods, method_count * POINTER_SIZE);
+        memmove(out->methods, methods, method_count * POINTER_SIZE);
+    } else {
+        out->method_count = 0;
+        out->methods = NULL;
     }
 
     DEBUGF(
         "[interface_casting] union_base: %p, memmove value_ref(%p) -> any->value(%p), size=%lu, fetch_value_8byte=%p",
-        mu, value_ref,
-        &mu->value, rtype->stack_size, (void *) fetch_addr_value((addr_t) value_ref));
+        out, value_ref,
+        &out->value, rtype->storage_size, (void *) fetch_addr_value((addr_t) value_ref));
 
-    mu->rtype = rtype;
+    out->rtype = rtype;
     uint64_t stack_size = rtype->storage_size;
+    out->value.i64_value = 0;
 
     if (rtype->storage_kind != STORAGE_KIND_PTR) {
         // TODO number 可以直接存储在 value 中
         // union 进行了数据的额外缓存，并进行值 copy，不需要担心 arr/struct 这样的大数据的丢失问题
         void *new_value = rti_gc_malloc(rtype->gc_heap_size, rtype);
         memmove(new_value, value_ref, stack_size);
-        rti_write_barrier_ptr(&mu->value.ptr_value, new_value, false);
+        out->value.ptr_value = new_value;
     } else {
         // 特殊类型参数处理，为了兼容 fn method 中的 self 自动化参数, self 如果是 int/struct 等类型，会自动转换为 ref<int>
         // 如果是 vec/string 等类型，self 的类型依旧是 vec/string 等，而不是 ref<vec>/ref<string> 这有点多余, 因为 vec/string
         // 本来就是在堆中分配的, 传递的是一个指针, 虽然后续可以能会进行统一处理，但是目前还是需要进行特殊处理，value 中直接存放可以作为
         // fn method 传递的参数
-        memmove(&mu->value, value_ref, stack_size);
+        memmove(&out->value, value_ref, stack_size);
     }
 
     DEBUGF("[interface_casting] success, union_base: %p, union_rtype: %p, union_i64_value: %ld, union_ptr_value: %p",
-           mu,
-           mu->rtype,
-           mu->value.i64_value, mu->value.ptr_value);
-
-    return mu;
+           out,
+           out->rtype,
+           out->value.i64_value, out->value.ptr_value);
 }
 
 /**
@@ -488,7 +487,7 @@ void co_throw_error(n_interface_t *error, char *path, char *fn_name, n_int_t lin
     };
     rt_vec_push(&co->traces, errort_trace_rtype.hash, &trace);
 
-    rti_write_barrier_ptr(&co->error, error, false);
+    rti_write_barrier_rtype(&co->error, error, &throwable_rtype);
     co->has_error = true;
 }
 
@@ -504,10 +503,10 @@ void throw_index_out_error(n_int_t *index, n_int_t *len, n_bool_t be_catch) {
     char *msg = tlsprintf("index out of range [%d] with length %d", index, len);
 
     if (be_catch) {
-        n_interface_t *error = n_error_new(string_new(msg, strlen(msg)), true);
-        assert(error->method_count == 1);
+        n_interface_t error = n_error_new(string_new(msg, strlen(msg)), true);
+        assert(error.method_count == 1);
 
-        DEBUGF("[runtime.co_throw_error_msg] co=%p, error=%p, msg=%s", co, (void *) error, (char *) msg);
+        DEBUGF("[runtime.co_throw_error_msg] co=%p, error=%p, msg=%s", co, (void *) &error, (char *) msg);
 
         assert(co->traces.data == NULL);
 
@@ -522,7 +521,7 @@ void throw_index_out_error(n_int_t *index, n_int_t *len, n_bool_t be_catch) {
             .column = caller->column,
         };
         rt_vec_push(&co->traces, errort_trace_rtype.hash, &trace);
-        rti_write_barrier_ptr(&co->error, error, false);
+        rti_write_barrier_rtype(&co->error, &error, &throwable_rtype);
         co->has_error = true;
     } else {
         char *copy_msg = strdup(msg);
@@ -531,15 +530,16 @@ void throw_index_out_error(n_int_t *index, n_int_t *len, n_bool_t be_catch) {
     }
 }
 
-n_interface_t *co_remove_error() {
+n_interface_t co_remove_error() {
     coroutine_t *co = coroutine_get();
 
-    assert(co->error);
+    assert(co->has_error);
     co->has_error = false;
 
-    n_interface_t *error = co->error;
+    n_interface_t error = co->error;
 
-    rti_write_barrier_ptr(&co->error, NULL, false);
+    n_interface_t empty = {0};
+    rti_write_barrier_rtype(&co->error, &empty, &throwable_rtype);
     co->traces = (n_vec_t){0};
     return error;
 }
@@ -569,11 +569,11 @@ uint8_t co_has_panic(bool be_catch, char *path, char *fn_name, n_int_t line, n_i
         return 1;
     }
 
-    assert(co->error);
+    assert(co->has_error);
 
     // 在 runtime 调用 nature 代码， rti_error_msg 会让 gc scan_stack 异常，不过马上就要退出了，问题不大
     // 可以考虑增加 safepoint_lock, 避免进入 safepoint 状态
-    n_string_t msg = rti_error_msg(co->error);
+    n_string_t msg = rti_error_msg(&co->error);
 
     char *dump_msg;
     if (co->main) {

runtime/nutils/nutils.h

@@ -39,7 +39,7 @@ void union_to_any(n_any_t *out, n_union_t *input);
 
 void tagged_union_casting(n_tagged_union_t *out, int64_t id, int64_t value_rtype_hash, void *value_ref);
 
-n_interface_t *interface_casting(uint64_t input_rtype_hash, void *value_ref, int64_t method_count, int64_t *methods);
+void interface_casting(n_interface_t *out, uint64_t input_rtype_hash, void *value_ref, int64_t method_count, int64_t *methods);
 
 int64_t iterator_next_key(void *iterator, uint64_t rtype_hash, int64_t cursor, void *key_ref);
 
@@ -51,7 +51,7 @@ void co_throw_error(n_interface_t *error, char *path, char *fn_name, n_int_t lin
 
 void throw_index_out_error(n_int_t *index, n_int_t *len, n_bool_t be_catch);
 
-n_interface_t *co_remove_error();
+n_interface_t co_remove_error();
 
 uint8_t co_has_error(char *path, char *fn_name, n_int_t line, n_int_t column);
 

runtime/nutils/process.h

@@ -19,9 +19,9 @@ typedef struct {
     n_string_t cwd;
     n_vec_t env;
 
-    n_interface_t *io_stdin;
-    n_interface_t *io_stdout;
-    n_interface_t *io_stderr;
+    n_interface_t io_stdin;
+    n_interface_t io_stdout;
+    n_interface_t io_stderr;
 } command_t;
 
 typedef struct {

runtime/processor.c

@@ -250,13 +250,13 @@ NO_OPTIMIZE static void coroutine_wrapper() {
 
 
     DEBUGF(
-            "[runtime.coroutine_wrapper] user fn completed, p_index=%d co=%p, main=%d, rt_fn=%d,err=%p",
+            "[runtime.coroutine_wrapper] user fn completed, p_index=%d co=%p, main=%d, rt_fn=%d,has_error=%d",
             p->index, co,
-            co->main, co->flag & FLAG(CO_FLAG_RTFN), co->error);
+            co->main, co->flag & FLAG(CO_FLAG_RTFN), co->has_error);
 
 
     // coroutine 即将退出，避免被 gc 清理，所以将 error保存在 co->future 中?
-    if (co->error && co->future) {
+    if (co->has_error && co->future) {
         union_casting(&co->future->error, throwable_rtype.hash, &co->error); // 将 co error 赋值给 co->future 避免被 gc
     }
 
@@ -616,30 +616,30 @@ coroutine_t *coroutine_get() {
 void rti_throw(char *msg, bool panic) {
     DEBUGF("[runtime.rti_throw] msg=%s", msg);
     coroutine_t *co = coroutine_get();
-    n_interface_t *error = n_error_new(string_new(msg, strlen(msg)), panic);
+    n_interface_t error = n_error_new(string_new(msg, strlen(msg)), panic);
 
     co->has_error = true;
     if (co->traces.data == NULL) {
         n_vec_t traces = rti_vec_new(&errort_trace_rtype, 0, 0);
         co->traces = traces;
     }
-    rti_write_barrier_ptr(&co->error, error, false);
+    rti_write_barrier_rtype(&co->error, &error, &throwable_rtype);
 }
 
 void rti_co_throw(coroutine_t *co, char *msg, bool panic) {
-    n_interface_t *error = n_error_new(string_new(msg, strlen(msg)), panic);
+    n_interface_t error = n_error_new(string_new(msg, strlen(msg)), panic);
     co->has_error = true;
     if (co->traces.data == NULL) {
         n_vec_t traces = rti_vec_new(&errort_trace_rtype, 0, 0);
         co->traces = traces;
     }
-    rti_write_barrier_ptr(&co->error, error, false);
+    rti_write_barrier_rtype(&co->error, &error, &throwable_rtype);
 }
 
 void coroutine_dump_error(coroutine_t *co) {
-    DEBUGF("[runtime.coroutine_dump_error] co=%p, errort base=%p", co, co->error);
+    DEBUGF("[runtime.coroutine_dump_error] co=%p, errort base=%p", co, &co->error);
 
-    n_string_t msg = rti_error_msg(co->error);
+    n_string_t msg = rti_error_msg(&co->error);
     DEBUGF("[runtime.coroutine_dump_error] memory_string len: %lu, base: %p", msg.length, msg.data);
 
     assert(co->traces.length > 0);
@@ -726,6 +726,10 @@ coroutine_t *rt_coroutine_new(void *fn, int64_t flag, n_future_t *fu, void *arg)
     co->status = CO_STATUS_RUNNABLE;
     co->p = NULL;
     co->next = NULL;
+    co->has_error = false;
+    co->error = (n_interface_t){0};
+    co->traces = (n_vec_t){0};
+    co->await_co = NULL;
     co->aco.inited = 0; // 标记为为初始化
 
     return co;

runtime/rtype.h

@@ -137,7 +137,7 @@ static inline void builtin_rtype_init() {
                                   TYPE_GC_NOSCAN, TYPE_GC_NOSCAN);
     sc_map_put_64v(&rt_rtype_map, errort_trace_rtype.hash, &errort_trace_rtype);
 
-    throwable_rtype = GC_RTYPE(TYPE_INTERFACE, 4, TYPE_GC_SCAN, TYPE_GC_NOSCAN, TYPE_GC_NOSCAN, TYPE_GC_SCAN);
+    throwable_rtype = GC_RTYPE(TYPE_INTERFACE, 4, TYPE_GC_SCAN, TYPE_GC_SCAN, TYPE_GC_NOSCAN, TYPE_GC_NOSCAN);
     sc_map_put_64v(&rt_rtype_map, throwable_rtype.hash, &throwable_rtype);
 
     // 初始化错误 rtype

runtime/runtime.h

@@ -421,7 +421,7 @@ struct coroutine_t {
     //    uint64_t scan_ret_addr;
 
     bool has_error;
-    n_interface_t *error; // throwable
+    n_interface_t error; // throwable
     n_vec_t traces; // element is n_trace_t
 
     ATOMIC int32_t select_done;