deps: V8: backport 9997fc013952

Original commit message:

    [wasm][exnref] Use wasm_null for exnref

    A JS null caught in wasm as an exnref with catch_(all_)ref should be
    observably different from a null exnref: a JS null should behave like a
    regular JS exception with null as the externref package, while a null
    exnref is the actual null value for this type. In particular, a JS
    null exception can be rethrown while a null exnref cannot.
    Represent null exnrefs with wasm_null instead of JS null to avoid the
    confusion.

    [email protected]

    Fixed: 374790906
    Change-Id: If9f16a24407ee7d1399613255c3f14e0a6ebef9e
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/5953226
    Reviewed-by: Jakob Kummerow <[email protected]>
    Commit-Queue: Thibaud Michaud <[email protected]>
    Cr-Commit-Position: refs/heads/main@{#96782}

Refs: v8/v8@9997fc013952

Author: thibaudmichaud

deps/v8/src/builtins/wasm.tq

@@ -373,7 +373,12 @@ builtin WasmThrow(tag: Object, values: FixedArray): JSAny {
 }
 
 builtin WasmRethrow(exception: Object): JSAny {
-  if (exception == Null) tail ThrowWasmTrapRethrowNull();
+  dcheck(exception != kWasmNull);
+  tail runtime::WasmReThrow(LoadContextFromFrame(), exception);
+}
+
+builtin WasmThrowRef(exception: Object): JSAny {
+  if (exception == kWasmNull) tail ThrowWasmTrapRethrowNull();
   tail runtime::WasmReThrow(LoadContextFromFrame(), exception);
 }
 

deps/v8/src/compiler/wasm-compiler.cc

@@ -391,10 +391,8 @@ Node* WasmGraphBuilder::EffectPhi(unsigned count, Node** effects_and_control) {
 Node* WasmGraphBuilder::RefNull(wasm::ValueType type) {
   // We immediately lower null in wrappers, as they do not go through a lowering
   // phase.
-  // TODO(thibaudm): Can we use wasm null for exnref?
   return parameter_mode_ == kInstanceParameterMode ? gasm_->Null(type)
-         : (type == wasm::kWasmExternRef || type == wasm::kWasmNullExternRef ||
-            type == wasm::kWasmExnRef || type == wasm::kWasmNullExnRef)
+         : (type == wasm::kWasmExternRef || type == wasm::kWasmNullExternRef)
              ? LOAD_ROOT(NullValue, null_value)
              : LOAD_ROOT(WasmNull, wasm_null);
 }
@@ -2372,6 +2370,14 @@ Node* WasmGraphBuilder::Rethrow(Node* except_obj) {
       Builtin::kWasmRethrow, Operator::kNoProperties, except_obj);
 }
 
+Node* WasmGraphBuilder::ThrowRef(Node* except_obj) {
+  // TODO(v8:8091): Currently the message of the original exception is not being
+  // preserved when rethrown to the console. The pending message will need to be
+  // saved when caught and restored here while being rethrown.
+  return gasm_->CallBuiltinThroughJumptable(
+      Builtin::kWasmThrowRef, Operator::kNoProperties, except_obj);
+}
+
 Node* WasmGraphBuilder::IsExceptionTagUndefined(Node* tag) {
   return gasm_->TaggedEqual(tag, UndefinedValue());
 }

deps/v8/src/compiler/wasm-compiler.h

@@ -233,6 +233,7 @@ class WasmGraphBuilder {
               const base::Vector<Node*> values,
               wasm::WasmCodePosition position);
   Node* Rethrow(Node* except_obj);
+  Node* ThrowRef(Node* except_obj);
   Node* IsExceptionTagUndefined(Node* tag);
   Node* LoadJSTag();
   Node* ExceptionTagEqual(Node* caught_tag, Node* expected_tag);

deps/v8/src/wasm/baseline/liftoff-compiler.cc

@@ -1668,7 +1668,7 @@ class LiftoffCompiler {
   void ThrowRef(FullDecoder* decoder, Value*) {
     // Like Rethrow, but pops the exception from the stack.
     VarState exn = __ PopVarState();
-    CallBuiltin(Builtin::kWasmRethrow, MakeSig::Params(kRef), {exn},
+    CallBuiltin(Builtin::kWasmThrowRef, MakeSig::Params(kRef), {exn},
                 decoder->position());
     int pc_offset = __ pc_offset();
     MaybeOSR();
@@ -8253,11 +8253,9 @@ class LiftoffCompiler {
   }
 
   void LoadNullValue(Register null, ValueType type) {
-    // TODO(thibaudm): Can we use wasm null for exnref?
     __ LoadFullPointer(
         null, kRootRegister,
-        type == kWasmExternRef || type == kWasmNullExternRef ||
-                type == kWasmExnRef || type == kWasmNullExnRef
+        type == kWasmExternRef || type == kWasmNullExternRef
             ? IsolateData::root_slot_offset(RootIndex::kNullValue)
             : IsolateData::root_slot_offset(RootIndex::kWasmNull));
   }
@@ -8270,8 +8268,7 @@ class LiftoffCompiler {
                                ValueType type) {
 #if V8_STATIC_ROOTS_BOOL
     // TODO(14616): Extend this for shared types.
-    bool is_wasm_null = type != kWasmExternRef && type != kWasmNullExternRef &&
-                        type != kWasmExnRef && type != kWasmNullExnRef;
+    bool is_wasm_null = type != kWasmExternRef && type != kWasmNullExternRef;
     uint32_t value = is_wasm_null ? StaticReadOnlyRoot::kWasmNull
                                   : StaticReadOnlyRoot::kNullValue;
     __ LoadConstant(LiftoffRegister(null),

deps/v8/src/wasm/constant-expression-interface.cc

@@ -105,8 +105,7 @@ void ConstantExpressionInterface::RefNull(FullDecoder* decoder, ValueType type,
                                           Value* result) {
   if (!generate_value()) return;
   result->runtime_value =
-      WasmValue((IsSubtypeOf(type, kWasmExternRef, decoder->module_) ||
-                 IsSubtypeOf(type, kWasmExnRef, decoder->module_))
+      WasmValue(IsSubtypeOf(type, kWasmExternRef, decoder->module_)
                     ? Handle<Object>::cast(isolate_->factory()->null_value())
                     : Handle<Object>::cast(isolate_->factory()->wasm_null()),
                 type);
@@ -201,8 +200,7 @@ WasmValue DefaultValueForType(ValueType type, Isolate* isolate) {
       return WasmValue(Simd128());
     case kRefNull:
       return WasmValue(
-          type == kWasmExternRef || type == kWasmNullExternRef ||
-                  type == kWasmExnRef || type == kWasmNullExnRef
+          type == kWasmExternRef || type == kWasmNullExternRef
               ? Handle<Object>::cast(isolate->factory()->null_value())
               : Handle<Object>::cast(isolate->factory()->wasm_null()),
           type);

deps/v8/src/wasm/graph-builder-interface.cc

@@ -2799,7 +2799,7 @@ class WasmGraphBuildingInterface {
 
   void ThrowRef(FullDecoder* decoder, TFNode* exception) {
     DCHECK_NOT_NULL(exception);
-    CheckForException(decoder, builder_->Rethrow(exception), false);
+    CheckForException(decoder, builder_->ThrowRef(exception), false);
     builder_->TerminateThrow(effect(), control());
   }
 };

deps/v8/src/wasm/wasm-builtin-list.h

@@ -51,6 +51,7 @@ namespace v8::internal::wasm {
   V(WasmAllocateFixedArray)                                                    \
   V(WasmThrow)                                                                 \
   V(WasmRethrow)                                                               \
+  V(WasmThrowRef)                                                              \
   V(WasmRethrowExplicitContext)                                                \
   V(WasmTraceEnter)                                                            \
   V(WasmTraceExit)                                                             \