src, lib: take control of prepareStackTrace

Refs https://crbug.com/v8/7848
PR-URL: #23926
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

Author: devsnek

lib/internal/bootstrap/node.js

@@ -35,6 +35,8 @@
 // passed by node::RunBootstrapping()
 /* global process, require, internalBinding, isMainThread, ownsProcessState */
 
+setupPrepareStackTrace();
+
 const{JSON, Object, Symbol }=primordials;
 constconfig=internalBinding('config');
 const{ deprecate }=require('internal/util');
@@ -290,6 +292,12 @@ process.emitWarning = emitWarning;
 // Note: only after this point are the timers effective
 }
 
+functionsetupPrepareStackTrace(){
+const{ setPrepareStackTraceCallback }=internalBinding('errors');
+const{ prepareStackTrace }=require('internal/errors');
+setPrepareStackTraceCallback(prepareStackTrace);
+}
+
 functionsetupProcessObject(){
 constEventEmitter=require('events');
 constorigProcProto=Object.getPrototypeOf(process);

lib/internal/errors.js

@@ -19,6 +19,31 @@ const codes = {};
 
 const{ kMaxLength }=internalBinding('buffer');
 
+constMainContextError=Error;
+constErrorToString=Error.prototype.toString;
+// Polyfill of V8's Error.prepareStackTrace API.
+// https://crbug.com/v8/7848
+constprepareStackTrace=(globalThis,error,trace)=>{
+// `globalThis` is the global that contains the constructor which
+// created `error`.
+if(typeofglobalThis.Error.prepareStackTrace==='function'){
+returnglobalThis.Error.prepareStackTrace(error,trace);
+}
+// We still have legacy usage that depends on the main context's `Error`
+// being used, even when the error is from a different context.
+// TODO(devsnek): evaluate if this can be eventually deprecated/removed.
+if(typeofMainContextError.prepareStackTrace==='function'){
+returnMainContextError.prepareStackTrace(error,trace);
+}
+
+consterrorString=ErrorToString.call(error);
+if(trace.length===0){
+returnerrorString;
+}
+return`${errorString}\n at ${trace.join('\n at ')}`;
+};
+
+
 letexcludedStackFn;
 
 // Lazily loaded
@@ -598,7 +623,8 @@ module.exports = {
  uvExceptionWithHostPort,
  SystemError,
 // This is exported only to facilitate testing.
- E
+ E,
+ prepareStackTrace,
 };
 
 // To declare an error message, use the E(sym, val, def) function above. The sym

src/api/environment.cc

@@ -13,6 +13,8 @@
 #endif
 
 namespacenode {
+using errors::TryCatchScope;
+using v8::Array;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::Function;
@@ -45,6 +47,41 @@ static bool ShouldAbortOnUncaughtException(Isolate* isolate) {
  !env->inside_should_not_abort_on_uncaught_scope();
 }
 
+static MaybeLocal<Value> PrepareStackTraceCallback(Local<Context> context,
+ Local<Value> exception,
+ Local<Array> trace) {
+ Environment* env = Environment::GetCurrent(context);
+if (env == nullptr) {
+ MaybeLocal<String> s = exception->ToString(context);
+return s.IsEmpty() ?
+ MaybeLocal<Value>() :
+ MaybeLocal<Value>(s.ToLocalChecked());
+ }
+ Local<Function> prepare = env->prepare_stack_trace_callback();
+if (prepare.IsEmpty()) {
+ MaybeLocal<String> s = exception->ToString(context);
+return s.IsEmpty() ?
+ MaybeLocal<Value>() :
+ MaybeLocal<Value>(s.ToLocalChecked());
+ }
+ Local<Value> args[] = {
+ context->Global(),
+ exception,
+ trace,
+ };
+// This TryCatch + Rethrow is required by V8 due to details around exception
+// handling there. For C++ callbacks, V8 expects a scheduled exception (which
+// is what ReThrow gives us). Just returning the empty MaybeLocal would leave
+// us with a pending exception.
+ TryCatchScope try_catch(env);
+ MaybeLocal<Value> result = prepare->Call(
+ context, Undefined(env->isolate()), arraysize(args), args);
+if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
+ try_catch.ReThrow();
+ }
+return result;
+}
+
 void* NodeArrayBufferAllocator::Allocate(size_t size) {
 if (zero_fill_field_ || per_process::cli_options->zero_fill_all_buffers)
 returnUncheckedCalloc(size);
@@ -166,6 +203,7 @@ void SetIsolateUpForNode(v8::Isolate* isolate, IsolateSettingCategories cat) {
  isolate->SetAbortOnUncaughtExceptionCallback(
  ShouldAbortOnUncaughtException);
  isolate->SetFatalErrorHandler(OnFatalError);
+ isolate->SetPrepareStackTraceCallback(PrepareStackTraceCallback);
 break;
 case IsolateSettingCategories::kMisc:
  isolate->SetMicrotasksPolicy(MicrotasksPolicy::kExplicit);

src/env.h

@@ -402,6 +402,7 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
 V(native_module_require, v8::Function) \
 V(performance_entry_callback, v8::Function) \
 V(performance_entry_template, v8::Function) \
+V(prepare_stack_trace_callback, v8::Function) \
 V(process_object, v8::Object) \
 V(primordials, v8::Object) \
 V(promise_reject_callback, v8::Function) \

src/node_binding.cc

@@ -48,6 +48,7 @@
  V(contextify) \
  V(credentials) \
  V(domain) \
+ V(errors) \
  V(fs) \
  V(fs_event_wrap) \
  V(heap_utils) \

src/node_errors.cc

@@ -17,6 +17,7 @@ using v8::Boolean;
 using v8::Context;
 using v8::Exception;
 using v8::Function;
+using v8::FunctionCallbackInfo;
 using v8::HandleScope;
 using v8::Int32;
 using v8::Isolate;
@@ -767,6 +768,21 @@ void PerIsolateMessageListener(Local<Message> message, Local<Value> error) {
  }
 }
 
+voidSetPrepareStackTraceCallback(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args[0]->IsFunction());
+ env->set_prepare_stack_trace_callback(args[0].As<Function>());
+}
+
+voidInitialize(Local<Object> target,
+ Local<Value> unused,
+ Local<Context> context,
+void* priv) {
+ Environment* env = Environment::GetCurrent(context);
+ env->SetMethod(
+ target, "setPrepareStackTraceCallback", SetPrepareStackTraceCallback);
+}
+
 } // namespace errors
 
 voidDecorateErrorStack(Environment* env,
@@ -880,3 +896,5 @@ void FatalException(Isolate* isolate,
 }
 
 } // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(errors, node::errors::Initialize)

test/parallel/test-bootstrap-modules.js

@@ -9,6 +9,7 @@ const common = require('../common');
 constassert=require('assert');
 
 constexpectedModules=newSet([
+'Internal Binding errors',
 'Internal Binding async_wrap',
 'Internal Binding buffer',
 'Internal Binding config',