mini_racer 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e73ac3193df3f33b51463ba1125ac4eee312caecd47833c545e098ba91d11ece
-  data.tar.gz: d6d754829b36953d239ba85e84d2fc88c0af3ccbadd3f8d2e4cd9759bd24fab2
+  metadata.gz: 5d56d838af805799a79c79077af28cd6f141a236407b974d74fb2a9b9ccc012a
+  data.tar.gz: 930da203d2f0a9370a586f838cde68306fa3de03bb1114d887426457277c4682
 SHA512:
-  metadata.gz: 52a0799d84be10bb03774789b3d12d4f0fe2d4159d310b9c6a1ae3dcf878a99cd6b7c786fae813f29754a894ecf5fcc6b7e07834c0aba994a16da5c54d75595b
-  data.tar.gz: bc478bdb582d7b786d28754200063d7ef185396e0da23840f006679bc1af6707f54c7a719918360afa9b24c2b4ab083ca081e2b2d6853095ecd5949a9482ecbd
+  metadata.gz: caa253f750407e8bb4500105dcbe4318eafc8bf8bdf3dd4727efe5540fd273bd8e97d4f4f235b3d4c58e318687a255e88881c0dfe2b47ab67c91bfe801c8741a
+  data.tar.gz: 6dd05e37d3fc792f8f0b3e417023a0fd8e5dc3322a03528ac0b474b603a5d0a3551f791b57b83332ca24ea6596795ee9aaafa9e0d40e5f80e833a02e22ee3038

data/.github/workflows/ci.yml

@@ -29,8 +29,6 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
-          - '2.4'
-          - '2.5'
           - '2.6'
           - '2.7'
           - '3.0'

data/.gitignore

@@ -10,3 +10,4 @@ Gemfile.lock
 lib/mini_racer_extension.so
 lib/mini_racer_loader.so
 *.bundle
+.vscode/

data/.travis.yml

@@ -1,8 +1,6 @@
 language: ruby
 os: linux
 rvm:
-  - 2.4
-  - 2.5
   - 2.6
   - 2.7
   - 3.0
@@ -12,9 +10,6 @@ arch:
   - arm64
 jobs:
   include:
-    - rvm: 2.5
-      os: osx
-      osx_image: xcode9.4
     - rvm: 2.6
       os: osx
       osx_image: xcode11.3
@@ -25,7 +20,4 @@ jobs:
       os: osx
       osx_image: xcode12.2
 dist: xenial
-before_install:
-  - gem update --system
-  - gem install bundler -v 1.16.2
 cache: bundler

data/CHANGELOG

@@ -1,5 +1,26 @@
+- 31-12-2021
+
+- 0.6.1
+
+  - Added support for single threaded platform: `MiniRacer::Platform.set_flags! :single_threaded`
+  must be called prior to booting ANY MiniRacer::Context
+
+- 0.6.0
+
+   - Ruby 3.1 support
+   - Fixes memory leak in heap snapshotting
+   - Improved compilation ergonomics in clang
+   - Migrated internal storage in c extension to TypedData
+
 - 11-04-2021
 
