Delegate throwing in RegExpExecStub to CEntryStub.

src/arm64/code-stubs-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 1004 matching lines @@
 
 
 void CEntryStub::GenerateAheadOfTime(Isolate* isolate) {
   CEntryStub stub(isolate, 1, kDontSaveFPRegs);
   stub.GetCode();
   CEntryStub stub_fp(isolate, 1, kSaveFPRegs);
   stub_fp.GetCode();
 }
 
 
-static void ThrowPendingException(MacroAssembler* masm, Register scratch1,
-                                  Register scratch2) {
-  Isolate* isolate = masm->isolate();
-
-  ExternalReference pending_handler_context_address(
-      Isolate::kPendingHandlerContextAddress, isolate);
-  ExternalReference pending_handler_code_address(
-      Isolate::kPendingHandlerCodeAddress, isolate);
-  ExternalReference pending_handler_offset_address(
-      Isolate::kPendingHandlerOffsetAddress, isolate);
-  ExternalReference pending_handler_fp_address(
-      Isolate::kPendingHandlerFPAddress, isolate);
-  ExternalReference pending_handler_sp_address(
-      Isolate::kPendingHandlerSPAddress, isolate);
-
-  // Ask the runtime for help to determine the handler. This will set x0 to
-  // contain the current pending exception, don't clobber it.
-  ExternalReference find_handler(Runtime::kFindExceptionHandler, isolate);
-  DCHECK(csp.Is(masm->StackPointer()));
-  {
-    FrameScope scope(masm, StackFrame::MANUAL);
-    __ Mov(x0, 0);  // argc.
-    __ Mov(x1, 0);  // argv.
-    __ Mov(x2, ExternalReference::isolate_address(isolate));
-    __ CallCFunction(find_handler, 3);
-  }
-
-  // We didn't execute a return case, so the stack frame hasn't been updated
-  // (except for the return address slot). However, we don't need to initialize
-  // jssp because the throw method will immediately overwrite it when it
-  // unwinds the stack.
-  __ SetStackPointer(jssp);
-
-  // Retrieve the handler context, SP and FP.
-  __ Mov(cp, Operand(pending_handler_context_address));
-  __ Ldr(cp, MemOperand(cp));
-  __ Mov(jssp, Operand(pending_handler_sp_address));
-  __ Ldr(jssp, MemOperand(jssp));
-  __ Mov(fp, Operand(pending_handler_fp_address));
-  __ Ldr(fp, MemOperand(fp));
-
-  // If the handler is a JS frame, restore the context to the frame.
-  // (kind == ENTRY) == (fp == 0) == (cp == 0), so we could test either fp
-  // or cp.
-  Label not_js_frame;
-  __ Cbz(cp, &not_js_frame);
-  __ Str(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
-  __ Bind(&not_js_frame);
-
-  // Compute the handler entry address and jump to it.
-  __ Mov(scratch1, Operand(pending_handler_code_address));
-  __ Ldr(scratch1, MemOperand(scratch1));
-  __ Mov(scratch2, Operand(pending_handler_offset_address));
-  __ Ldr(scratch2, MemOperand(scratch2));
-  __ Add(scratch1, scratch1, Code::kHeaderSize - kHeapObjectTag);
-  __ Add(scratch1, scratch1, scratch2);
-  __ Br(scratch1);
-}
-
-
 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.
   MacroAssembler::NoUseRealAbortsScope no_use_real_aborts(masm);
 
   ASM_LOCATION("CEntryStub::Generate entry");
   ProfileEntryHookStub::MaybeCallEntryHook(masm);
@@ skipping 146 matching lines @@
   __ Drop(x11);
   __ AssertFPCRState();
   __ Ret();
 
   // The stack pointer is still csp if we aren't returning, and the frame
   // hasn't changed (except for the return address).
   __ SetStackPointer(csp);
 
   // Handling of exception.
   __ Bind(&exception_returned);
-  ThrowPendingException(masm, x10, x11);
+
+  ExternalReference pending_handler_context_address(
+      Isolate::kPendingHandlerContextAddress, isolate());
+  ExternalReference pending_handler_code_address(
+      Isolate::kPendingHandlerCodeAddress, isolate());
+  ExternalReference pending_handler_offset_address(
+      Isolate::kPendingHandlerOffsetAddress, isolate());
+  ExternalReference pending_handler_fp_address(
+      Isolate::kPendingHandlerFPAddress, isolate());
+  ExternalReference pending_handler_sp_address(
+      Isolate::kPendingHandlerSPAddress, isolate());
+
+  // Ask the runtime for help to determine the handler. This will set x0 to
+  // contain the current pending exception, don't clobber it.
+  ExternalReference find_handler(Runtime::kFindExceptionHandler, isolate());
+  DCHECK(csp.Is(masm->StackPointer()));
+  {
+    FrameScope scope(masm, StackFrame::MANUAL);
+    __ Mov(x0, 0);  // argc.
+    __ Mov(x1, 0);  // argv.
+    __ Mov(x2, ExternalReference::isolate_address(isolate()));
+    __ CallCFunction(find_handler, 3);
+  }
+
+  // We didn't execute a return case, so the stack frame hasn't been updated
+  // (except for the return address slot). However, we don't need to initialize
+  // jssp because the throw method will immediately overwrite it when it
+  // unwinds the stack.
+  __ SetStackPointer(jssp);
+
+  // Retrieve the handler context, SP and FP.
+  __ Mov(cp, Operand(pending_handler_context_address));
+  __ Ldr(cp, MemOperand(cp));
+  __ Mov(jssp, Operand(pending_handler_sp_address));
+  __ Ldr(jssp, MemOperand(jssp));
+  __ Mov(fp, Operand(pending_handler_fp_address));
+  __ Ldr(fp, MemOperand(fp));
+
+  // If the handler is a JS frame, restore the context to the frame.
+  // (kind == ENTRY) == (fp == 0) == (cp == 0), so we could test either fp
+  // or cp.
+  Label not_js_frame;
+  __ Cbz(cp, &not_js_frame);
+  __ Str(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  __ Bind(&not_js_frame);
+
+  // Compute the handler entry address and jump to it.
+  __ Mov(x10, Operand(pending_handler_code_address));
+  __ Ldr(x10, MemOperand(x10));
+  __ Mov(x11, Operand(pending_handler_offset_address));
+  __ Ldr(x11, MemOperand(x11));
+  __ Add(x10, x10, Code::kHeaderSize - kHeapObjectTag);
+  __ Add(x10, x10, x11);
+  __ Br(x10);
 }
 
 
 // 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 1413 matching lines @@
   // If there is no pending exception, handle that in the runtime system.
   __ Mov(x10, Operand(isolate()->factory()->the_hole_value()));
   __ Mov(x11,
          Operand(ExternalReference(Isolate::kPendingExceptionAddress,
                                    isolate())));
   __ Ldr(exception_value, MemOperand(x11));
   __ Cmp(x10, exception_value);
   __ B(eq, &runtime);
 
   // For exception, throw the exception again.
-  __ EnterExitFrame(false, x10);
-  ThrowPendingException(masm, x10, x11);
+  __ TailCallRuntime(Runtime::kRegExpExecReThrow, 4, 1);
 
   __ Bind(&failure);
   __ Mov(x0, Operand(isolate()->factory()->null_value()));
   __ PopCPURegList(used_callee_saved_registers);
   // Drop the 4 arguments of the stub from the stack.
   __ Drop(4);
   __ Ret();
 
   __ Bind(&runtime);
   __ PopCPURegList(used_callee_saved_registers);
@@ skipping 3048 matching lines @@
                            kStackUnwindSpace, NULL, spill_offset,
                            MemOperand(fp, 6 * kPointerSize), NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64