A64: Synchronize with r17441.

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 961 matching lines @@
   Cmp(current_object, empty_fixed_array_value);
   B(ne, call_runtime);
 
   Ldr(current_object, FieldMemOperand(map, Map::kPrototypeOffset));
   Cmp(current_object, null_value);
   B(ne, &next);
 }
 
 
 void MacroAssembler::TestJSArrayForAllocationMemento(Register receiver,
-                                                      Register scratch1,
-                                                      Register scratch2) {
-  Label no_memento_available;
+                                                     Register scratch1,
+                                                     Register scratch2,
+                                                     Label* no_memento_found) {
   ExternalReference new_space_start =
       ExternalReference::new_space_start(isolate());
   ExternalReference new_space_allocation_top =
       ExternalReference::new_space_allocation_top_address(isolate());
 
   Add(scratch1, receiver,
       JSArray::kSize + AllocationMemento::kSize - kHeapObjectTag);
   Cmp(scratch1, Operand(new_space_start));
-  B(lt, &no_memento_available);
+  B(lt, no_memento_found);
 
   Mov(scratch2, Operand(new_space_allocation_top));
   Ldr(scratch2, MemOperand(scratch2));
   Cmp(scratch1, scratch2);
-  B(gt, &no_memento_available);
+  B(gt, no_memento_found);
 
   Ldr(scratch1, MemOperand(scratch1, -AllocationMemento::kSize));
   Cmp(scratch1,
       Operand(isolate()->factory()->allocation_memento_map()));
-
-  Bind(&no_memento_available);
 }
 
 
 void MacroAssembler::JumpToHandlerEntry(Register exception,
                                         Register object,
                                         Register state,
                                         Register scratch1,
                                         Register scratch2) {
   // Handler expects argument in x0.
   ASSERT(exception.Is(x0));
@@ skipping 1415 matching lines @@
                                     const CallWrapper& call_wrapper,
                                     CallKind call_kind,
                                     Register function_reg) {
   // You can't call a function without a valid frame.
   ASSERT(flag == JUMP_FUNCTION || has_frame());
 
   // Load the function object, if it isn't already loaded.
   ASSERT(function_reg.Is(x1) || function_reg.IsNone());
   if (function_reg.IsNone()) {
     function_reg = x1;
-    LoadHeapObject(function_reg, function);
+    LoadObject(function_reg, function);
   }
 
   Register code_reg = x3;
 
   // Set up the context.
   Ldr(cp, FieldMemOperand(function_reg, JSFunction::kContextOffset));
 
   // We call indirectly through the code field in the function to
   // allow recompilation to take effect without changing any of the
   // call sites.
@@ skipping 104 matching lines @@
     JumpIfHeapNumber(heap_number, &ok);
     Abort(kExpectedHeapNumber);
     Bind(&ok);
   }
 
   Ldr(double_scratch, FieldMemOperand(heap_number, HeapNumber::kValueOffset));
   ECMA262ToInt32(result, double_scratch, scratch1, scratch2, format);
 }
 
 
+void MacroAssembler::Prologue(PrologueFrameMode frame_mode) {
+  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, 2 * kPointerSize);
+  } else {
+    TODO_UNIMPLEMENTED("Prologue: Implement FLAG_optimize_for_size.");
+    __ 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());
   // jssp[4] : lr
   // jssp[3] : fp
   // jssp[2] : cp
   // jssp[1] : type
@@ skipping 2122 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64