+- 0.5.0
+  - Fixes issues on aarch (Apple M1)
+  - Update to use libv8-node 16.x (#210) [Loic Nageleisen]
+  - FEATURE: Configurable max marshal stack depth (#202) [seanmakesgames]
+  - FEATURE: Configurable max marshal stack depth (#202) [seanmakesgames]
+  - Ruby 2.3 and 2.4 are EOL, we no longer support them
+
 - 0.4.0
 
   - FEATURE: upgrade to libv8 node 15.14.0 (v8 8.6.395.17)

data/README.md

@@ -85,6 +85,19 @@ context.eval 'var a = new Array(10000); while(true) {a = a.concat(new Array(1000
 # => V8OutOfMemoryError is raised
 ```
 
+### Object marshal max stackdepth support
+
+Contexts can specify a stack depth limit for object marshalling. Max depth is unbounded by default.
+
+```ruby
+# terminates script if stack depth exceeds max during marshal
+context = MiniRacer::Context.new(marshal_stack_depth: 500)
+context.attach("a", proc{|a| a})
+
+context.eval("let arr = []; arr.push(arr); a(arr)")
+# => RuntimeError is raised
+```
+
 ### Rich debugging with "filename" support
 
 ```ruby
@@ -403,14 +416,14 @@ Or install it yourself as:
     $ gem install mini_racer
 
 
-**Note** using v8.h and compiling MiniRacer requires a C++11 standard compiler, more specifically clang 3.5 (or later) or gcc 4.8 (or later).
+**Note** using v8.h and compiling MiniRacer requires a C++11 standard compiler, more specifically clang 3.5 (or later) or GCC 6.3 (or later).
 
 
 ## Travis-ci
 
-To install `mini-racer` you will need a version of gcc that supports C++11 (gcc 4.8) this is included by default in ubuntu trusty based images.
+To install `mini-racer` you will need a version of GCC that supports C++11 (GCC 6.3) this is included by default in ubuntu trusty based images.
 
-Travis today ships by default with a precise based image. Precise Pangolin (12.04 LTS) was first released in August 2012. Even though you can install GCC 4.8 on precise the simpler approach is to opt for the trusty based image.
+Travis today ships by default with a precise based image. Precise Pangolin (12.04 LTS) was first released in August 2012. Even though you can install GCC 6.3 on precise the simpler approach is to opt for the trusty based image.
 
 Add this to your .travis.yml file:
 

data/Rakefile

@@ -92,5 +92,5 @@ task :lint do
               portability-*
               readability-*).join(',')
 
-  sh RbConfig::expand("clang-tidy -checks='#{checks}' ext/mini_racer_extension/mini_racer_extension.cc -- #$INCFLAGS #$CPPFLAGS", conf)
+  sh RbConfig::expand("clang-tidy -checks='#{checks}' ext/mini_racer_extension/mini_racer_extension.cc -- #$INCFLAGS #$CXXFLAGS", conf)
 end

data/ext/mini_racer_extension/extconf.rb

@@ -7,18 +7,25 @@ IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 
 have_library('pthread')
 have_library('objc') if IS_DARWIN
-$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
-$CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
-$CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
-$CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or IS_DARWIN
-$CPPFLAGS += " -std=c++0x"
-$CPPFLAGS += " -fpermissive"
-$CPPFLAGS += " -DV8_COMPRESS_POINTERS"
-$CPPFLAGS += " -fvisibility=hidden "
-
-$CPPFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
-
-$LDFLAGS.insert(0, " -stdlib=libc++ ") if IS_DARWIN
+$CXXFLAGS += " -Wall" unless $CXXFLAGS.split.include? "-Wall"
+$CXXFLAGS += " -g" unless $CXXFLAGS.split.include? "-g"
+$CXXFLAGS += " -rdynamic" unless $CXXFLAGS.split.include? "-rdynamic"
+$CXXFLAGS += " -fPIC" unless $CXXFLAGS.split.include? "-rdynamic" or IS_DARWIN
+$CXXFLAGS += " -std=c++14"
+$CXXFLAGS += " -fpermissive"
+#$CXXFLAGS += " -DV8_COMPRESS_POINTERS"
+$CXXFLAGS += " -fvisibility=hidden "
+
+# __declspec gets used by clang via ruby 3.x headers...
+$CXXFLAGS += " -fms-extensions"
+
+$CXXFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
+
+if IS_DARWIN
+  $LDFLAGS.insert(0, " -stdlib=libc++ ")
+else
+  $LDFLAGS.insert(0, " -lstdc++ ")
+end
 
 # check for missing symbols at link time
 # $LDFLAGS += " -Wl,--no-undefined " unless IS_DARWIN
@@ -64,7 +71,7 @@ end
 Libv8::Node.configure_makefile
 
 if enable_config('asan')
-  $CPPFLAGS.insert(0, " -fsanitize=address ")
+  $CXXFLAGS.insert(0, " -fsanitize=address ")
   $LDFLAGS.insert(0, " -fsanitize=address ")
 end
 

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -11,6 +11,7 @@
 #include <mutex>
 #include <atomic>
 #include <math.h>
+#include <errno.h>
 
 using namespace v8;
 
@@ -115,6 +116,7 @@ typedef struct {
     useconds_t timeout;
     EvalResult* result;
     size_t max_memory;
+    size_t marshal_stackdepth;
 } EvalParams;
 
 typedef struct {
@@ -126,13 +128,152 @@ typedef struct {
     Local<Value> *argv;
     EvalResult result;
     size_t max_memory;
+    size_t marshal_stackdepth;
 } FunctionCall;
 
-enum IsolateFlags {
-    IN_GVL,
-    DO_TERMINATE,
-    MEM_SOFTLIMIT_VALUE,
-    MEM_SOFTLIMIT_REACHED,
+class IsolateData {
+public:
+    enum Flag {
+        // first flags are bitfield
+        //  max count: sizeof(uintptr_t) * 8
+        IN_GVL, // whether we are inside of ruby gvl or not
+        DO_TERMINATE, // terminate as soon as possible
+        MEM_SOFTLIMIT_REACHED, // we've hit the memory soft limit
+        MEM_SOFTLIMIT_MAX, // maximum memory value
+        MARSHAL_STACKDEPTH_REACHED, // we've hit our max stack depth
+        MARSHAL_STACKDEPTH_VALUE, // current stackdepth
+        MARSHAL_STACKDEPTH_MAX, // maximum stack depth during marshal
+    };
+
+    static void Init(Isolate *isolate) {
+        // zero out all fields in the bitfield
+        isolate->SetData(0, 0);
+    }
+
+    static uintptr_t Get(Isolate *isolate, Flag flag) {
+        Bitfield u = { reinterpret_cast<uint64_t>(isolate->GetData(0)) };
+        switch (flag) {
+            case IN_GVL: return u.IN_GVL;
+            case DO_TERMINATE: return u.DO_TERMINATE;
+            case MEM_SOFTLIMIT_REACHED: return u.MEM_SOFTLIMIT_REACHED;
+            case MEM_SOFTLIMIT_MAX: return static_cast<uintptr_t>(u.MEM_SOFTLIMIT_MAX) << 10;
+            case MARSHAL_STACKDEPTH_REACHED: return u.MARSHAL_STACKDEPTH_REACHED;
+            case MARSHAL_STACKDEPTH_VALUE: return u.MARSHAL_STACKDEPTH_VALUE;
+            case MARSHAL_STACKDEPTH_MAX: return u.MARSHAL_STACKDEPTH_MAX;
+        }
+
+	// avoid compiler warning
+	return u.IN_GVL;
+    }
+
+    static void Set(Isolate *isolate, Flag flag, uintptr_t value) {
+        Bitfield u = { reinterpret_cast<uint64_t>(isolate->GetData(0)) };
+        switch (flag) {
+            case IN_GVL: u.IN_GVL = value; break;
+            case DO_TERMINATE: u.DO_TERMINATE = value; break;
+            case MEM_SOFTLIMIT_REACHED: u.MEM_SOFTLIMIT_REACHED = value; break;
+            // drop least significant 10 bits 'store memory amount in kb'
+            case MEM_SOFTLIMIT_MAX: u.MEM_SOFTLIMIT_MAX = value >> 10; break;
+            case MARSHAL_STACKDEPTH_REACHED: u.MARSHAL_STACKDEPTH_REACHED = value; break;
+            case MARSHAL_STACKDEPTH_VALUE: u.MARSHAL_STACKDEPTH_VALUE = value; break;
+            case MARSHAL_STACKDEPTH_MAX: u.MARSHAL_STACKDEPTH_MAX = value; break;
+        }
+        isolate->SetData(0, reinterpret_cast<void*>(u.dataPtr));
+    }
+
+private:
+    struct Bitfield {
+        // WARNING: this would explode on platforms below 64 bit ptrs
+        //  compiler will fail here, making it clear for them.
+        //  Additionally, using the other part of the union to reinterpret the
+        //  memory is undefined behavior according to spec, but is / has been stable
+        //  across major compilers for decades.
+        static_assert(sizeof(uintptr_t) >= sizeof(uint64_t), "mini_racer not supported on this platform. ptr size must be at least 64 bit.");
+        union {
+            uint64_t dataPtr: 64;
+            // order in this struct matters. For cpu performance keep larger subobjects
+            //  aligned on their boundaries (8 16 32), try not to straddle
+            struct {
+                size_t MEM_SOFTLIMIT_MAX:22;
+                bool IN_GVL:1;
+                bool DO_TERMINATE:1;
+                bool MEM_SOFTLIMIT_REACHED:1;
+                bool MARSHAL_STACKDEPTH_REACHED:1;
+                uint8_t :0; // align to next 8bit bound
+                size_t MARSHAL_STACKDEPTH_VALUE:10;
+                uint8_t :0; // align to next 8bit bound
+                size_t MARSHAL_STACKDEPTH_MAX:10;
+            };
+        };
+    };
+};
+
+struct StackCounter {
+    static void Reset(Isolate* isolate) {
+        if (IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX) > 0) {
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, 0);
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, false);
+        }
+    }
+
+    static void SetMax(Isolate* isolate, size_t marshalMaxStackDepth) {
+        if (marshalMaxStackDepth > 0) {
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX, marshalMaxStackDepth);
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, 0);
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, false);
+        }
+    }
+
+    StackCounter(Isolate* isolate) {
+        this->isActive = IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX) > 0;
+
+        if (this->isActive) {
+            this->isolate = isolate;
+            this->IncDepth(1);
+        }
+    }
+
+    bool IsTooDeep() {
+        if (!this->IsActive()) {
+            return false;
+        }
+
+        size_t depth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE);
+        size_t maxDepth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_MAX);
+        if (depth > maxDepth) {
+            IsolateData::Set(this->isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, true);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool IsActive() {
+        return this->isActive && !IsolateData::Get(this->isolate, IsolateData::DO_TERMINATE);
+    }
+
+    ~StackCounter() {
+        if (this->IsActive()) {
+            this->IncDepth(-1);
+        }
+    }
+
+private: 
+    Isolate* isolate;
+    bool isActive;
+
+    void IncDepth(int direction) {
+        int inc = direction > 0 ? 1 : -1;
+
+        size_t depth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE);
+
+        // don't decrement past 0
+        if (inc > 0 || depth > 0) {
+            depth += inc;
+        }
+
+        IsolateData::Set(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, depth);
+    }
 };
 
 static VALUE rb_cContext;
