rt: Run resource destructors during cycle collection

Author: brson

src/rt/rust_cc.cpp

@@ -565,9 +565,26 @@ class sweep : public shape::data<sweep,shape::ptr> {
         }
     }
 
+    struct run_dtor_args {
+        const shape::rust_fn *dtor;
+        void *data;
+    };
+
+    typedef void (*dtor)(void **retptr, void *env, void *dptr);
+
+    static void run_dtor(run_dtor_args *args) {
+        dtor f = (dtor)args->dtor;
+        f(NULL, args->dtor->env, args->data);
+    }
+
     void walk_res2(const shape::rust_fn *dtor, unsigned n_params,
                    const shape::type_param *params, const uint8_t *end_sp,
                    bool live) {
+        void *data = (void*)(uintptr_t)dp;
+        // Switch back to the Rust stack to run the destructor
+        run_dtor_args args = {dtor, data};
+        task->call_on_rust_stack((void*)&args, (void*)run_dtor);
+
         while (this->sp != end_sp) {
             this->walk();
             align = true;

src/rt/rust_task.h

@@ -252,6 +252,7 @@ rust_task : public kernel_owned<rust_task>, rust_cond
     void prev_stack();
     void record_stack_limit();
     void reset_stack_limit();
+    
     bool on_rust_stack();
     void check_stack_canary();
     void delete_all_stacks();
@@ -334,6 +335,7 @@ inline void
 rust_task::call_on_rust_stack(void *args, void *fn_ptr) {
     // Too expensive to check
     // I(thread, !on_rust_stack());
+    A(thread, get_sp_limit() != 0, "Stack must be configured");
     I(thread, next_rust_sp);
 
     bool had_reentered_rust_stack = reentered_rust_stack;
@@ -344,6 +346,8 @@ rust_task::call_on_rust_stack(void *args, void *fn_ptr) {
 
     uintptr_t sp = sanitize_next_sp(next_rust_sp);
 
+    // FIXME(2047): There are times when this is called and needs
+    // to be able to throw, and we don't account for that.
     __morestack(args, fn_ptr, sp);
 
     next_c_sp = prev_c_sp;

src/test/run-pass/resource-cycle.rs

@@ -0,0 +1,30 @@
+// Don't leak the unique pointers
+
+resource r(v: *int) unsafe {
+    let v2: ~int = unsafe::reinterpret_cast(v);
+}
+
+enum t = {
+    mut next: option<@t>,
+    r: r
+};
+
+fn main() unsafe {
+    let i1 = ~0;
+    let i1p = unsafe::reinterpret_cast(i1);
+    unsafe::forget(i1);
+    let i2 = ~0;
+    let i2p = unsafe::reinterpret_cast(i2);
+    unsafe::forget(i2);
+
+    let x1 = @t({
+        mut next: none,
+        r: r(i1p)
+    });
+    let x2 = @t({
+        mut next: none,
+        r: r(i2p)
+    });
+    x1.next = some(x2);
+    x2.next = some(x1);
+}

src/test/run-pass/resource-cycle2.rs

@@ -0,0 +1,39 @@
+// Don't leak the unique pointers
+
+type u = {
+    a: int,
+    b: int,
+    c: *int
+};
+
+resource r(v: u) unsafe {
+    let v2: ~int = unsafe::reinterpret_cast(v.c);
+}
+
+enum t = {
+    mut next: option<@t>,
+    r: r
+};
+
+fn main() unsafe {
+    let i1 = ~0xA;
+    let i1p = unsafe::reinterpret_cast(i1);
+    unsafe::forget(i1);
+    let i2 = ~0xA;
+    let i2p = unsafe::reinterpret_cast(i2);
+    unsafe::forget(i2);
+
+    let u1 = {a: 0xB, b: 0xC, c: i1p};
+    let u2 = {a: 0xB, b: 0xC, c: i2p};
+
+    let x1 = @t({
+        mut next: none,
+        r: r(u1)
+    });
+    let x2 = @t({
+        mut next: none,
+        r: r(u2)
+    });
+    x1.next = some(x2);
+    x2.next = some(x1);
+}