[wasm] Move and add functionality to WasmGraphAssembler

Specifically, move numeric conversions from WasmGraphBuilder, and add
functionality for traps.
These will be used in wasm-gc lowering phases.

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

src/compiler/wasm-compiler.h

@@ -695,19 +695,6 @@ class WasmGraphBuilder {
                        MachineType result_type, wasm::TrapReason trap_zero,
                        wasm::WasmCodePosition position);
 
-  Node* BuildTruncateIntPtrToInt32(Node* value);
-  Node* BuildChangeInt32ToIntPtr(Node* value);
-  Node* BuildChangeIntPtrToInt64(Node* value);
-  Node* BuildChangeUint32ToUintPtr(Node*);
-  Node* BuildChangeInt32ToSmi(Node* value);
-  Node* BuildChangeUint31ToSmi(Node* value);
-  Node* BuildSmiShiftBitsConstant();
-  Node* BuildSmiShiftBitsConstant32();
-  Node* BuildChangeSmiToInt32(Node* value);
-  Node* BuildChangeSmiToIntPtr(Node* value);
-  // generates {index > max ? Smi(max) : Smi(index)}
-  Node* BuildConvertUint32ToSmiWithSaturation(Node* index, uint32_t maxval);
-
   void MemTypeToUintPtrOrOOBTrap(std::initializer_list<Node**> nodes,
                                  wasm::WasmCodePosition position);
 

src/compiler/wasm-graph-assembler.cc

@@ -4,6 +4,8 @@
 
 #include "src/compiler/wasm-graph-assembler.h"
 
+#include "src/compiler/diamond.h"
+#include "src/compiler/node-matchers.h"
 #include "src/wasm/object-access.h"
 #include "src/wasm/wasm-objects.h"
 
@@ -48,6 +50,77 @@ Node* WasmGraphAssembler::Branch(Node* cond, Node** true_node,
   return branch;
 }
 
+Node* WasmGraphAssembler::BuildTruncateIntPtrToInt32(Node* value) {
+  return mcgraph()->machine()->Is64() ? TruncateInt64ToInt32(value) : value;
+}
+
+Node* WasmGraphAssembler::BuildChangeInt32ToIntPtr(Node* value) {
+  return mcgraph()->machine()->Is64() ? ChangeInt32ToInt64(value) : value;
+}
+
+Node* WasmGraphAssembler::BuildChangeIntPtrToInt64(Node* value) {
+  return mcgraph()->machine()->Is32() ? ChangeInt32ToInt64(value) : value;
+}
+
+Node* WasmGraphAssembler::BuildChangeUint32ToUintPtr(Node* node) {
+  if (mcgraph()->machine()->Is32()) return node;
+  // Fold instances of ChangeUint32ToUint64(IntConstant) directly.
+  Uint32Matcher matcher(node);
+  if (matcher.HasResolvedValue()) {
+    uintptr_t value = matcher.ResolvedValue();
+    return mcgraph()->IntPtrConstant(base::bit_cast<intptr_t>(value));
+  }
+  return ChangeUint32ToUint64(node);
+}
+
+Node* WasmGraphAssembler::BuildSmiShiftBitsConstant() {
+  return IntPtrConstant(kSmiShiftSize + kSmiTagSize);
+}
+
+Node* WasmGraphAssembler::BuildSmiShiftBitsConstant32() {
+  return Int32Constant(kSmiShiftSize + kSmiTagSize);
+}
+
+Node* WasmGraphAssembler::BuildChangeInt32ToSmi(Node* value) {
+  // With pointer compression, only the lower 32 bits are used.
+  return COMPRESS_POINTERS_BOOL
+             ? Word32Shl(value, BuildSmiShiftBitsConstant32())
+             : WordShl(BuildChangeInt32ToIntPtr(value),
+                       BuildSmiShiftBitsConstant());
+}
+
+Node* WasmGraphAssembler::BuildChangeUint31ToSmi(Node* value) {
+  return COMPRESS_POINTERS_BOOL
+             ? Word32Shl(value, BuildSmiShiftBitsConstant32())
+             : WordShl(BuildChangeUint32ToUintPtr(value),
+                       BuildSmiShiftBitsConstant());
+}
+
+Node* WasmGraphAssembler::BuildChangeSmiToInt32(Node* value) {
+  return COMPRESS_POINTERS_BOOL
+             ? Word32Sar(value, BuildSmiShiftBitsConstant32())
+             : BuildTruncateIntPtrToInt32(
+                   WordSar(value, BuildSmiShiftBitsConstant()));
+}
+
+Node* WasmGraphAssembler::BuildConvertUint32ToSmiWithSaturation(
+    Node* value, uint32_t maxval) {
+  DCHECK(Smi::IsValid(maxval));
+  Node* max = mcgraph()->Uint32Constant(maxval);
+  Node* check = Uint32LessThanOrEqual(value, max);
+  Node* valsmi = BuildChangeUint31ToSmi(value);
+  Node* maxsmi = NumberConstant(maxval);
+  Diamond d(graph(), mcgraph()->common(), check, BranchHint::kTrue);
+  d.Chain(control());
+  return d.Phi(MachineRepresentation::kTagged, valsmi, maxsmi);
+}
+
+Node* WasmGraphAssembler::BuildChangeSmiToIntPtr(Node* value) {
+  return COMPRESS_POINTERS_BOOL ? BuildChangeInt32ToIntPtr(Word32Sar(
+                                      value, BuildSmiShiftBitsConstant32()))
+                                : WordSar(value, BuildSmiShiftBitsConstant());
+}
+
 // 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.

src/compiler/wasm-graph-assembler.h

@@ -91,6 +91,29 @@ class WasmGraphAssembler : public GraphAssembler {
     NodeProperties::MergeControlToEnd(graph(), common(), control);
   }
 
+  // Numeric conversions
+  Node* BuildTruncateIntPtrToInt32(Node* value);
+
+  Node* BuildChangeInt32ToIntPtr(Node* value);
+
+  Node* BuildChangeIntPtrToInt64(Node* value);
+
+  Node* BuildChangeUint32ToUintPtr(Node* node);
+
+  Node* BuildSmiShiftBitsConstant();
+
+  Node* BuildSmiShiftBitsConstant32();
+
+  Node* BuildChangeInt32ToSmi(Node* value);
+
+  Node* BuildChangeUint31ToSmi(Node* value);
+
+  Node* BuildChangeSmiToInt32(Node* value);
+
+  Node* BuildConvertUint32ToSmiWithSaturation(Node* value, uint32_t maxval);
+
+  Node* BuildChangeSmiToIntPtr(Node* value);
+
   // 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.
@@ -221,6 +244,16 @@ class WasmGraphAssembler : public GraphAssembler {
 
   Node* HasInstanceType(Node* heap_object, InstanceType type);
 
+  Node* TrapIf(Node* condition, TrapId reason) {
+    return AddNode(graph()->NewNode(mcgraph()->common()->TrapIf(reason),
+                                    condition, effect(), control()));
+  }
+
+  Node* TrapUnless(Node* condition, TrapId reason) {
+    return AddNode(graph()->NewNode(mcgraph()->common()->TrapUnless(reason),
+                                    condition, effect(), control()));
+  }
+
   SimplifiedOperatorBuilder* simplified() { return &simplified_; }
 
  private: