wip

Author: y21

Cargo.lock

@@ -35,6 +35,7 @@ resolver = "2"
 [profile.release]
 lto = "fat"
 codegen-units = 1
+debug = true
 
 [profile.dev]
 debug = true

Cargo.toml

@@ -254,6 +254,7 @@ impl InstructionBuilder<'_, '_> {
         self.write_instr(Instruction::StaticPropAccess);
         self.writew(id);
         self.write(preserve_this.into());
+        self.write_all(&1234123456u32.to_ne_bytes());
 
         Ok(())
     }

crates/dash_compiler/src/instruction.rs

@@ -220,6 +220,9 @@ impl<'interner, 'buf> FunctionDecompiler<'interner, 'buf> {
                 Instruction::StaticPropAccess => {
                     let b = self.read_u16()?;
                     let _preserve_this = self.read()?;
+                    for _ in 0..4 {
+                        self.read()?;
+                    }
                     let ident = self
                         .interner
                         .resolve(self.constants.symbols[SymbolConstant(b)])

crates/dash_decompiler/src/decompiler.rs

@@ -28,6 +28,7 @@ ahash = "0.8.3"
 rustc-hash = "2.1.0"
 hashbrown = "0.15.0"
 if_chain = "1.0.2"
+rand = "0.9.1"
 
 [dev-dependencies]
 criterion = "0.5.0"

crates/dash_vm/Cargo.toml

@@ -1626,17 +1626,58 @@ mod handlers {
     }
 
     pub fn staticpropertyaccess(mut cx: DispatchContext<'_>) -> Result<Option<HandleResult>, Unrooted> {
+        // let (id, cache) = {
+        //     let frame = cx.active_frame_mut();
+        //     let ip = frame.ip;
+        //     frame.function.buffer.with(|buf| unsafe {
+        //         let id = u16::from_ne_bytes(buf.get_unchecked(ip..ip + 2).try_into().unwrap());
+        //         let cache = u32::from_ne_bytes(buf.get_unchecked(ip + 2..ip + 6).try_into().unwrap());
+        //         frame.ip += 6;
+        //         (id, cache)
+        //     })
+        // };
         let id = cx.fetchw_and_inc_ip();
+
         let ident = JsString::from(cx.constants().symbols[SymbolConstant(id)]);
 
         let preserve_this = cx.fetch_and_inc_ip() == 1;
+        let cache = cx.fetchw32_and_inc_ip();
 
         let target = if preserve_this {
             cx.peek_stack()
         } else {
             cx.pop_stack_rooted()
         };
 
+        if ident.sym() == sym::length {
+            let k = sym::from.to_key(&mut cx.scope);
+            let i = std::time::Instant::now();
+            let c = 1000000;
+            let mut x = None;
+            let (data, fun) = match target.unpack() {
+                ValueKind::Object(object) => {
+                    let data = object.data_ptr(&cx.scope);
+                    let vt = object.vtable(&cx.scope);
+                    // unsafe {
+                    //     ||
+                    // }
+                    (data, vt.js_get_property_descriptor)
+                }
+                _ => unreachable!(),
+            };
+            if let Some(target_) = target.extract::<OrdObject>(&cx.scope) {
+                for _ in 0..c {
+                    x = unsafe { Some(fun(data, k, &mut cx.scope)) };
+                    // x = Some(target.get_property_descriptor(k, &mut cx.scope).unwrap());
+                }
+                let e = i.elapsed();
+                dbg!(e / c);
+                // dbg!(x);
+                // assert!(x.unwrap().root(&mut cx.scope));
+            }
+            // dbg!(x.unwrap().root(&mut cx.scope).unpack());
+        }
+
         let value = target.get_property(ident.to_key(&mut cx.scope), &mut cx.scope)?;
         cx.push_stack(value);
         Ok(None)

crates/dash_vm/src/dispatch.rs

@@ -1264,6 +1264,21 @@ impl Vm {
         u16::from_ne_bytes(value)
     }
 
+    /// Fetches a wide value (16-bit) in the currently executing frame
+    /// and increments the instruction pointer
+    #[cfg_attr(dash_lints, dash_lints::trusted_no_gc)]
+    pub(crate) fn fetchw32_and_inc_ip(&mut self) -> u32 {
+        let frame = self.active_frame_mut();
+        let value: [u8; 4] = frame.function.buffer.with(|buf| {
+            buf[frame.ip..frame.ip + 4]
+                .try_into()
+                .expect("Failed to get wide instruction")
+        });
+
+        frame.ip += 4;
+        u32::from_ne_bytes(value)
+    }
+
     #[cfg_attr(dash_lints, dash_lints::trusted_no_gc)]
     pub(crate) fn get_frame_sp(&self) -> usize {
         self.active_frame().sp

crates/dash_vm/src/lib.rs

@@ -219,7 +219,51 @@ unsafe impl Trace for Value {
 }
 
 // TODO: can we just get rid of this impl if ExternalValue stores ValueId instead of ObjectId which should remove the need for having an object vtable for value
+#[warn(clippy::missing_trait_methods)]
 impl Object for Value {
+    fn get_property(&self, this: This, key: PropertyKey, sc: &mut LocalScope<'_>) -> Result<Unrooted, Unrooted> {
+        match self.unpack() {
+            ValueKind::Object(o) => o.get_property(key, sc),
+            ValueKind::Number(n) => n.get_property(this, key, sc),
+            ValueKind::Boolean(b) => b.get_property(this, key, sc),
+            ValueKind::String(s) => s.get_property(this, key, sc),
+            ValueKind::External(e) => e.get_property(this, key, sc),
+            ValueKind::Undefined(u) => u.get_property(this, key, sc),
+            ValueKind::Null(n) => n.get_property(this, key, sc),
+            ValueKind::Symbol(s) => s.get_property(this, key, sc),
+        }
+    }
+
+    fn get_own_property(&self, this: This, key: PropertyKey, sc: &mut LocalScope<'_>) -> Result<Unrooted, Unrooted> {
+        match self.unpack() {
+            ValueKind::Object(o) => o.get_own_property(key, sc),
+            ValueKind::Number(n) => n.get_own_property(this, key, sc),
+            ValueKind::Boolean(b) => b.get_own_property(this, key, sc),
+            ValueKind::String(s) => s.get_own_property(this, key, sc),
+            ValueKind::External(e) => e.get_own_property(this, key, sc),
+            ValueKind::Undefined(u) => u.get_own_property(this, key, sc),
+            ValueKind::Null(n) => n.get_own_property(this, key, sc),
+            ValueKind::Symbol(s) => s.get_own_property(this, key, sc),
+        }
+    }
+
+    fn get_property_descriptor(
+        &self,
+        key: PropertyKey,
+        sc: &mut LocalScope,
+    ) -> Result<Option<PropertyValue>, Unrooted> {
+        match self.unpack() {
+            ValueKind::Number(n) => n.get_property_descriptor(key, sc),
+            ValueKind::Boolean(b) => b.get_property_descriptor(key, sc),
+            ValueKind::String(s) => s.get_property_descriptor(key, sc),
+            ValueKind::Undefined(u) => u.get_property_descriptor(key, sc),
+            ValueKind::Null(n) => n.get_property_descriptor(key, sc),
+            ValueKind::Symbol(s) => s.get_property_descriptor(key, sc),
+            ValueKind::Object(o) => o.get_property_descriptor(key, sc),
+            ValueKind::External(e) => e.get_property_descriptor(key, sc),
+        }
+    }
+
     fn get_own_property_descriptor(
         &self,
         key: PropertyKey,

crates/dash_vm/src/value/mod.rs

@@ -124,6 +124,29 @@ impl OrdObject {
 }
 
 impl Object for OrdObject {
+    fn get_property_descriptor(
+        &self,
+        key: PropertyKey,
+        sc: &mut LocalScope,
+    ) -> Result<Option<PropertyValue>, Unrooted> {
+        if let Some(pv) = self.get_own_property_descriptor(key, sc)? {
+            Ok(Some(pv))
+        } else {
+            #[cold]
+            fn f() {}
+            f();
+            eprintln!("SLOW PATH!!! {key:?}");
+            if let InnerOrdObject::Linear(l) = &*self.0.borrow() {
+                let ks = l
+                    .raw_keys()
+                    .iter()
+                    .map(|v| sc.interner.resolve(interner::Symbol::from_raw(*v)))
+                    .collect::<Vec<_>>();
+                println!("Keys: {ks:?}")
+            }
+            self.get_prototype(sc)?.get_property_descriptor(key, sc)
+        }
+    }
     fn get_own_property_descriptor(
         &self,
         key: PropertyKey,
@@ -860,7 +883,7 @@ impl PropertyVec {
         let descriptors = unsafe {
             align_ptr_mut(
                 values
-                    .add(self.len() as usize)
+                    .add(self.capacity().get() as usize)
                     .cast::<InternalLinearPropertyVecDescriptor>(),
             )
         };
@@ -880,7 +903,7 @@ impl PropertyVec {
         let descriptors = unsafe {
             align_ptr(
                 values
-                    .add(self.len() as usize)
+                    .add(self.capacity().get() as usize)
                     .cast::<InternalLinearPropertyVecDescriptor>(),
             )
         };