Skip to content

/ rust-mozjs

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

More inlining possibilities #277

Merged
merged 2 commits into from Jul 13, 2016
+54 −2
Merged

More inlining possibilities #277

Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
6615425
Preallocate a string upfront when converting from latin1.
jdm Jul 13, 2016
53871a2
Enable cross-crate inlining for JSVal methods.
jdm Jul 13, 2016
File filter...
Filter file types
Clear filters
Jump to…
Jump to file
Failed to load files.

Always

Just for now

Prev
Loading status checks…

Enable cross-crate inlining for JSVal methods.

  • Loading branch information
@jdm
jdm committed Jul 13, 2016
commit 53871a2060a18ca6f81117497673ff6b47c4b571
43 src/jsval.rs
View file
Open in desktop
@@ -198,140 +198,167 @@ pub fn PrivateValue(o: *const c_void) -> JSVal {
}

impl JSVal {
#[inline(always)]
fn asBits(&self) -> u64 {
self.data._bindgen_data_
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_undefined(&self) -> bool {
self.asBits() == ValueShiftedTag::UNDEFINED as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_undefined(&self) -> bool {
(self.asBits() >> 32) == ValueTag::UNDEFINED as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_null(&self) -> bool {
self.asBits() == ValueShiftedTag::NULL as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_null(&self) -> bool {
(self.asBits() >> 32) == ValueTag::NULL as u64
}

#[inline(always)]
pub fn is_null_or_undefined(&self) -> bool {
self.is_null() || self.is_undefined()
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_boolean(&self) -> bool {
(self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::BOOLEAN as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_boolean(&self) -> bool {
(self.asBits() >> 32) == ValueTag::BOOLEAN as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_int32(&self) -> bool {
(self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::INT32 as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_int32(&self) -> bool {
(self.asBits() >> 32) == ValueTag::INT32 as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_double(&self) -> bool {
self.asBits() <= ValueShiftedTag::MAX_DOUBLE as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_double(&self) -> bool {
(self.asBits() >> 32) <= JSVAL_TAG_CLEAR as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_number(&self) -> bool {
const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET: u64 = ValueShiftedTag::UNDEFINED as u64;
self.asBits() < JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_number(&self) -> bool {
const JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET: u64 = ValueTag::INT32 as u64;
(self.asBits() >> 32) <= JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_primitive(&self) -> bool {
const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET: u64 = ValueShiftedTag::OBJECT as u64;
self.asBits() < JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_primitive(&self) -> bool {
const JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET: u64 = ValueTag::OBJECT as u64;
(self.asBits() >> 32) < JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_string(&self) -> bool {
(self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::STRING as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_string(&self) -> bool {
(self.asBits() >> 32) == ValueTag::STRING as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_object(&self) -> bool {
assert!((self.asBits() >> JSVAL_TAG_SHIFT) <= ValueTag::OBJECT as u64);
self.asBits() >= ValueShiftedTag::OBJECT as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_object(&self) -> bool {
(self.asBits() >> 32) == ValueTag::OBJECT as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_symbol(&self) -> bool {
self.asBits() == ValueShiftedTag::SYMBOL as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_symbol(&self) -> bool {
(self.asBits() >> 32) == ValueTag::SYMBOL as u64
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn to_boolean(&self) -> bool {
assert!(self.is_boolean());
(self.asBits() & JSVAL_PAYLOAD_MASK) != 0
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn to_boolean(&self) -> bool {
(self.asBits() & 0x00000000FFFFFFFF) != 0
}

#[inline(always)]
pub fn to_int32(&self) -> i32 {
assert!(self.is_int32());
(self.asBits() & 0x00000000FFFFFFFF) as i32
}

#[inline(always)]
pub fn to_double(&self) -> f64 {
assert!(self.is_double());
unsafe { mem::transmute(self.asBits()) }
}

#[inline(always)]
pub fn to_number(&self) -> f64 {
assert!(self.is_number());
if self.is_double() {
@@ -341,39 +368,45 @@ impl JSVal {
}
}

#[inline(always)]
pub fn to_object(&self) -> *mut JSObject {
assert!(self.is_object());
self.to_object_or_null()
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn to_string(&self) -> *mut JSString {
assert!(self.is_string());
let ptrBits = self.asBits() & JSVAL_PAYLOAD_MASK;
ptrBits as usize as *mut JSString
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn to_string(&self) -> *mut JSString {
assert!(self.is_string());
let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32;
ptrBits as *mut JSString
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_object_or_null(&self) -> bool {
const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET: u64 = ValueShiftedTag::NULL as u64;
assert!((self.asBits() >> JSVAL_TAG_SHIFT) <= ValueTag::OBJECT as u64);
self.asBits() >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_object_or_null(&self) -> bool {
const JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET: u64 = ValueTag::NULL as u64;
assert!((self.asBits() >> 32) <= ValueTag::OBJECT as u64);
(self.asBits() >> 32) >= JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn to_object_or_null(&self) -> *mut JSObject {
assert!(self.is_object_or_null());
@@ -382,38 +415,44 @@ impl JSVal {
ptrBits as usize as *mut JSObject
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn to_object_or_null(&self) -> *mut JSObject {
assert!(self.is_object_or_null());
let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32;
ptrBits as *mut JSObject
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn to_private(&self) -> *const c_void {
assert!(self.is_double());
assert!((self.asBits() & 0x8000000000000000u64) == 0);
(self.asBits() << 1) as usize as *const c_void
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn to_private(&self) -> *const c_void {
let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32;
ptrBits as *const c_void
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn is_gcthing(&self) -> bool {
const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET: u64 = ValueShiftedTag::STRING as u64;
self.asBits() >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn is_gcthing(&self) -> bool {
const JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET: u64 = ValueTag::STRING as u64;
(self.asBits() >> 32) >= JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET
}

#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn to_gcthing(&self) -> *mut c_void {
assert!(self.is_gcthing());
@@ -422,24 +461,26 @@ impl JSVal {
ptrBits as *mut c_void
}

#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn to_gcthing(&self) -> *mut c_void {
assert!(self.is_gcthing());
let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32;
ptrBits as *mut c_void
}

#[inline(always)]
pub fn is_markable(&self) -> bool {
self.is_gcthing() && !self.is_null()
}

#[inline(always)]
pub fn trace_kind(&self) -> TraceKind {
assert!(self.is_markable());
if self.is_object() {
TraceKind::Object
} else {
TraceKind::String
}

}
}
9 src/rust.rs
View file
Open in desktop
@@ -233,38 +233,47 @@ impl HeapSizeOf for Runtime {
// Rooting API for standard JS things

pub trait RootKind {
#[inline(always)]
fn rootKind() -> jsapi::RootKind;
}

impl RootKind for *mut JSObject {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Object }
}

impl RootKind for *mut JSFlatString {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::String }
}

impl RootKind for *mut JSFunction {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Object }
}

impl RootKind for *mut JSString {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::String }
}

impl RootKind for *mut Symbol {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Symbol }
}

impl RootKind for *mut JSScript {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Script }
}

impl RootKind for jsid {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Id }
}

impl RootKind for Value {
#[inline(always)]
fn rootKind() -> jsapi::RootKind { jsapi::RootKind::Value }
}

ProTip! Use n and p to navigate between commits in a pull request.
You can’t perform that action at this time.