A64: Synchronize with r16849.

src/a64/full-codegen-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 1628 matching lines @@
       ? ObjectLiteral::kFastElements
       : ObjectLiteral::kNoFlags;
   flags |= expr->has_function()
       ? ObjectLiteral::kHasFunction
       : ObjectLiteral::kNoFlags;
   __ Mov(x0, Operand(Smi::FromInt(flags)));
   int properties_count = constant_properties->length() / 2;
   const int max_cloned_properties =
       FastCloneShallowObjectStub::kMaximumClonedProperties;
   if ((FLAG_track_double_fields && expr->may_store_doubles()) ||
-      expr->depth() > 1) {
+      (expr->depth() > 1 || Serializer::enabled()) ||
+      (flags != ObjectLiteral::kFastElements) ||
+      (properties_count > max_cloned_properties)) {
     __ Push(x3, x2, x1, x0);
     __ CallRuntime(Runtime::kCreateObjectLiteral, 4);
-  } else if (Serializer::enabled() || (flags != ObjectLiteral::kFastElements) ||
-             (properties_count > max_cloned_properties)) {
-    __ Push(x3, x2, x1, x0);
-    __ CallRuntime(Runtime::kCreateObjectLiteralShallow, 4);
   } else {
     FastCloneShallowObjectStub stub(properties_count);
     __ CallStub(&stub);
   }
 
   // If result_saved is true the result is on top of the stack.  If
   // result_saved is false the result is in x0.
   bool result_saved = false;
 
   // Mark all computed expressions that are bound to a key that
@@ skipping 3271 matching lines @@
   // Uncook the return address (see EnterFinallyBlock).
   __ SmiUntag(x10);
   __ Add(x11, x10, Operand(masm_->CodeObject()));
   __ Br(x11);
 }
 
 
 #undef __
 
 
+// The back edge bookkeeping code matches the pattern:
+//
+//  <decrement profiling counter>
+//  .. .. .. ..       b.pl ok
+//  .. .. .. ..       ldr x16, pc+<interrupt stub address>
+//  .. .. .. ..       blr x16
+//  ok-label
+//
+// We patch the code to the following form:
+//
+//  <decrement profiling counter>
+//  .. .. .. ..       mov x0, x0 (NOP)
+//  .. .. .. ..       ldr x16, pc+<on-stack replacement address>
+//  .. .. .. ..       blr x16
+void BackEdgeTable::PatchAt(Code* unoptimized_code,
+                            Address pc_after,
+                            Code* replacement_code) {
+  // Turn the jump into a nop.
+  Instruction* jump = Instruction::Cast(pc_after)->preceding(3);
+  PatchingAssembler patcher(jump, 1);
+  patcher.nop(Assembler::INTERRUPT_CODE_NOP);
+
+  // Replace the call address.
+  Instruction* load = Instruction::Cast(pc_after)->preceding(2);
+  Address interrupt_address_pointer =
+      reinterpret_cast<Address>(load) + load->ImmPCOffset();
+  Memory::uint64_at(interrupt_address_pointer) =
+      reinterpret_cast<uint64_t>(replacement_code->entry());
+
+  unoptimized_code->GetHeap()->incremental_marking()->RecordCodeTargetPatch(
+      unoptimized_code, pc_after - 2 * kInstructionSize, replacement_code);
+}
+
+
+void BackEdgeTable::RevertAt(Code* unoptimized_code,
+                             Address pc_after,
+                             Code* interrupt_code) {
+  // Turn the nop into a jump.
+  Instruction* jump = Instruction::Cast(pc_after)->preceding(3);
+  PatchingAssembler patcher(jump, 1);
+  patcher.b(6, pl);  // The ok label is 6 instructions later.
+
+  // Replace the call address.
+  Instruction* load = Instruction::Cast(pc_after)->preceding(2);
+  Address interrupt_address_pointer =
+      reinterpret_cast<Address>(load) + load->ImmPCOffset();
+  Memory::uint64_at(interrupt_address_pointer) =
+      reinterpret_cast<uint64_t>(interrupt_code->entry());
+
+  interrupt_code->GetHeap()->incremental_marking()->RecordCodeTargetPatch(
+      unoptimized_code, pc_after - 2 * kInstructionSize, interrupt_code);
+}
+
+
+#ifdef DEBUG
+BackEdgeTable::BackEdgeState BackEdgeTable::GetBackEdgeState(
+    Isolate* isolate,
+    Code* unoptimized_code,
+    Address pc_after) {
+  // TODO(jbramley): There should be some extra assertions here (as in the ARM
+  // back-end), but this function is gone in bleeding_edge so it might not
+  // matter anyway.
+  Instruction* jump_or_nop = Instruction::Cast(pc_after)->preceding(3);
+  return jump_or_nop->IsNop(Assembler::INTERRUPT_CODE_NOP) ?
+      ON_STACK_REPLACEMENT : INTERRUPT;
+}
+#endif
+
+
 #define __ ACCESS_MASM(masm())
 
 
 FullCodeGenerator::NestedStatement* FullCodeGenerator::TryFinally::Exit(
     int* stack_depth,
     int* context_length) {
   ASM_LOCATION("FullCodeGenerator::TryFinally::Exit");
   // The macros used here must preserve the result register.
 
   // Because the handler block contains the context of the finally
@@ skipping 14 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64