@@ -159,6 +300,29 @@ static pthread_rwlock_t exit_lock = PTHREAD_RWLOCK_INITIALIZER;
 static bool ruby_exiting = false; // guarded by exit_lock
 static bool single_threaded = false;
 
+static void mark_context(void *);
+static void deallocate(void *);
+static size_t context_memsize(const void *);
+static const rb_data_type_t context_type = {
+    "mini_racer/context_info",
+    { mark_context, deallocate, context_memsize }
+};
+
+static void deallocate_snapshot(void *);
+static size_t snapshot_memsize(const void *);
+static const rb_data_type_t snapshot_type = {
+    "mini_racer/snapshot_info",
+    { NULL, deallocate_snapshot, snapshot_memsize }
+};
+
+static void mark_isolate(void *);
+static void deallocate_isolate(void *);
+static size_t isolate_memsize(const void *);
+static const rb_data_type_t isolate_type = {
+    "mini_racer/isolate_info",
+    { mark_isolate, deallocate_isolate, isolate_memsize }
+};
+
 static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
     bool platform_already_initialized = false;
 
@@ -196,7 +360,11 @@ static void init_v8() {
 
     if (current_platform == NULL) {
         V8::InitializeICU();
-        current_platform = platform::NewDefaultPlatform();
+	if (single_threaded) {
+	    current_platform = platform::NewSingleThreadedDefaultPlatform();
+	} else {
+	    current_platform = platform::NewDefaultPlatform();
+	}
         V8::InitializePlatform(current_platform.get());
         V8::Initialize();
     }
@@ -205,16 +373,18 @@ static void init_v8() {
 }
 
 static void gc_callback(Isolate *isolate, GCType type, GCCallbackFlags flags) {
-    if((bool)isolate->GetData(MEM_SOFTLIMIT_REACHED)) return;
+    if (IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED)) {
+        return;
+    }
 
-    size_t softlimit = *(size_t*) isolate->GetData(MEM_SOFTLIMIT_VALUE);
+    size_t softlimit = IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_MAX);
 
     HeapStatistics stats;
     isolate->GetHeapStatistics(&stats);
     size_t used = stats.used_heap_size();
 
     if(used > softlimit) {
-        isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)true);
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, true);
         isolate->TerminateExecution();
     }
 }
