feat(vm): Global property lookup caches (#822)

Author: aapoalas

nova_vm/src/ecmascript/builtins/array.rs

@@ -595,7 +595,13 @@ impl<'a> InternalMethods<'a> for Array<'a> {
             if let Some(backing_object) = self.get_backing_object(agent) {
                 // Note: this looks up in the prototype chain as well, so we
                 // don't need to fall-through if this returns false or such.
-                return ordinary_try_has_property(agent, backing_object, property_key, gc);
+                return ordinary_try_has_property(
+                    agent,
+                    self.into_object(),
+                    backing_object,
+                    property_key,
+                    gc,
+                );
             }
         }
         // Data is not found in the array or its backing object (or one does
@@ -654,7 +660,13 @@ impl<'a> InternalMethods<'a> for Array<'a> {
             if let Some(backing_object) = self.get_backing_object(agent) {
                 // Note: this looks up in the prototype chain as well, so we
                 // don't need to fall-through if this returns false or such.
-                return ordinary_has_property(agent, backing_object, property_key, gc);
+                return ordinary_has_property(
+                    agent,
+                    self.into_object(),
+                    backing_object,
+                    property_key,
+                    gc,
+                );
             }
         }
         // Data is not found in the array or its backing object (or one does

nova_vm/src/ecmascript/builtins/error.rs

