Switch representation

stevenfontanella · stevenfontanella · commit f475fe64aa53 · 2026-04-27T15:30:27.000Z
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -146,7 +146,7 @@
     ("i64.shr_u",      "makeBinary(BinaryOp::ShrUInt64)"),
     ("i64.rotl",       "makeBinary(BinaryOp::RotLInt64)"),
     ("i64.rotr",       "makeBinary(BinaryOp::RotRInt64)"),
-    ("i64.add128",     "makeWideIntBinary(WideIntBinaryOp::AddInt128)"),
+    ("i64.add128",     "makeWideIntAddSub(WideIntAddSubOp::AddInt128)"),
     ("f32.abs",        "makeUnary(UnaryOp::AbsFloat32)"),
     ("f32.neg",        "makeUnary(UnaryOp::NegFloat32)"),
     ("f32.ceil",       "makeUnary(UnaryOp::CeilFloat32)"),
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -3415,7 +3415,7 @@ switch (buf[0]) {
                         goto parse_error;
                       case '1':
                         if (op == "i64.add128"sv) {
-                          CHECK_ERR(makeWideIntBinary(ctx, pos, annotations, WideIntBinaryOp::AddInt128));
+                          CHECK_ERR(makeWideIntAddSub(ctx, pos, annotations, WideIntAddSubOp::AddInt128));
                           return Ok{};
                         }
                         goto parse_error;
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -217,7 +217,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
     }
   }
   Flow visitSelect(Select* curr) { WASM_UNREACHABLE("TODO"); }
-  Flow visitWideIntBinary(WideIntBinary* curr) {
+  Flow visitWideIntAddSub(WideIntAddSub* curr) {
     if (curr->op == AddInt128) {
       uint64_t highRHS = pop().geti64();
       uint64_t lowRHS = pop().geti64();
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -109,7 +109,7 @@ void ReFinalize::visitMemoryFill(MemoryFill* curr) { curr->finalize(); }
 void ReFinalize::visitConst(Const* curr) { curr->finalize(); }
 void ReFinalize::visitUnary(Unary* curr) { curr->finalize(); }
 void ReFinalize::visitBinary(Binary* curr) { curr->finalize(); }
-void ReFinalize::visitWideIntBinary(WideIntBinary* curr) { curr->finalize(); }
+void ReFinalize::visitWideIntAddSub(WideIntAddSub* curr) { curr->finalize(); }
 void ReFinalize::visitSelect(Select* curr) { curr->finalize(); }
 void ReFinalize::visitDrop(Drop* curr) { curr->finalize(); }
 void ReFinalize::visitReturn(Return* curr) { curr->finalize(); }
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
@@ -703,12 +703,11 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     }
   }
 
-  void visitWideIntBinary(WideIntBinary* curr) {
-    size_t num = 4;
-    curr->operands.resize(num);
-    for (size_t i = 0; i < num; ++i) {
-      note(&curr->operands[i], Type::i64);
-    }
+  void visitWideIntAddSub(WideIntAddSub* curr) {
+    note(&curr->leftLow, Type::i64);
+    note(&curr->leftHigh, Type::i64);
+    note(&curr->rightLow, Type::i64);
+    note(&curr->rightHigh, Type::i64);
   }
 
   void visitSelect(Select* curr, std::optional<Type> type = std::nullopt) {
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -573,12 +573,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     }
     return ret + visit(curr->left) + visit(curr->right);
   }
-  CostType visitWideIntBinary(WideIntBinary* curr) {
-    CostType ret = 1;
-    for (auto* child : curr->operands) {
-      ret += visit(child);
-    }
-    return ret;
+  CostType visitWideIntAddSub(WideIntAddSub* curr) {
+    return 1 + visit(curr->leftLow) + visit(curr->leftHigh) +
+           visit(curr->rightLow) + visit(curr->rightHigh);
   }
   CostType visitSelect(Select* curr) {
     return 1 + visit(curr->condition) + visit(curr->ifTrue) +
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -945,7 +945,7 @@ class EffectAnalyzer {
         }
       }
     }
-    void visitWideIntBinary(WideIntBinary* curr) {}
+    void visitWideIntAddSub(WideIntAddSub* curr) {}
     void visitSelect(Select* curr) {}
     void visitDrop(Drop* curr) {}
     void visitReturn(Return* curr) { parent.branchesOut = true; }
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -634,7 +634,7 @@ struct InfoCollector
     addRoot(curr);
   }
   void visitBinary(Binary* curr) { addRoot(curr); }
