fixup: use typed array

Signed-off-by: Daeyeon Jeong <[email protected]>

Author: daeyeon

lib/internal/bootstrap/node.js

@@ -81,11 +81,9 @@ const {
 } = require('internal/validators');
 const {
   exiting_aliased_Uint32Array,
+  exit_info_private_symbol,
   getHiddenValue,
 } = internalBinding('util');
-const {
-  exit_code_symbol: kExitCode,
-} = internalBinding('symbols');
 
 setupProcessObject();
 
@@ -111,6 +109,11 @@ process.domain = null;
 process._exiting = false;
 
 {
+  // Must match `Environment::ExitInfo::Fields` in `src/env.h`.
+  const kExitCode = 0;
+  const kHasExitCode = 1;
+  const fields = getHiddenValue(process, exit_info_private_symbol);
+
   let exitCode;
 
   ObjectDefineProperty(process, 'exitCode', {
@@ -126,10 +129,10 @@ process._exiting = false;
           value = code;
         }
         validateInteger(value, 'code');
-        process[kExitCode] = value;
+        fields[kExitCode] = value;
+        fields[kHasExitCode] = 1;
       } else {
-        // unset exit code
-        process[kExitCode] = code;
+        fields[kHasExitCode] = 0;
       }
       exitCode = code;
     },

src/api/hooks.cc

@@ -37,12 +37,11 @@ Maybe<bool> EmitProcessBeforeExit(Environment* env) {
 
   Isolate* isolate = env->isolate();
   HandleScope handle_scope(isolate);
-  Local<Context> context = env->context();
-  Context::Scope context_scope(context);
+  Context::Scope context_scope(env->context());
 
   Local<Integer> exit_code = v8::Integer::New(
       isolate,
-      env->exit_code().value_or(static_cast<int32_t>(ExitCode::kNoFailure)));
+      env->maybe_exit_code(static_cast<int32_t>(ExitCode::kNoFailure)));
 
   return ProcessEmit(env, "beforeExit", exit_code).IsEmpty() ?
       Nothing<bool>() : Just(true);
@@ -60,21 +59,19 @@ Maybe<ExitCode> EmitProcessExitInternal(Environment* env) {
   // process.emit('exit')
   Isolate* isolate = env->isolate();
   HandleScope handle_scope(isolate);
-  Local<Context> context = env->context();
-  Context::Scope context_scope(context);
+  Context::Scope context_scope(env->context());
 
   env->set_exiting(true);
 
-  const std::optional<int32_t>& exit_code = env->exit_code();
   const int no_failure = static_cast<int32_t>(ExitCode::kNoFailure);
 
   if (ProcessEmit(
-          env, "exit", Integer::New(isolate, exit_code.value_or(no_failure)))
+          env, "exit", Integer::New(isolate, env->maybe_exit_code(no_failure)))
           .IsEmpty()) {
     return Nothing<ExitCode>();
   }
   // Reload exit code, it may be changed by `emit('exit')`
