Revert "[maglev] Remove input_count from Node constructors"

This reverts commit 2ee36e4c.

Reason for revert: https://ci.chromium.org/ui/p/v8/builders/ci/V8%20Linux64%20UBSan/20570/overview

Original change's description:
> [maglev] Remove input_count from Node constructors
>
> Change the NodeBase bitfield to be out-of-line, and initialised by
> NodeBase::Allocate. This means that we don't have to thread the
> input_count through the Derived constructor just to pass it back into
> the NodeBase constructor, and so we can remove those arguments (plus the
> opcode ones while we're at it).
>
> Bug: v8:7700
> Change-Id: I0c96db8cdd05ef106b3cfeb31c5e0d4770d13cc9
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3553103
> Reviewed-by: Toon Verwaest <verwaest@chromium.org>
> Commit-Queue: Leszek Swirski <leszeks@chromium.org>
> Cr-Commit-Position: refs/heads/main@{#79627}

Bug: v8:7700
Change-Id: Ice38908e85f2980dbbe66c61fab17326b3d0be41
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3553005
Owners-Override: Tobias Tebbi <tebbi@chromium.org>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/main@{#79631}

src/maglev/maglev-ir.h

@@ -318,17 +318,7 @@ NODE_BASE_LIST(DEF_OPCODE_OF)
 }  // namespace detail
 
 class NodeBase : public ZoneObject {
- private:
-  // Bitfield specification.
-  using OpcodeField = base::BitField<Opcode, 0, 6>;
-  STATIC_ASSERT(OpcodeField::is_valid(kLastOpcode));
-  using InputCountField = OpcodeField::Next<uint16_t, 16>;
-
  protected:
-  // Subclasses may use the remaining bitfield bits.
-  template <class T, int size>
-  using NextBitField = InputCountField::Next<T, size>;
-
   template <class T>
   static constexpr Opcode opcode_of = detail::opcode_of_helper<T>::value;
 
@@ -360,7 +350,7 @@ class NodeBase : public ZoneObject {
   static constexpr OpProperties kProperties = OpProperties::Pure();
   inline const OpProperties& properties() const;
 
-  constexpr Opcode opcode() const { return OpcodeField::decode(bit_field()); }
+  constexpr Opcode opcode() const { return OpcodeField::decode(bit_field_); }
 
   template <class T>
   constexpr bool Is() const;
@@ -382,7 +372,7 @@ class NodeBase : public ZoneObject {
 
   constexpr bool has_inputs() const { return input_count() > 0; }
   constexpr uint16_t input_count() const {
-    return InputCountField::decode(bit_field());
+    return InputCountField::decode(bit_field_);
   }
 
   Input& input(int index) { return *input_address(index); }
@@ -437,64 +427,60 @@ class NodeBase : public ZoneObject {
   void Print(std::ostream& os, MaglevGraphLabeller*) const;
 
  protected:
-  NodeBase() : num_temporaries_needed_(0) {}
+  NodeBase(Opcode opcode, size_t input_count)
+      : bit_field_(OpcodeField::encode(opcode) |
+                   InputCountField::encode(input_count)) {}
 
   Input* input_address(int index) {
     DCHECK_LT(index, input_count());
-    return reinterpret_cast<Input*>(bit_field_address()) - (index + 1);
+    return reinterpret_cast<Input*>(this) - (index + 1);
   }
   const Input* input_address(int index) const {
     DCHECK_LT(index, input_count());
-    return reinterpret_cast<const Input*>(bit_field_address()) - (index + 1);
+    return reinterpret_cast<const Input*>(this) - (index + 1);
   }
 
   void set_input(int index, ValueNode* input) {
     new (input_address(index)) Input(input);
   }
 
-  uint32_t bit_field() const { return *bit_field_address(); }
-  void set_bit_field(uint32_t value) { *bit_field_address() = value; }
-
-  void set_temporaries_needed(int value) {
-#ifdef DEBUG
-    DCHECK_EQ(kTemporariesState, kUnset);
-    kTemporariesState = kNeedsTemporaries;
-#endif  // DEBUG
-    num_temporaries_needed_ = value;
-  }
-
  private:
   template <class Derived, typename... Args>
   static Derived* Allocate(Zone* zone, size_t input_count, Args&&... args) {
-    const size_t size =
-        sizeof(Derived) + sizeof(uint32_t) + input_count * sizeof(Input);
+    const size_t size = sizeof(Derived) + input_count * sizeof(Input);
     intptr_t raw_buffer =
         reinterpret_cast<intptr_t>(zone->Allocate<NodeWithInlineInputs>(size));
-    void* node_buffer = reinterpret_cast<void*>(raw_buffer + sizeof(uint32_t) +
-                                                input_count * sizeof(Input));
-
-    *reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(node_buffer) -
-                                 sizeof(uint32_t)) =
-        OpcodeField::encode(opcode_of<Derived>) |
-        InputCountField::encode(input_count);
-
-    Derived* node = new (node_buffer) Derived(std::forward<Args>(args)...);
+    void* node_buffer =
+        reinterpret_cast<void*>(raw_buffer + input_count * sizeof(Input));
+    Derived* node =
+        new (node_buffer) Derived(input_count, std::forward<Args>(args)...);
     return node;
   }
 
-  uint32_t* bit_field_address() {
-    return reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(this) -
-                                       sizeof(uint32_t));
-  }
-  const uint32_t* bit_field_address() const {
-    return reinterpret_cast<const uint32_t*>(
-        reinterpret_cast<const char*>(this) - sizeof(uint32_t));
+ protected:
+  // Bitfield specification.
+  using OpcodeField = base::BitField<Opcode, 0, 6>;
+  STATIC_ASSERT(OpcodeField::is_valid(kLastOpcode));
+  using InputCountField = OpcodeField::Next<uint16_t, 16>;
+  // Subclasses may use the remaining bits.
+  template <class T, int size>
+  using NextBitField = InputCountField::Next<T, size>;
+
+  void set_temporaries_needed(int value) {
+#ifdef DEBUG
+    DCHECK_EQ(kTemporariesState, kUnset);
+    kTemporariesState = kNeedsTemporaries;
+#endif  // DEBUG
+    num_temporaries_needed_ = value;
   }
 
+  uint32_t bit_field_;
+
+ private:
   NodeIdT id_ = kInvalidNodeId;
 
   union {
-    int num_temporaries_needed_;
+    int num_temporaries_needed_ = 0;
     RegList temporaries_;
   };
 #ifdef DEBUG
@@ -505,6 +491,7 @@ class NodeBase : public ZoneObject {
   } kTemporariesState = kUnset;
 #endif  // DEBUG
 
+  NodeBase() = delete;
   NodeBase(const NodeBase&) = delete;
   NodeBase(NodeBase&&) = delete;
   NodeBase& operator=(const NodeBase&) = delete;
@@ -537,6 +524,10 @@ class Node : public NodeBase {
 
   inline ValueLocation& result();
 
+ protected:
+  explicit Node(Opcode opcode, size_t input_count)
+      : NodeBase(opcode, input_count) {}
+
  private:
   Node** next() { return &next_; }
   Node* next_ = nullptr;
@@ -635,8 +626,9 @@ class ValueNode : public Node {
   }
 
  protected:
-  ValueNode()
-      : last_uses_next_use_id_(&next_use_)
+  explicit ValueNode(Opcode opcode, size_t input_count)
+      : Node(opcode, input_count),
+        last_uses_next_use_id_(&next_use_)
 #ifdef DEBUG
         ,
         state_(kLastUse)
@@ -674,8 +666,11 @@ class NodeT : public Node {
   STATIC_ASSERT(!IsValueNode(opcode_of<Derived>));
 
  public:
-  constexpr Opcode opcode() const { return opcode_of<Derived>; }
+  constexpr Opcode opcode() const { return NodeBase::opcode_of<Derived>; }
   const OpProperties& properties() const { return Derived::kProperties; }
+
+ protected:
+  explicit NodeT(size_t input_count) : Node(opcode_of<Derived>, input_count) {}
 };
 
 template <size_t InputCount, class Derived>
@@ -691,7 +686,10 @@ class FixedInputNodeT : public NodeT<Derived> {
   }
 
  protected:
-  FixedInputNodeT() { DCHECK_EQ(NodeBase::input_count(), kInputCount); }
+  explicit FixedInputNodeT(size_t input_count) : NodeT<Derived>(kInputCount) {
+    DCHECK_EQ(input_count, kInputCount);
+    USE(input_count);
+  }
 };
 
 template <class Derived>
@@ -699,8 +697,12 @@ class ValueNodeT : public ValueNode {
   STATIC_ASSERT(IsValueNode(opcode_of<Derived>));
 
  public:
-  constexpr Opcode opcode() const { return opcode_of<Derived>; }
+  constexpr Opcode opcode() const { return NodeBase::opcode_of<Derived>; }
   const OpProperties& properties() const { return Derived::kProperties; }
+
+ protected:
+  explicit ValueNodeT(size_t input_count)
+      : ValueNode(opcode_of<Derived>, input_count) {}
 };
 
 template <size_t InputCount, class Derived>
@@ -716,7 +718,11 @@ class FixedInputValueNodeT : public ValueNodeT<Derived> {
   }
 
  protected:
-  FixedInputValueNodeT() { DCHECK_EQ(NodeBase::input_count(), kInputCount); }
+  explicit FixedInputValueNodeT(size_t input_count)
+      : ValueNodeT<Derived>(InputCount) {
+    DCHECK_EQ(input_count, InputCount);
+    USE(input_count);
+  }
 };
 
 template <class Derived, Operation kOperation>
@@ -732,8 +738,9 @@ class UnaryWithFeedbackNode : public FixedInputValueNodeT<1, Derived> {
   compiler::FeedbackSource feedback() const { return feedback_; }
 
  protected:
-  explicit UnaryWithFeedbackNode(const compiler::FeedbackSource& feedback)
-      : feedback_(feedback) {}
+  explicit UnaryWithFeedbackNode(size_t input_count,
+                                 const compiler::FeedbackSource& feedback)
+      : Base(input_count), feedback_(feedback) {}
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
   void GenerateCode(MaglevCodeGenState*, const ProcessingState&);
@@ -757,8 +764,9 @@ class BinaryWithFeedbackNode : public FixedInputValueNodeT<2, Derived> {
   compiler::FeedbackSource feedback() const { return feedback_; }
 
  protected:
-  explicit BinaryWithFeedbackNode(const compiler::FeedbackSource& feedback)
-      : feedback_(feedback) {}
+  BinaryWithFeedbackNode(size_t input_count,
+                         const compiler::FeedbackSource& feedback)
+      : Base(input_count), feedback_(feedback) {}
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
   void GenerateCode(MaglevCodeGenState*, const ProcessingState&);
@@ -772,8 +780,8 @@ class BinaryWithFeedbackNode : public FixedInputValueNodeT<2, Derived> {
     using Base = Super<Name, Operation::k##OpName>;                        \
                                                                            \
    public:                                                                 \
-    explicit Name(const compiler::FeedbackSource& feedback)                \
-        : Base(feedback) {}                                                \
+    Name(size_t input_count, const compiler::FeedbackSource& feedback)     \
+        : Base(input_count, feedback) {}                                   \
     void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&); \
     void GenerateCode(MaglevCodeGenState*, const ProcessingState&);        \
     void PrintParams(std::ostream&, MaglevGraphLabeller*) const {}         \
@@ -793,7 +801,8 @@ class InitialValue : public FixedInputValueNodeT<0, InitialValue> {
   using Base = FixedInputValueNodeT<0, InitialValue>;
 
  public:
-  explicit InitialValue(interpreter::Register source) : source_(source) {}
+  explicit InitialValue(size_t input_count, interpreter::Register source)
+      : Base(input_count), source_(source) {}
 
   interpreter::Register source() const { return source_; }
 
@@ -809,7 +818,8 @@ class RegisterInput : public FixedInputValueNodeT<0, RegisterInput> {
   using Base = FixedInputValueNodeT<0, RegisterInput>;
 
  public:
-  explicit RegisterInput(Register input) : input_(input) {}
+  explicit RegisterInput(size_t input_count, Register input)
+      : Base(input_count), input_(input) {}
 
   Register input() const { return input_; }
 
@@ -825,7 +835,8 @@ class SmiConstant : public FixedInputValueNodeT<0, SmiConstant> {
   using Base = FixedInputValueNodeT<0, SmiConstant>;
 
  public:
-  explicit SmiConstant(Smi value) : value_(value) {}
+  explicit SmiConstant(size_t input_count, Smi value)
+      : Base(input_count), value_(value) {}
 
   Smi value() const { return value_; }
 
@@ -841,7 +852,8 @@ class Constant : public FixedInputValueNodeT<0, Constant> {
   using Base = FixedInputValueNodeT<0, Constant>;
 
  public:
-  explicit Constant(const compiler::HeapObjectRef& object) : object_(object) {}
+  explicit Constant(size_t input_count, const compiler::HeapObjectRef& object)
+      : Base(input_count), object_(object) {}
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
   void GenerateCode(MaglevCodeGenState*, const ProcessingState&);
@@ -855,7 +867,8 @@ class RootConstant : public FixedInputValueNodeT<0, RootConstant> {
   using Base = FixedInputValueNodeT<0, RootConstant>;
 
  public:
-  explicit RootConstant(RootIndex index) : index_(index) {}
+  explicit RootConstant(size_t input_count, RootIndex index)
+      : Base(input_count), index_(index) {}
 
   RootIndex index() const { return index_; }
 
@@ -871,7 +884,8 @@ class SoftDeopt : public FixedInputNodeT<0, SoftDeopt> {
   using Base = FixedInputNodeT<0, SoftDeopt>;
 
  public:
-  explicit SoftDeopt(Checkpoint* checkpoint) : checkpoint_(checkpoint) {}
+  explicit SoftDeopt(size_t input_count, Checkpoint* checkpoint)
+      : Base(input_count), checkpoint_(checkpoint) {}
 
   static constexpr OpProperties kProperties = OpProperties::Deopt();
 
@@ -889,8 +903,9 @@ class CheckMaps : public FixedInputNodeT<1, CheckMaps> {
   using Base = FixedInputNodeT<1, CheckMaps>;
 
  public:
-  explicit CheckMaps(const compiler::MapRef& map, Checkpoint* checkpoint)
-      : map_(map), checkpoint_(checkpoint) {}
+  explicit CheckMaps(size_t input_count, const compiler::MapRef& map,
+                     Checkpoint* checkpoint)
+      : Base(input_count), map_(map), checkpoint_(checkpoint) {}
 
   // TODO(verwaest): This just calls in deferred code, so probably we'll need to
   // mark that to generate stack maps. Mark as call so we at least clear the
@@ -918,7 +933,8 @@ class LoadField : public FixedInputValueNodeT<1, LoadField> {
   using Base = FixedInputValueNodeT<1, LoadField>;
 
  public:
-  explicit LoadField(int handler) : handler_(handler) {}
+  explicit LoadField(size_t input_count, int handler)
+      : Base(input_count), handler_(handler) {}
 
   static constexpr OpProperties kProperties = OpProperties::Reading();
 
@@ -939,7 +955,8 @@ class StoreField : public FixedInputNodeT<2, StoreField> {
   using Base = FixedInputNodeT<2, StoreField>;
 
  public:
-  explicit StoreField(int handler) : handler_(handler) {}
+  explicit StoreField(size_t input_count, int handler)
+      : Base(input_count), handler_(handler) {}
 
   static constexpr OpProperties kProperties = OpProperties::Writing();
 
@@ -962,7 +979,8 @@ class LoadGlobal : public FixedInputValueNodeT<1, LoadGlobal> {
   using Base = FixedInputValueNodeT<1, LoadGlobal>;
 
  public:
-  explicit LoadGlobal(const compiler::NameRef& name) : name_(name) {}
+  explicit LoadGlobal(size_t input_count, const compiler::NameRef& name)
+      : Base(input_count), name_(name) {}
 
   // The implementation currently calls runtime.
   static constexpr OpProperties kProperties = OpProperties::JSCall();
@@ -982,7 +1000,8 @@ class LoadNamedGeneric : public FixedInputValueNodeT<2, LoadNamedGeneric> {
   using Base = FixedInputValueNodeT<2, LoadNamedGeneric>;
 
  public:
-  explicit LoadNamedGeneric(const compiler::NameRef& name) : name_(name) {}
+  explicit LoadNamedGeneric(size_t input_count, const compiler::NameRef& name)
+      : Base(input_count), name_(name) {}
 
   // The implementation currently calls runtime.
   static constexpr OpProperties kProperties = OpProperties::JSCall();
@@ -1006,8 +1025,9 @@ class GapMove : public FixedInputNodeT<0, GapMove> {
   using Base = FixedInputNodeT<0, GapMove>;
 
  public:
-  GapMove(compiler::AllocatedOperand source, compiler::AllocatedOperand target)
-      : source_(source), target_(target) {}
+  GapMove(size_t input_count, compiler::AllocatedOperand source,
+          compiler::AllocatedOperand target)
+      : Base(input_count), source_(source), target_(target) {}
 
   compiler::AllocatedOperand source() const { return source_; }
   compiler::AllocatedOperand target() const { return target_; }
@@ -1031,8 +1051,8 @@ class Phi : public ValueNodeT<Phi> {
   using List = base::ThreadedList<Phi>;
 
   // TODO(jgruber): More intuitive constructors, if possible.
-  Phi(interpreter::Register owner, int merge_offset)
-      : owner_(owner), merge_offset_(merge_offset) {}
+  Phi(size_t input_count, interpreter::Register owner, int merge_offset)
+      : Base(input_count), owner_(owner), merge_offset_(merge_offset) {}
 
   interpreter::Register owner() const { return owner_; }
   int merge_offset() const { return merge_offset_; }
@@ -1058,11 +1078,12 @@ class CallProperty : public ValueNodeT<CallProperty> {
   using Base = ValueNodeT<CallProperty>;
 
  public:
-  CallProperty() = default;
+  explicit CallProperty(size_t input_count) : Base(input_count) {}
 
   // This ctor is used when for variable input counts.
   // Inputs must be initialized manually.
-  CallProperty(ValueNode* function, ValueNode* context) {
+  CallProperty(size_t input_count, ValueNode* function, ValueNode* context)
+      : Base(input_count) {
     set_input(0, function);
     set_input(1, context);
   }
@@ -1086,6 +1107,8 @@ class CallUndefinedReceiver : public ValueNodeT<CallUndefinedReceiver> {
   using Base = ValueNodeT<CallUndefinedReceiver>;
 
  public:
+  explicit CallUndefinedReceiver(size_t input_count) : Base(input_count) {}
+
   static constexpr OpProperties kProperties = OpProperties::JSCall();
 
   Input& function() { return input(0); }
@@ -1211,6 +1234,10 @@ class ControlNode : public NodeBase {
     next_post_dominating_hole_ = node;
   }
 
+ protected:
+  explicit ControlNode(Opcode opcode, size_t input_count)
+      : NodeBase(opcode, input_count) {}
+
  private:
   ControlNode* next_post_dominating_hole_ = nullptr;
 };
@@ -1222,9 +1249,12 @@ class UnconditionalControlNode : public ControlNode {
   void set_predecessor_id(int id) { predecessor_id_ = id; }
 
  protected:
-  explicit UnconditionalControlNode(BasicBlockRef* target_refs)
-      : target_(target_refs) {}
-  explicit UnconditionalControlNode(BasicBlock* target) : target_(target) {}
+  explicit UnconditionalControlNode(Opcode opcode, size_t input_count,
+                                    BasicBlockRef* target_refs)
+      : ControlNode(opcode, input_count), target_(target_refs) {}
+  explicit UnconditionalControlNode(Opcode opcode, size_t input_count,
+                                    BasicBlock* target)
+      : ControlNode(opcode, input_count), target_(target) {}
 
  private:
   const BasicBlockRef target_;
@@ -1238,7 +1268,7 @@ class UnconditionalControlNodeT : public UnconditionalControlNode {
 
  public:
   // Shadowing for static knowledge.
-  constexpr Opcode opcode() const { return opcode_of<Derived>; }
+  constexpr Opcode opcode() const { return NodeBase::opcode_of<Derived>; }
   constexpr bool has_inputs() const { return input_count() > 0; }
   constexpr uint16_t input_count() const { return kInputCount; }
   auto end() {
@@ -1246,21 +1276,27 @@ class UnconditionalControlNodeT : public UnconditionalControlNode {
   }
 
  protected:
-  explicit UnconditionalControlNodeT(BasicBlockRef* target_refs)
-      : UnconditionalControlNode(target_refs) {
-    DCHECK_EQ(NodeBase::input_count(), kInputCount);
+  explicit UnconditionalControlNodeT(size_t input_count,
+                                     BasicBlockRef* target_refs)
+      : UnconditionalControlNode(opcode_of<Derived>, kInputCount, target_refs) {
+    DCHECK_EQ(input_count, kInputCount);
+    USE(input_count);
   }
-  explicit UnconditionalControlNodeT(BasicBlock* target)
-      : UnconditionalControlNode(target) {
-    DCHECK_EQ(NodeBase::input_count(), kInputCount);
+  explicit UnconditionalControlNodeT(size_t input_count, BasicBlock* target)
+      : UnconditionalControlNode(opcode_of<Derived>, kInputCount, target) {
+    DCHECK_EQ(input_count, kInputCount);
+    USE(input_count);
   }
 };
 
 class ConditionalControlNode : public ControlNode {
  public:
-  ConditionalControlNode(BasicBlockRef* if_true_refs,
+  ConditionalControlNode(Opcode opcode, size_t input_count,
+                         BasicBlockRef* if_true_refs,
                          BasicBlockRef* if_false_refs)
-      : if_true_(if_true_refs), if_false_(if_false_refs) {}
+      : ControlNode(opcode, input_count),
+        if_true_(if_true_refs),
+        if_false_(if_false_refs) {}
 
   BasicBlock* if_true() const { return if_true_.block_ptr(); }
   BasicBlock* if_false() const { return if_false_.block_ptr(); }
@@ -1277,7 +1313,7 @@ class ConditionalControlNodeT : public ConditionalControlNode {
 
  public:
   // Shadowing for static knowledge.
-  constexpr Opcode opcode() const { return opcode_of<Derived>; }
+  constexpr Opcode opcode() const { return NodeBase::opcode_of<Derived>; }
   constexpr bool has_inputs() const { return input_count() > 0; }
   constexpr uint16_t input_count() const { return kInputCount; }
   auto end() {
@@ -1285,10 +1321,13 @@ class ConditionalControlNodeT : public ConditionalControlNode {
   }
 
  protected:
-  explicit ConditionalControlNodeT(BasicBlockRef* if_true_refs,
+  explicit ConditionalControlNodeT(size_t input_count,
+                                   BasicBlockRef* if_true_refs,
                                    BasicBlockRef* if_false_refs)
-      : ConditionalControlNode(if_true_refs, if_false_refs) {
-    DCHECK_EQ(NodeBase::input_count(), kInputCount);
+      : ConditionalControlNode(opcode_of<Derived>, kInputCount, if_true_refs,
+                               if_false_refs) {
+    DCHECK_EQ(input_count, kInputCount);
+    USE(input_count);
   }
 };
 
@@ -1296,7 +1335,8 @@ class Jump : public UnconditionalControlNodeT<Jump> {
   using Base = UnconditionalControlNodeT<Jump>;
 
  public:
-  explicit Jump(BasicBlockRef* target_refs) : Base(target_refs) {}
+  explicit Jump(size_t input_count, BasicBlockRef* target_refs)
+      : Base(input_count, target_refs) {}
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
   void GenerateCode(MaglevCodeGenState*, const ProcessingState&);
@@ -1307,9 +1347,11 @@ class JumpLoop : public UnconditionalControlNodeT<JumpLoop> {
   using Base = UnconditionalControlNodeT<JumpLoop>;
 
  public:
-  explicit JumpLoop(BasicBlock* target) : Base(target) {}
+  explicit JumpLoop(size_t input_count, BasicBlock* target)
+      : Base(input_count, target) {}
 
-  explicit JumpLoop(BasicBlockRef* ref) : Base(ref) {}
+  explicit JumpLoop(size_t input_count, BasicBlockRef* ref)
+      : Base(input_count, ref) {}
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
   void GenerateCode(MaglevCodeGenState*, const ProcessingState&);
@@ -1318,6 +1360,9 @@ class JumpLoop : public UnconditionalControlNodeT<JumpLoop> {
 
 class Return : public ControlNode {
  public:
+  explicit Return(size_t input_count)
+      : ControlNode(opcode_of<Return>, input_count) {}
+
   Input& value_input() { return input(0); }
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
@@ -1329,9 +1374,9 @@ class BranchIfTrue : public ConditionalControlNodeT<1, BranchIfTrue> {
   using Base = ConditionalControlNodeT<1, BranchIfTrue>;
 
  public:
-  explicit BranchIfTrue(BasicBlockRef* if_true_refs,
+  explicit BranchIfTrue(size_t input_count, BasicBlockRef* if_true_refs,
                         BasicBlockRef* if_false_refs)
-      : Base(if_true_refs, if_false_refs) {}
+      : Base(input_count, if_true_refs, if_false_refs) {}
 
   Input& condition_input() { return input(0); }
 
@@ -1345,9 +1390,10 @@ class BranchIfToBooleanTrue
   using Base = ConditionalControlNodeT<1, BranchIfToBooleanTrue>;
 
  public:
-  explicit BranchIfToBooleanTrue(BasicBlockRef* if_true_refs,
+  explicit BranchIfToBooleanTrue(size_t input_count,
+                                 BasicBlockRef* if_true_refs,
                                  BasicBlockRef* if_false_refs)
-      : Base(if_true_refs, if_false_refs) {}
+      : Base(input_count, if_true_refs, if_false_refs) {}
 
   static constexpr OpProperties kProperties = OpProperties::Call();
 
@@ -1368,9 +1414,10 @@ class BranchIfCompare
   Input& left_input() { return NodeBase::input(kLeftIndex); }
   Input& right_input() { return NodeBase::input(kRightIndex); }
 
-  explicit BranchIfCompare(Operation operation, BasicBlockRef* if_true_refs,
+  explicit BranchIfCompare(size_t input_count, Operation operation,
+                           BasicBlockRef* if_true_refs,
                            BasicBlockRef* if_false_refs)
-      : Base(if_true_refs, if_false_refs), operation_(operation) {}
+      : Base(input_count, if_true_refs, if_false_refs), operation_(operation) {}
 
   void AllocateVreg(MaglevVregAllocationState*, const ProcessingState&);
   void GenerateCode(MaglevCodeGenState*, const ProcessingState&);