Added BigInt Support (#384)

* Added BigInt Value Support

* Added BigInt Root Support

* Added BigInt Functions To Bindings

* Added Tracing for Heap<BigInt> and Heap<Symbol>

Author: redfire75369

mozjs/src/jsgc.rs

@@ -46,6 +46,13 @@ impl RootKind for *mut JS::Symbol {
     }
 }
 
+impl RootKind for *mut JS::BigInt {
+    #[inline(always)]
+    fn rootKind() -> JS::RootKind {
+        JS::RootKind::BigInt
+    }
+}
+
 impl RootKind for *mut JSScript {
     #[inline(always)]
     fn rootKind() -> JS::RootKind {
@@ -132,6 +139,15 @@ impl GCMethods for *mut JS::Symbol {
     unsafe fn post_barrier(_: *mut *mut JS::Symbol, _: *mut JS::Symbol, _: *mut JS::Symbol) {}
 }
 
+impl GCMethods for *mut JS::BigInt {
+    unsafe fn initial() -> *mut JS::BigInt {
+        ptr::null_mut()
+    }
+    unsafe fn post_barrier(v: *mut *mut JS::BigInt, prev: *mut JS::BigInt, next: *mut JS::BigInt) {
+        JS::HeapBigIntWriteBarriers(v, prev, next);
+    }
+}
+
 impl GCMethods for *mut JSScript {
     unsafe fn initial() -> *mut JSScript {
         ptr::null_mut()

mozjs/src/jsglue.hpp

@@ -8,6 +8,7 @@
 #define _JSGLUE_INCLUDED
 
 #include "js/ArrayBuffer.h"
+#include "js/BigInt.h"
 #include "js/BuildId.h"
 #include "js/CompilationAndEvaluation.h"
 #include "js/ContextOptions.h"

mozjs/src/jsval.rs

@@ -9,6 +9,7 @@ use jsapi::JSContext;
 use jsapi::JSObject;
 use jsapi::JSString;
 use jsapi::JSValueType;
+use jsapi::JS::BigInt;
 use jsapi::JS::Symbol;
 use jsapi::JS::TraceKind;
 use jsapi::JS::Value;
@@ -36,6 +37,7 @@ enum ValueTag {
     UNDEFINED = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_UNDEFINED as u32),
     STRING = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_STRING as u32),
     SYMBOL = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_SYMBOL as u32),
+    BIGINT = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_BIGINT as u32),
     BOOLEAN = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_BOOLEAN as u32),
     MAGIC = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_MAGIC as u32),
     NULL = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_NULL as u32),
@@ -51,6 +53,7 @@ enum ValueTag {
     UNDEFINED = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_UNDEFINED as u32),
     STRING = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_STRING as u32),
     SYMBOL = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_SYMBOL as u32),
+    BIGINT = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_BIGINT as u32),
     BOOLEAN = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_BOOLEAN as u32),
     MAGIC = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_MAGIC as u32),
     NULL = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_NULL as u32),
