[wasm] Torqueify more Wasm builtins

- Rewrites the following builtins in Torque:
  WasmThrow
  WasmRethrow
  WasmStackGuard
  WasmStackOverflow
  WasmTraceMemory
  WasmAllocateJSArray
  ThrowWasmTrap* builtins

- Changes return type of LoadContext* functions to NativeContext,
  so we can more easily construct JS objects.

Change-Id: Id034358f9f15e0acc58fd1f493b15d1cfd177a23
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2174830
Commit-Queue: Bill Budge <bbudge@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#67621}

src/builtins/base.tq

@@ -307,7 +307,21 @@ extern enum MessageTemplate {
   kProxySetPrototypeOfNonExtensible,
   kProxyDeletePropertyNonExtensible,
   kWeakRefsCleanupMustBeCallable,
+  kWasmTrapUnreachable,
+  kWasmTrapMemOutOfBounds,
+  kWasmTrapUnalignedAccess,
+  kWasmTrapDivByZero,
+  kWasmTrapDivUnrepresentable,
+  kWasmTrapRemByZero,
+  kWasmTrapFloatUnrepresentable,
+  kWasmTrapFuncInvalid,
+  kWasmTrapFuncSigMismatch,
+  kWasmTrapDataSegmentDropped,
+  kWasmTrapElemSegmentDropped,
   kWasmTrapTableOutOfBounds,
+  kWasmTrapBrOnExnNullRef,
+  kWasmTrapRethrowNullRef,
+  kWasmTrapNullDereference,
   ...
 }
 

src/builtins/builtins-definitions.h

