ARM: Implement PatchStackCheckCodeAt and RevertStackCheckCode.

src/arm/deoptimizer-arm.cc

 // Copyright 2011 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 106 matching lines @@
     PrintF("[forced deoptimization: ");
     function->PrintName();
     PrintF(" / %x]\n", reinterpret_cast<uint32_t>(function));
   }
 }
 
 
 void Deoptimizer::PatchStackCheckCodeAt(Address pc_after,
                                         Code* check_code,
                                         Code* replacement_code) {
-  UNIMPLEMENTED();
+  // The call of the stack guard check has the following form:
+  //  e1 5d 00 0c       cmp sp, <limit>
+  //  2a ?? ?? ??       bcs ok

[Søren Thygesen Gjesse, 2011/02/04 13:54:27]

?? ?? ?? -> 00 00 01, the restoring puts in 1 here.

[Karl Klose, 2011/02/04 18:06:49]

Done.

+  //  e5 9f c? ??       ldr ip, [pc, <stack guard address>]
+  //  e1 2f ff 3c       blx ip
+  ASSERT(Memory::uint32_at(pc_after - 4) == 0xe12fff3c);

[Søren Thygesen Gjesse, 2011/02/04 13:54:27]

0xe12fff3c -> al | B24 | B21 | 15*B16 | 15*B12 | 15*B8 | BLX | ip.code()

[Søren Thygesen Gjesse, 2011/02/04 13:54:27]

4 -> kInstrSize

[Karl Klose, 2011/02/04 18:06:49]

Done.

[Karl Klose, 2011/02/04 18:06:49]

Done.

+  ASSERT(Memory::uint8_at(pc_after - 5) == 0xe5);

[Søren Thygesen Gjesse, 2011/02/04 13:54:27]

Use Assembler::IsLdrPcImmediateOffset() to check this. Maybe add
Assembler::IsLdrPcImmediateOffset() which also takes a register and checks that
it is ldr ip, [...

[Karl Klose, 2011/02/04 18:06:49]

Done.

+  ASSERT(Memory::uint8_at(pc_after - 6) == 0x9f);
+
+  // 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.
+  Memory::uint32_at(pc_after - 12) = 0xe1a00000;

[Søren Thygesen Gjesse, 2011/02/04 13:54:27]

I think you should be able to use the code patcher here:

CodePatcher patcher(pc_after - 3 * kInstrSize, 1)
patcher.masm()->nop();

if not

0xe1a00000 -> al | MOV

[Karl Klose, 2011/02/04 18:06:49]

Done.

+
+  // 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 - 8) &
+      0xfff;
+  Address stack_check_address_pointer = pc_after + stack_check_address_offset;
+  ASSERT(Memory::uint32_at(stack_check_address_pointer) ==
+         reinterpret_cast<uint32_t>(check_code->entry()));
+  Memory::uint32_at(stack_check_address_pointer) =
+      reinterpret_cast<uint32_t>(replacement_code->entry());
 }
 
 
 void Deoptimizer::RevertStackCheckCodeAt(Address pc_after,
                                          Code* check_code,
                                          Code* replacement_code) {
-  UNIMPLEMENTED();
+  ASSERT(Memory::uint32_at(pc_after - 4) == 0xe12fff3c);
+  ASSERT(Memory::uint8_at(pc_after - 5) == 0xe5);
+  ASSERT(Memory::uint8_at(pc_after - 6) == 0x9f);
+
+  // Replace NOP with conditional jump.
+  Memory::uint32_at(pc_after - 12) = 0x2a000001;

[Søren Thygesen Gjesse, 2011/02/04 13:54:27]

Use CodePatcher if possible, or at least:

0x2a000001 -> cs | B27 | B25 | 1

[Karl Klose, 2011/02/04 18:06:49]

I used the CodePatcher.

+
+  // 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 - 8) &
+      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());
 }
 
 
 void Deoptimizer::DoComputeOsrOutputFrame() {
   UNIMPLEMENTED();
 }
 
 
 // This code is very similar to ia32 code, but relies on register names (fp, sp)
 // and how the frame is laid out.
@@ skipping 362 matching lines @@
     __ push(ip);
     __ b(&done);
     ASSERT(masm()->pc_offset() - start == table_entry_size_);
   }
   __ bind(&done);
 }
 
 #undef __
 
 } }  // namespace v8::internal