Ensure yksom works safely with untraceable allocation

.gitignore

@@ -1,3 +1,5 @@
 Cargo.lock
 target/
 *.core
+rebench.conf
+rebench.data

Cargo.toml

@@ -38,7 +38,6 @@ arrayvec = "0.5"
 cfgrammar = "0.9"
 getopts = "0.2"
 itertools = "0.9"
-libgc = { git = "https://github.com/softdevteam/libgc" }
 lrlex = "0.9"
 lrpar = "0.9"
 natrob = { git="https://github.com/softdevteam/natrob", features=["libgc"] }

src/lib/mod.rs

@@ -15,6 +15,7 @@
 #![feature(arbitrary_self_types)]
 #![feature(box_patterns)]
 #![feature(coerce_unsized)]
+#![feature(negative_impls)]
 #![feature(dispatch_from_dyn)]
 #![feature(entry_insert)]
 #![feature(raw_ref_op)]

src/lib/vm/objects/array.rs

@@ -7,6 +7,8 @@ use std::{
 
 use std::gc::Gc;
 
+use std::gc::NoTrace;
+
 use crate::vm::{
     core::VM,
     error::{VMError, VMErrorKind},
@@ -44,6 +46,8 @@ pub struct NormalArray {
     len: usize,
 }
 
+impl !NoTrace for NormalArray {}
+
 // Since arrays have a fixed number of elements in their store, we do not need to allocate a separate
 // object and store: we can fit both in a single block. We thus use a custom layout where
 // the `NormalArray` comes first, followed immediately by a contiguous array of `Val`s. On a

src/lib/vm/somstack.rs

@@ -4,6 +4,8 @@ use std::gc::Gc;
 
 use crate::vm::{objects::NormalArray, val::Val};
 
+use std::gc::NoTrace;
+
 pub const SOM_STACK_LEN: usize = 4096;
 
 /// A contiguous stack of SOM values. This stack does minimal or no checking on important
@@ -34,6 +36,8 @@ pub struct SOMStack {
     len: Cell<usize>,
 }
 
+impl !NoTrace for SOMStack {}
+
 macro_rules! storage {
     ($self:ident) => {
         // We assume that the stack immediately follows the `SOMStack` without padding. This

src/lib/vm/val.rs

@@ -14,6 +14,8 @@ use num_enum::{IntoPrimitive, UnsafeFromPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 use std::gc::Gc;
 
+use std::gc::NoTrace;
+
 use super::{
     core::VM,
     error::{VMError, VMErrorKind},
@@ -65,6 +67,8 @@ pub struct Val {
     pub val: usize,
 }
 
+impl !NoTrace for Val {}
+
 impl Val {
     /// Create a new `Val` from an object that should be allocated on the heap.
     pub fn from_obj<T: Obj + 'static>(obj: T) -> Val {