@@ -841,7 +841,6 @@ namespace internal {
   ASM(WasmDebugBreak, Dummy)                                                   \
   TFC(WasmFloat32ToNumber, WasmFloat32ToNumber)                                \
   TFC(WasmFloat64ToNumber, WasmFloat64ToNumber)                                \
-  TFS(WasmAllocateJSArray, kArraySize)                                         \
   TFS(WasmAllocateStruct, kMapIndex)                                           \
   TFC(WasmAtomicNotify, WasmAtomicNotify)                                      \
   TFS(WasmGetOwnProperty, kObject, kUniqueName)                                \
@@ -849,29 +848,8 @@ namespace internal {
   TFC(WasmI32AtomicWait64, WasmI32AtomicWait64)                                \
   TFC(WasmI64AtomicWait32, WasmI64AtomicWait32)                                \
   TFC(WasmI64AtomicWait64, WasmI64AtomicWait64)                                \
-  TFC(WasmMemoryGrow, WasmMemoryGrow)                                          \
   TFC(WasmTableInit, WasmTableInit)                                            \
   TFC(WasmTableCopy, WasmTableCopy)                                            \
-  TFC(WasmStackGuard, NoContext)                                               \
-  TFC(WasmStackOverflow, NoContext)                                            \
-  TFC(WasmThrow, WasmThrow)                                                    \
-  TFC(WasmRethrow, WasmThrow)                                                  \
-  TFS(WasmTraceMemory, kMemoryTracingInfo)                                     \
-  TFS(ThrowWasmTrapUnreachable)                                                \
-  TFS(ThrowWasmTrapMemOutOfBounds)                                             \
-  TFS(ThrowWasmTrapUnalignedAccess)                                            \
-  TFS(ThrowWasmTrapDivByZero)                                                  \
-  TFS(ThrowWasmTrapDivUnrepresentable)                                         \
-  TFS(ThrowWasmTrapRemByZero)                                                  \
-  TFS(ThrowWasmTrapFloatUnrepresentable)                                       \
-  TFS(ThrowWasmTrapFuncInvalid)                                                \
-  TFS(ThrowWasmTrapFuncSigMismatch)                                            \
-  TFS(ThrowWasmTrapDataSegmentDropped)                                         \
-  TFS(ThrowWasmTrapElemSegmentDropped)                                         \
-  TFS(ThrowWasmTrapTableOutOfBounds)                                           \
-  TFS(ThrowWasmTrapBrOnExnNullRef)                                             \
-  TFS(ThrowWasmTrapRethrowNullRef)                                             \
-  TFS(ThrowWasmTrapNullDereference)                                            \
                                                                                \
   /* WeakMap */                                                                \
   TFJ(WeakMapConstructor, kDontAdaptArgumentsSentinel)                         \

src/builtins/builtins-wasm-gen.cc

@@ -19,7 +19,7 @@ TNode<WasmInstanceObject> WasmBuiltinsAssembler::LoadInstanceFromFrame() {
       LoadFromParentFrame(WasmCompiledFrameConstants::kWasmInstanceOffset));
 }
 
-TNode<Context> WasmBuiltinsAssembler::LoadContextFromInstance(
+TNode<NativeContext> WasmBuiltinsAssembler::LoadContextFromInstance(
     TNode<WasmInstanceObject> instance) {
   return CAST(Load(MachineType::AnyTagged(), instance,
                    IntPtrConstant(WasmInstanceObject::kNativeContextOffset -
@@ -56,59 +56,6 @@ TF_BUILTIN(WasmFloat64ToNumber, WasmBuiltinsAssembler) {
   Return(ChangeFloat64ToTagged(val));
 }
 
-TF_BUILTIN(WasmStackGuard, WasmBuiltinsAssembler) {
-  TNode<WasmInstanceObject> instance = LoadInstanceFromFrame();
-  TNode<Context> context = LoadContextFromInstance(instance);
-  TailCallRuntime(Runtime::kWasmStackGuard, context);
-}
-
-TF_BUILTIN(WasmStackOverflow, WasmBuiltinsAssembler) {
-  TNode<WasmInstanceObject> instance = LoadInstanceFromFrame();
-  TNode<Context> context = LoadContextFromInstance(instance);
-  TailCallRuntime(Runtime::kThrowWasmStackOverflow, context);
-}
-
-TF_BUILTIN(WasmThrow, WasmBuiltinsAssembler) {
-  TNode<Object> exception = CAST(Parameter(Descriptor::kException));
-  TNode<WasmInstanceObject> instance = LoadInstanceFromFrame();
-  TNode<Context> context = LoadContextFromInstance(instance);
-  TailCallRuntime(Runtime::kThrow, context, exception);
-}
-
-TF_BUILTIN(WasmRethrow, WasmBuiltinsAssembler) {
-  TNode<Object> exception = CAST(Parameter(Descriptor::kException));
-  TNode<WasmInstanceObject> instance = LoadInstanceFromFrame();
-  TNode<Context> context = LoadContextFromInstance(instance);
-
-  Label nullref(this, Label::kDeferred);
-  GotoIf(TaggedEqual(NullConstant(), exception), &nullref);
-
-  TailCallRuntime(Runtime::kReThrow, context, exception);
-
-  BIND(&nullref);
-  MessageTemplate message_id = MessageTemplate::kWasmTrapRethrowNullRef;
-  TailCallRuntime(Runtime::kThrowWasmError, context,
-                  SmiConstant(static_cast<int>(message_id)));
-}
-
-TF_BUILTIN(WasmTraceMemory, WasmBuiltinsAssembler) {
-  TNode<Smi> info = CAST(Parameter(Descriptor::kMemoryTracingInfo));
-  TNode<WasmInstanceObject> instance = LoadInstanceFromFrame();
-  TNode<Context> context = LoadContextFromInstance(instance);
-  TailCallRuntime(Runtime::kWasmTraceMemory, context, info);
-}
-
-TF_BUILTIN(WasmAllocateJSArray, WasmBuiltinsAssembler) {
-  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
-  TNode<Smi> array_size = CAST(Parameter(Descriptor::kArraySize));
-
-  TNode<Map> array_map = CAST(
-      LoadContextElement(context, Context::JS_ARRAY_PACKED_ELEMENTS_MAP_INDEX));
-
-  Return(CodeStubAssembler::AllocateJSArray(PACKED_ELEMENTS, array_map,
-                                            array_size, array_size));
-}
-
 TF_BUILTIN(WasmGetOwnProperty, CodeStubAssembler) {
   TNode<Object> object = CAST(Parameter(Descriptor::kObject));
   TNode<Name> unique_name = CAST(Parameter(Descriptor::kUniqueName));
@@ -271,26 +218,6 @@ TF_BUILTIN(WasmI64AtomicWait64, WasmBuiltinsAssembler) {
   Return(Unsigned(SmiToInt32(result_smi)));
 }
 
-TF_BUILTIN(WasmMemoryGrow, WasmBuiltinsAssembler) {
-  TNode<Int32T> num_pages =
-      UncheckedCast<Int32T>(Parameter(Descriptor::kNumPages));
-  Label num_pages_out_of_range(this, Label::kDeferred);
-
-  TNode<BoolT> num_pages_fits_in_smi =
-      IsValidPositiveSmi(ChangeInt32ToIntPtr(num_pages));
-  GotoIfNot(num_pages_fits_in_smi, &num_pages_out_of_range);
-
-  TNode<Smi> num_pages_smi = SmiFromInt32(num_pages);
-  TNode<WasmInstanceObject> instance = LoadInstanceFromFrame();
-  TNode<Context> context = LoadContextFromInstance(instance);
-  TNode<Smi> ret_smi = CAST(
-      CallRuntime(Runtime::kWasmMemoryGrow, context, instance, num_pages_smi));
-  Return(SmiToInt32(ret_smi));
-
-  BIND(&num_pages_out_of_range);
-  Return(Int32Constant(-1));
-}
-
 TF_BUILTIN(WasmTableInit, WasmBuiltinsAssembler) {
   TNode<Uint32T> dst_raw =
       UncheckedCast<Uint32T>(Parameter(Descriptor::kDestination));
@@ -364,17 +291,5 @@ TF_BUILTIN(WasmAllocateStruct, WasmBuiltinsAssembler) {
   Return(result);
 }
 
-#define DECLARE_THROW_RUNTIME_FN(name)                            \
-  TF_BUILTIN(ThrowWasm##name, WasmBuiltinsAssembler) {            \
-    TNode<WasmInstanceObject> instance = LoadInstanceFromFrame(); \
-    TNode<Context> context = LoadContextFromInstance(instance);   \
-    MessageTemplate message_id =                                  \
-        wasm::WasmOpcodes::TrapReasonToMessageId(wasm::k##name);  \
-    TailCallRuntime(Runtime::kThrowWasmError, context,            \
-                    SmiConstant(static_cast<int>(message_id)));   \
-  }
-FOREACH_WASM_TRAPREASON(DECLARE_THROW_RUNTIME_FN)
-#undef DECLARE_THROW_RUNTIME_FN
-
 }  // namespace internal
 }  // namespace v8

src/builtins/builtins-wasm-gen.h

@@ -17,7 +17,8 @@ class WasmBuiltinsAssembler : public CodeStubAssembler {
 
   TNode<WasmInstanceObject> LoadInstanceFromFrame();
 
-  TNode<Context> LoadContextFromInstance(TNode<WasmInstanceObject> instance);
+  TNode<NativeContext> LoadContextFromInstance(
+      TNode<WasmInstanceObject> instance);
 
   TNode<FixedArray> LoadTablesFromInstance(TNode<WasmInstanceObject> instance);
 

src/builtins/wasm.tq

@@ -5,17 +5,23 @@
 #include 'src/builtins/builtins-wasm-gen.h'
 
 namespace runtime {
+  extern runtime WasmMemoryGrow(Context, WasmInstanceObject, Smi): Smi;
   extern runtime WasmRefFunc(Context, WasmInstanceObject, Smi): JSAny;
   extern runtime WasmFunctionTableGet(Context, WasmInstanceObject, Smi, Smi):
       JSAny;
   extern runtime WasmFunctionTableSet(
       Context, WasmInstanceObject, Smi, Smi, Object): JSAny;
   extern runtime ThrowWasmError(Context, Smi): JSAny;
+  extern runtime Throw(Context, Object): JSAny;
+  extern runtime ReThrow(Context, Object): JSAny;
+  extern runtime WasmStackGuard(Context): JSAny;
+  extern runtime ThrowWasmStackOverflow(Context): JSAny;
+  extern runtime WasmTraceMemory(Context, Smi): JSAny;
 }
 
 namespace wasm {
-  const kFuncTableType: constexpr int31
-  generates 'wasm::ValueType::Kind::kFuncRef';
+  const kFuncTableType:
+      constexpr int31 generates 'wasm::ValueType::Kind::kFuncRef';
 
   extern macro WasmBuiltinsAssembler::LoadInstanceFromFrame():
       WasmInstanceObject;
@@ -23,12 +29,16 @@ namespace wasm {
   // WasmInstanceObject has a field layout that Torque can't handle yet.
   // TODO(bbudge) Eliminate these functions when Torque is ready.
   extern macro WasmBuiltinsAssembler::LoadContextFromInstance(
-      WasmInstanceObject): Context;
+      WasmInstanceObject): NativeContext;
   extern macro WasmBuiltinsAssembler::LoadTablesFromInstance(
       WasmInstanceObject): FixedArray;
   extern macro WasmBuiltinsAssembler::LoadExternalFunctionsFromInstance(
       WasmInstanceObject): FixedArray;
 
+  macro LoadContextFromFrame(): NativeContext {
+    return LoadContextFromInstance(LoadInstanceFromFrame());
+  }
+
   builtin WasmInt32ToHeapNumber(val: int32): HeapNumber {
     return AllocateHeapNumberWithValue(Convert<float64>(val));
   }
@@ -42,6 +52,16 @@ namespace wasm {
     return ChangeTaggedToFloat64(val);
   }
 
+  builtin WasmMemoryGrow(numPages: int32): int32 {
+    if (!IsValidPositiveSmi(ChangeInt32ToIntPtr(numPages)))
+      return Int32Constant(-1);
+    const instance: WasmInstanceObject = LoadInstanceFromFrame();
+    const context: NativeContext = LoadContextFromInstance(instance);
+    const result: Smi =
+        runtime::WasmMemoryGrow(context, instance, SmiFromInt32(numPages));
+    return SmiToInt32(result);
+  }
+
   builtin WasmTableGet(tableIndex: intptr, index: int32): Object {
     const instance: WasmInstanceObject = LoadInstanceFromFrame();
     const entryIndex: intptr = ChangeInt32ToIntPtr(index);
@@ -71,9 +91,7 @@ namespace wasm {
           LoadContextFromInstance(instance), instance,
           SmiFromIntPtr(tableIndex), SmiFromIntPtr(entryIndex));
     } label IndexOutOfRange deferred {
-      tail runtime::ThrowWasmError(
-          LoadContextFromInstance(instance),
-          SmiConstant(MessageTemplate::kWasmTrapTableOutOfBounds));
+      tail ThrowWasmTrapTableOutOfBounds();
     }
   }
 
@@ -105,9 +123,7 @@ namespace wasm {
           LoadContextFromInstance(instance), instance,
           SmiFromIntPtr(tableIndex), SmiFromIntPtr(entryIndex), value);
     } label IndexOutOfRange deferred {
-      tail runtime::ThrowWasmError(
-          LoadContextFromInstance(instance),
-          SmiConstant(MessageTemplate::kWasmTrapTableOutOfBounds));
+      tail ThrowWasmTrapTableOutOfBounds();
     }
   }
 
@@ -125,4 +141,96 @@ namespace wasm {
           LoadContextFromInstance(instance), instance, SmiFromUint32(index));
     }
   }
+
+  builtin WasmThrow(exception: Object): JSAny {
+    tail runtime::Throw(LoadContextFromFrame(), exception);
+  }
+
+  builtin WasmRethrow(exception: Object): JSAny {
+    if (exception == Null) tail ThrowWasmTrapRethrowNullRef();
+    tail runtime::ReThrow(LoadContextFromFrame(), exception);
+  }
+
+  builtin WasmStackGuard(): JSAny {
+    tail runtime::WasmStackGuard(LoadContextFromFrame());
+  }
+
+  builtin WasmStackOverflow(): JSAny {
+    tail runtime::ThrowWasmStackOverflow(LoadContextFromFrame());
+  }
+
+  builtin WasmTraceMemory(info: Smi): JSAny {
+    tail runtime::WasmTraceMemory(LoadContextFromFrame(), info);
+  }
+
+  builtin WasmAllocateJSArray(implicit context: Context)(size: Smi): JSArray {
+    const map: Map = GetFastPackedElementsJSArrayMap();
+    return AllocateJSArray(ElementsKind::PACKED_ELEMENTS, map, size, size);
+  }
+
+  // Trap builtins.
+
+  builtin WasmTrap(error: Smi): JSAny {
+    tail runtime::ThrowWasmError(LoadContextFromFrame(), error);
+  }
+
+  builtin ThrowWasmTrapUnreachable(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapUnreachable));
+  }
+
+  builtin ThrowWasmTrapMemOutOfBounds(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapMemOutOfBounds));
+  }
+
+  builtin ThrowWasmTrapUnalignedAccess(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapUnalignedAccess));
+  }
+
+  builtin ThrowWasmTrapDivByZero(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapDivByZero));
+  }
+
+  builtin ThrowWasmTrapDivUnrepresentable(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapDivUnrepresentable));
+  }
+
+  builtin ThrowWasmTrapRemByZero(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapRemByZero));
+  }
+
+  builtin ThrowWasmTrapFloatUnrepresentable(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapFloatUnrepresentable));
+  }
+
+  builtin ThrowWasmTrapFuncInvalid(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapFuncInvalid));
+  }
+
+  builtin ThrowWasmTrapFuncSigMismatch(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapFuncSigMismatch));
+  }
+
+  builtin ThrowWasmTrapDataSegmentDropped(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapDataSegmentDropped));
+  }
+
+  builtin ThrowWasmTrapElemSegmentDropped(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapElemSegmentDropped));
+  }
+
+  builtin ThrowWasmTrapTableOutOfBounds(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapTableOutOfBounds));
+  }
+
+  builtin ThrowWasmTrapBrOnExnNullRef(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapBrOnExnNullRef));
+  }
+
+  builtin ThrowWasmTrapRethrowNullRef(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapRethrowNullRef));
+  }
+
+  builtin ThrowWasmTrapNullDereference(): JSAny {
+    tail WasmTrap(SmiConstant(MessageTemplate::kWasmTrapNullDereference));
+  }
 }

