[compiler] Refactor opcode macro lists

This extends the opcode macro lists to include both the long name
(e.g.: JSAdd) and short name (Add) to reduce duplication. The change
is only for JS operators for now but can be extended to others in the
future.

Drive-by: Base more predicates off the macro lists for robustness.

Bug: v8:8888
Change-Id: I10debdf86166dbe9dac63a6df57938820a8af8d0
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2255468
Commit-Queue: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#68477}

src/compiler/js-generic-lowering.cc

@@ -43,10 +43,10 @@ JSGenericLowering::~JSGenericLowering() = default;
 
 Reduction JSGenericLowering::Reduce(Node* node) {
   switch (node->opcode()) {
-#define DECLARE_CASE(x)  \
-    case IrOpcode::k##x: \
-      Lower##x(node);    \
-      break;
+#define DECLARE_CASE(x, ...) \
+  case IrOpcode::k##x:       \
+    Lower##x(node);          \
+    break;
     JS_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
     default:
@@ -123,10 +123,7 @@ void JSGenericLowering::ReplaceWithRuntimeCall(Node* node,
 void JSGenericLowering::ReplaceUnaryOpWithBuiltinCall(
     Node* node, Builtins::Name builtin_without_feedback,
     Builtins::Name builtin_with_feedback) {
-  DCHECK(node->opcode() == IrOpcode::kJSBitwiseNot ||
-         node->opcode() == IrOpcode::kJSDecrement ||
-         node->opcode() == IrOpcode::kJSIncrement ||
-         node->opcode() == IrOpcode::kJSNegate);
+  DCHECK(JSOperator::IsUnaryWithFeedback(node->opcode()));
   const FeedbackParameter& p = FeedbackParameterOf(node->op());
   if (CollectFeedbackInGenericLowering() && p.feedback().IsValid()) {
     Callable callable = Builtins::CallableFor(isolate(), builtin_with_feedback);
@@ -163,23 +160,7 @@ DEF_UNARY_LOWERING(Negate)
 void JSGenericLowering::ReplaceBinaryOrCompareOpWithBuiltinCall(
     Node* node, Builtins::Name builtin_without_feedback,
     Builtins::Name builtin_with_feedback) {
-  DCHECK(node->opcode() == IrOpcode::kJSAdd ||
-         node->opcode() == IrOpcode::kJSBitwiseAnd ||
-         node->opcode() == IrOpcode::kJSBitwiseOr ||
-         node->opcode() == IrOpcode::kJSBitwiseXor ||
-         node->opcode() == IrOpcode::kJSDivide ||
-         node->opcode() == IrOpcode::kJSEqual ||
-         node->opcode() == IrOpcode::kJSExponentiate ||
-         node->opcode() == IrOpcode::kJSGreaterThan ||
-         node->opcode() == IrOpcode::kJSGreaterThanOrEqual ||
-         node->opcode() == IrOpcode::kJSLessThan ||
-         node->opcode() == IrOpcode::kJSLessThanOrEqual ||
-         node->opcode() == IrOpcode::kJSModulus ||
-         node->opcode() == IrOpcode::kJSMultiply ||
-         node->opcode() == IrOpcode::kJSShiftLeft ||
-         node->opcode() == IrOpcode::kJSShiftRight ||
-         node->opcode() == IrOpcode::kJSShiftRightLogical ||
-         node->opcode() == IrOpcode::kJSSubtract);
+  DCHECK(JSOperator::IsBinaryWithFeedback(node->opcode()));
   Builtins::Name builtin_id;
   const FeedbackParameter& p = FeedbackParameterOf(node->op());
   if (CollectFeedbackInGenericLowering() && p.feedback().IsValid()) {

src/compiler/js-generic-lowering.h

@@ -31,7 +31,7 @@ class JSGenericLowering final : public AdvancedReducer {
   Reduction Reduce(Node* node) final;
 
  protected:
-#define DECLARE_LOWER(x) void Lower##x(Node* node);
+#define DECLARE_LOWER(x, ...) void Lower##x(Node* node);
   // Dispatched depending on opcode.
   JS_OP_LIST(DECLARE_LOWER)
 #undef DECLARE_LOWER

src/compiler/js-operator.cc

@@ -16,6 +16,17 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
+namespace {
+
+// Returns properties for the given binary op.
+constexpr Operator::Properties BinopProperties(Operator::Opcode opcode) {
+  CONSTEXPR_DCHECK(JSOperator::IsBinaryWithFeedback(opcode));
+  return opcode == IrOpcode::kJSStrictEqual ? Operator::kPure
+                                            : Operator::kNoProperties;
+}
+
+}  // namespace
+
 std::ostream& operator<<(std::ostream& os, CallFrequency const& f) {
   if (f.IsUnknown()) return os << "unknown";
   return os << f.value();
@@ -224,46 +235,13 @@ std::ostream& operator<<(std::ostream& os, FeedbackParameter const& p) {
   return os << p.feedback();
 }
 
-#define UNARY_OP_LIST(V) \
-  V(BitwiseNot)          \
-  V(Decrement)           \
-  V(Increment)           \
-  V(Negate)
-
-#define BINARY_OP_LIST(V) \
-  V(Add)                  \
-  V(Subtract)             \
-  V(Multiply)             \
-  V(Divide)               \
-  V(Modulus)              \
-  V(Exponentiate)         \
-  V(BitwiseOr)            \
-  V(BitwiseXor)           \
-  V(BitwiseAnd)           \
-  V(ShiftLeft)            \
-  V(ShiftRight)           \
-  V(ShiftRightLogical)
-
-#define COMPARE_OP_LIST(V)                    \
-  V(Equal, Operator::kNoProperties)           \
-  V(StrictEqual, Operator::kPure)             \
-  V(LessThan, Operator::kNoProperties)        \
-  V(GreaterThan, Operator::kNoProperties)     \
-  V(LessThanOrEqual, Operator::kNoProperties) \
-  V(GreaterThanOrEqual, Operator::kNoProperties)
-
 FeedbackParameter const& FeedbackParameterOf(const Operator* op) {
-#define V(Name, ...) op->opcode() == IrOpcode::kJS##Name ||
-  // clang-format off
-  DCHECK(UNARY_OP_LIST(V)
-         BINARY_OP_LIST(V)
-         COMPARE_OP_LIST(V)
+  DCHECK(JSOperator::IsUnaryWithFeedback(op->opcode()) ||
+         JSOperator::IsBinaryWithFeedback(op->opcode()) ||
          op->opcode() == IrOpcode::kJSCreateEmptyLiteralArray ||
          op->opcode() == IrOpcode::kJSInstanceOf ||
          op->opcode() == IrOpcode::kJSStoreDataPropertyInLiteral ||
          op->opcode() == IrOpcode::kJSStoreInArrayLiteral);
-  // clang-format on
-#undef V
   return OpParameter<FeedbackParameter>(op);
 }
 
@@ -732,36 +710,27 @@ JSOperatorBuilder::JSOperatorBuilder(Zone* zone)
 CACHED_OP_LIST(CACHED_OP)
 #undef CACHED_OP
 
-#define UNARY_OP(Name)                                                        \
+#define UNARY_OP(JSName, Name)                                                \
   const Operator* JSOperatorBuilder::Name(FeedbackSource const& feedback) {   \
     FeedbackParameter parameters(feedback);                                   \
     return new (zone()) Operator1<FeedbackParameter>(                         \
-        IrOpcode::kJS##Name, Operator::kNoProperties, "JS" #Name, 2, 1, 1, 1, \
-        1, 2, parameters);                                                    \
+        IrOpcode::k##JSName, Operator::kNoProperties, #JSName, 2, 1, 1, 1, 1, \
+        2, parameters);                                                       \
   }
-UNARY_OP_LIST(UNARY_OP)
+JS_UNOP_WITH_FEEDBACK(UNARY_OP)
 #undef UNARY_OP
 
-#define BINARY_OP(Name)                                                       \
+#define BINARY_OP(JSName, Name)                                               \
   const Operator* JSOperatorBuilder::Name(FeedbackSource const& feedback) {   \
+    static constexpr auto kProperties = BinopProperties(IrOpcode::k##JSName); \
     FeedbackParameter parameters(feedback);                                   \
     return new (zone()) Operator1<FeedbackParameter>(                         \
-        IrOpcode::kJS##Name, Operator::kNoProperties, "JS" #Name, 2, 1, 1, 1, \
-        1, 2, parameters);                                                    \
+        IrOpcode::k##JSName, kProperties, #JSName, 2, 1, 1, 1, 1,             \
+        Operator::ZeroIfNoThrow(kProperties), parameters);                    \
   }
-BINARY_OP_LIST(BINARY_OP)
+JS_BINOP_WITH_FEEDBACK(BINARY_OP)
 #undef BINARY_OP
 
-#define COMPARE_OP(Name, Properties)                                        \
-  const Operator* JSOperatorBuilder::Name(FeedbackSource const& feedback) { \
-    FeedbackParameter parameters(feedback);                                 \
-    return new (zone()) Operator1<FeedbackParameter>(                       \
-        IrOpcode::kJS##Name, Properties, "JS" #Name, 2, 1, 1, 1, 1,         \
-        Operator::ZeroIfNoThrow(Properties), parameters);                   \
-  }
-COMPARE_OP_LIST(COMPARE_OP)
-#undef COMPARE_OP
-
 const Operator* JSOperatorBuilder::StoreDataPropertyInLiteral(
     const FeedbackSource& feedback) {
   FeedbackParameter parameters(feedback);
@@ -1333,10 +1302,7 @@ Handle<ScopeInfo> ScopeInfoOf(const Operator* op) {
   return OpParameter<Handle<ScopeInfo>>(op);
 }
 
-#undef UNARY_OP_LIST
-#undef BINARY_OP_LIST
 #undef CACHED_OP_LIST
-#undef COMPARE_OP_LIST
 
 }  // namespace compiler
 }  // namespace internal

src/compiler/js-operator.h

@@ -29,15 +29,52 @@ namespace compiler {
 class Operator;
 struct JSOperatorGlobalCache;
 
+// Macro lists.
+#define JS_UNOP_WITH_FEEDBACK(V) \
+  JS_BITWISE_UNOP_LIST(V)        \
+  JS_ARITH_UNOP_LIST(V)
+
+#define JS_BINOP_WITH_FEEDBACK(V) \
+  JS_ARITH_BINOP_LIST(V)          \
+  JS_BITWISE_BINOP_LIST(V)        \
+  JS_COMPARE_BINOP_LIST(V)
+
+// Predicates.
+class JSOperator final : public AllStatic {
+ public:
+  static constexpr bool IsUnaryWithFeedback(Operator::Opcode opcode) {
+#define CASE(Name, ...)   \
+  case IrOpcode::k##Name: \
+    return true;
+    switch (opcode) {
+      JS_UNOP_WITH_FEEDBACK(CASE);
+      default:
+        return false;
+    }
+#undef CASE
+    return false;
+  }
+
+  static constexpr bool IsBinaryWithFeedback(Operator::Opcode opcode) {
+#define CASE(Name, ...)   \
+  case IrOpcode::k##Name: \
+    return true;
+    switch (opcode) {
+      JS_BINOP_WITH_FEEDBACK(CASE);
+      default:
+        return false;
+    }
+#undef CASE
+    return false;
+  }
+};
+
 // Node wrappers.
 
 class JSUnaryOpNode final : public NodeWrapper {
  public:
   explicit constexpr JSUnaryOpNode(Node* node) : NodeWrapper(node) {
-    CONSTEXPR_DCHECK(node->opcode() == IrOpcode::kJSBitwiseNot ||
-                     node->opcode() == IrOpcode::kJSDecrement ||
-                     node->opcode() == IrOpcode::kJSIncrement ||
-                     node->opcode() == IrOpcode::kJSNegate);
+    CONSTEXPR_DCHECK(JSOperator::IsUnaryWithFeedback(node->opcode()));
   }
 
   static constexpr int ValueIndex() { return 0; }

src/compiler/node-matchers.h

@@ -39,7 +39,7 @@ struct NodeMatcher {
 
   bool IsComparison() const;
 
-#define DEFINE_IS_OPCODE(Opcode) \
+#define DEFINE_IS_OPCODE(Opcode, ...) \
   bool Is##Opcode() const { return opcode() == IrOpcode::k##Opcode; }
   ALL_OP_LIST(DEFINE_IS_OPCODE)
 #undef DEFINE_IS_OPCODE

src/compiler/opcodes.cc

@@ -16,7 +16,7 @@ namespace compiler {
 namespace {
 
 char const* const kMnemonics[] = {
-#define DECLARE_MNEMONIC(x) #x,
+#define DECLARE_MNEMONIC(x, ...) #x,
     ALL_OP_LIST(DECLARE_MNEMONIC)
 #undef DECLARE_MNEMONIC
         "UnknownOpcode"};

src/compiler/opcodes.h

@@ -85,29 +85,30 @@
   V(StaticAssert)
 
 // Opcodes for JavaScript operators.
-#define JS_COMPARE_BINOP_LIST(V) \
-  V(JSEqual)                     \
-  V(JSStrictEqual)               \
-  V(JSLessThan)                  \
-  V(JSGreaterThan)               \
-  V(JSLessThanOrEqual)           \
-  V(JSGreaterThanOrEqual)
+// Arguments are JSName (the name with a 'JS' prefix), and Name.
+#define JS_COMPARE_BINOP_LIST(V)        \
+  V(JSEqual, Equal)                     \
+  V(JSStrictEqual, StrictEqual)         \
+  V(JSLessThan, LessThan)               \
+  V(JSGreaterThan, GreaterThan)         \
+  V(JSLessThanOrEqual, LessThanOrEqual) \
+  V(JSGreaterThanOrEqual, GreaterThanOrEqual)
 
 #define JS_BITWISE_BINOP_LIST(V) \
-  V(JSBitwiseOr)                 \
-  V(JSBitwiseXor)                \
-  V(JSBitwiseAnd)                \
-  V(JSShiftLeft)                 \
-  V(JSShiftRight)                \
-  V(JSShiftRightLogical)
+  V(JSBitwiseOr, BitwiseOr)      \
+  V(JSBitwiseXor, BitwiseXor)    \
+  V(JSBitwiseAnd, BitwiseAnd)    \
+  V(JSShiftLeft, ShiftLeft)      \
+  V(JSShiftRight, ShiftRight)    \
+  V(JSShiftRightLogical, ShiftRightLogical)
 
 #define JS_ARITH_BINOP_LIST(V) \
-  V(JSAdd)                     \
-  V(JSSubtract)                \
-  V(JSMultiply)                \
-  V(JSDivide)                  \
-  V(JSModulus)                 \
-  V(JSExponentiate)
+  V(JSAdd, Add)                \
+  V(JSSubtract, Subtract)      \
+  V(JSMultiply, Multiply)      \
+  V(JSDivide, Divide)          \
+  V(JSModulus, Modulus)        \
+  V(JSExponentiate, Exponentiate)
 
 #define JS_SIMPLE_BINOP_LIST(V) \
   JS_COMPARE_BINOP_LIST(V)      \
@@ -127,12 +128,18 @@
   V(JSToString)                    \
   V(JSParseInt)
 
+#define JS_BITWISE_UNOP_LIST(V) \
+  V(JSBitwiseNot, BitwiseNot)   \
+  V(JSNegate, Negate)
+
+#define JS_ARITH_UNOP_LIST(V) \
+  V(JSDecrement, Decrement)   \
+  V(JSIncrement, Increment)
+
 #define JS_SIMPLE_UNOP_LIST(V) \
-  JS_CONVERSION_UNOP_LIST(V)   \
-  V(JSBitwiseNot)              \
-  V(JSDecrement)               \
-  V(JSIncrement)               \
-  V(JSNegate)
+  JS_ARITH_UNOP_LIST(V)        \
+  JS_BITWISE_UNOP_LIST(V)      \
+  JS_CONVERSION_UNOP_LIST(V)
 
 #define JS_CREATE_OP_LIST(V)     \
   V(JSCloneObject)               \
@@ -971,12 +978,12 @@ namespace compiler {
 class V8_EXPORT_PRIVATE IrOpcode {
  public:
   enum Value {
-#define DECLARE_OPCODE(x) k##x,
+#define DECLARE_OPCODE(x, ...) k##x,
     ALL_OP_LIST(DECLARE_OPCODE)
 #undef DECLARE_OPCODE
-    kLast = -1
-#define COUNT_OPCODE(x) +1
-            ALL_OP_LIST(COUNT_OPCODE)
+        kLast = -1
+#define COUNT_OPCODE(...) +1
+                ALL_OP_LIST(COUNT_OPCODE)
 #undef COUNT_OPCODE
   };
 
@@ -1000,7 +1007,16 @@ class V8_EXPORT_PRIVATE IrOpcode {
 
   // Returns true if opcode for constant operator.
   static bool IsConstantOpcode(Value value) {
-    return kInt32Constant <= value && value <= kRelocatableInt64Constant;
+#define CASE(Name) \
+  case k##Name:    \
+    return true;
+    switch (value) {
+      CONSTANT_OP_LIST(CASE);
+      default:
+        return false;
+    }
+#undef CASE
+    UNREACHABLE();
   }
 
   static bool IsPhiOpcode(Value value) {
@@ -1015,8 +1031,9 @@ class V8_EXPORT_PRIVATE IrOpcode {
     return kIfTrue <= value && value <= kIfDefault;
   }
 
-  // Returns true if opcode terminates control flow in a graph (i.e. respective
-  // nodes are expected to have control uses by the graphs {End} node only).
+  // Returns true if opcode terminates control flow in a graph (i.e.
+  // respective nodes are expected to have control uses by the graphs {End}
+  // node only).
   static bool IsGraphTerminator(Value value) {
     return value == kDeoptimize || value == kReturn || value == kTailCall ||
            value == kTerminate || value == kThrow;
@@ -1029,9 +1046,18 @@ class V8_EXPORT_PRIVATE IrOpcode {
 
   // Returns true if opcode for comparison operator.
   static bool IsComparisonOpcode(Value value) {
-    return (kJSEqual <= value && value <= kJSGreaterThanOrEqual) ||
-           (kNumberEqual <= value && value <= kStringLessThanOrEqual) ||
-           (kWord32Equal <= value && value <= kFloat64LessThanOrEqual);
+#define CASE(Name, ...) \
+  case k##Name:         \
+    return true;
+    switch (value) {
+      JS_COMPARE_BINOP_LIST(CASE);
+      SIMPLIFIED_COMPARE_BINOP_LIST(CASE);
+      MACHINE_COMPARE_BINOP_LIST(CASE);
+      default:
+        return false;
+    }
+#undef CASE
+    UNREACHABLE();
   }
 
   static bool IsContextChainExtendingOpcode(Value value) {

src/compiler/operator-properties.cc

@@ -24,7 +24,7 @@ bool OperatorProperties::NeedsExactContext(const Operator* op) {
   DCHECK(HasContextInput(op));
   IrOpcode::Value const opcode = static_cast<IrOpcode::Value>(op->opcode());
   switch (opcode) {
-#define CASE(Name) case IrOpcode::k##Name:
+#define CASE(Name, ...) case IrOpcode::k##Name:
     // Binary/unary operators, calls and constructor calls only
     // need the context to generate exceptions or lookup fields
     // on the native context, so passing any context is fine.

src/compiler/schedule.cc

@@ -228,7 +228,7 @@ namespace {
 
 bool IsPotentiallyThrowingCall(IrOpcode::Value opcode) {
   switch (opcode) {
-#define BUILD_BLOCK_JS_CASE(Name) case IrOpcode::k##Name:
+#define BUILD_BLOCK_JS_CASE(Name, ...) case IrOpcode::k##Name:
     JS_OP_LIST(BUILD_BLOCK_JS_CASE)
 #undef BUILD_BLOCK_JS_CASE
     case IrOpcode::kCall:

src/compiler/scheduler.cc

@@ -354,7 +354,7 @@ class CFGBuilder : public ZoneObject {
       case IrOpcode::kSwitch:
         BuildBlocksForSuccessors(node);
         break;
-#define BUILD_BLOCK_JS_CASE(Name) case IrOpcode::k##Name:
+#define BUILD_BLOCK_JS_CASE(Name, ...) case IrOpcode::k##Name:
         JS_OP_LIST(BUILD_BLOCK_JS_CASE)
 // JS opcodes are just like calls => fall through.
 #undef BUILD_BLOCK_JS_CASE
@@ -398,7 +398,7 @@ class CFGBuilder : public ZoneObject {
         scheduler_->UpdatePlacement(node, Scheduler::kFixed);
         ConnectThrow(node);
         break;
-#define CONNECT_BLOCK_JS_CASE(Name) case IrOpcode::k##Name:
+#define CONNECT_BLOCK_JS_CASE(Name, ...) case IrOpcode::k##Name:
         JS_OP_LIST(CONNECT_BLOCK_JS_CASE)
 // JS opcodes are just like calls => fall through.
 #undef CONNECT_BLOCK_JS_CASE

src/compiler/simplified-lowering.cc

@@ -3717,7 +3717,7 @@ class RepresentationSelector {
       case IrOpcode::kUnreachable:
       case IrOpcode::kRuntimeAbort:
 // All JavaScript operators except JSToNumber have uniform handling.
-#define OPCODE_CASE(name) case IrOpcode::k##name:
+#define OPCODE_CASE(name, ...) case IrOpcode::k##name:
         JS_SIMPLE_BINOP_LIST(OPCODE_CASE)
         JS_OBJECT_OP_LIST(OPCODE_CASE)
         JS_CONTEXT_OP_LIST(OPCODE_CASE)

src/compiler/typer.cc

@@ -72,8 +72,8 @@ class Typer::Visitor : public Reducer {
 
   Type TypeNode(Node* node) {
     switch (node->opcode()) {
-#define DECLARE_UNARY_CASE(x) \
-  case IrOpcode::k##x:        \
+#define DECLARE_UNARY_CASE(x, ...) \
+  case IrOpcode::k##x:             \
     return Type##x(Operand(node, 0));
       JS_SIMPLE_UNOP_LIST(DECLARE_UNARY_CASE)
       SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_UNARY_CASE)
@@ -81,8 +81,8 @@ class Typer::Visitor : public Reducer {
       SIMPLIFIED_SPECULATIVE_NUMBER_UNOP_LIST(DECLARE_UNARY_CASE)
       SIMPLIFIED_SPECULATIVE_BIGINT_UNOP_LIST(DECLARE_UNARY_CASE)
 #undef DECLARE_UNARY_CASE
-#define DECLARE_BINARY_CASE(x) \
-  case IrOpcode::k##x:         \
+#define DECLARE_BINARY_CASE(x, ...) \
+  case IrOpcode::k##x:              \
     return Type##x(Operand(node, 0), Operand(node, 1));
       JS_SIMPLE_BINOP_LIST(DECLARE_BINARY_CASE)
       SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_BINARY_CASE)
@@ -90,8 +90,8 @@ class Typer::Visitor : public Reducer {
       SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_BINARY_CASE)
       SIMPLIFIED_SPECULATIVE_BIGINT_BINOP_LIST(DECLARE_BINARY_CASE)
 #undef DECLARE_BINARY_CASE
-#define DECLARE_OTHER_CASE(x) \
-  case IrOpcode::k##x:        \
+#define DECLARE_OTHER_CASE(x, ...) \
+  case IrOpcode::k##x:             \
     return Type##x(node);
       DECLARE_OTHER_CASE(Start)
       DECLARE_OTHER_CASE(IfException)
@@ -102,7 +102,7 @@ class Typer::Visitor : public Reducer {
       JS_CONTEXT_OP_LIST(DECLARE_OTHER_CASE)
       JS_OTHER_OP_LIST(DECLARE_OTHER_CASE)
 #undef DECLARE_OTHER_CASE
-#define DECLARE_IMPOSSIBLE_CASE(x) case IrOpcode::k##x:
+#define DECLARE_IMPOSSIBLE_CASE(x, ...) case IrOpcode::k##x:
       DECLARE_IMPOSSIBLE_CASE(Loop)
       DECLARE_IMPOSSIBLE_CASE(Branch)
       DECLARE_IMPOSSIBLE_CASE(IfTrue)
@@ -141,7 +141,7 @@ class Typer::Visitor : public Reducer {
   LoopVariableOptimizer* induction_vars_;
   ZoneSet<NodeId> weakened_nodes_;
 
-#define DECLARE_METHOD(x) inline Type Type##x(Node* node);
+#define DECLARE_METHOD(x, ...) inline Type Type##x(Node* node);
   DECLARE_METHOD(Start)
   DECLARE_METHOD(IfException)
   COMMON_OP_LIST(DECLARE_METHOD)
@@ -151,7 +151,7 @@ class Typer::Visitor : public Reducer {
   JS_CONTEXT_OP_LIST(DECLARE_METHOD)
   JS_OTHER_OP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
-#define DECLARE_METHOD(x) inline Type Type##x(Type input);
+#define DECLARE_METHOD(x, ...) inline Type Type##x(Type input);
   JS_SIMPLE_UNOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
 
@@ -229,13 +229,13 @@ class Typer::Visitor : public Reducer {
   SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_METHOD)
   SIMPLIFIED_SPECULATIVE_BIGINT_BINOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
-#define DECLARE_METHOD(Name)                       \
+#define DECLARE_METHOD(Name, ...)                  \
   inline Type Type##Name(Type left, Type right) {  \
     return TypeBinaryOp(left, right, Name##Typer); \
   }
   JS_SIMPLE_BINOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
-#define DECLARE_METHOD(Name)                      \
+#define DECLARE_METHOD(Name, ...)                 \
   inline Type Type##Name(Type left, Type right) { \
     return TypeBinaryOp(left, right, Name);       \
   }
@@ -244,7 +244,7 @@ class Typer::Visitor : public Reducer {
   SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_METHOD)
   SIMPLIFIED_SPECULATIVE_BIGINT_BINOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
-#define DECLARE_METHOD(Name) \
+#define DECLARE_METHOD(Name, ...) \
   inline Type Type##Name(Type input) { return TypeUnaryOp(input, Name); }
   SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_METHOD)
   SIMPLIFIED_BIGINT_UNOP_LIST(DECLARE_METHOD)
@@ -271,7 +271,7 @@ class Typer::Visitor : public Reducer {
   static ComparisonOutcome JSCompareTyper(Type, Type, Typer*);
   static ComparisonOutcome NumberCompareTyper(Type, Type, Typer*);
 
-#define DECLARE_METHOD(x) static Type x##Typer(Type, Type, Typer*);
+#define DECLARE_METHOD(x, ...) static Type x##Typer(Type, Type, Typer*);
   JS_SIMPLE_BINOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
 

test/unittests/compiler/opcodes-unittest.cc

@@ -40,7 +40,7 @@ bool IsControlOpcode(IrOpcode::Value opcode) {
 
 bool IsJsOpcode(IrOpcode::Value opcode) {
   switch (opcode) {
-#define OPCODE(Opcode)      \
+#define OPCODE(Opcode, ...) \
   case IrOpcode::k##Opcode: \
     return true;
     JS_OP_LIST(OPCODE)
@@ -66,7 +66,7 @@ bool IsConstantOpcode(IrOpcode::Value opcode) {
 
 bool IsComparisonOpcode(IrOpcode::Value opcode) {
   switch (opcode) {
-#define OPCODE(Opcode)      \
+#define OPCODE(Opcode, ...) \
   case IrOpcode::k##Opcode: \
     return true;
     JS_COMPARE_BINOP_LIST(OPCODE)
@@ -79,13 +79,13 @@ bool IsComparisonOpcode(IrOpcode::Value opcode) {
 }
 
 char const* const kMnemonics[] = {
-#define OPCODE(Opcode) #Opcode,
+#define OPCODE(Opcode, ...) #Opcode,
     ALL_OP_LIST(OPCODE)
 #undef OPCODE
 };
 
 const IrOpcode::Value kOpcodes[] = {
-#define OPCODE(Opcode) IrOpcode::k##Opcode,
+#define OPCODE(Opcode, ...) IrOpcode::k##Opcode,
     ALL_OP_LIST(OPCODE)
 #undef OPCODE
 };