[wasm][refactor] Move WasmGraphAssembler to separate file

This way we can use it later in the pipeline for optimizations.

Change-Id: I0e97d061fd3d474ca7033ed2b68f43b52617d3e8
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3634961
Commit-Queue: Manos Koukoutos <manoskouk@chromium.org>
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/main@{#80437}

BUILD.bazel

@@ -2432,6 +2432,7 @@ filegroup(
             "src/compiler/int64-lowering.h",
             "src/compiler/wasm-compiler.h",
             "src/compiler/wasm-escape-analysis.h",
+            "src/compiler/wasm-graph-assembler.h",
             "src/compiler/wasm-inlining.h",
             "src/compiler/wasm-loop-peeling.h",
             "src/debug/debug-wasm-objects.cc",
@@ -2843,6 +2844,7 @@ filegroup(
             "src/compiler/wasm-compiler.cc",
             "src/compiler/wasm-loop-peeling.cc",
             "src/compiler/wasm-escape-analysis.cc",
+            "src/compiler/wasm-graph-assembler.cc",
             "src/compiler/wasm-inlining.cc",
         ],
         "//conditions:default": [],

BUILD.gn

@@ -3518,6 +3518,7 @@ v8_header_set("v8_internal_headers") {
       "src/compiler/int64-lowering.h",
       "src/compiler/wasm-compiler.h",
       "src/compiler/wasm-escape-analysis.h",
+      "src/compiler/wasm-graph-assembler.h",
       "src/compiler/wasm-inlining.h",
       "src/compiler/wasm-loop-peeling.h",
       "src/debug/debug-wasm-objects-inl.h",
@@ -4012,6 +4013,7 @@ if (v8_enable_webassembly) {
     "src/compiler/int64-lowering.cc",
     "src/compiler/wasm-compiler.cc",
     "src/compiler/wasm-escape-analysis.cc",
+    "src/compiler/wasm-graph-assembler.cc",
     "src/compiler/wasm-inlining.cc",
     "src/compiler/wasm-loop-peeling.cc",
   ]

src/compiler/wasm-graph-assembler.h

+// Copyright 2022 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#if !V8_ENABLE_WEBASSEMBLY
+#error This header should only be included if WebAssembly is enabled.
+#endif  // !V8_ENABLE_WEBASSEMBLY
+
+#ifndef V8_COMPILER_WASM_GRAPH_ASSEMBLER_H_
+#define V8_COMPILER_WASM_GRAPH_ASSEMBLER_H_
+
+#include "src/compiler/graph-assembler.h"
+#include "src/wasm/wasm-code-manager.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+constexpr Builtin WasmRuntimeStubIdToBuiltinName(
+    wasm::WasmCode::RuntimeStubId runtime_stub_id) {
+  switch (runtime_stub_id) {
+#define DEF_CASE(name)          \
+  case wasm::WasmCode::k##name: \
+    return Builtin::k##name;
+#define DEF_TRAP_CASE(name) DEF_CASE(ThrowWasm##name)
+    WASM_RUNTIME_STUB_LIST(DEF_CASE, DEF_TRAP_CASE)
+#undef DEF_CASE
+#undef DEF_TRAP_CASE
+    default:
+      UNREACHABLE();
+  }
+}
+
+CallDescriptor* GetBuiltinCallDescriptor(
+    Builtin name, Zone* zone, StubCallMode stub_mode,
+    bool needs_frame_state = false,
+    Operator::Properties properties = Operator::kNoProperties);
+
+ObjectAccess ObjectAccessForGCStores(wasm::ValueType type);
+
+class WasmGraphAssembler : public GraphAssembler {
+ public:
+  WasmGraphAssembler(MachineGraph* mcgraph, Zone* zone)
+      : GraphAssembler(mcgraph, zone), simplified_(zone) {}
+
+  template <typename... Args>
+  Node* CallRuntimeStub(wasm::WasmCode::RuntimeStubId stub_id,
+                        Operator::Properties properties, Args*... args) {
+    auto* call_descriptor = GetBuiltinCallDescriptor(
+        WasmRuntimeStubIdToBuiltinName(stub_id), temp_zone(),
+        StubCallMode::kCallWasmRuntimeStub, false, properties);
+    // A direct call to a wasm runtime stub defined in this module.
+    // Just encode the stub index. This will be patched at relocation.
+    Node* call_target = mcgraph()->RelocatableIntPtrConstant(
+        stub_id, RelocInfo::WASM_STUB_CALL);
+    return Call(call_descriptor, call_target, args...);
+  }
+
+  Node* GetBuiltinPointerTarget(Builtin builtin) {
+    static_assert(std::is_same<Smi, BuiltinPtr>(), "BuiltinPtr must be Smi");
+    return NumberConstant(static_cast<int>(builtin));
+  }
+
+  template <typename... Args>
+  Node* CallBuiltin(Builtin name, Operator::Properties properties,
+                    Args*... args) {
+    auto* call_descriptor = GetBuiltinCallDescriptor(
+        name, temp_zone(), StubCallMode::kCallBuiltinPointer, false,
+        properties);
+    Node* call_target = GetBuiltinPointerTarget(name);
+    return Call(call_descriptor, call_target, args...);
+  }
+
+  // Sets {true_node} and {false_node} to their corresponding Branch outputs.
+  // Returns the Branch node. Does not change control().
+  Node* Branch(Node* cond, Node** true_node, Node** false_node,
+               BranchHint hint);
+
+  Node* NumberConstant(volatile double value) {
+    return graph()->NewNode(mcgraph()->common()->NumberConstant(value));
+  }
+
+  Node* SmiConstant(Tagged_t value) {
+    Address tagged_value = Internals::IntToSmi(static_cast<int>(value));
+    return kTaggedSize == kInt32Size
+               ? Int32Constant(static_cast<int32_t>(tagged_value))
+               : Int64Constant(static_cast<int64_t>(tagged_value));
+  }
+
+  void MergeControlToEnd(Node* control) {
+    NodeProperties::MergeControlToEnd(graph(), common(), control);
+  }
+
+  // Helper functions for dealing with HeapObjects.
+  // Rule of thumb: if access to a given field in an object is required in
+  // at least two places, put a helper function here.
+
+  Node* Allocate(int size);
+
+  Node* Allocate(Node* size,
+                 AllowLargeObjects allow_large = AllowLargeObjects::kTrue);
+
+  Node* LoadFromObject(MachineType type, Node* base, Node* offset);
+
+  Node* LoadFromObject(MachineType type, Node* base, int offset) {
+    return LoadFromObject(type, base, IntPtrConstant(offset));
+  }
+
+  Node* LoadImmutableFromObject(MachineType type, Node* base, Node* offset);
+
+  Node* LoadImmutableFromObject(MachineType type, Node* base, int offset) {
+    return LoadImmutableFromObject(type, base, IntPtrConstant(offset));
+  }
+
+  Node* LoadImmutable(LoadRepresentation rep, Node* base, Node* offset);
+
+  Node* LoadImmutable(LoadRepresentation rep, Node* base, int offset) {
+    return LoadImmutable(rep, base, IntPtrConstant(offset));
+  }
+
+  Node* StoreToObject(ObjectAccess access, Node* base, Node* offset,
+                      Node* value);
+
+  Node* StoreToObject(ObjectAccess access, Node* base, int offset,
+                      Node* value) {
+    return StoreToObject(access, base, IntPtrConstant(offset), value);
+  }
+
+  Node* InitializeImmutableInObject(ObjectAccess access, Node* base,
+                                    Node* offset, Node* value);
+
+  Node* InitializeImmutableInObject(ObjectAccess access, Node* base, int offset,
+                                    Node* value) {
+    return InitializeImmutableInObject(access, base, IntPtrConstant(offset),
+                                       value);
+  }
+
+  Node* IsI31(Node* object);
+
+  // Maps and their contents.
+
+  Node* LoadMap(Node* object);
+
+  void StoreMap(Node* heap_object, Node* map);
+
+  Node* LoadInstanceType(Node* map);
+
+  Node* LoadWasmTypeInfo(Node* map);
+
+  Node* LoadSupertypes(Node* wasm_type_info);
+
+  // FixedArrays.
+
+  Node* LoadFixedArrayLengthAsSmi(Node* fixed_array);
+
+  Node* LoadFixedArrayElement(Node* fixed_array, Node* index_intptr,
+                              MachineType type = MachineType::AnyTagged());
+
+  Node* LoadImmutableFixedArrayElement(
+      Node* fixed_array, Node* index_intptr,
+      MachineType type = MachineType::AnyTagged());
+
+  Node* LoadFixedArrayElement(Node* array, int index, MachineType type);
+
+  Node* LoadFixedArrayElementSmi(Node* array, int index) {
+    return LoadFixedArrayElement(array, index, MachineType::TaggedSigned());
+  }
+
+  Node* LoadFixedArrayElementPtr(Node* array, int index) {
+    return LoadFixedArrayElement(array, index, MachineType::TaggedPointer());
+  }
+
+  Node* LoadFixedArrayElementAny(Node* array, int index) {
+    return LoadFixedArrayElement(array, index, MachineType::AnyTagged());
+  }
+
+  Node* StoreFixedArrayElement(Node* array, int index, Node* value,
+                               ObjectAccess access);
+
+  Node* StoreFixedArrayElementSmi(Node* array, int index, Node* value) {
+    return StoreFixedArrayElement(
+        array, index, value,
+        ObjectAccess(MachineType::TaggedSigned(), kNoWriteBarrier));
+  }
+
+  Node* StoreFixedArrayElementAny(Node* array, int index, Node* value) {
+    return StoreFixedArrayElement(
+        array, index, value,
+        ObjectAccess(MachineType::AnyTagged(), kFullWriteBarrier));
+  }
+
+  // Functions, SharedFunctionInfos, FunctionData.
+
+  Node* LoadSharedFunctionInfo(Node* js_function);
+
+  Node* LoadContextFromJSFunction(Node* js_function);
+
+  Node* LoadFunctionDataFromJSFunction(Node* js_function);
+
+  Node* LoadExportedFunctionIndexAsSmi(Node* exported_function_data);
+
+  Node* LoadExportedFunctionInstance(Node* exported_function_data);
+
+  // JavaScript objects.
+
+  Node* LoadJSArrayElements(Node* js_array);
+
+  // WasmGC objects.
+
+  Node* FieldOffset(const wasm::StructType* type, uint32_t field_index);
+
+  Node* StoreStructField(Node* struct_object, const wasm::StructType* type,
+                         uint32_t field_index, Node* value);
+  Node* WasmArrayElementOffset(Node* index, wasm::ValueType element_type);
+
+  Node* LoadWasmArrayLength(Node* array);
+
+  Node* IsDataRefMap(Node* map);
+
+  // Generic HeapObject helpers.
+
+  Node* HasInstanceType(Node* heap_object, InstanceType type);
+
+  SimplifiedOperatorBuilder* simplified() { return &simplified_; }
+
+ private:
+  SimplifiedOperatorBuilder simplified_;
+};
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_COMPILER_WASM_GRAPH_ASSEMBLER_H_