[ignition] Remove unused count from param index getters

We don't need this with reversed arguments.

Change-Id: I86c5183bccc62ba1727080ebbd685df083608d2f
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3344947
Auto-Submit: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Maya Lekova <mslekova@chromium.org>
Commit-Queue: Maya Lekova <mslekova@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78396}

src/builtins/builtins-generator-gen.cc

@@ -231,7 +231,7 @@ TF_BUILTIN(SuspendGeneratorBaseline, GeneratorBuiltinsAssembler) {
 
   // Copy over the function parameters
   auto parameter_base_index = IntPtrConstant(
-      interpreter::Register::FromParameterIndex(0, 1).ToOperand() + 1);
+      interpreter::Register::FromParameterIndex(0).ToOperand() + 1);
   CSA_CHECK(this, UintPtrLessThan(formal_parameter_count,
                                   parameters_and_registers_length));
   auto parent_frame_pointer = LoadParentFramePointer();

src/compiler/bytecode-analysis.cc

@@ -25,7 +25,7 @@ BytecodeLoopAssignments::BytecodeLoopAssignments(int parameter_count,
 
 void BytecodeLoopAssignments::Add(interpreter::Register r) {
   if (r.is_parameter()) {
-    bit_vector_->Add(r.ToParameterIndex(parameter_count_));
+    bit_vector_->Add(r.ToParameterIndex());
   } else {
     bit_vector_->Add(parameter_count_ + r.index());
   }
@@ -35,7 +35,7 @@ void BytecodeLoopAssignments::AddList(interpreter::Register r, uint32_t count) {
   if (r.is_parameter()) {
     for (uint32_t i = 0; i < count; i++) {
       DCHECK(interpreter::Register(r.index() + i).is_parameter());
-      bit_vector_->Add(r.ToParameterIndex(parameter_count_) + i);
+      bit_vector_->Add(r.ToParameterIndex() + i);
     }
   } else {
     for (uint32_t i = 0; i < count; i++) {

src/compiler/bytecode-graph-builder.cc

@@ -724,7 +724,7 @@ BytecodeGraphBuilder::Environment::Environment(
 int BytecodeGraphBuilder::Environment::RegisterToValuesIndex(
     interpreter::Register the_register) const {
   if (the_register.is_parameter()) {
-    return the_register.ToParameterIndex(parameter_count());
+    return the_register.ToParameterIndex();
   } else {
     return the_register.index() + register_base();
   }

src/interpreter/bytecode-array-builder.cc

@@ -69,11 +69,11 @@ Register BytecodeArrayBuilder::Parameter(int parameter_index) const {
   DCHECK_GE(parameter_index, 0);
   // The parameter indices are shifted by 1 (receiver is the
   // first entry).
-  return Register::FromParameterIndex(parameter_index + 1, parameter_count());
+  return Register::FromParameterIndex(parameter_index + 1);
 }
 
 Register BytecodeArrayBuilder::Receiver() const {
-  return Register::FromParameterIndex(0, parameter_count());
+  return Register::FromParameterIndex(0);
 }
 
 Register BytecodeArrayBuilder::Local(int index) const {
@@ -1576,7 +1576,7 @@ bool BytecodeArrayBuilder::RegisterIsValid(Register reg) const {
   if (reg.is_current_context() || reg.is_function_closure()) {
     return true;
   } else if (reg.is_parameter()) {
-    int parameter_index = reg.ToParameterIndex(parameter_count());
+    int parameter_index = reg.ToParameterIndex();
     return parameter_index >= 0 && parameter_index < parameter_count();
   } else if (reg.index() < fixed_register_count()) {
     return true;

src/interpreter/bytecode-array-iterator.cc

@@ -130,15 +130,14 @@ FeedbackSlot BytecodeArrayIterator::GetSlotOperand(int operand_index) const {
 }
 
 Register BytecodeArrayIterator::GetReceiver() const {
-  return Register::FromParameterIndex(0, bytecode_array()->parameter_count());
+  return Register::FromParameterIndex(0);
 }
 
 Register BytecodeArrayIterator::GetParameter(int parameter_index) const {
   DCHECK_GE(parameter_index, 0);
   // The parameter indices are shifted by 1 (receiver is the
   // first entry).
-  return Register::FromParameterIndex(parameter_index + 1,
-                                      bytecode_array()->parameter_count());
+  return Register::FromParameterIndex(parameter_index + 1);
 }
 
 Register BytecodeArrayIterator::GetRegisterOperand(int operand_index) const {
@@ -275,8 +274,7 @@ int BytecodeArrayIterator::GetAbsoluteOffset(int relative_offset) const {
 }
 
 std::ostream& BytecodeArrayIterator::PrintTo(std::ostream& os) const {
-  return BytecodeDecoder::Decode(os, cursor_ - prefix_size_,
-                                 bytecode_array()->parameter_count());
+  return BytecodeDecoder::Decode(os, cursor_ - prefix_size_);
 }
 
 void BytecodeArrayIterator::UpdatePointers() {

src/interpreter/bytecode-decoder.cc

@@ -93,8 +93,7 @@ const char* NameForNativeContextIndex(uint32_t idx) {
 
 // static
 std::ostream& BytecodeDecoder::Decode(std::ostream& os,
-                                      const uint8_t* bytecode_start,
-                                      int parameter_count) {
+                                      const uint8_t* bytecode_start) {
   Bytecode bytecode = Bytecodes::FromByte(bytecode_start[0]);
   int prefix_offset = 0;
   OperandScale operand_scale = OperandScale::kSingle;
@@ -169,22 +168,22 @@ std::ostream& BytecodeDecoder::Decode(std::ostream& os,
       case interpreter::OperandType::kRegOut: {
         Register reg =
             DecodeRegisterOperand(operand_start, op_type, operand_scale);
-        os << reg.ToString(parameter_count);
+        os << reg.ToString();
         break;
       }
       case interpreter::OperandType::kRegOutTriple: {
         RegisterList reg_list =
             DecodeRegisterListOperand(operand_start, 3, op_type, operand_scale);
-        os << reg_list.first_register().ToString(parameter_count) << "-"
-           << reg_list.last_register().ToString(parameter_count);
+        os << reg_list.first_register().ToString() << "-"
+           << reg_list.last_register().ToString();
         break;
       }
       case interpreter::OperandType::kRegOutPair:
       case interpreter::OperandType::kRegPair: {
         RegisterList reg_list =
             DecodeRegisterListOperand(operand_start, 2, op_type, operand_scale);
-        os << reg_list.first_register().ToString(parameter_count) << "-"
-           << reg_list.last_register().ToString(parameter_count);
+        os << reg_list.first_register().ToString() << "-"
+           << reg_list.last_register().ToString();
         break;
       }
       case interpreter::OperandType::kRegOutList:
@@ -200,8 +199,8 @@ std::ostream& BytecodeDecoder::Decode(std::ostream& os,
             reg_count_operand, OperandType::kRegCount, operand_scale);
         RegisterList reg_list = DecodeRegisterListOperand(
             operand_start, count, op_type, operand_scale);
-        os << reg_list.first_register().ToString(parameter_count) << "-"
-           << reg_list.last_register().ToString(parameter_count);
+        os << reg_list.first_register().ToString() << "-"
+           << reg_list.last_register().ToString();
         i++;  // Skip kRegCount.
         break;
       }

src/interpreter/bytecode-decoder.h

@@ -39,8 +39,7 @@ class V8_EXPORT_PRIVATE BytecodeDecoder final {
                                         OperandScale operand_scale);
 
   // Decode a single bytecode and operands to |os|.
-  static std::ostream& Decode(std::ostream& os, const uint8_t* bytecode_start,
-                              int number_of_parameters);
+  static std::ostream& Decode(std::ostream& os, const uint8_t* bytecode_start);
 };
 
 }  // namespace interpreter

src/interpreter/bytecode-register-optimizer.cc

@@ -235,7 +235,7 @@ BytecodeRegisterOptimizer::BytecodeRegisterOptimizer(
   DCHECK_NE(parameter_count, 0);
   int first_slot_index = parameter_count - 1;
   register_info_table_offset_ =
-      -Register::FromParameterIndex(first_slot_index, parameter_count).index();
+      -Register::FromParameterIndex(first_slot_index).index();
 
   // Initialize register map for parameters, locals, and the
   // accumulator.

src/interpreter/bytecode-register.cc

@@ -37,15 +37,14 @@ static const int kArgumentCountRegisterIndex =
      InterpreterFrameConstants::kArgCOffset) /
     kSystemPointerSize;
 
-Register Register::FromParameterIndex(int index, int parameter_count) {
+Register Register::FromParameterIndex(int index) {
   DCHECK_GE(index, 0);
-  DCHECK_LT(index, parameter_count);
   int register_index = kFirstParamRegisterIndex - index;
   DCHECK_LT(register_index, 0);
   return Register(register_index);
 }
 
-int Register::ToParameterIndex(int parameter_count) const {
+int Register::ToParameterIndex() const {
   DCHECK(is_parameter());
   return kFirstParamRegisterIndex - index();
 }
@@ -120,13 +119,13 @@ bool Register::AreContiguous(Register reg1, Register reg2, Register reg3,
   return true;
 }
 
-std::string Register::ToString(int parameter_count) const {
+std::string Register::ToString() const {
   if (is_current_context()) {
     return std::string("<context>");
   } else if (is_function_closure()) {
     return std::string("<closure>");
   } else if (is_parameter()) {
-    int parameter_index = ToParameterIndex(parameter_count);
+    int parameter_index = ToParameterIndex();
     if (parameter_index == 0) {
       return std::string("<this>");
     } else {

src/interpreter/bytecode-register.h

@@ -26,8 +26,8 @@ class V8_EXPORT_PRIVATE Register final {
   bool is_parameter() const { return index() < 0; }
   bool is_valid() const { return index_ != kInvalidIndex; }
 
-  static Register FromParameterIndex(int index, int parameter_count);
-  int ToParameterIndex(int parameter_count) const;
+  static Register FromParameterIndex(int index);
+  int ToParameterIndex() const;
 
   // Returns an invalid register.
   static Register invalid_value() { return Register(); }
@@ -87,7 +87,7 @@ class V8_EXPORT_PRIVATE Register final {
                             Register reg4 = invalid_value(),
                             Register reg5 = invalid_value());
 
-  std::string ToString(int parameter_count) const;
+  std::string ToString() const;
 
   bool operator==(const Register& other) const {
     return index() == other.index();

src/interpreter/interpreter-assembler.cc

@@ -1462,7 +1462,7 @@ TNode<FixedArray> InterpreterAssembler::ExportParametersAndRegisterFile(
     Label loop(this, &var_index), done_loop(this);
 
     TNode<IntPtrT> reg_base =
-        IntPtrConstant(Register::FromParameterIndex(0, 1).ToOperand() + 1);
+        IntPtrConstant(Register::FromParameterIndex(0).ToOperand() + 1);
 
     Goto(&loop);
     BIND(&loop);

src/objects/code.cc

@@ -647,8 +647,7 @@ void BytecodeArray::Disassemble(std::ostream& os) {
     os << reinterpret_cast<const void*>(current_address) << " @ "
        << std::setw(4) << iterator.current_offset() << " : ";
     interpreter::BytecodeDecoder::Decode(
-        os, reinterpret_cast<byte*>(current_address),
-        static_cast<int>(parameter_count()));
+        os, reinterpret_cast<byte*>(current_address));
     if (interpreter::Bytecodes::IsJump(iterator.current_bytecode())) {
       Address jump_target = base_address + iterator.GetJumpTargetOffset();
       os << " (" << reinterpret_cast<void*>(jump_target) << " @ "

src/runtime/runtime-trace.cc

@@ -46,9 +46,7 @@ void PrintRegisterRange(UnoptimizedFrame* frame, std::ostream& os,
        reg_index++) {
     Object reg_object = frame->ReadInterpreterRegister(reg_index);
     os << "      [ " << std::setw(reg_field_width)
-       << interpreter::Register(reg_index).ToString(
-              bytecode_iterator.bytecode_array()->parameter_count())
-       << arrow_direction;
+       << interpreter::Register(reg_index).ToString() << arrow_direction;
     reg_object.ShortPrint(os);
     os << " ]" << std::endl;
   }
@@ -146,8 +144,7 @@ RUNTIME_FUNCTION(Runtime_TraceUnoptimizedBytecodeEntry) {
     }
     os << static_cast<const void*>(bytecode_address) << " @ " << std::setw(4)
        << offset << " : ";
-    interpreter::BytecodeDecoder::Decode(os, bytecode_address,
-                                         bytecode_array->parameter_count());
+    interpreter::BytecodeDecoder::Decode(os, bytecode_address);
     os << std::endl;
     // Print all input registers and accumulator.
     PrintRegisters(frame, os, true, bytecode_iterator, accumulator);

test/cctest/interpreter/bytecode-expectations-printer.cc

@@ -178,7 +178,7 @@ void BytecodeExpectationsPrinter::PrintBytecodeOperand(
     } else if (register_value.is_function_closure()) {
       *stream << "(closure)";
     } else if (register_value.is_parameter()) {
-      int parameter_index = register_value.ToParameterIndex(parameter_count);
+      int parameter_index = register_value.ToParameterIndex();
       if (parameter_index == 0) {
         *stream << "(this)";
       } else {

test/unittests/interpreter/bytecode-array-iterator-unittest.cc

@@ -38,7 +38,7 @@ TEST_F(BytecodeArrayIteratorTest, IteratesBytecodeArray) {
   Register reg_16(16);  // Something not eligible for short Star.
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t name_index = 2;
   uint32_t load_feedback_slot = feedback_spec.AddLoadICSlot().ToInt();

test/unittests/interpreter/bytecode-array-random-iterator-unittest.cc

@@ -38,7 +38,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, InvalidBeforeStart) {
   Register reg_1(1);
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();
 
@@ -90,7 +90,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, InvalidAfterEnd) {
   Register reg_1(1);
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();
 
@@ -142,7 +142,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, AccessesFirst) {
   Register reg_1(1);
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();
 
@@ -199,7 +199,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, AccessesLast) {
   Register reg_1(1);
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();
 
@@ -256,7 +256,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, RandomAccessValid) {
   Register reg_16(16);  // Something not eligible for short Star.
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t name_index = 2;
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();
@@ -434,7 +434,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArray) {
   Register reg_16(16);  // Something not eligible for short Star.
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t name_index = 2;
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();
@@ -687,7 +687,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArrayBackwards) {
   Register reg_16(16);  // Something not eligible for short Star.
   RegisterList pair = BytecodeUtils::NewRegisterList(0, 2);
   RegisterList triple = BytecodeUtils::NewRegisterList(0, 3);
-  Register param = Register::FromParameterIndex(2, builder.parameter_count());
+  Register param = Register::FromParameterIndex(2);
   const AstRawString* name = ast_factory.GetOneByteString("abc");
   uint32_t name_index = 2;
   uint32_t feedback_slot = feedback_spec.AddLoadICSlot().ToInt();

test/unittests/interpreter/bytecode-decoder-unittest.cc

@@ -22,53 +22,41 @@ TEST(BytecodeDecoder, DecodeBytecodeAndOperands) {
   struct BytecodesAndResult {
     const uint8_t bytecode[32];
     const size_t length;
-    int parameter_count;
     const char* output;
   };
 
   const BytecodesAndResult cases[] = {
-      {{B(LdaSmi), U8(1)}, 2, 0, "            LdaSmi [1]"},
-      {{B(Wide), B(LdaSmi), U16(1000)}, 4, 0, "      LdaSmi.Wide [1000]"},
-      {{B(ExtraWide), B(LdaSmi), U32(100000)},
-       6,
-       0,
-       "LdaSmi.ExtraWide [100000]"},
-      {{B(LdaSmi), U8(-1)}, 2, 0, "            LdaSmi [-1]"},
-      {{B(Wide), B(LdaSmi), U16(-1000)}, 4, 0, "      LdaSmi.Wide [-1000]"},
+      {{B(LdaSmi), U8(1)}, 2, "            LdaSmi [1]"},
+      {{B(Wide), B(LdaSmi), U16(1000)}, 4, "      LdaSmi.Wide [1000]"},
+      {{B(ExtraWide), B(LdaSmi), U32(100000)}, 6, "LdaSmi.ExtraWide [100000]"},
+      {{B(LdaSmi), U8(-1)}, 2, "            LdaSmi [-1]"},
+      {{B(Wide), B(LdaSmi), U16(-1000)}, 4, "      LdaSmi.Wide [-1000]"},
       {{B(ExtraWide), B(LdaSmi), U32(-100000)},
        6,
-       0,
        "LdaSmi.ExtraWide [-100000]"},
-      {{B(Star), R8(5)}, 2, 0, "            Star r5"},
-      {{B(Wide), B(Star), R16(136)}, 4, 0, "      Star.Wide r136"},
+      {{B(Star), R8(5)}, 2, "            Star r5"},
+      {{B(Wide), B(Star), R16(136)}, 4, "      Star.Wide r136"},
       {{B(Wide), B(CallAnyReceiver), R16(134), R16(135), U16(10), U16(177)},
        10,
-       0,
        "CallAnyReceiver.Wide r134, r135-r144, [177]"},
       {{B(ForInPrepare), R8(10), U8(11)},
        3,
-       0,
        "         ForInPrepare r10-r12, [11]"},
       {{B(CallRuntime), U16(Runtime::FunctionId::kIsSmi), R8(0), U8(0)},
        5,
-       0,
        "   CallRuntime [IsSmi], r0-r0"},
       {{B(Ldar),
-        static_cast<uint8_t>(Register::FromParameterIndex(2, 3).ToOperand())},
+        static_cast<uint8_t>(Register::FromParameterIndex(2).ToOperand())},
        2,
-       3,
        "            Ldar a1"},
       {{B(Wide), B(CreateObjectLiteral), U16(513), U16(1027), U8(165)},
        7,
-       0,
        "CreateObjectLiteral.Wide [513], [1027], #165"},
       {{B(ExtraWide), B(JumpIfNull), U32(123456789)},
        6,
-       0,
        "JumpIfNull.ExtraWide [123456789]"},
       {{B(CallJSRuntime), U8(Context::BOOLEAN_FUNCTION_INDEX), R8(0), U8(0)},
        4,
-       0,
        "      CallJSRuntime [boolean_function], r0-r0"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
@@ -88,8 +76,7 @@ TEST(BytecodeDecoder, DecodeBytecodeAndOperands) {
 
     // Generate decoded byte output.
     std::stringstream actual_ss;
-    BytecodeDecoder::Decode(actual_ss, cases[i].bytecode,
-                            cases[i].parameter_count);
+    BytecodeDecoder::Decode(actual_ss, cases[i].bytecode);
 
     // Compare.
     CHECK_EQ(actual_ss.str(), expected_ss.str());

test/unittests/interpreter/bytecode-register-optimizer-unittest.cc

@@ -92,7 +92,7 @@ TEST_F(BytecodeRegisterOptimizerTest, TemporaryMaterializedForJump) {
 
 TEST_F(BytecodeRegisterOptimizerTest, TemporaryNotEmitted) {
   Initialize(3, 1);
-  Register parameter = Register::FromParameterIndex(1, 3);
+  Register parameter = Register::FromParameterIndex(1);
   optimizer()->DoLdar(parameter);
   CHECK_EQ(write_count(), 0u);
   Register temp = NewTemporary();
@@ -155,7 +155,7 @@ TEST_F(BytecodeRegisterOptimizerTest, ReleasedRegisterNotFlushed) {
 
 TEST_F(BytecodeRegisterOptimizerTest, StoresToLocalsImmediate) {
   Initialize(3, 1);
-  Register parameter = Register::FromParameterIndex(1, 3);
+  Register parameter = Register::FromParameterIndex(1);
   optimizer()->DoLdar(parameter);
   CHECK_EQ(write_count(), 0u);
   Register local = Register(0);
@@ -175,7 +175,7 @@ TEST_F(BytecodeRegisterOptimizerTest, StoresToLocalsImmediate) {
 
 TEST_F(BytecodeRegisterOptimizerTest, SingleTemporaryNotMaterializedForInput) {
   Initialize(3, 1);
-  Register parameter = Register::FromParameterIndex(1, 3);
+  Register parameter = Register::FromParameterIndex(1);
   Register temp0 = NewTemporary();
   Register temp1 = NewTemporary();
   optimizer()->DoMov(parameter, temp0);
@@ -193,7 +193,7 @@ TEST_F(BytecodeRegisterOptimizerTest, SingleTemporaryNotMaterializedForInput) {
 
 TEST_F(BytecodeRegisterOptimizerTest, RangeOfTemporariesMaterializedForInput) {
   Initialize(3, 1);
-  Register parameter = Register::FromParameterIndex(1, 3);
+  Register parameter = Register::FromParameterIndex(1);
   Register temp0 = NewTemporary();
   Register temp1 = NewTemporary();
   optimizer()

test/unittests/interpreter/bytecodes-unittest.cc

@@ -41,10 +41,10 @@ TEST(OperandConversion, Parameters) {
   for (size_t p = 0; p < count; p++) {
     int parameter_count = parameter_counts[p];
     for (int i = 0; i < parameter_count; i++) {
-      Register r = Register::FromParameterIndex(i, parameter_count);
+      Register r = Register::FromParameterIndex(i);
       uint32_t operand_value = r.ToOperand();
       Register s = Register::FromOperand(operand_value);
-      CHECK_EQ(i, s.ToParameterIndex(parameter_count));
+      CHECK_EQ(i, s.ToParameterIndex());
     }
   }
 }
@@ -67,7 +67,7 @@ TEST(OperandConversion, RegistersParametersNoOverlap) {
   }
 
   for (int i = 0; i < parameter_count; i += 1) {
-    Register r = Register::FromParameterIndex(i, parameter_count);
+    Register r = Register::FromParameterIndex(i);
     uint32_t operand = r.ToOperand();
     uint8_t index = static_cast<uint8_t>(operand);
     CHECK_LT(index, operand_count.size());