src/codegen/interface-descriptors.cc

@@ -391,11 +391,6 @@ void WasmFloat64ToNumberDescriptor::InitializePlatformSpecific(
 }
 #endif  // !V8_TARGET_ARCH_IA32
 
-void WasmMemoryGrowDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  DefaultInitializePlatformSpecific(data, kParameterCount);
-}
-
 void WasmTableInitDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   DefaultInitializePlatformSpecific(data,
@@ -408,11 +403,6 @@ void WasmTableCopyDescriptor::InitializePlatformSpecific(
                                     kParameterCount - kStackArgumentsCount);
 }
 
-void WasmThrowDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  DefaultInitializePlatformSpecific(data, kParameterCount);
-}
-
 void WasmAtomicNotifyDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   DefaultInitializePlatformSpecific(data, kParameterCount);

src/codegen/interface-descriptors.h

@@ -102,10 +102,8 @@ namespace internal {
   V(WasmI32AtomicWait64)              \
   V(WasmI64AtomicWait32)              \
   V(WasmI64AtomicWait64)              \
-  V(WasmMemoryGrow)                   \
-  V(WasmTableCopy)                    \
   V(WasmTableInit)                    \
-  V(WasmThrow)                        \
+  V(WasmTableCopy)                    \
   BUILTIN_LIST_TFS(V)                 \
   TORQUE_BUILTIN_LIST_TFC(V)
 
@@ -1333,14 +1331,6 @@ class WasmFloat64ToNumberDescriptor final : public CallInterfaceDescriptor {
   DECLARE_DESCRIPTOR(WasmFloat64ToNumberDescriptor, CallInterfaceDescriptor)
 };
 
-class WasmMemoryGrowDescriptor final : public CallInterfaceDescriptor {
- public:
-  DEFINE_PARAMETERS_NO_CONTEXT(kNumPages)
-  DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int32(),  // result 1
-                                    MachineType::Int32())  // kNumPages
-  DECLARE_DESCRIPTOR(WasmMemoryGrowDescriptor, CallInterfaceDescriptor)
-};
-
 class WasmTableInitDescriptor final : public CallInterfaceDescriptor {
  public:
   DEFINE_PARAMETERS_NO_CONTEXT(kDestination, kSource, kSize, kTableIndex,
@@ -1387,14 +1377,6 @@ class WasmTableCopyDescriptor final : public CallInterfaceDescriptor {
   DECLARE_DESCRIPTOR(WasmTableCopyDescriptor, CallInterfaceDescriptor)
 };
 
-class WasmThrowDescriptor final : public CallInterfaceDescriptor {
- public:
-  DEFINE_PARAMETERS_NO_CONTEXT(kException)
-  DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(),  // result 1
-                                    MachineType::AnyTagged())  // kException
-  DECLARE_DESCRIPTOR(WasmThrowDescriptor, CallInterfaceDescriptor)
-};
-
 class V8_EXPORT_PRIVATE I64ToBigIntDescriptor final
     : public CallInterfaceDescriptor {
  public: