A64: Call ProfileEntryHook in JSEntryStub and do not use real aborts in ProfileEntryHook.

src/a64/code-stubs-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 2548 matching lines @@
   // The result (x0) is passed through as the next PerformGC parameter.
 }
 
 
 void CEntryStub::Generate(MacroAssembler* masm) {
   // The Abort mechanism relies on CallRuntime, which in turn relies on
   // CEntryStub, so until this stub has been generated, we have to use a
   // fall-back Abort mechanism.
   //
   // Note that this stub must be generated before any use of Abort.
-  masm->set_use_real_aborts(false);
+  MacroAssembler::NoUseRealAbortsScope no_use_real_aborts(masm);
 
   ASM_LOCATION("CEntryStub::Generate entry");
   ProfileEntryHookStub::MaybeCallEntryHook(masm);
 
   // Register parameters:
   //    x0: argc (including receiver, untagged)
   //    x1: target
   //
   // The stack on entry holds the arguments and the receiver, with the receiver
   // at the highest address:
@@ skipping 122 matching lines @@
   __ Mov(argc, 0);
   __ Mov(target, 0);
   __ ThrowUncatchable(x0, x10, x11, x12, x13);
 
   __ Bind(&throw_normal);
   ASM_LOCATION("Throw normal");
   __ Mov(argv, 0);
   __ Mov(argc, 0);
   __ Mov(target, 0);
   __ Throw(x0, x10, x11, x12, x13);
-
-  masm->set_use_real_aborts(true);
 }
 
 
 // This is the entry point from C++. 5 arguments are provided in x0-x4.
 // See use of the CALL_GENERATED_CODE macro for example in src/execution.cc.
 // Input:
 //   x0: code entry.
 //   x1: function.
 //   x2: receiver.
 //   x3: argc.
@@ skipping 13 matching lines @@
   // Push callee-saved registers and synchronize the system stack pointer (csp)
   // and the JavaScript stack pointer (jssp).
   //
   // We must not write to jssp until after the PushCalleeSavedRegisters()
   // call, since jssp is itself a callee-saved register.
   __ SetStackPointer(csp);
   __ PushCalleeSavedRegisters();
   __ Mov(jssp, csp);
   __ SetStackPointer(jssp);
 
+  ProfileEntryHookStub::MaybeCallEntryHook(masm);
+
   // Build an entry frame (see layout below).
   Isolate* isolate = masm->isolate();
 
   // Build an entry frame.
   int marker = is_construct ? StackFrame::ENTRY_CONSTRUCT : StackFrame::ENTRY;
   int64_t bad_frame_pointer = -1L;  // Bad frame pointer to fail if it is used.
   __ Mov(x13, bad_frame_pointer);
   __ Mov(x12, Operand(Smi::FromInt(marker)));
   __ Mov(x11, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate)));
   __ Ldr(x10, MemOperand(x11));
@@ skipping 3692 matching lines @@
     AllowStubCallsScope allow_stub_calls(masm, true);
     ProfileEntryHookStub stub;
     __ Push(lr);
     __ CallStub(&stub);
     __ Pop(lr);
   }
 }
 
 
 void ProfileEntryHookStub::Generate(MacroAssembler* masm) {
+  MacroAssembler::NoUseRealAbortsScope no_use_real_aborts(masm);
   // The entry hook is a "BumpSystemStackPointer" instruction (sub), followed by
   // a "Push lr" instruction, followed by a call.
   // TODO(jbramley): Verify that this call is always made with relocation.
   static const int kReturnAddressDistanceFromFunctionStart =
       Assembler::kCallSizeWithRelocation + (2 * kInstructionSize);
 
   // Save all kCallerSaved registers (including lr), since this can be called
   // from anywhere.
   // TODO(jbramley): What about FP registers?
   __ PushCPURegList(kCallerSaved);
@@ skipping 454 matching lines @@
                                 JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     __ JumpIfSmi(x10, &unexpected_map);
     __ JumpIfObjectType(x10, x10, x11, MAP_TYPE, &map_ok);
     __ Bind(&unexpected_map);
     __ Abort("Unexpected initial map for Array function");
     __ Bind(&map_ok);
 
     // In type_info_cell, we expect either undefined or a valid Cell.
     Label okay_here;
-    Handle<Map> cell_map(masm->isolate()->heap()->global_property_cell_map());
+    Handle<Map> cell_map = masm->isolate()->factory()->cell_map();
     __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &okay_here);
     __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kMapOffset));
     __ Cmp(x10, Operand(cell_map));
     __ Assert(eq, "Expected property cell in type_info_cell");
     __ Bind(&okay_here);
   }
 
   Register kind = x3;
   Label no_info, switch_ready;
   // Get the elements kind and case on that.
@@ skipping 137 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64