MIPS: Fix dd() implementations for compact branches.

test/cctest/test-assembler-mips64.cc

 // Copyright 2012 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 3204 matching lines @@
   HandleScope scope(isolate);
   Assembler assm(isolate, nullptr, 0);
 
   const int kNumCases = 512;
   int values[kNumCases];
   isolate->random_number_generator()->NextBytes(values, sizeof(values));
   Label labels[kNumCases];
 
   __ daddiu(sp, sp, -8);
   __ sd(ra, MemOperand(sp));
-  if ((assm.pc_offset() & 7) == 0) {
-    __ nop();
-  }
+  __ Align(8);
 
   Label done;
   {
     __ BlockTrampolinePoolFor(kNumCases * 2 + 7);
     PredictableCodeSizeScope predictable(
         &assm, (kNumCases * 2 + 7) * Assembler::kInstrSize);
     Label here;
 
     __ bal(&here);
     __ nop();
@@ skipping 59 matching lines @@
   __ nop();
 
   for (int i = 0; i < kNumCases; ++i) {
     __ bind(&labels[i]);
     __ lui(v0, (values[i] >> 16) & 0xffff);
     __ ori(v0, v0, values[i] & 0xffff);
     __ b(&done);
     __ nop();
   }
 
-  if ((assm.pc_offset() & 7) == 0) {
-    __ nop();
-  }
+  __ Align(8);
   __ bind(&dispatch);
   {
     __ BlockTrampolinePoolFor(kNumCases * 2 + 7);
     PredictableCodeSizeScope predictable(
         &assm, (kNumCases * 2 + 7) * Assembler::kInstrSize);
     Label here;
 
     __ bal(&here);
     __ nop();
     __ bind(&here);
@@ skipping 45 matching lines @@
   }
   Label labels[kNumCases];
   Object* obj;
   int64_t imm64;
 
   __ daddiu(sp, sp, -8);
   __ sd(ra, MemOperand(sp));
 
   Label done, dispatch;
   __ b(&dispatch);
+  __ nop();
 
 
   for (int i = 0; i < kNumCases; ++i) {
     __ bind(&labels[i]);
     obj = *values[i];
     imm64 = reinterpret_cast<intptr_t>(obj);
     __ lui(v0, (imm64 >> 32) & kImm16Mask);
     __ ori(v0, v0, (imm64 >> 16) & kImm16Mask);
     __ dsll(v0, v0, 16);
     __ ori(v0, v0, imm64 & kImm16Mask);
     __ b(&done);
     __ nop();
   }
 
-  __ stop("chk");
-  if ((assm.pc_offset() & 7) == 0) {
-    __ nop();
-  }
+  __ Align(8);
   __ bind(&dispatch);
   {
     __ BlockTrampolinePoolFor(kNumCases * 2 + 7);
     PredictableCodeSizeScope predictable(
         &assm, (kNumCases * 2 + 7) * Assembler::kInstrSize);
     Label here;
 
     __ bal(&here);
     __ nop();
     __ bind(&here);
@@ skipping 2137 matching lines @@
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label continue_1, stop_execution;
   __ push(ra);
   __ li(v0, 0);
   __ li(t8, 0);
   __ li(t9, 2);   // Condition for the stopping execution.
 
-  uint32_t instruction_addiu = 0x24420001;  // addiu v0, v0, 1
   for (int32_t i = -100; i <= -11; ++i) {
-    __ dd(instruction_addiu);
+    __ addiu(v0, v0, 1);
   }
 
   __ addiu(t8, t8, 1);              // -10
 
   __ beq(t8, t9, &stop_execution);  // -9
   __ nop();                         // -8
   __ beq(t8, t8, &continue_1);      // -7
   __ nop();                         // -6
 
   __ bind(&stop_execution);
   __ pop(ra);                       // -5, -4
   __ jr(ra);                        // -3
   __ nop();                         // -2
 
   __ bind(&continue_1);
   __ bc(offset);                    // -1
 
   for (int32_t i = 0; i <= 99; ++i) {
-    __ dd(instruction_addiu);
+    __ addiu(v0, v0, 1);
   }
 
   __ pop(ra);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
@@ skipping 241 matching lines @@
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 42, 42, 0, 0, 0));
   CHECK_EQ(res, 0);
 }
 
 
 #undef __