@@ -66,6 +69,7 @@ enum ValueShiftedTag {
     UNDEFINED = (ValueTag::UNDEFINED as u64) << JSVAL_TAG_SHIFT,
     STRING = (ValueTag::STRING as u64) << JSVAL_TAG_SHIFT,
     SYMBOL = (ValueTag::SYMBOL as u64) << JSVAL_TAG_SHIFT,
+    BIGINT = (ValueTag::BIGINT as u64) << JSVAL_TAG_SHIFT,
     BOOLEAN = (ValueTag::BOOLEAN as u64) << JSVAL_TAG_SHIFT,
     MAGIC = (ValueTag::MAGIC as u64) << JSVAL_TAG_SHIFT,
     NULL = (ValueTag::NULL as u64) << JSVAL_TAG_SHIFT,
@@ -191,6 +195,21 @@ pub fn SymbolValue(s: &Symbol) -> JSVal {
     BuildJSVal(ValueTag::SYMBOL, bits)
 }
 
+#[cfg(target_pointer_width = "64")]
+#[inline(always)]
+pub fn BigIntValue(s: &BigInt) -> JSVal {
+    let bits = s as *const BigInt as usize as u64;
+    assert!((bits >> JSVAL_TAG_SHIFT) == 0);
+    BuildJSVal(ValueTag::BIGINT, bits)
+}
+
+#[cfg(target_pointer_width = "32")]
+#[inline(always)]
+pub fn BigIntValue(s: &BigInt) -> JSVal {
+    let bits = s as *const BigInt as usize as u64;
+    BuildJSVal(ValueTag::BIGINT, bits)
+}
+
 #[inline(always)]
 pub fn PrivateValue(o: *const c_void) -> JSVal {
     let ptrBits = o as usize as u64;
@@ -363,6 +382,18 @@ impl JSVal {
         (self.asBits() >> 32) == ValueTag::SYMBOL as u64
     }
 
+    #[inline(always)]
+    #[cfg(target_pointer_width = "64")]
+    pub fn is_bigint(&self) -> bool {
+        (self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::BIGINT as u64
+    }
+
+    #[inline(always)]
+    #[cfg(target_pointer_width = "32")]
+    pub fn is_bigint(&self) -> bool {
+        (self.asBits() >> 32) == ValueTag::BIGINT as u64
+    }
+
     #[inline(always)]
     #[cfg(target_pointer_width = "64")]
     pub fn is_gcthing(&self) -> bool {
@@ -459,6 +490,14 @@ impl JSVal {
         ptrBits as usize as *mut Symbol
     }
 
+    #[inline(always)]
+    pub fn to_bigint(&self) -> *mut BigInt {
+        assert!(self.is_bigint());
+        let ptrBits = self.asBits() & JSVAL_PAYLOAD_MASK;
+        assert!((ptrBits & 0x7) == 0);
+        ptrBits as usize as *mut BigInt
+    }
+
     #[inline(always)]
     pub fn to_private(&self) -> *const c_void {
         assert!(self.is_double());
@@ -496,8 +535,10 @@ impl JSVal {
             TraceKind::Object
         } else if self.is_string() {
             TraceKind::String
-        } else {
+        } else if self.is_symbol() {
             TraceKind::Symbol
+        } else {
+            TraceKind::BigInt
         }
     }
 }

rust-mozjs/src/gc/trace.rs

@@ -1,10 +1,9 @@
 use c_str;
 use glue::{
-    CallFunctionTracer, CallIdTracer, CallObjectTracer, CallScriptTracer, CallStringTracer,
-    CallValueTracer,
+    CallBigIntTracer, CallFunctionTracer, CallIdTracer, CallObjectTracer, CallScriptTracer, CallStringTracer,
+    CallSymbolTracer, CallValueTracer,
 };
-use jsapi::{jsid, JSFunction, JSObject, JSScript, JSString, JSTracer, Value};
-use mozjs_sys::jsapi::JS::JobQueue;
+use jsapi::{BigInt, JobQueue, jsid, JSFunction, JSObject, JSScript, JSString, JSTracer, Symbol, Value};
 use mozjs_sys::jsgc::Heap;
 use std::borrow::Cow;
 use std::cell::{Cell, RefCell, UnsafeCell};
@@ -61,6 +60,24 @@ unsafe impl Traceable for Heap<*mut JSObject> {
     }
 }
 
+unsafe impl Traceable for Heap<*mut Symbol> {
+    unsafe fn trace(&self, trc: *mut JSTracer) {
+        if self.get().is_null() {
+            return;
+        }
+        CallSymbolTracer(trc, self as *const _ as *mut Self, c_str!("symbol"));
+    }
+}
+
+unsafe impl Traceable for Heap<*mut BigInt> {
+    unsafe fn trace(&self, trc: *mut JSTracer) {
+        if self.get().is_null() {
+            return;
+        }
+        CallBigIntTracer(trc, self as *const _ as *mut Self, c_str!("bigint"));
+    }
+}
+
 unsafe impl Traceable for Heap<*mut JSScript> {
     #[inline]
     unsafe fn trace(&self, trc: *mut JSTracer) {

rust-mozjs/src/glue.rs

@@ -472,6 +472,16 @@ extern "C" {
         strp: *mut Heap<*mut JSString>,
         name: *const c_char,
     );
+    pub fn CallSymbolTracer(
+        trc: *mut JSTracer,
+        bip: *mut Heap<*mut Symbol>,
+        name: *const c_char,
+    );
+    pub fn CallBigIntTracer(
+        trc: *mut JSTracer,
+        bip: *mut Heap<*mut BigInt>,
+        name: *const c_char,
+    );
     pub fn CallScriptTracer(
         trc: *mut JSTracer,
         scriptp: *mut Heap<*mut JSScript>,

rust-mozjs/src/jsglue.cpp

@@ -890,6 +890,16 @@ void CallStringTracer(JSTracer* trc, JS::Heap<JSString*>* strp,
   JS::TraceEdge(trc, strp, name);
 }
 
+void CallSymbolTracer(JSTracer* trc, JS::Heap<JS::Symbol*>* bip,
+                      const char* name) {
+  JS::TraceEdge(trc, bip, name);
+}
+
+void CallBigIntTracer(JSTracer* trc, JS::Heap<JS::BigInt*>* bip,
+                      const char* name) {
+  JS::TraceEdge(trc, bip, name);
+}
+
 void CallScriptTracer(JSTracer* trc, JS::Heap<JSScript*>* scriptp,
                       const char* name) {
   JS::TraceEdge(trc, scriptp, name);