-  void visitWideIntBinary(WideIntBinary* curr) { addRoot(curr); }
+  void visitWideIntAddSub(WideIntAddSub* curr) { addRoot(curr); }
   void visitSelect(Select* curr) {
     receiveChildValue(curr->ifTrue, curr);
     receiveChildValue(curr->ifFalse, curr);
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
@@ -213,7 +213,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitConst(Const* curr) {}
   void visitUnary(Unary* curr) {}
   void visitBinary(Binary* curr) {}
-  void visitWideIntBinary(WideIntBinary* curr) {}
+  void visitWideIntAddSub(WideIntAddSub* curr) {}
   void visitSelect(Select* curr) {
     self()->noteSubtype(curr->ifTrue, curr);
     self()->noteSubtype(curr->ifFalse, curr);
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -477,9 +477,10 @@ struct NullInstrParserCtx {
     return Ok{};
   }
   Result<>
-  makeWideIntBinary(Index, const std::vector<Annotation>&, WideIntBinaryOp) {
+  makeWideIntAddSub(Index, const std::vector<Annotation>&, WideIntAddSubOp) {
     return Ok{};
   }
+
   Result<> makeUnary(Index, const std::vector<Annotation>&, UnaryOp) {
     return Ok{};
   }
@@ -2163,10 +2164,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeBinary(op));
   }
 
-  Result<> makeWideIntBinary(Index pos,
+  Result<> makeWideIntAddSub(Index pos,
                              const std::vector<Annotation>& annotations,
-                             WideIntBinaryOp op) {
-    return withLoc(pos, irBuilder.makeWideIntBinary(op));
+                             WideIntAddSubOp op) {
+    return withLoc(pos, irBuilder.makeWideIntAddSub(op));
   }
 
   Result<>
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -91,10 +91,9 @@ Result<> makeNop(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeBinary(Ctx&, Index, const std::vector<Annotation>&, BinaryOp op);
 template<typename Ctx>
-Result<> makeWideIntBinary(Ctx&,
-                           Index,
-                           const std::vector<Annotation>&,
-                           WideIntBinaryOp op);
+Result<>
+makeWideIntAddSub(Ctx&, Index, const std::vector<Annotation>&, WideIntAddSubOp op);
+
 template<typename Ctx>
 Result<> makeUnary(Ctx&, Index, const std::vector<Annotation>&, UnaryOp op);
 template<typename Ctx>
@@ -1598,11 +1597,11 @@ Result<> makeBinary(Ctx& ctx,
 }
 
 template<typename Ctx>
-Result<> makeWideIntBinary(Ctx& ctx,
+Result<> makeWideIntAddSub(Ctx& ctx,
                            Index pos,
                            const std::vector<Annotation>& annotations,
-                           WideIntBinaryOp op) {
-  return ctx.makeWideIntBinary(pos, annotations, op);
+                           WideIntAddSubOp op) {
+  return ctx.makeWideIntAddSub(pos, annotations, op);
 }
 
 template<typename Ctx>
diff --git a/src/passes/I64ToI32Lowering.cpp b/src/passes/I64ToI32Lowering.cpp
@@ -1553,7 +1553,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
     }
   }
 
-  void visitWideIntBinary(WideIntBinary* curr) {
+  void visitWideIntAddSub(WideIntAddSub* curr) {
     WASM_UNREACHABLE("TODO: wide arithmetic lowering");
   }
 
diff --git a/src/passes/Precompute.cpp b/src/passes/Precompute.cpp
@@ -282,8 +282,8 @@ class PrecomputingExpressionRunner
     return Flow(NONCONSTANT_FLOW);
   }
 
-  Flow visitWideIntBinary(WideIntBinary* curr) {
-    return Super::visitWideIntBinary(curr);
+  Flow visitWideIntAddSub(WideIntAddSub* curr) {
+    return Super::visitWideIntAddSub(curr);
   }
 
   Flow visitStringEncode(StringEncode* curr) {
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -2025,7 +2025,7 @@ struct PrintExpressionContents
     }
     restoreNormalColor(o);
   }
-  void visitWideIntBinary(WideIntBinary* curr) {
+  void visitWideIntAddSub(WideIntAddSub* curr) {
     prepareColor(o);
     switch (curr->op) {
       case AddInt128:
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -433,7 +433,7 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
   void visitConst(Const* curr) {}
   void visitUnary(Unary* curr) {}
   void visitBinary(Binary* curr) {}
-  void visitWideIntBinary(WideIntBinary* curr) {}
+  void visitWideIntAddSub(WideIntAddSub* curr) {}
 
   void visitSelect(Select* curr) {
     if (curr->type.isRef()) {
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -660,11 +660,17 @@ class Builder {
     ret->finalize();
     return ret;
   }
-  WideIntBinary* makeWideIntBinary(WideIntBinaryOp op,
-                                   const std::vector<Expression*>& operands) {
-    auto* ret = wasm.allocator.alloc<WideIntBinary>();
+  WideIntAddSub* makeWideIntAddSub(WideIntAddSubOp op,
+                                   Expression* leftLow,
+                                   Expression* leftHigh,
+                                   Expression* rightLow,
+                                   Expression* rightHigh) {
+    auto* ret = wasm.allocator.alloc<WideIntAddSub>();
     ret->op = op;
-    ret->operands.set(operands);
+    ret->leftLow = leftLow;
+    ret->leftHigh = leftHigh;
+    ret->rightLow = rightLow;
+    ret->rightHigh = rightHigh;
     ret->finalize();
     return ret;
   }
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -931,10 +931,13 @@ DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructNotify, ref)
 DELEGATE_FIELD_INT(StructNotify, index)
 DELEGATE_FIELD_CASE_END(StructNotify)
 
-DELEGATE_FIELD_CASE_START(WideIntBinary)
-DELEGATE_FIELD_INT(WideIntBinary, op)
-DELEGATE_FIELD_CHILD_VECTOR(WideIntBinary, operands)
-DELEGATE_FIELD_CASE_END(WideIntBinary)
+DELEGATE_FIELD_CASE_START(WideIntAddSub)
+DELEGATE_FIELD_INT(WideIntAddSub, op)
+DELEGATE_FIELD_CHILD(WideIntAddSub, leftLow)
+DELEGATE_FIELD_CHILD(WideIntAddSub, leftHigh)
+DELEGATE_FIELD_CHILD(WideIntAddSub, rightLow)
+DELEGATE_FIELD_CHILD(WideIntAddSub, rightHigh)
+DELEGATE_FIELD_CASE_END(WideIntAddSub)
 
 DELEGATE_FIELD_MAIN_END
 
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -119,6 +119,6 @@ DELEGATE(ResumeThrow);
 DELEGATE(StackSwitch);
 DELEGATE(StructWait);
 DELEGATE(StructNotify);
-DELEGATE(WideIntBinary);
+DELEGATE(WideIntAddSub);
 
 #undef DELEGATE
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -1797,14 +1797,16 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(condition, curr->condition)
     return condition.getSingleValue().geti32() ? ifTrue : ifFalse; // ;-)
   }
-  Flow visitWideIntBinary(WideIntBinary* curr) {
-    Literals arguments;
-    VISIT_ARGUMENTS(flow, curr->operands, arguments);
+  Flow visitWideIntAddSub(WideIntAddSub* curr) {
+    VISIT(leftLow, curr->leftLow);
+    VISIT(leftHigh, curr->leftHigh);
+    VISIT(rightLow, curr->rightLow);
+    VISIT(rightHigh, curr->rightHigh);
     if (curr->op == AddInt128) {
-      uint64_t lowLHS = arguments[0].geti64();
-      uint64_t highLHS = arguments[1].geti64();
-      uint64_t lowRHS = arguments[2].geti64();
-      uint64_t highRHS = arguments[3].geti64();
+      uint64_t lowLHS = leftLow.getSingleValue().geti64();
+      uint64_t highLHS = leftHigh.getSingleValue().geti64();
+      uint64_t lowRHS = rightLow.getSingleValue().geti64();
+      uint64_t highRHS = rightHigh.getSingleValue().geti64();
 
       uint64_t lowRes = lowLHS + lowRHS;
       uint64_t highRes = highLHS + highRHS + (lowRes < lowLHS);
@@ -3066,8 +3068,8 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   Flow visitAtomicCmpxchg(AtomicCmpxchg* curr) {
     return Flow(NONCONSTANT_FLOW);
   }
-  Flow visitWideIntBinary(WideIntBinary* curr) {
-    return ExpressionRunner<SubType>::visitWideIntBinary(curr);
+  Flow visitWideIntAddSub(WideIntAddSub* curr) {
+    return ExpressionRunner<SubType>::visitWideIntAddSub(curr);
   }
   Flow visitAtomicWait(AtomicWait* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitAtomicNotify(AtomicNotify* curr) { return Flow(NONCONSTANT_FLOW); }
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -190,7 +190,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeConst(Literal val);
   Result<> makeUnary(UnaryOp op);
   Result<> makeBinary(BinaryOp op);
-  Result<> makeWideIntBinary(WideIntBinaryOp op);
+  Result<> makeWideIntAddSub(WideIntAddSubOp op);
   Result<> makeSelect(std::optional<Type> type = std::nullopt);
   Result<> makeDrop();
   Result<> makeReturn();
diff --git a/src/wasm.h b/src/wasm.h
@@ -638,7 +638,7 @@ enum StringEqOp {
   StringEqCompare,
 };
 
-enum WideIntBinaryOp {
+enum WideIntAddSubOp {
   AddInt128,
 };
 
@@ -771,7 +771,7 @@ class Expression {
     StackSwitchId,
     StructWaitId,
     StructNotifyId,
-    WideIntBinaryId,
+    WideIntAddSubId,
     NumExpressionIds
   };
   Id _id;
@@ -1303,12 +1303,16 @@ class Binary : public SpecificExpression<Expression::BinaryId> {
   void finalize();
 };
 
-class WideIntBinary : public SpecificExpression<Expression::WideIntBinaryId> {
+class WideIntAddSub : public SpecificExpression<Expression::WideIntAddSubId> {
 public:
-  WideIntBinary(MixedArena& allocator) : operands(allocator) {}
+  WideIntAddSub() = default;
+  WideIntAddSub(MixedArena& allocator) {}
 
-  WideIntBinaryOp op;
-  ExpressionList operands;
+  WideIntAddSubOp op;
+  Expression* leftLow;
+  Expression* leftHigh;
+  Expression* rightLow;
+  Expression* rightHigh;
 
   void finalize();
 };
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -3999,7 +3999,8 @@ Result<> WasmBinaryReader::readInst() {
         case BinaryConsts::MemoryFill:
           return builder.makeMemoryFill(getMemoryName(getU32LEB()));
         case BinaryConsts::I64Add128:
-          return builder.makeWideIntBinary(AddInt128);
+          return builder.makeWideIntAddSub(AddInt128);
+
         case BinaryConsts::TableSize:
           return builder.makeTableSize(getTableName(getU32LEB()));
         case BinaryConsts::TableGrow:
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -1757,12 +1757,12 @@ Result<> IRBuilder::makeBinary(BinaryOp op) {
   return Ok{};
 }
 
-Result<> IRBuilder::makeWideIntBinary(WideIntBinaryOp op) {
-  WideIntBinary curr(wasm.allocator);
+Result<> IRBuilder::makeWideIntAddSub(WideIntAddSubOp op) {
+  WideIntAddSub curr;
   curr.op = op;
-  CHECK_ERR(visitWideIntBinary(&curr));
-  push(builder.makeWideIntBinary(
-    op, std::vector<Expression*>(curr.operands.begin(), curr.operands.end())));
+  CHECK_ERR(visitWideIntAddSub(&curr));
+  push(builder.makeWideIntAddSub(
+    op, curr.leftLow, curr.leftHigh, curr.rightLow, curr.rightHigh));
   return Ok{};
 }
 
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
@@ -2287,7 +2287,7 @@ void BinaryInstWriter::visitSelect(Select* curr) {
   }
 }
 
-void BinaryInstWriter::visitWideIntBinary(WideIntBinary* curr) {
+void BinaryInstWriter::visitWideIntAddSub(WideIntAddSub* curr) {
   o << static_cast<int8_t>(BinaryConsts::MiscPrefix);
   switch (curr->op) {
     case AddInt128:
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
@@ -508,7 +508,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitMemoryCopy(MemoryCopy* curr);
   void visitMemoryFill(MemoryFill* curr);
   void visitBinary(Binary* curr);
-  void visitWideIntBinary(WideIntBinary* curr);
+  void visitWideIntAddSub(WideIntAddSub* curr);
   void visitUnary(Unary* curr);
   void visitSelect(Select* curr);
   void visitDrop(Drop* curr);
@@ -2444,26 +2444,21 @@ void FunctionValidator::visitSelect(Select* curr) {
   }
 }
 
-void FunctionValidator::visitWideIntBinary(WideIntBinary* curr) {
+void FunctionValidator::visitWideIntAddSub(WideIntAddSub* curr) {
   if (!shouldBeTrue(getModule()->features.hasWideArithmetic(),
                     curr,
                     "Wide arithmetic is not enabled")) {
     return;
   }
-  for (auto* operand : curr->operands) {
+  for (auto* operand : {curr->leftLow, curr->leftHigh, curr->rightLow, curr->rightHigh}) {
     if (operand->type != Type::unreachable) {
-      shouldBeEqual(operand->type,
-                    Type(Type::i64),
-                    curr,
-                    "wide binary child types must be i64");
+      shouldBeEqual(
+        operand->type, Type(Type::i64), curr, "wide binary child types must be i64");
     }
   }
-  if (curr->op == AddInt128) {
-    shouldBeEqual(
-      curr->operands.size(), size_t(4), curr, "add128 must have 4 operands");
-  }
 }
 
+
 void FunctionValidator::visitDrop(Drop* curr) {
   shouldBeTrue(curr->value->type.isConcrete() ||
                  curr->value->type == Type::unreachable,
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
diff --git a/src/wasm2js.h b/src/wasm2js.h

Original file line number	Diff line number	Diff line change
`@@ -3415,7 +3415,7 @@ switch (buf[0]) {`
`3415`	`3415`	`goto parse_error;`
`3416`	`3416`	`case '1':`
`3417`	`3417`	`if (op == "i64.add128"sv) {`
`3418`		`- CHECK_ERR(makeWideIntBinary(ctx, pos, annotations, WideIntBinaryOp::AddInt128));`
	`3418`	`+ CHECK_ERR(makeWideIntAddSub(ctx, pos, annotations, WideIntAddSubOp::AddInt128));`
`3419`	`3419`	`return Ok{};`
`3420`	`3420`	`}`
`3421`	`3421`	`goto parse_error;`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`Flow visitSelect(Select* curr) { WASM_UNREACHABLE("TODO"); }`
`220`		`- Flow visitWideIntBinary(WideIntBinary* curr) {`
	`220`	`+ Flow visitWideIntAddSub(WideIntAddSub* curr) {`
`221`	`221`	`if (curr->op == AddInt128) {`
`222`	`222`	`uint64_t highRHS = pop().geti64();`
`223`	`223`	`uint64_t lowRHS = pop().geti64();`
Original file line number	Diff line number	Diff line change
`@@ -703,12 +703,11 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {`
`703`	`703`	`}`
`704`	`704`	`}`
`705`	`705`
`706`		`- void visitWideIntBinary(WideIntBinary* curr) {`
`707`		`- size_t num = 4;`
`708`		`- curr->operands.resize(num);`
`709`		`- for (size_t i = 0; i < num; ++i) {`
`710`		`- note(&curr->operands[i], Type::i64);`
`711`		`- }`
	`706`	`+ void visitWideIntAddSub(WideIntAddSub* curr) {`
	`707`	`+ note(&curr->leftLow, Type::i64);`
	`708`	`+ note(&curr->leftHigh, Type::i64);`
	`709`	`+ note(&curr->rightLow, Type::i64);`
	`710`	`+ note(&curr->rightHigh, Type::i64);`
`712`	`711`	`}`
`713`	`712`
`714`	`713`	`void visitSelect(Select* curr, std::optional<Type> type = std::nullopt) {`
Original file line number	Diff line number	Diff line change
`@@ -573,12 +573,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {`
`573`	`573`	`}`
`574`	`574`	`return ret + visit(curr->left) + visit(curr->right);`
`575`	`575`	`}`
`576`		`- CostType visitWideIntBinary(WideIntBinary* curr) {`
`577`		`- CostType ret = 1;`
`578`		`- for (auto* child : curr->operands) {`
`579`		`- ret += visit(child);`
`580`		`- }`
`581`		`- return ret;`
	`576`	`+ CostType visitWideIntAddSub(WideIntAddSub* curr) {`
	`577`	`+ return 1 + visit(curr->leftLow) + visit(curr->leftHigh) +`
	`578`	`+ visit(curr->rightLow) + visit(curr->rightHigh);`
`582`	`579`	`}`
`583`	`580`	`CostType visitSelect(Select* curr) {`
`584`	`581`	`return 1 + visit(curr->condition) + visit(curr->ifTrue) +`
Original file line number	Diff line number	Diff line change
`@@ -945,7 +945,7 @@ class EffectAnalyzer {`
`945`	`945`	`}`
`946`	`946`	`}`
`947`	`947`	`}`
`948`		`- void visitWideIntBinary(WideIntBinary* curr) {}`
	`948`	`+ void visitWideIntAddSub(WideIntAddSub* curr) {}`
`949`	`949`	`void visitSelect(Select* curr) {}`
`950`	`950`	`void visitDrop(Drop* curr) {}`
`951`	`951`	`void visitReturn(Return* curr) { parent.branchesOut = true; }`
Original file line number	Diff line number	Diff line change
`@@ -634,7 +634,7 @@ struct InfoCollector`
`634`	`634`	`addRoot(curr);`
`635`	`635`	`}`
`636`	`636`	`void visitBinary(Binary* curr) { addRoot(curr); }`
`637`		`- void visitWideIntBinary(WideIntBinary* curr) { addRoot(curr); }`
	`637`	`+ void visitWideIntAddSub(WideIntAddSub* curr) { addRoot(curr); }`
`638`	`638`	`void visitSelect(Select* curr) {`
`639`	`639`	`receiveChildValue(curr->ifTrue, curr);`
`640`	`640`	`receiveChildValue(curr->ifFalse, curr);`
Original file line number	Diff line number	Diff line change
`@@ -477,9 +477,10 @@ struct NullInstrParserCtx {`
`477`	`477`	`return Ok{};`
`478`	`478`	`}`
`479`	`479`	`Result<>`
`480`		`- makeWideIntBinary(Index, const std::vector<Annotation>&, WideIntBinaryOp) {`
	`480`	`+ makeWideIntAddSub(Index, const std::vector<Annotation>&, WideIntAddSubOp) {`
`481`	`481`	`return Ok{};`
`482`	`482`	`}`
	`483`	`+`
`483`	`484`	`Result<> makeUnary(Index, const std::vector<Annotation>&, UnaryOp) {`
`484`	`485`	`return Ok{};`
`485`	`486`	`}`
`@@ -2163,10 +2164,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {`
`2163`	`2164`	`return withLoc(pos, irBuilder.makeBinary(op));`
`2164`	`2165`	`}`
`2165`	`2166`
`2166`		`- Result<> makeWideIntBinary(Index pos,`
	`2167`	`+ Result<> makeWideIntAddSub(Index pos,`
`2167`	`2168`	`const std::vector<Annotation>& annotations,`
`2168`		`- WideIntBinaryOp op) {`
`2169`		`- return withLoc(pos, irBuilder.makeWideIntBinary(op));`
	`2169`	`+ WideIntAddSubOp op) {`
	`2170`	`+ return withLoc(pos, irBuilder.makeWideIntAddSub(op));`
`2170`	`2171`	`}`
`2171`	`2172`
`2172`	`2173`	`Result<>`