@@ -311,7 +481,7 @@ static void prepare_result(MaybeLocal<Value> v8res,
     }
 }
 
-void*
+static void*
 nogvl_context_eval(void* arg) {
 
     EvalParams* eval_params = (EvalParams*)arg;
@@ -326,14 +496,15 @@ nogvl_context_eval(void* arg) {
     Context::Scope context_scope(context);
     v8::ScriptOrigin *origin = NULL;
 
-    // in gvl flag
-    isolate->SetData(IN_GVL, (void*)false);
-    // terminate ASAP
-    isolate->SetData(DO_TERMINATE, (void*)false);
-    // Memory softlimit
-    isolate->SetData(MEM_SOFTLIMIT_VALUE, (void*)false);
-    // Memory softlimit hit flag
-    isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)false);
+    IsolateData::Init(isolate);
+
+    if (eval_params->max_memory > 0) {
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_MAX, eval_params->max_memory);
+        if (!isolate_info->added_gc_cb) {
+            isolate->AddGCEpilogueCallback(gc_callback);
+            isolate_info->added_gc_cb = true;
+        }
+    }
 
     MaybeLocal<Script> parsed_script;
 
@@ -359,12 +530,8 @@ nogvl_context_eval(void* arg) {
         result->message->Reset(isolate, trycatch.Exception());
     } else {
         // parsing successful
-        if (eval_params->max_memory > 0) {
-            isolate->SetData(MEM_SOFTLIMIT_VALUE, &eval_params->max_memory);
-            if (!isolate_info->added_gc_cb) {
-            isolate->AddGCEpilogueCallback(gc_callback);
-                isolate_info->added_gc_cb = true;
-            }
+        if (eval_params->marshal_stackdepth > 0) {
+            StackCounter::SetMax(isolate, eval_params->marshal_stackdepth);
         }
 
         maybe_value = parsed_script.ToLocalChecked()->Run(context);
@@ -372,7 +539,7 @@ nogvl_context_eval(void* arg) {
 
     prepare_result(maybe_value, trycatch, isolate, context, *result);
 
-    isolate->SetData(IN_GVL, (void*)true);
+    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
 
     return NULL;
 }
@@ -390,6 +557,18 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
     Isolate::Scope isolate_scope(isolate);
     HandleScope scope(isolate);
 
+    StackCounter stackCounter(isolate);
+
+    if (IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED)) {
+        return Qnil;
+    }
+
+    if (stackCounter.IsTooDeep()) {
+        IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
+        isolate->TerminateExecution();
+        return Qnil;
+    }
+
     if (value->IsNull() || value->IsUndefined()){
         return Qnil;
     }
@@ -478,7 +657,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 	    rb_enc_find("utf-8")
 	);
 
-	return ID2SYM(rb_intern_str(str_symbol));
+	return rb_str_intern(str_symbol);
     }
 
     MaybeLocal<String> rstr_maybe = value->ToString(context);
@@ -543,7 +722,8 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
 	length = RARRAY_LEN(value);
 	array = Array::New(isolate, (int)length);
 	for(i=0; i<length; i++) {
-            array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
+            Maybe<bool> success = array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
+	    (void)(success);
 	}
 	return scope.Escape(array);
     case T_HASH:
@@ -552,8 +732,9 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
 	length = RARRAY_LEN(hash_as_array);
 	for(i=0; i<length; i++) {
 	    pair = rb_ary_entry(hash_as_array, i);
-            object->Set(context, convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
+            Maybe<bool> success = object->Set(context, convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
                   convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 1)));
+	    (void)(success);
 	}
 	return scope.Escape(object);
     case T_SYMBOL:
@@ -633,6 +814,7 @@ create_snapshot_data_blob(const char *embedded_source = nullptr) {
             SnapshotCreator::FunctionCodeHandling::kClear);
     }
 
