Port count-based profiler to ARM

src/arm/deoptimizer-arm.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 90 matching lines @@
   function->ReplaceCode(function->shared()->code());
 
   if (FLAG_trace_deopt) {
     PrintF("[forced deoptimization: ");
     function->PrintName();
     PrintF(" / %x]\n", reinterpret_cast<uint32_t>(function));
   }
 }
 
 
+static const int32_t kBranchBeforeStackCheck = 0x2a000001;
+static const int32_t kBranchBeforeInterrupt =  0x5a000004;

[Erik Corry, 2012/03/23 09:55:53]

There is a bunch of these in assembler-arm.h eg kMovLrPc.  I think these should
go there too.

[Jakob Kummerow, 2012/03/23 12:07:32]

I disagree. They contain condition codes and jump offsets, and are therefore
strictly tied to this usage site. I don't think they can ever be shared, so IMHO
pulling them up to a more global place reduces readability/understandability of
this code here.

I could split the definitions:
/*assembler-arm.{h|cc}*/
const Instr kBcs = 0x2a000000;
const Instr kBpl = 0x5a000000;
/*here/*
static const int32_t kBranchBeforeStackCheck = kBce | 1;
static const int32_t kBranchBeforeInterrupt = kBpl | 4;

Would you like that better?

+
+
 void Deoptimizer::PatchStackCheckCodeAt(Code* unoptimized_code,
                                         Address pc_after,
                                         Code* check_code,
                                         Code* replacement_code) {
   const int kInstrSize = Assembler::kInstrSize;
   // The call of the stack guard check has the following form:
   //  e1 5d 00 0c       cmp sp, <limit>
   //  2a 00 00 01       bcs ok
   //  e5 9f c? ??       ldr ip, [pc, <stack guard address>]
   //  e1 2f ff 3c       blx ip
   ASSERT(Memory::int32_at(pc_after - kInstrSize) ==
       (al | B24 | B21 | 15*B16 | 15*B12 | 15*B8 | BLX | ip.code()));
   ASSERT(Assembler::IsLdrPcImmediateOffset(
       Assembler::instr_at(pc_after - 2 * kInstrSize)));
+  if (FLAG_count_based_interrupts) {
+    ASSERT_EQ(kBranchBeforeInterrupt,
+              Memory::int32_at(pc_after - 3 * kInstrSize));
+  } else {
+    ASSERT_EQ(kBranchBeforeStackCheck,
+              Memory::int32_at(pc_after - 3 * kInstrSize));
+  }
 
   // We patch the code to the following form:
   //  e1 5d 00 0c       cmp sp, <limit>
   //  e1 a0 00 00       mov r0, r0 (NOP)
   //  e5 9f c? ??       ldr ip, [pc, <on-stack replacement address>]
   //  e1 2f ff 3c       blx ip
   // and overwrite the constant containing the
   // address of the stack check stub.
 
   // Replace conditional jump with NOP.
@@ skipping 13 matching lines @@
   unoptimized_code->GetHeap()->incremental_marking()->RecordCodeTargetPatch(
       unoptimized_code, pc_after - 2 * kInstrSize, replacement_code);
 }
 
 
 void Deoptimizer::RevertStackCheckCodeAt(Code* unoptimized_code,
                                          Address pc_after,
                                          Code* check_code,
                                          Code* replacement_code) {
   const int kInstrSize = Assembler::kInstrSize;
-  ASSERT(Memory::uint32_at(pc_after - kInstrSize) == 0xe12fff3c);
-  ASSERT(Memory::uint8_at(pc_after - kInstrSize - 1) == 0xe5);
-  ASSERT(Memory::uint8_at(pc_after - kInstrSize - 2) == 0x9f);
+  ASSERT(Memory::int32_at(pc_after - kInstrSize) ==
+      (al | B24 | B21 | 15*B16 | 15*B12 | 15*B8 | BLX | ip.code()));

[Erik Corry, 2012/03/23 09:55:53]

What is this instruction?

[Jakob Kummerow, 2012/03/23 12:07:32]

"blx ip", copied from above in the interest of unification, see also the
comments in PatchStackCheckCodeAt listing the relevant machine code.
Since this instruction is not specific to this site, I've moved it to
assembler-arm.h.

+  ASSERT(Assembler::IsLdrPcImmediateOffset(
+      Assembler::instr_at(pc_after - 2 * kInstrSize)));
 
   // Replace NOP with conditional jump.
   CodePatcher patcher(pc_after - 3 * kInstrSize, 1);
-  patcher.masm()->b(+4, cs);
+  if (FLAG_count_based_interrupts) {
+    patcher.masm()->b(+16, pl);
+    ASSERT_EQ(kBranchBeforeInterrupt,
+              Memory::int32_at(pc_after - 3 * kInstrSize));
+  } else {
+    patcher.masm()->b(+4, cs);
+    ASSERT_EQ(kBranchBeforeStackCheck,
+              Memory::int32_at(pc_after - 3 * kInstrSize));
+  }
 
   // Replace the stack check address in the constant pool
   // with the entry address of the replacement code.
   uint32_t stack_check_address_offset = Memory::uint16_at(pc_after -
       2 * kInstrSize) & 0xfff;
   Address stack_check_address_pointer = pc_after + stack_check_address_offset;
   ASSERT(Memory::uint32_at(stack_check_address_pointer) ==
          reinterpret_cast<uint32_t>(replacement_code->entry()));
   Memory::uint32_at(stack_check_address_pointer) =
       reinterpret_cast<uint32_t>(check_code->entry());
@@ skipping 776 matching lines @@
     __ push(ip);
     __ b(&done);
     ASSERT(masm()->pc_offset() - start == table_entry_size_);
   }
   __ bind(&done);
 }
 
 #undef __
 
 } }  // namespace v8::internal