MIPS[64]: Fix jump_tables6 test for r6 architectures

test/cctest/test-macro-assembler-mips64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 346 matching lines @@
   // greater than number of counted instructions from code, as we are expecting
   // generation of trampoline in this case (when number of kFillInstr
   // instructions is close to 32K)
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   MacroAssembler assembler(isolate, nullptr, 0,
                            v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assembler;
 
-  const int kNumCases = 40;
-  const int kFillInstr = 32551;
-  const int kMaxBranchOffset = (1 << (18 - 1)) - 1;
-  const int kTrampolineSlotsSize = 2 * Instruction::kInstrSize;
+  const int kSwitchTableCases = 40;
+
+  const int kInstrSize = Assembler::kInstrSize;
+  const int kMaxBranchOffset = Assembler::kMaxBranchOffset;
+  const int kTrampolineSlotsSize = Assembler::kTrampolineSlotsSize;
+  const int kSwitchTablePrologueSize = MacroAssembler::kSwitchTablePrologueSize;
+
   const int kMaxOffsetForTrampolineStart =
       kMaxBranchOffset - 16 * kTrampolineSlotsSize;
+  const int kFillInstr = (kMaxOffsetForTrampolineStart / kInstrSize) -
+                         (kSwitchTablePrologueSize + 2 * kSwitchTableCases) -
+                         20;
 
-  int values[kNumCases];
+  int values[kSwitchTableCases];
   isolate->random_number_generator()->NextBytes(values, sizeof(values));
-  Label labels[kNumCases];
+  Label labels[kSwitchTableCases];
   Label near_start, end, done;
 
   __ Push(ra);
   __ mov(v0, zero_reg);
 
   int offs1 = masm->pc_offset();
   int gen_insn = 0;
 
   __ Branch(&end);
-  gen_insn += 2;
+  gen_insn += Assembler::IsCompactBranchSupported() ? 1 : 2;
   __ bind(&near_start);
 
   // Generate slightly less than 32K instructions, which will soon require
   // trampoline for branch distance fixup.
   for (int i = 0; i < kFillInstr; ++i) {
     __ addiu(v0, v0, 1);
   }
   gen_insn += kFillInstr;
 
-  __ GenerateSwitchTable(a0, kNumCases,
+  __ GenerateSwitchTable(a0, kSwitchTableCases,
                          [&labels](size_t i) { return labels + i; });
-  gen_insn += (11 + 2 * kNumCases);
+  gen_insn += (kSwitchTablePrologueSize + 2 * kSwitchTableCases);
 
-  for (int i = 0; i < kNumCases; ++i) {
+  for (int i = 0; i < kSwitchTableCases; ++i) {
     __ bind(&labels[i]);
     __ li(v0, values[i]);
     __ Branch(&done);
   }
-  gen_insn += (4 * kNumCases);
+  gen_insn +=
+      ((Assembler::IsCompactBranchSupported() ? 3 : 4) * kSwitchTableCases);
 
   // If offset from here to first branch instr is greater than max allowed
   // offset for trampoline ...
   CHECK_LT(kMaxOffsetForTrampolineStart, masm->pc_offset() - offs1);
   // ... number of generated instructions must be greater then "gen_insn",
   // as we are expecting trampoline generation
-  CHECK_LT(gen_insn, (masm->pc_offset() - offs1) / Instruction::kInstrSize);
+  CHECK_LT(gen_insn, (masm->pc_offset() - offs1) / kInstrSize);
 
   __ bind(&done);
   __ Pop(ra);
   __ jr(ra);
   __ nop();
 
   __ bind(&end);
   __ Branch(&near_start);
 
   CodeDesc desc;
   masm->GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
-  for (int i = 0; i < kNumCases; ++i) {
+  for (int i = 0; i < kSwitchTableCases; ++i) {
     int64_t res = reinterpret_cast<int64_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
     CHECK_EQ(values[i], res);
   }
 }
 
 static uint64_t run_lsa(uint32_t rt, uint32_t rs, int8_t sa) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
@@ skipping 1520 matching lines @@
 
       auto fn_2 = [](MacroAssembler* masm, uint64_t imm) {
         __ Sltu(v0, a0, a1);
       };
       CHECK_EQ(rs < rd, run_Sltu(rs, rd, fn_2));
     }
   }
 }
 
 #undef __