+static
 StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
                                        const char *warmup_source) {
     // Use following steps to create a warmed up snapshot blob from a cold one:
@@ -668,14 +850,14 @@ StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
 
 static VALUE rb_snapshot_size(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     return INT2NUM(snapshot_info->raw_size);
 }
 
 static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     if(TYPE(str) != T_STRING) {
         rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
@@ -698,14 +880,14 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
 
 static VALUE rb_snapshot_dump(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     return rb_str_new(snapshot_info->data, snapshot_info->raw_size);
 }
 
 static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
     if(TYPE(str) != T_STRING) {
         rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
@@ -752,13 +934,13 @@ void IsolateInfo::init(SnapshotInfo* snapshot_info) {
 
 static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     init_v8();
 
     SnapshotInfo* snapshot_info = nullptr;
     if (!NIL_P(snapshot)) {
-        Data_Get_Struct(snapshot, SnapshotInfo, snapshot_info);
+        TypedData_Get_Struct(snapshot, SnapshotInfo, &snapshot_type, snapshot_info);
     }
 
     isolate_info->init(snapshot_info);
@@ -769,7 +951,7 @@ static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
 
 static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -780,7 +962,7 @@ static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
 
 static VALUE rb_isolate_low_memory_notification(VALUE self) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -790,7 +972,7 @@ static VALUE rb_isolate_low_memory_notification(VALUE self) {
 
 static VALUE rb_isolate_pump_message_loop(VALUE self) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -803,7 +985,7 @@ static VALUE rb_isolate_pump_message_loop(VALUE self) {
 
 static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     init_v8();
 
@@ -814,11 +996,11 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
 
         SnapshotInfo *snapshot_info = nullptr;
         if (!NIL_P(snap) && rb_obj_is_kind_of(snap, rb_cSnapshot)) {
-            Data_Get_Struct(snap, SnapshotInfo, snapshot_info);
+            TypedData_Get_Struct(snap, SnapshotInfo, &snapshot_type, snapshot_info);
         }
         isolate_info->init(snapshot_info);
     } else { // given isolate or snapshot
-        Data_Get_Struct(isolate, IsolateInfo, isolate_info);
+        TypedData_Get_Struct(isolate, IsolateInfo, &isolate_type, isolate_info);
     }
 
     context_info->isolate_info = isolate_info;
@@ -848,7 +1030,7 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
 static VALUE convert_result_to_ruby(VALUE self /* context */,
                                     EvalResult& result) {
     ContextInfo *context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     Isolate *isolate = context_info->isolate_info->isolate;
     Persistent<Context> *p_ctx = context_info->context;
@@ -884,9 +1066,14 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
     if (!result.executed) {
         VALUE ruby_exception = rb_iv_get(self, "@current_exception");
         if (ruby_exception == Qnil) {
-            bool mem_softlimit_reached = (bool)isolate->GetData(MEM_SOFTLIMIT_REACHED);
+            bool mem_softlimit_reached = IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED);
+            bool marshal_stack_maxdepth_reached = IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED);
             // If we were terminated or have the memory softlimit flag set
-            if (result.terminated || mem_softlimit_reached) {
+            if (marshal_stack_maxdepth_reached) {
+                ruby_exception = rb_eScriptRuntimeError;
+                std::string msg = std::string("Marshal object depth too deep. Script terminated.");
+                message = rb_enc_str_new(msg.c_str(), msg.length(), rb_enc_find("utf-8"));
+            } else if (result.terminated || mem_softlimit_reached) {
                 ruby_exception = mem_softlimit_reached ? rb_eV8OutOfMemoryError : rb_eScriptTerminatedError;
             } else {
                 ruby_exception = rb_eScriptRuntimeError;
@@ -921,6 +1108,7 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
             VALUE json_string = rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), rb_enc_find("utf-8"));
             ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
         } else {
+            StackCounter::Reset(isolate);
             ret = convert_v8_to_ruby(isolate, *p_ctx, tmp);
         }
 
@@ -943,7 +1131,7 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
     EvalResult eval_result;
     ContextInfo* context_info;
 
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     if(TYPE(str) != T_STRING) {
@@ -978,6 +1166,7 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
         eval_params.result = &eval_result;
         eval_params.timeout = 0;
         eval_params.max_memory = 0;
+        eval_params.marshal_stackdepth = 0;
         VALUE timeout = rb_iv_get(self, "@timeout");
         if (timeout != Qnil) {
             eval_params.timeout = (useconds_t)NUM2LONG(timeout);
@@ -988,6 +1177,11 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
             eval_params.max_memory = (size_t)NUM2ULONG(mem_softlimit);
         }
 
+        VALUE stack_depth = rb_iv_get(self, "@marshal_stack_depth");
+        if (stack_depth != Qnil) {
+            eval_params.marshal_stackdepth = (size_t)NUM2ULONG(stack_depth);
+        }
+
         eval_result.message = NULL;
         eval_result.backtrace = NULL;
 
@@ -1025,7 +1219,7 @@ VALUE rescue_callback(VALUE rdata, VALUE exception) {
     return exception;
 }
 
-void*
+static void*
 gvl_ruby_callback(void* data) {
 
     FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
@@ -1041,7 +1235,7 @@ gvl_ruby_callback(void* data) {
         HandleScope scope(args->GetIsolate());
         Local<External> external = Local<External>::Cast(args->Data());
 
-        self = *(VALUE*)(external->Value());
+        self = (VALUE)(external->Value());
         callback = rb_iv_get(self, "@callback");
 
         parent = rb_iv_get(self, "@parent");
@@ -1049,7 +1243,7 @@ gvl_ruby_callback(void* data) {
             return NULL;
         }
 
-        Data_Get_Struct(parent, ContextInfo, context_info);
+        TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
 
         if (length > 0) {
             ruby_args = rb_ary_tmp_new(length);
@@ -1057,6 +1251,7 @@ gvl_ruby_callback(void* data) {
 
         for (int i = 0; i < length; i++) {
             Local<Value> value = ((*args)[i]).As<Value>();
+            StackCounter::Reset(args->GetIsolate());
             VALUE tmp = convert_v8_to_ruby(args->GetIsolate(),
                                            *context_info->context, value);
             rb_ary_push(ruby_args, tmp);
@@ -1070,20 +1265,22 @@ gvl_ruby_callback(void* data) {
     callback_data.ruby_args = ruby_args;
     callback_data.failed = false;
 
-    if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
+    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
         args->GetIsolate()->ThrowException(
                     String::NewFromUtf8Literal(args->GetIsolate(),
                                                "Terminated execution during transition from Ruby to JS"));
         args->GetIsolate()->TerminateExecution();
         if (length > 0) {
             rb_ary_clear(ruby_args);
-            rb_gc_force_recycle(ruby_args);
         }
         return NULL;
     }
 
-    result = rb_rescue2((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
-            (VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
+    VALUE callback_data_value = (VALUE)&callback_data;
+
+    // TODO: use rb_vrescue2 in Ruby 2.7 and above
+    result = rb_rescue2(protected_callback, callback_data_value,
+            rescue_callback, callback_data_value, rb_eException, (VALUE)0);
 
     if(callback_data.failed) {
         rb_iv_set(parent, "@current_exception", result);
@@ -1097,26 +1294,24 @@ gvl_ruby_callback(void* data) {
 
     if (length > 0) {
         rb_ary_clear(ruby_args);
-        rb_gc_force_recycle(ruby_args);
     }
 
-    if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
-      Isolate* isolate = args->GetIsolate();
-      isolate->TerminateExecution();
+    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
+      args->GetIsolate()->TerminateExecution();
     }
 
     return NULL;
 }
 
 static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-    bool has_gvl = (bool)args.GetIsolate()->GetData(IN_GVL);
+    bool has_gvl = IsolateData::Get(args.GetIsolate(), IsolateData::IN_GVL);
 
     if(has_gvl) {
         gvl_ruby_callback((void*)&args);
     } else {
-        args.GetIsolate()->SetData(IN_GVL, (void*)true);
+        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, true);
         rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
-        args.GetIsolate()->SetData(IN_GVL, (void*)false);
+        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, false);
     }
 }
 
@@ -1133,7 +1328,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     bool parse_error = false;
     bool attach_error = false;
 
-    Data_Get_Struct(parent, ContextInfo, context_info);
+    TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     {
@@ -1149,20 +1344,18 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
                                 NewStringType::kNormal, (int)RSTRING_LEN(name))
                 .ToLocalChecked();
 
-        // copy self so we can access from v8 external
-        VALUE* self_copy;
-        Data_Get_Struct(self, VALUE, self_copy);
-        *self_copy = self;
-
-        Local<Value> external = External::New(isolate, self_copy);
+        // Note that self (rb_cExternalFunction) is a pure Ruby T_OBJECT,
+        // not a T_DATA type like most other classes in this file
+        Local<Value> external = External::New(isolate, (void *)self);
 
         if (parent_object == Qnil) {
-            context->Global()->Set(
+            Maybe<bool> success = context->Global()->Set(
                         context,
                         v8_str,
                         FunctionTemplate::New(isolate, ruby_callback, external)
                             ->GetFunction(context)
                             .ToLocalChecked());
+	    (void)success;
 
         } else {
             Local<String> eval =
@@ -1182,12 +1375,13 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
                 if (!maybe_value.IsEmpty()) {
                     Local<Value> value = maybe_value.ToLocalChecked();
                     if (value->IsObject()) {
-                        value.As<Object>()->Set(
+                        Maybe<bool> success = value.As<Object>()->Set(
                                     context,
                                     v8_str,
                                     FunctionTemplate::New(isolate, ruby_callback, external)
                                         ->GetFunction(context)
                                         .ToLocalChecked());
+			(void)success;
                     attach_error = false;
                     }
                 }
@@ -1209,7 +1403,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
 static VALUE rb_context_isolate_mutex(VALUE self) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     if (!context_info->isolate_info) {
         rb_raise(rb_eScriptRuntimeError, "Context has no Isolate available anymore");
@@ -1319,6 +1513,11 @@ static void mark_isolate(void* data) {
     isolate_info->mark();
 }
 
+static size_t isolate_memsize(const void *ptr) {
+     const IsolateInfo *isolate_info = (const IsolateInfo *)ptr;
+     return sizeof(*isolate_info);
+}
+
 static void deallocate(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
 
@@ -1327,6 +1526,11 @@ static void deallocate(void* data) {
     xfree(data);
 }
 
+static size_t context_memsize(const void *ptr)
+{
+    return sizeof(ContextInfo);
+}
+
 static void mark_context(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
     if (context_info->isolate_info) {
@@ -1334,48 +1538,39 @@ static void mark_context(void* data) {
     }
 }
 
-static void deallocate_external_function(void * data) {
-    xfree(data);
-}
-
 static void deallocate_snapshot(void * data) {
     SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
     delete[] snapshot_info->data;
     xfree(snapshot_info);
 }
 
-static VALUE allocate_external_function(VALUE klass) {
-    VALUE* self = ALLOC(VALUE);
-    return Data_Wrap_Struct(klass, NULL, deallocate_external_function, (void*)self);
+static size_t snapshot_memsize(const void *data) {
+    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
+    return sizeof(*snapshot_info) + snapshot_info->raw_size;
 }
 
 static VALUE allocate(VALUE klass) {
-    ContextInfo* context_info = ALLOC(ContextInfo);
-    context_info->isolate_info = NULL;
-    context_info->context = NULL;
-
-    return Data_Wrap_Struct(klass, mark_context, deallocate, (void*)context_info);
+    ContextInfo* context_info;
+    return TypedData_Make_Struct(klass, ContextInfo, &context_type, context_info);
 }
 
 static VALUE allocate_snapshot(VALUE klass) {
-    SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
-    snapshot_info->data = NULL;
-    snapshot_info->raw_size = 0;
+    SnapshotInfo* snapshot_info;
 
-    return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
+    return TypedData_Make_Struct(klass, SnapshotInfo, &snapshot_type, snapshot_info);
 }
 
 static VALUE allocate_isolate(VALUE klass) {
     IsolateInfo* isolate_info = new IsolateInfo();
 
-    return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
+    return TypedData_Wrap_Struct(klass, &isolate_type, isolate_info);
 }
 
 static VALUE
 rb_heap_stats(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate;
     v8::HeapStatistics stats;
 
@@ -1407,7 +1602,9 @@ rb_heap_stats(VALUE self) {
 // https://github.com/bnoordhuis/node-heapdump/blob/master/src/heapdump.cc
 class FileOutputStream : public OutputStream {
  public:
-  FileOutputStream(FILE* stream) : stream_(stream) {}
+  int err;
+
+  FileOutputStream(int fd) : fd(fd) { err = 0; }
 
   virtual int GetChunkSize() {
     return 65536;
@@ -1416,17 +1613,27 @@ class FileOutputStream : public OutputStream {
   virtual void EndOfStream() {}
 
   virtual WriteResult WriteAsciiChunk(char* data, int size) {
-    const size_t len = static_cast<size_t>(size);
-    size_t off = 0;
-
-    while (off < len && !feof(stream_) && !ferror(stream_))
-      off += fwrite(data + off, 1, len - off, stream_);
-
-    return off == len ? kContinue : kAbort;
+    size_t len = static_cast<size_t>(size);
+
+    while (len) {
+        ssize_t w = write(fd, data, len);
+
+        if (w > 0) {
+            data += w;
+            len -= w;
+        } else if (w < 0) {
+            err = errno;
+            return kAbort;
+        } else { /* w == 0, could be out-of-space */
+            err = -1;
+            return kAbort;
+        }
+    }
+    return kContinue;
   }
 
  private:
-  FILE* stream_;
+  int fd;
 };
 
 
@@ -1439,13 +1646,11 @@ rb_heap_snapshot(VALUE self, VALUE file) {
 
     if (!fptr) return Qfalse;
 
-    FILE* fp;
-    fp = fdopen(fptr->fd, "w");
-    if (fp == NULL) return Qfalse;
-
+    // prepare for unbuffered write(2) below:
+    rb_funcall(file, rb_intern("flush"), 0);
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate;
     isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
 
@@ -1459,13 +1664,14 @@ rb_heap_snapshot(VALUE self, VALUE file) {
 
     const HeapSnapshot* const snap = heap_profiler->TakeHeapSnapshot();
 
-    FileOutputStream stream(fp);
+    FileOutputStream stream(fptr->fd);
     snap->Serialize(&stream, HeapSnapshot::kJSON);
 
-    fflush(fp);
-
     const_cast<HeapSnapshot*>(snap)->Delete();
 
+    /* TODO: perhaps rb_sys_fail here */
+    if (stream.err) return Qfalse;
+
     return Qtrue;
 }
 
@@ -1473,12 +1679,12 @@ static VALUE
 rb_context_stop(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     Isolate* isolate = context_info->isolate_info->isolate;
 
     // flag for termination
-    isolate->SetData(DO_TERMINATE, (void*)true);
+    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
 
     isolate->TerminateExecution();
     rb_funcall(self, rb_intern("stop_attached"), 0);
@@ -1490,7 +1696,7 @@ static VALUE
 rb_context_dispose(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     free_context(context_info);
 
@@ -1507,18 +1713,20 @@ nogvl_context_call(void *args) {
     IsolateInfo *isolate_info = call->context_info->isolate_info;
     Isolate* isolate = isolate_info->isolate;
 
-    // in gvl flag
-    isolate->SetData(IN_GVL, (void*)false);
-    // terminate ASAP
-    isolate->SetData(DO_TERMINATE, (void*)false);
+    IsolateData::Set(isolate, IsolateData::IN_GVL, false);
+    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, false);
 
     if (call->max_memory > 0) {
-        isolate->SetData(MEM_SOFTLIMIT_VALUE, &call->max_memory);
-        isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)false);
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_MAX, call->max_memory);
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, false);
         if (!isolate_info->added_gc_cb) {
-        isolate->AddGCEpilogueCallback(gc_callback);
+            isolate->AddGCEpilogueCallback(gc_callback);
             isolate_info->added_gc_cb = true;
+        }
     }
+ 
+    if (call->marshal_stackdepth > 0) {
+        StackCounter::SetMax(isolate, call->marshal_stackdepth);
     }
 
     Isolate::Scope isolate_scope(isolate);
@@ -1536,7 +1744,7 @@ nogvl_context_call(void *args) {
     MaybeLocal<v8::Value> res = fun->Call(context, context->Global(), call->argc, call->argv);
     prepare_result(res, trycatch, isolate, context, eval_res);
 
-    isolate->SetData(IN_GVL, (void*)true);
+    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
 
     return NULL;
 }
@@ -1551,7 +1759,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
     FunctionCall call;
     VALUE *call_argv = NULL;
 
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     if (argc < 1) {
@@ -1584,6 +1792,13 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
         unsigned long sl_int = NUM2ULONG(mem_softlimit);
         call.max_memory = (size_t)sl_int;
     }
+ 
+    call.marshal_stackdepth = 0;
+    VALUE marshal_stackdepth = rb_iv_get(self, "@marshal_stack_depth");
+    if (marshal_stackdepth != Qnil) {
+        unsigned long sl_int = NUM2ULONG(marshal_stackdepth);
+        call.marshal_stackdepth = (size_t)sl_int;
+    }
 
     bool missingFunction = false;
     {
@@ -1634,7 +1849,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
 
 static VALUE rb_context_create_isolate_value(VALUE self) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     IsolateInfo *isolate_info = context_info->isolate_info;
 
     if (!isolate_info) {
@@ -1642,7 +1857,7 @@ static VALUE rb_context_create_isolate_value(VALUE self) {
     }
 
     isolate_info->hold();
-    return Data_Wrap_Struct(rb_cIsolate, NULL, &deallocate_isolate, isolate_info);
+    return TypedData_Wrap_Struct(rb_cIsolate, &isolate_type, isolate_info);
 }
 
 static void set_ruby_exiting(VALUE value) {
@@ -1698,7 +1913,6 @@ extern "C" {
         rb_define_alloc_func(rb_cIsolate, allocate_isolate);
 
         rb_define_private_method(rb_cExternalFunction, "notify_v8", (VALUE(*)(...))&rb_external_function_notify_v8, 0);
-        rb_define_alloc_func(rb_cExternalFunction, allocate_external_function);
 
         rb_define_method(rb_cSnapshot, "size", (VALUE(*)(...))&rb_snapshot_size, 0);
         rb_define_method(rb_cSnapshot, "dump", (VALUE(*)(...))&rb_snapshot_dump, 0);

data/ext/mini_racer_loader/extconf.rb

@@ -3,6 +3,6 @@ require 'mkmf'
 extension_name = 'mini_racer_loader'
 dir_config extension_name
 
-$CPPFLAGS += " -fvisibility=hidden "
+$CXXFLAGS += " -fvisibility=hidden "
 
 create_makefile extension_name

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.4.0"
-  LIBV8_NODE_VERSION = "~> 15.14.0.0"
+  VERSION = "0.6.1"
+  LIBV8_NODE_VERSION = "~> 16.10.0.0"
 end

data/lib/mini_racer.rb

@@ -15,6 +15,9 @@ require "json"
 
 module MiniRacer
 
+  MARSHAL_STACKDEPTH_DEFAULT = 2**9-2
+  MARSHAL_STACKDEPTH_MAX_VALUE = 2**10-2
+
   class Error < ::StandardError; end
 
   class ContextDisposedError < Error; end
@@ -140,10 +143,10 @@ module MiniRacer
       end
     end
 
-    def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil)
+    def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil, marshal_stack_depth: nil)
       options ||= {}
 
-      check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)
+      check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, marshal_stack_depth: marshal_stack_depth, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)
 
       @functions = {}
       @timeout = nil
@@ -151,6 +154,7 @@ module MiniRacer
       @current_exception = nil
       @timeout = timeout
       @max_memory = max_memory
+      @marshal_stack_depth = marshal_stack_depth
 
       # false signals it should be fetched if requested
       @isolate = isolate || false
@@ -379,11 +383,12 @@ module MiniRacer
       rp.close if rp
     end
 
-    def check_init_options!(isolate:, snapshot:, max_memory:, ensure_gc_after_idle:, timeout:)
+    def check_init_options!(isolate:, snapshot:, max_memory:, marshal_stack_depth:, ensure_gc_after_idle:, timeout:)
       assert_option_is_nil_or_a('isolate', isolate, Isolate)
       assert_option_is_nil_or_a('snapshot', snapshot, Snapshot)
 
-      assert_numeric_or_nil('max_memory', max_memory, min_value: 10_000)
+      assert_numeric_or_nil('max_memory', max_memory, min_value: 10_000, max_value: 2**32-1)
+      assert_numeric_or_nil('marshal_stack_depth', marshal_stack_depth, min_value: 1, max_value: MARSHAL_STACKDEPTH_MAX_VALUE)
       assert_numeric_or_nil('ensure_gc_after_idle', ensure_gc_after_idle, min_value: 1)
       assert_numeric_or_nil('timeout', timeout, min_value: 1)
 
@@ -392,9 +397,13 @@ module MiniRacer
       end
     end
 
-    def assert_numeric_or_nil(option_name, object, min_value:)
+    def assert_numeric_or_nil(option_name, object, min_value:, max_value: nil)
+      if max_value && object.is_a?(Numeric) && object > max_value
+        raise ArgumentError, "#{option_name} must be less than or equal to #{max_value}"
+      end
+
       if object.is_a?(Numeric) && object < min_value
-        raise ArgumentError, "#{option_name} must be larger than #{min_value}"
+        raise ArgumentError, "#{option_name} must be larger than or equal to #{min_value}"
       end
 
       if !object.nil? && !object.is_a?(Numeric)

data/mini_racer.gemspec

@@ -22,8 +22,6 @@ Gem::Specification.new do |spec|
   }
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(benchmark|test|spec|features|examples)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
@@ -37,5 +35,5 @@ Gem::Specification.new do |spec|
 
   spec.extensions = ["ext/mini_racer_loader/extconf.rb", "ext/mini_racer_extension/extconf.rb"]
 
-  spec.required_ruby_version = '>= 2.3'
+  spec.required_ruby_version = '>= 2.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2021-04-12 00:00:00.000000000 Z
+date: 2022-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 15.14.0.0
+        version: 16.10.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 15.14.0.0
+        version: 16.10.0.0
 description: Minimal embedded v8 engine for Ruby
 email:
 - sam.saffron@gmail.com
@@ -128,9 +128,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.4.0/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.4.0
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.4.0
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.6.1/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.6.1
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.6.1
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -140,14 +140,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.2
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Minimal embedded v8 for Ruby