A64: Implement pre-aging support for A64.

src/a64/macro-assembler-a64.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 2582 matching lines @@
   if (frame_mode == BUILD_STUB_FRAME) {
     ASSERT(StackPointer().Is(jssp));
     // TODO(jbramley): Does x1 contain a JSFunction here, or does it already
     // have the special STUB smi?
     __ Mov(Tmp0(), Operand(Smi::FromInt(StackFrame::STUB)));
     // Compiled stubs don't age, and so they don't need the predictable code
     // ageing sequence.
     __ Push(lr, fp, cp, Tmp0());
     __ Add(fp, jssp, StandardFrameConstants::kFixedFrameSizeFromFp);
   } else {
-    TODO_UNIMPLEMENTED("Prologue: Support IsCodePreAgingActive().");
-    __ EmitFrameSetupForCodeAgePatching();
+    if (isolate()->IsCodePreAgingActive()) {
+      Code* stub = Code::GetPreAgedCodeAgeStub(isolate());
+      __ EmitCodeAgeSequence(stub);
+    } else {
+      __ EmitFrameSetupForCodeAgePatching();
+    }
   }
 }
 
 
 void MacroAssembler::EnterFrame(StackFrame::Type type) {
   ASSERT(jssp.Is(StackPointer()));
   Push(lr, fp, cp);
   Mov(Tmp1(), Operand(Smi::FromInt(type)));
   Mov(Tmp0(), Operand(CodeObject()));
   Push(Tmp1(), Tmp0());
@@ skipping 2044 matching lines @@
 void MacroAssembler::EmitFrameSetupForCodeAgePatching() {
   // TODO(jbramley): Other architectures use the internal memcpy to copy the
   // sequence. If this is a performance bottleneck, we should consider caching
   // the sequence and copying it in the same way.
   InstructionAccurateScope scope(this, kCodeAgeSequenceSize / kInstructionSize);
   ASSERT(jssp.Is(StackPointer()));
   EmitFrameSetupForCodeAgePatching(this);
 }
 
 
+
+void MacroAssembler::EmitCodeAgeSequence(Code* stub) {
+  InstructionAccurateScope scope(this, kCodeAgeSequenceSize / kInstructionSize);
+  ASSERT(jssp.Is(StackPointer()));
+  EmitCodeAgeSequence(this, stub);
+}
+
+
 #undef __
 #define __ assm->
 
 
 void MacroAssembler::EmitFrameSetupForCodeAgePatching(Assembler * assm) {
   Label start;
   __ bind(&start);
 
   // We can do this sequence using four instructions, but the code ageing
   // sequence that patches it needs five, so we use the extra space to try to
   // simplify some addressing modes and remove some dependencies (compared to
   // using two stp instructions with write-back).
   __ sub(jssp, jssp, 4 * kXRegSizeInBytes);
   __ sub(csp, csp, 4 * kXRegSizeInBytes);
   __ stp(x1, cp, MemOperand(jssp, 0 * kXRegSizeInBytes));
   __ stp(fp, lr, MemOperand(jssp, 2 * kXRegSizeInBytes));
   __ add(fp, jssp, StandardFrameConstants::kFixedFrameSizeFromFp);
 
   __ AssertSizeOfCodeGeneratedSince(&start, kCodeAgeSequenceSize);
 }
 
 
-void MacroAssembler::EmitCodeAgeSequence(PatchingAssembler * assm,
+void MacroAssembler::EmitCodeAgeSequence(Assembler * assm,
                                          Code * stub) {
   Label start;
   __ bind(&start);
   // When the stub is called, the sequence is replaced with the young sequence
   // (as in EmitFrameSetupForCodeAgePatching). After the code is replaced, the
   // stub jumps to &start, stored in x0. The young sequence does not call the
   // stub so there is no infinite loop here.
   //
   // A branch (br) is used rather than a call (blr) because this code replaces
   // the frame setup code that would normally preserve lr.
@@ skipping 92 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64