@@ -31,8 +31,8 @@ use crate::{
 };
 
 use super::ordinary::{
-    caches::PropertyLookupCache, ordinary_delete, ordinary_get_own_property, ordinary_set,
-    ordinary_try_get, ordinary_try_set,
+    caches::PropertyLookupCache, ordinary_delete, ordinary_get_own_property, ordinary_has_property,
+    ordinary_set, ordinary_try_get, ordinary_try_has_property, ordinary_try_set,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -219,7 +219,13 @@ impl<'a> InternalMethods<'a> for Error<'a> {
         gc: NoGcScope,
     ) -> TryResult<bool> {
         match self.get_backing_object(agent) {
-            Some(backing_object) => backing_object.try_has_property(agent, property_key, gc),
+            Some(backing_object) => ordinary_try_has_property(
+                agent,
+                self.into_object(),
+                backing_object,
+                property_key,
+                gc,
+            ),
             None => {
                 let found_direct =
                     if property_key == PropertyKey::from(BUILTIN_STRING_MEMORY.message) {
@@ -250,9 +256,13 @@ impl<'a> InternalMethods<'a> for Error<'a> {
     ) -> JsResult<'gc, bool> {
         let property_key = property_key.bind(gc.nogc());
         match self.get_backing_object(agent) {
-            Some(backing_object) => {
-                backing_object.internal_has_property(agent, property_key.unbind(), gc)
-            }
+            Some(backing_object) => ordinary_has_property(
+                agent,
+                self.into_object(),
+                backing_object,
+                property_key.unbind(),
+                gc,
+            ),
             None => {
                 let found_direct =
                     if property_key == PropertyKey::from(BUILTIN_STRING_MEMORY.message) {

nova_vm/src/ecmascript/builtins/global_object.rs

@@ -41,7 +41,9 @@ use crate::{
     heap::IntrinsicFunctionIndexes,
 };
 
-use super::{ArgumentsList, Behaviour, Builtin, BuiltinIntrinsic};
+use super::{
+    ArgumentsList, Behaviour, Builtin, BuiltinIntrinsic, ordinary::caches::PropertyLookupCache,
+};
 
 pub(crate) struct GlobalObject;
 
@@ -386,8 +388,15 @@ pub fn perform_eval<'gc>(
         // 29. If result is a normal completion, then
         match result {
             Ok(_) => {
-                let exe =
-                    Executable::compile_eval_body(agent, body, gc.nogc()).scope(agent, gc.nogc());
+                let source_code = agent
+                    .running_execution_context()
+                    .ecmascript_code
+                    .as_ref()
+                    .unwrap()
+                    .source_code
+                    .bind(gc.nogc());
+                let exe = Executable::compile_eval_body(agent, body, source_code, gc.nogc())
+                    .scope(agent, gc.nogc());
                 // a. Set result to Completion(Evaluation of body).
                 // 30. If result is a normal completion and result.[[Value]] is empty, then
                 // a. Set result to NormalCompletion(undefined).
@@ -750,16 +759,25 @@ fn eval_declaration_instantiation<'a>(
                 // 3. Perform ! varEnv.InitializeBinding(fn, fo).
                 scoped_var_env
                     .get(agent)
-                    .initialize_binding(agent, function_name.get(agent).unbind(), fo, gc.reborrow())
+                    .initialize_binding(
+                        agent,
+                        function_name.get(agent).unbind(),
+                        None,
+                        fo,
+                        gc.reborrow(),
+                    )
                     .unwrap();
             } else {
                 // iii. Else,
                 // 1. Perform ! varEnv.SetMutableBinding(fn, fo, false).
+                let function_name = function_name.get(agent).bind(gc.nogc());
+                let cache = PropertyLookupCache::new(agent, function_name.to_property_key());
                 scoped_var_env
                     .get(agent)
                     .set_mutable_binding(
                         agent,
-                        function_name.get(agent).unbind(),
+                        function_name.unbind(),
+                        Some(cache.unbind()),
                         fo,
                         false,
                         gc.reborrow(),
@@ -773,9 +791,10 @@ fn eval_declaration_instantiation<'a>(
         // a. If varEnv is a Global Environment Record, then
         if let Environment::Global(var_env) = scoped_var_env.get(agent).bind(gc.nogc()) {
             // i. Perform ? varEnv.CreateGlobalVarBinding(vn, true).
+            let cache = PropertyLookupCache::new(agent, vn.get(agent).to_property_key());
             var_env
                 .unbind()
-                .create_global_var_binding(agent, vn.get(agent), true, gc.reborrow())
+                .create_global_var_binding(agent, vn.get(agent), cache, true, gc.reborrow())
                 .unbind()?
                 .bind(gc.nogc());
         } else {
@@ -797,7 +816,7 @@ fn eval_declaration_instantiation<'a>(
                 // 3. Perform ! varEnv.InitializeBinding(vn, undefined).
                 scoped_var_env
                     .get(agent)
-                    .initialize_binding(agent, vn.get(agent), Value::Undefined, gc.reborrow())
+                    .initialize_binding(agent, vn.get(agent), None, Value::Undefined, gc.reborrow())
                     .unwrap();
             }
         }

nova_vm/src/ecmascript/builtins/ordinary.rs

@@ -617,24 +617,46 @@ fn validate_and_apply_property_descriptor(
 /// ### [10.1.7.1 OrdinaryHasProperty ( O, P )](https://tc39.es/ecma262/#sec-ordinaryhasproperty)
 pub(crate) fn ordinary_try_has_property(
     agent: &mut Agent,
-    object: OrdinaryObject,
+    object: Object,
+    backing_object: OrdinaryObject,
     property_key: PropertyKey,
     gc: NoGcScope,
 ) -> TryResult<bool> {
     // 1. Let hasOwn be ? O.[[GetOwnProperty]](P).
-    // Note: ? means that if we'd call a Proxy's GetOwnProperty trap then we'll
-    // instead return None.
-    let has_own = object.try_get_own_property(agent, property_key, gc)?;
+    let has_own = backing_object
+        .object_shape(agent)
+        .keys(&agent.heap.object_shapes, &agent.heap.elements)
+        .iter()
+        .enumerate()
+        .find(|(_, p)| *p == &property_key)
+        .map(|(i, _)| i as u32);
 
     // 2. If hasOwn is not undefined, return true.
-    if has_own.is_some() {
+    if let Some(offset) = has_own {
+        if let Some(CacheToPopulate {
+            receiver,
+            cache,
+            key: _,
+            shape,
+        }) = agent
+            .heap
+            .caches
+            .take_current_cache_to_populate(property_key)
+        {
+            let is_receiver = object.into_value() == receiver;
+            if is_receiver {
+                cache.insert_lookup_offset(agent, shape, offset);
+            } else {
+                cache.insert_prototype_lookup_offset(agent, shape, offset, object);
+            }
+        }
         return TryResult::Continue(true);
-    }
+    };
 
     // 3. Let parent be ? O.[[GetPrototypeOf]]().
     // Note: ? means that if we'd call a Proxy's GetPrototypeOf trap then we'll
     // instead return None.
-    let parent = object.try_get_prototype_of(agent, gc)?;
+    let parent = backing_object.try_get_prototype_of(agent, gc)?;
 
     // 4. If parent is not null, then
     if let Some(parent) = parent {
@@ -644,6 +666,19 @@ pub(crate) fn ordinary_try_has_property(
         return parent.try_has_property(agent, property_key, gc);
     }
 
+    if let Some(CacheToPopulate {
+        receiver: _,
+        cache,
+        key: _,
+        shape,
+    }) = agent
+        .heap
+        .caches
+        .take_current_cache_to_populate(property_key)
+    {
+        cache.insert_unset(agent, shape);
+    }
+
     // 5. Return false.
     TryResult::Continue(false)
 }
@@ -655,7 +690,13 @@ pub(crate) fn ordinary_try_has_property_entry<'a>(
     gc: NoGcScope,
 ) -> TryResult<bool> {
     match object.get_backing_object(agent) {
-        Some(backing_object) => ordinary_try_has_property(agent, backing_object, property_key, gc),
+        Some(backing_object) => ordinary_try_has_property(
+            agent,
+            object.into_object(),
+            backing_object,
+            property_key,
+            gc,
+        ),
         None => {
             // 3. Let parent be ? O.[[GetPrototypeOf]]().
             let parent = unwrap_try(object.try_get_prototype_of(agent, gc));
@@ -665,6 +706,18 @@ pub(crate) fn ordinary_try_has_property_entry<'a>(
                 // a. Return ? parent.[[HasProperty]](P).
                 parent.try_has_property(agent, property_key, gc)
             } else {
+                if let Some(CacheToPopulate {
+                    receiver: _,
+                    cache,
+                    key: _,
+                    shape,
+                }) = agent
+                    .heap
+                    .caches
+                    .take_current_cache_to_populate(property_key)
+                {
+                    cache.insert_unset(agent, shape);
+                }
                 // 5. Return false.
                 TryResult::Continue(false)
             }
@@ -675,26 +728,47 @@ pub(crate) fn ordinary_try_has_property_entry<'a>(
 /// ### [10.1.7.1 OrdinaryHasProperty ( O, P )](https://tc39.es/ecma262/#sec-ordinaryhasproperty)
 pub(crate) fn ordinary_has_property<'a>(
     agent: &mut Agent,
-    object: OrdinaryObject,
+    object: Object,
+    backing_object: OrdinaryObject,
     property_key: PropertyKey,
     gc: GcScope<'a, '_>,
 ) -> JsResult<'a, bool> {
-    let object = object.bind(gc.nogc());
+    let backing_object = backing_object.bind(gc.nogc());
     let property_key = property_key.bind(gc.nogc());
     // 1. Let hasOwn be ? O.[[GetOwnProperty]](P).
 
-    let has_own = object
+    let has_own = backing_object
         .object_shape(agent)
         .keys(&agent.heap.object_shapes, &agent.heap.elements)
-        .contains(&property_key);
+        .iter()
+        .enumerate()
+        .find(|(_, p)| *p == &property_key)
+        .map(|(i, _)| i as u32);
 
     // 2. If hasOwn is not undefined, return true.
-    if has_own {
+    if let Some(offset) = has_own {
+        if let Some(CacheToPopulate {
+            receiver,
+            cache,
+            key: _,
+            shape,
+        }) = agent
+            .heap
+            .caches
+            .take_current_cache_to_populate(property_key)
+        {
+            let is_receiver = object.into_value() == receiver;
+            if is_receiver {
+                cache.insert_lookup_offset(agent, shape, offset);
+            } else {
+                cache.insert_prototype_lookup_offset(agent, shape, offset, object);
+            }
+        }
         return Ok(true);
-    }
+    };
 
     // 3. Let parent be ? O.[[GetPrototypeOf]]().
-    let parent = object.internal_prototype(agent).bind(gc.nogc());
+    let parent = backing_object.internal_prototype(agent).bind(gc.nogc());
 
     // 4. If parent is not null, then
     if let Some(parent) = parent {
@@ -704,6 +778,19 @@ pub(crate) fn ordinary_has_property<'a>(
             .internal_has_property(agent, property_key.unbind(), gc);
     }
 
+    if let Some(CacheToPopulate {
+        receiver: _,
+        cache,
+        key: _,
+        shape,
+    }) = agent
+        .heap
+        .caches
+        .take_current_cache_to_populate(property_key)
+    {
+        cache.insert_unset(agent, shape);
+    }
+
     // 5. Return false.
     Ok(false)
 }
@@ -716,9 +803,13 @@ pub(crate) fn ordinary_has_property_entry<'a, 'gc>(
 ) -> JsResult<'gc, bool> {
     let property_key = property_key.bind(gc.nogc());
     match object.get_backing_object(agent) {
-        Some(backing_object) => {
-            ordinary_has_property(agent, backing_object, property_key.unbind(), gc)
-        }
+        Some(backing_object) => ordinary_has_property(
+            agent,
+            object.into_object(),
+            backing_object,
+            property_key.unbind(),
+            gc,
+        ),
         None => {
             // 3. Let parent be ? O.[[GetPrototypeOf]]().
             let parent = unwrap_try(object.try_get_prototype_of(agent, gc.nogc()));

nova_vm/src/ecmascript/builtins/ordinary/caches.rs

@@ -14,6 +14,7 @@ use crate::{
     engine::{
         TryResult,
         context::{Bindable, GcToken, NoGcScope},
+        rootable::{HeapRootData, HeapRootRef, Rootable},
     },
     heap::{
         CompactionLists, HeapMarkAndSweep, HeapSweepWeakReference, PropertyKeyHeap, WeakReference,
@@ -715,6 +716,29 @@ unsafe impl Bindable for PropertyLookupCache<'_> {
     }
 }
 
+impl<'a> Rootable for PropertyLookupCache<'a> {
+    type RootRepr = HeapRootRef;
+
+    fn to_root_repr(value: Self) -> Result<Self::RootRepr, HeapRootData> {
+        Err(HeapRootData::PropertyLookupCache(value.unbind()))
+    }
+
+    fn from_root_repr(value: &Self::RootRepr) -> Result<Self, HeapRootRef> {
+        Err(*value)
+    }
+
+    fn from_heap_ref(heap_ref: HeapRootRef) -> Self::RootRepr {
+        heap_ref
+    }
+
+    fn from_heap_data(heap_data: HeapRootData) -> Option<Self> {
+        match heap_data {
+            HeapRootData::PropertyLookupCache(object) => Some(object),
+            _ => None,
+        }
+    }
+}
+
 const N: usize = 4;
 
 #[derive(Debug)]

nova_vm/src/ecmascript/builtins/ordinary/shape.rs

@@ -185,7 +185,7 @@ impl<'a> ObjectShape<'a> {
             // A cached lookup result was found.
             if offset.is_unset() {
                 // The property is unset.
-                Value::Undefined.into()
+                GetCachedResult::Unset.into()
             } else {
                 let o = prototype.unwrap_or_else(|| Object::try_from(receiver).unwrap());
                 o.get_own_property_at_offset(agent, offset, gc)