-  return Just(static_cast<ExitCode>(exit_code.value_or(no_failure)));
+  return Just(static_cast<ExitCode>(env->maybe_exit_code(no_failure)));
 }
 
 Maybe<int> EmitProcessExit(Environment* env) {

src/env-inl.h

@@ -171,6 +171,18 @@ inline bool TickInfo::has_rejection_to_warn() const {
   return fields_[kHasRejectionToWarn] == 1;
 }
 
+inline const AliasedInt32Array& ExitInfo::fields() {
+  return fields_;
+}
+
+inline bool ExitInfo::has_exit_code() const {
+  return fields_[kHasExitCode] == 1;
+}
+
+inline int32_t ExitInfo::exit_code() const {
+  return fields_[kExitCode];
+}
+
 inline Environment* Environment::GetCurrent(v8::Isolate* isolate) {
   if (UNLIKELY(!isolate->InContext())) return nullptr;
   v8::HandleScope handle_scope(isolate);
@@ -327,6 +339,14 @@ inline TickInfo* Environment::tick_info() {
   return &tick_info_;
 }
 
+inline ExitInfo* Environment::exit_info() {
+  return &exit_info_;
+}
+
+inline int32_t Environment::maybe_exit_code(const int32_t default_code) const {
+  return exit_info_.has_exit_code() ? exit_info_.exit_code() : default_code;
+}
+
 inline uint64_t Environment::timer_base() const {
   return timer_base_;
 }
@@ -371,14 +391,6 @@ inline AliasedUint32Array& Environment::exiting() {
   return exiting_;
 }
 
-inline void Environment::set_exit_code(const std::optional<int32_t> value) {
-  exit_code_ = value;
-}
-
-inline const std::optional<int32_t>& Environment::exit_code() const {
-  return exit_code_;
-}
-
 inline void Environment::set_abort_on_uncaught_exception(bool value) {
   options_->abort_on_uncaught_exception = value;
 }

src/env.cc

@@ -640,6 +640,7 @@ Environment::Environment(IsolateData* isolate_data,
       async_hooks_(isolate, MAYBE_FIELD_PTR(env_info, async_hooks)),
       immediate_info_(isolate, MAYBE_FIELD_PTR(env_info, immediate_info)),
       tick_info_(isolate, MAYBE_FIELD_PTR(env_info, tick_info)),
+      exit_info_(isolate, MAYBE_FIELD_PTR(env_info, exit_info)),
       timer_base_(uv_now(isolate_data->event_loop())),
       exec_argv_(exec_args),
       argv_(args),
@@ -1507,6 +1508,29 @@ void AsyncHooks::FailWithCorruptedAsyncStack(double expected_async_id) {
   ABORT_NO_BACKTRACE();
 }
 
+ExitInfo::SerializeInfo ExitInfo::Serialize(Local<Context> context,
+                                            SnapshotCreator* creator) {
+  return {fields_.Serialize(context, creator)};
+}
+
+void ExitInfo::Deserialize(Local<Context> context) {
+  fields_.Deserialize(context);
+}
+
+std::ostream& operator<<(std::ostream& output,
+                         const ExitInfo::SerializeInfo& i) {
+  output << "{ " << i.fields << " }";
+  return output;
+}
+
+void ExitInfo::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("fields", fields_);
+}
+
+ExitInfo::ExitInfo(Isolate* isolate, const SerializeInfo* info)
+    : fields_(
+          isolate, kFieldsCount, info == nullptr ? nullptr : &(info->fields)) {}
+
 void Environment::Exit(ExitCode exit_code) {
   if (options()->trace_exit) {
     HandleScope handle_scope(isolate());
@@ -1595,6 +1619,7 @@ EnvSerializeInfo Environment::Serialize(SnapshotCreator* creator) {
   info.async_hooks = async_hooks_.Serialize(ctx, creator);
   info.immediate_info = immediate_info_.Serialize(ctx, creator);
   info.tick_info = tick_info_.Serialize(ctx, creator);
+  info.exit_info = exit_info_.Serialize(ctx, creator);
   info.performance_state = performance_state_->Serialize(ctx, creator);
   info.exiting = exiting_.Serialize(ctx, creator);
   info.stream_base_state = stream_base_state_.Serialize(ctx, creator);
@@ -1637,6 +1662,7 @@ void Environment::DeserializeProperties(const EnvSerializeInfo* info) {
   async_hooks_.Deserialize(ctx);
   immediate_info_.Deserialize(ctx);
   tick_info_.Deserialize(ctx);
+  exit_info_.Deserialize(ctx);
   performance_state_->Deserialize(ctx);
   exiting_.Deserialize(ctx);
   stream_base_state_.Deserialize(ctx);
@@ -1833,6 +1859,7 @@ void Environment::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("async_hooks", async_hooks_);
   tracker->TrackField("immediate_info", immediate_info_);
   tracker->TrackField("tick_info", tick_info_);
+  tracker->TrackField("exit_info", exit_info_);
   tracker->TrackField("principal_realm", principal_realm_);
 
   // FIXME(joyeecheung): track other fields in Environment.

src/env.h

@@ -54,7 +54,6 @@
 #include <functional>
 #include <list>
 #include <memory>
-#include <optional>
 #include <ostream>
 #include <set>
 #include <string>
@@ -460,6 +459,38 @@ class TickInfo : public MemoryRetainer {
   AliasedUint8Array fields_;
 };
 
+class ExitInfo : public MemoryRetainer {
+ public:
+  inline const AliasedInt32Array& fields();
+  inline bool has_exit_code() const;
+  inline int32_t exit_code() const;
+
+  SET_MEMORY_INFO_NAME(ExitInfo)
+  SET_SELF_SIZE(ExitInfo)
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
+  ExitInfo(const ExitInfo&) = delete;
+  ExitInfo& operator=(const ExitInfo&) = delete;
+  ExitInfo(ExitInfo&&) = delete;
+  ExitInfo& operator=(ExitInfo&&) = delete;
+  ~ExitInfo() = default;
+
+  struct SerializeInfo {
+    AliasedBufferIndex fields;
+  };
+  SerializeInfo Serialize(v8::Local<v8::Context> context,
+                          v8::SnapshotCreator* creator);
+  void Deserialize(v8::Local<v8::Context> context);
+
+  enum Fields { kExitCode = 0, kHasExitCode, kFieldsCount };
+
+ private:
+  friend class Environment;  // So we can call the constructor.
+  explicit ExitInfo(v8::Isolate* isolate, const SerializeInfo* info);
+
+  AliasedInt32Array fields_;
+};
+
 class TrackingTraceStateObserver :
     public v8::TracingController::TraceStateObserver {
  public:
@@ -515,6 +546,7 @@ struct EnvSerializeInfo {
   TickInfo::SerializeInfo tick_info;
   ImmediateInfo::SerializeInfo immediate_info;
   performance::PerformanceState::SerializeInfo performance_state;
+  ExitInfo::SerializeInfo exit_info;
   AliasedBufferIndex exiting;
   AliasedBufferIndex stream_base_state;
   AliasedBufferIndex should_abort_on_uncaught_toggle;
@@ -727,6 +759,8 @@ class Environment : public MemoryRetainer {
   inline AsyncHooks* async_hooks();
   inline ImmediateInfo* immediate_info();
   inline TickInfo* tick_info();
+  inline ExitInfo* exit_info();
+  inline int32_t maybe_exit_code(const int32_t default_code) const;
   inline uint64_t timer_base() const;
   inline std::shared_ptr<KVStore> env_vars();
   inline void set_env_vars(std::shared_ptr<KVStore> env_vars);
@@ -747,9 +781,6 @@ class Environment : public MemoryRetainer {
   inline void set_exiting(bool value);
   inline AliasedUint32Array& exiting();
 
-  inline void set_exit_code(const std::optional<int32_t> value);
-  inline const std::optional<int32_t>& exit_code() const;
-
   // This stores whether the --abort-on-uncaught-exception flag was passed
   // to Node.
   inline bool abort_on_uncaught_exception() const;
@@ -1058,6 +1089,7 @@ class Environment : public MemoryRetainer {
   AsyncHooks async_hooks_;
   ImmediateInfo immediate_info_;
   TickInfo tick_info_;
+  ExitInfo exit_info_;
   const uint64_t timer_base_;
   std::shared_ptr<KVStore> env_vars_;
   bool printed_error_ = false;
@@ -1105,8 +1137,8 @@ class Environment : public MemoryRetainer {
   uint32_t script_id_counter_ = 0;
   uint32_t function_id_counter_ = 0;
 
+  // TODO(daeyeon): merge into `exit_info_`
   AliasedUint32Array exiting_;
-  std::optional<int32_t> exit_code_;
 
   AliasedUint32Array should_abort_on_uncaught_toggle_;
   int should_not_abort_scope_counter_ = 0;

src/env_properties.h

@@ -25,7 +25,8 @@
   V(napi_type_tag, "node:napi:type_tag")                                       \
   V(napi_wrapper, "node:napi:wrapper")                                         \
   V(untransferable_object_private_symbol, "node:untransferableObject")         \
-  V(exiting_aliased_Uint32Array, "node:exiting_aliased_Uint32Array")
+  V(exiting_aliased_Uint32Array, "node:exiting_aliased_Uint32Array")           \
+  V(exit_info_private_symbol, "node:exit_info_private_symbol")
 
 // Symbols are per-isolate primitives but Environment proxies them
 // for the sake of convenience.
@@ -41,8 +42,7 @@
   V(owner_symbol, "owner_symbol")                                              \
   V(onpskexchange_symbol, "onpskexchange")                                     \
   V(resource_symbol, "resource_symbol")                                        \
-  V(trigger_async_id_symbol, "trigger_async_id_symbol")                        \
-  V(exit_code_symbol, "exit_code_symbol")
+  V(trigger_async_id_symbol, "trigger_async_id_symbol")
 
 // Strings are per-isolate primitives but Environment proxies them
 // for the sake of convenience.  Strings should be ASCII-only.

src/node_errors.cc

@@ -1152,8 +1152,8 @@ void TriggerUncaughtException(Isolate* isolate,
 
   // If the global uncaught exception handler sets process.exitCode,
   // exit with that code. Otherwise, exit with `ExitCode::kGenericUserError`.
-  env->Exit(static_cast<ExitCode>(env->exit_code().value_or(
-      static_cast<int32_t>(ExitCode::kGenericUserError))));
+  env->Exit(static_cast<ExitCode>(
+      env->maybe_exit_code(static_cast<int>(ExitCode::kGenericUserError))));
 }
 
 void TriggerUncaughtException(Isolate* isolate, const v8::TryCatch& try_catch) {

src/node_internals.h

@@ -414,6 +414,8 @@ std::ostream& operator<<(std::ostream& output,
 std::ostream& operator<<(std::ostream& output,
                          const AsyncHooks::SerializeInfo& d);
 std::ostream& operator<<(std::ostream& output, const SnapshotMetadata& d);
+std::ostream& operator<<(std::ostream& output,
+                         const ExitInfo::SerializeInfo& d);
 
 namespace performance {
 std::ostream& operator<<(std::ostream& output,