Store Runtime fields as PinnedValue

Summary:
Migrate all the PinnedHermesValues in `RuntimeHermesValueFields.def` to
PinnedValue. Use the correct type on each field.

`RootAcceptor` is made to be a `friend` of `PinnedValue` so that it can
take in a PV but internally simply cast it to a PHV and use that
`accept` overload.

Reviewed By: neildhar

Differential Revision: D59254376

fbshipit-source-id: 4db3175a00cfe6efbd956b01a440d054b132c6b0

Author: fbmal7

include/hermes/VM/Handle.h

@@ -168,6 +168,7 @@ template <typename T = HermesValue>
 class PinnedValue : private PinnedHermesValue {
   template <class U>
   friend class Handle;
+  friend struct RootAcceptor;
 
   using traits_type = HermesValueTraits<T>;
   using value_type = typename traits_type::value_type;

include/hermes/VM/JSArray.h

@@ -325,8 +325,8 @@ class JSArray final : public ArrayImpl {
     return createNoAllocPropStorage(
         runtime,
         prototypeHandle,
-        *prototypeHandle == runtime.arrayPrototype.getObject()
-            ? Handle<HiddenClass>::vmcast(&runtime.arrayClass)
+        *prototypeHandle == *runtime.arrayPrototype
+            ? runtime.arrayClass
             : createClass(runtime, prototypeHandle),
         capacity,
         length);

include/hermes/VM/Runtime.h

@@ -293,7 +293,7 @@ class Runtime : public RuntimeBase, public HandleRootOwner {
         runtimeModuleFlags,
         sourceURL,
         environment,
-        Handle<>(&global_));
+        global_);
   }
 
   ExecutionStatus loadSegment(
@@ -559,7 +559,7 @@ class Runtime : public RuntimeBase, public HandleRootOwner {
 
   /// \return `thrownValue`.
   HermesValue getThrownValue() const {
-    return thrownValue_;
+    return *thrownValue_;
   }
 
   /// Set `thrownValue` to the specified value \p value, `returnValue` to
@@ -760,7 +760,7 @@ class Runtime : public RuntimeBase, public HandleRootOwner {
 
   /// @}
 
-#define RUNTIME_HV_FIELD(name) PinnedHermesValue name{};
+#define RUNTIME_HV_FIELD(name, type) PinnedValue<type> name{};
 #include "hermes/VM/RuntimeHermesValueFields.def"
 #undef RUNTIME_HV_FIELD
 

include/hermes/VM/RuntimeHermesValueFields.def

@@ -9,95 +9,96 @@
 #error "RUNTIME_HV_FIELD must be defined"
 #endif
 
-RUNTIME_HV_FIELD(objectPrototype)
-RUNTIME_HV_FIELD(errorConstructor)
+RUNTIME_HV_FIELD(objectPrototype, JSObject)
+RUNTIME_HV_FIELD(errorConstructor, NativeConstructor)
 
 /// JSError.prototype, and prototype of all native error types.
-#define ALL_ERROR_TYPE(name) RUNTIME_HV_FIELD(name##Prototype)
+#define ALL_ERROR_TYPE(name) RUNTIME_HV_FIELD(name##Prototype, JSObject)
 #include "hermes/VM/NativeErrorTypes.def"
 #undef ALL_ERROR_TYPE
-RUNTIME_HV_FIELD(functionPrototype)
-RUNTIME_HV_FIELD(functionConstructor)
+RUNTIME_HV_FIELD(functionPrototype, NativeFunction)
+RUNTIME_HV_FIELD(functionConstructor, NativeConstructor)
 
-RUNTIME_HV_FIELD(stringPrototype)
-RUNTIME_HV_FIELD(bigintPrototype)
-RUNTIME_HV_FIELD(numberPrototype)
-RUNTIME_HV_FIELD(booleanPrototype)
-RUNTIME_HV_FIELD(symbolPrototype)
-RUNTIME_HV_FIELD(datePrototype)
-RUNTIME_HV_FIELD(arrayPrototype)
-RUNTIME_HV_FIELD(fastArrayPrototype)
+RUNTIME_HV_FIELD(stringPrototype, JSString)
+RUNTIME_HV_FIELD(bigintPrototype, JSObject)
+RUNTIME_HV_FIELD(numberPrototype, JSNumber)
+RUNTIME_HV_FIELD(booleanPrototype, JSBoolean)
+RUNTIME_HV_FIELD(symbolPrototype, JSObject)
+RUNTIME_HV_FIELD(datePrototype, JSObject)
+RUNTIME_HV_FIELD(arrayPrototype, JSArray)
+RUNTIME_HV_FIELD(fastArrayPrototype, JSObject)
 
-RUNTIME_HV_FIELD(arrayBufferPrototype)
-RUNTIME_HV_FIELD(dataViewPrototype)
-RUNTIME_HV_FIELD(typedArrayBasePrototype)
+RUNTIME_HV_FIELD(arrayBufferPrototype, JSObject)
+RUNTIME_HV_FIELD(dataViewPrototype, JSObject)
+RUNTIME_HV_FIELD(typedArrayBasePrototype, JSObject)
 
 /// %TypedArray%.prototype and constructor for each typed array.
-#define TYPED_ARRAY(name, type)                    \
-  RUNTIME_HV_FIELD(name##ArrayPrototype) \
-  RUNTIME_HV_FIELD(name##ArrayConstructor)
+#define TYPED_ARRAY(name, type)                             \
+  RUNTIME_HV_FIELD(name##ArrayPrototype, JSObject)          \
+  RUNTIME_HV_FIELD(name##ArrayConstructor, NativeConstructor)
 #include "hermes/VM/TypedArrays.def"
 #undef TYPED_ARRAY
 
-RUNTIME_HV_FIELD(setPrototype)
-RUNTIME_HV_FIELD(setPrototypeAdd)
-RUNTIME_HV_FIELD(setPrototypeValues)
-RUNTIME_HV_FIELD(setIteratorPrototype)
-RUNTIME_HV_FIELD(mapPrototype)
-RUNTIME_HV_FIELD(mapPrototypeSet)
-RUNTIME_HV_FIELD(mapPrototypeEntries)
-RUNTIME_HV_FIELD(mapIteratorPrototype)
-RUNTIME_HV_FIELD(weakMapPrototype)
-RUNTIME_HV_FIELD(weakSetPrototype)
-RUNTIME_HV_FIELD(weakRefPrototype)
-RUNTIME_HV_FIELD(regExpPrototype)
-RUNTIME_HV_FIELD(typedArrayBaseConstructor)
+RUNTIME_HV_FIELD(setPrototype, JSObject)
+RUNTIME_HV_FIELD(setPrototypeAdd, NativeFunction)
+RUNTIME_HV_FIELD(setPrototypeValues, NativeFunction)
+RUNTIME_HV_FIELD(setIteratorPrototype, JSObject)
+RUNTIME_HV_FIELD(mapPrototype, JSObject)
+RUNTIME_HV_FIELD(mapPrototypeSet, NativeFunction)
+RUNTIME_HV_FIELD(mapPrototypeEntries, NativeFunction)
+RUNTIME_HV_FIELD(mapIteratorPrototype, JSObject)
+RUNTIME_HV_FIELD(weakMapPrototype, JSObject)
+RUNTIME_HV_FIELD(weakSetPrototype, JSObject)
+RUNTIME_HV_FIELD(weakRefPrototype, JSObject)
+RUNTIME_HV_FIELD(regExpPrototype, JSObject)
+RUNTIME_HV_FIELD(typedArrayBaseConstructor, NativeConstructor)
 
-RUNTIME_HV_FIELD(regExpLastInput)
-RUNTIME_HV_FIELD(regExpLastRegExp)
+RUNTIME_HV_FIELD(regExpLastInput, StringPrimitive)
+RUNTIME_HV_FIELD(regExpLastRegExp, JSRegExp)
 
-RUNTIME_HV_FIELD(throwTypeErrorAccessor)
-RUNTIME_HV_FIELD(arrayClass)
-RUNTIME_HV_FIELD(fastArrayClass)
-RUNTIME_HV_FIELD(regExpMatchClass)
+RUNTIME_HV_FIELD(throwTypeErrorAccessor, PropertyAccessor)
+RUNTIME_HV_FIELD(arrayClass, HiddenClass)
+RUNTIME_HV_FIELD(fastArrayClass, HiddenClass)
+RUNTIME_HV_FIELD(regExpMatchClass, HiddenClass)
 
-RUNTIME_HV_FIELD(iteratorPrototype)
-RUNTIME_HV_FIELD(arrayIteratorPrototype)
-RUNTIME_HV_FIELD(arrayPrototypeValues)
-RUNTIME_HV_FIELD(asyncFunctionPrototype)
-RUNTIME_HV_FIELD(stringIteratorPrototype)
-RUNTIME_HV_FIELD(regExpStringIteratorPrototype)
-RUNTIME_HV_FIELD(generatorPrototype)
-RUNTIME_HV_FIELD(generatorFunctionPrototype)
-RUNTIME_HV_FIELD(parseIntFunction)
-RUNTIME_HV_FIELD(parseFloatFunction)
-RUNTIME_HV_FIELD(requireFunction)
-RUNTIME_HV_FIELD(jsErrorStackAccessor)
-RUNTIME_HV_FIELD(callSitePrototype)
-RUNTIME_HV_FIELD(textEncoderPrototype)
+RUNTIME_HV_FIELD(iteratorPrototype, JSObject)
+RUNTIME_HV_FIELD(arrayIteratorPrototype, JSObject)
+RUNTIME_HV_FIELD(arrayPrototypeValues, NativeFunction)
+RUNTIME_HV_FIELD(asyncFunctionPrototype, JSObject)
+RUNTIME_HV_FIELD(stringIteratorPrototype, JSObject)
+RUNTIME_HV_FIELD(regExpStringIteratorPrototype, JSObject)
+RUNTIME_HV_FIELD(generatorPrototype, JSObject)
+RUNTIME_HV_FIELD(generatorFunctionPrototype, JSObject)
+RUNTIME_HV_FIELD(parseIntFunction, NativeFunction)
+RUNTIME_HV_FIELD(parseFloatFunction, NativeFunction)
+RUNTIME_HV_FIELD(requireFunction, NativeFunction)
+RUNTIME_HV_FIELD(jsErrorStackAccessor, PropertyAccessor)
+RUNTIME_HV_FIELD(callSitePrototype, JSObject)
+RUNTIME_HV_FIELD(textEncoderPrototype, JSObject)
 
 // TODO: for Serialization/Deserialization  after global object initialization
 // we record specialCodeBlockDomain_ and create runtimemodule later need to
 // revisit this in stage 2
-RUNTIME_HV_FIELD(specialCodeBlockDomain_)
+RUNTIME_HV_FIELD(specialCodeBlockDomain_, Domain)
 
-RUNTIME_HV_FIELD(global_)
-RUNTIME_HV_FIELD(thrownValue_)
-RUNTIME_HV_FIELD(keptObjects_)
+RUNTIME_HV_FIELD(global_, JSObject)
+RUNTIME_HV_FIELD(thrownValue_, HermesValue)
+// TODO(T194880545) change to OrderedHashMap
+RUNTIME_HV_FIELD(keptObjects_, HermesValue)
 #ifdef HERMES_ENABLE_DEBUGGER
-RUNTIME_HV_FIELD(debuggerInternalObject_)
+RUNTIME_HV_FIELD(debuggerInternalObject_, JSObject)
 #endif // HERMES_ENABLE_DEBUGGER
 
 #ifdef HERMES_ENABLE_INTL
 // TODO T65916424: move these out of Runtime
-RUNTIME_HV_FIELD(intlCollator)
-RUNTIME_HV_FIELD(intlCollatorPrototype)
-RUNTIME_HV_FIELD(intlDateTimeFormat)
-RUNTIME_HV_FIELD(intlDateTimeFormatPrototype)
-RUNTIME_HV_FIELD(intlNumberFormat)
-RUNTIME_HV_FIELD(intlNumberFormatPrototype)
+RUNTIME_HV_FIELD(intlCollator, NativeConstructor)
+RUNTIME_HV_FIELD(intlCollatorPrototype, JSObject)
+RUNTIME_HV_FIELD(intlDateTimeFormat, NativeConstructor)
+RUNTIME_HV_FIELD(intlDateTimeFormatPrototype, JSObject)
+RUNTIME_HV_FIELD(intlNumberFormat, NativeConstructor)
+RUNTIME_HV_FIELD(intlNumberFormatPrototype, JSObject)
 #endif
 
-RUNTIME_HV_FIELD(promiseRejectionTrackingHook_)
+RUNTIME_HV_FIELD(promiseRejectionTrackingHook_, HermesValue)
 
 #undef RUNTIME_HV_FIELD

include/hermes/VM/SlotAcceptor.h

@@ -8,6 +8,7 @@
 #ifndef HERMES_VM_SLOTACCEPTOR_H
 #define HERMES_VM_SLOTACCEPTOR_H
 
+#include "hermes/VM/Handle.h"
 #include "hermes/VM/HermesValue.h"
 #include "hermes/VM/SmallHermesValue.h"
 #include "hermes/VM/SymbolID.h"
@@ -58,6 +59,10 @@ struct RootAcceptor : public RootSectionAcceptor {
   /// Same as the above, but allows the HermesValue to store a nullptr value.
   virtual void acceptNullable(PinnedHermesValue &hv) = 0;
   virtual void accept(const RootSymbolID &sym) = 0;
+  template <typename T>
+  void acceptNullablePV(PinnedValue<T> &pv) {
+    acceptNullable(pv);
+  }
 
   /// When we want to call an acceptor on "raw" root pointers of
   /// some JSObject subtype T, this method does the necessary

lib/VM/Callable.cpp

@@ -918,16 +918,14 @@ Handle<NativeJSFunction> NativeJSFunction::create(
 
 /// \return the inferred parent of a Callable based on its \p kind.
 static Handle<JSObject> inferredParent(Runtime &runtime, FuncKind kind) {
-  PinnedHermesValue *parent;
   if (kind == FuncKind::Generator) {
-    parent = &runtime.generatorFunctionPrototype;
+    return runtime.generatorFunctionPrototype;
   } else if (kind == FuncKind::Async) {
-    parent = &runtime.asyncFunctionPrototype;
+    return runtime.asyncFunctionPrototype;
   } else {
     assert(kind == FuncKind::Normal && "Unsupported function kind");
-    parent = &runtime.functionPrototype;
+    return runtime.functionPrototype;
   }
-  return Handle<JSObject>::vmcast(parent);
 }
 
 Handle<NativeJSFunction> NativeJSFunction::createWithInferredParent(

lib/VM/FastArray.cpp

@@ -92,7 +92,7 @@ CallResult<Handle<FastArray>> FastArray::create(
       runtime,
       runtime.makeAFixed<FastArray>(
           runtime,
-          Handle<JSObject>::vmcast(&runtime.fastArrayPrototype),
+          runtime.fastArrayPrototype,
           Handle<HiddenClass>::vmcast(&runtime.fastArrayClass),
           GCPointerBase::NoBarriers()));
 

lib/VM/Interpreter-slowpaths.cpp

@@ -119,7 +119,8 @@ ExecutionStatus Interpreter::caseIteratorBegin(
       }
       PseudoHandle<> slotValue = std::move(*slotValueRes);
       if (LLVM_LIKELY(
-              slotValue->getRaw() == runtime.arrayPrototypeValues.getRaw())) {
+              slotValue->getRaw() ==
+              runtime.arrayPrototypeValues.getHermesValue().getRaw())) {
         O1REG(IteratorBegin) = HermesValue::encodeTrustedNumberValue(0);
         return ExecutionStatus::RETURNED;
       }

lib/VM/Interpreter.cpp

@@ -516,8 +516,7 @@ static CallResult<HiddenClass *> getHiddenClassForBuffer(
   LocalsRAII lraii(runtime, &lv);
 
   lv.clazz = *runtime.getHiddenClassForPrototype(
-      vmcast<JSObject>(runtime.objectPrototype),
-      JSObject::numOverlapSlots<JSObject>());
+      *runtime.objectPrototype, JSObject::numOverlapSlots<JSObject>());
 
   ShapeTableEntry shapeInfo = curCodeBlock->getRuntimeModule()
                                   ->getBytecode()
@@ -1518,7 +1517,7 @@ CallResult<HermesValue> Interpreter::interpretFunction(
           O1REG(CoerceThisNS) = O2REG(CoerceThisNS);
         } else if (
             O2REG(CoerceThisNS).isNull() || O2REG(CoerceThisNS).isUndefined()) {
-          O1REG(CoerceThisNS) = runtime.global_;
+          O1REG(CoerceThisNS) = runtime.global_.getHermesValue();
         } else {
           tmpHandle = O2REG(CoerceThisNS);
           nextIP = NEXTINST(CoerceThisNS);
@@ -1533,7 +1532,7 @@ CallResult<HermesValue> Interpreter::interpretFunction(
         } else if (
             FRAME.getThisArgRef().isNull() ||
             FRAME.getThisArgRef().isUndefined()) {
-          O1REG(LoadThisNS) = runtime.global_;
+          O1REG(LoadThisNS) = runtime.global_.getHermesValue();
         } else {
           tmpHandle = FRAME.getThisArgRef();
           nextIP = NEXTINST(LoadThisNS);
@@ -1771,11 +1770,11 @@ CallResult<HermesValue> Interpreter::interpretFunction(
       }
 
       CASE(Catch) {
-        assert(!runtime.thrownValue_.isEmpty() && "Invalid thrown value");
+        assert(!runtime.thrownValue_->isEmpty() && "Invalid thrown value");
         assert(
-            !isUncatchableError(runtime.thrownValue_) &&
+            !isUncatchableError(*runtime.thrownValue_) &&
             "Uncatchable thrown value was caught");
-        O1REG(Catch) = runtime.thrownValue_;
+        O1REG(Catch) = *runtime.thrownValue_;
         runtime.clearThrownValue();
 #ifdef HERMES_ENABLE_DEBUGGER
         // Signal to the debugger that we're done unwinding an exception,
@@ -1790,7 +1789,7 @@ CallResult<HermesValue> Interpreter::interpretFunction(
         runtime.thrownValue_ = O1REG(Throw);
         SLOW_DEBUG(
             dbgs() << "Exception thrown: "
-                   << DumpHermesValue(runtime.thrownValue_) << "\n");
+                   << DumpHermesValue(*runtime.thrownValue_) << "\n");
         goto exception;
       }
 
@@ -2103,7 +2102,7 @@ CallResult<HermesValue> Interpreter::interpretFunction(
       }
 
       CASE(GetGlobalObject) {
-        O1REG(GetGlobalObject) = runtime.global_;
+        O1REG(GetGlobalObject) = runtime.global_.getHermesValue();
         ip = NEXTINST(GetGlobalObject);
         DISPATCH;
       }
@@ -3002,9 +3001,9 @@ CallResult<HermesValue> Interpreter::interpretFunction(
             Callable::newObject(
                 Handle<Callable>::vmcast(&O3REG(CreateThis)),
                 runtime,
-                Handle<JSObject>::vmcast(
-                    O2REG(CreateThis).isObject() ? &O2REG(CreateThis)
-                                                 : &runtime.objectPrototype)));
+                O2REG(CreateThis).isObject()
+                    ? Handle<JSObject>::vmcast(&O2REG(CreateThis))
+                    : runtime.objectPrototype));
         if (LLVM_UNLIKELY(res == ExecutionStatus::EXCEPTION)) {
           goto exception;
         }
@@ -3480,7 +3479,7 @@ CallResult<HermesValue> Interpreter::interpretFunction(
                   Runtime::getEmptyValue()));
           if (LLVM_UNLIKELY(res == ExecutionStatus::EXCEPTION)) {
             if (ip->iIteratorClose.op2 &&
-                !isUncatchableError(runtime.thrownValue_)) {
+                !isUncatchableError(*runtime.thrownValue_)) {
               // Ignore inner exception.
               runtime.clearThrownValue();
             } else {
@@ -3525,26 +3524,29 @@ CallResult<HermesValue> Interpreter::interpretFunction(
   exception:
     UPDATE_OPCODE_TIME_SPENT;
     assert(
-        !runtime.thrownValue_.isEmpty() &&
+        !runtime.thrownValue_->isEmpty() &&
         "thrownValue unavailable at exception");
 
     bool catchable = true;
     // If this is an Error object that was thrown internally, it didn't have
     // access to the current codeblock and IP, so collect the stack trace here.
-    if (auto *jsError = dyn_vmcast<JSError>(runtime.thrownValue_)) {
+    if (auto *jsError = dyn_vmcast<JSError>(*runtime.thrownValue_)) {
       catchable = jsError->catchable();
       if (!jsError->getStackTrace()) {
-        // Temporarily clear the thrown value for following operations.
-        CAPTURE_IP_ASSIGN(
-            auto errorHandle,
-            runtime.makeHandle(vmcast<JSError>(runtime.thrownValue_)));
+        // Temporarily clear the thrown value for following operations. Before
+        // we clear it, save the value in tmpHandle.
+        tmpHandle = *runtime.thrownValue_;
         runtime.clearThrownValue();
 
         CAPTURE_IP(JSError::recordStackTrace(
-            errorHandle, runtime, false, curCodeBlock, ip));
+            Handle<JSError>::vmcast(tmpHandle),
+            runtime,
+            false,
+            curCodeBlock,
+            ip));
 
         // Restore the thrown value.
-        runtime.setThrownValue(errorHandle.getHermesValue());
+        runtime.setThrownValue(*tmpHandle);
       }
     }
 

lib/VM/JSArray.cpp

@@ -436,8 +436,7 @@ CallResult<Handle<Arguments>> Arguments::create(
       P::length,
       runtime.makeHandle(HermesValue::encodeTrustedNumberValue(length)));
 
-  DEFINE_PROP(
-      selfHandle, P::SymbolIterator, Handle<>(&runtime.arrayPrototypeValues));
+  DEFINE_PROP(selfHandle, P::SymbolIterator, runtime.arrayPrototypeValues);
 
   if (strictMode) {
     // Define .callee and .caller properties: throw always in strict mode