Revert of [regexp] Remove remainder of native RegExpExecStub

src/regexp/mips64/regexp-macro-assembler-mips64.cc

 // Copyright 2012 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.
 
 #if V8_TARGET_ARCH_MIPS64
 
 #include "src/regexp/mips64/regexp-macro-assembler-mips64.h"
 
 #include "src/code-stubs.h"
 #include "src/log.h"
 #include "src/macro-assembler.h"
 #include "src/regexp/regexp-macro-assembler.h"
 #include "src/regexp/regexp-stack.h"
 #include "src/unicode.h"
 
 namespace v8 {
 namespace internal {
 
 #ifndef V8_INTERPRETED_REGEXP
-
-/* clang-format off
- *
+/*
  * This assembler uses the following register assignment convention
  * - t3 : Temporarily stores the index of capture start after a matching pass
  *        for a global regexp.
  * - a5 : Pointer to current code object (Code*) including heap object tag.
  * - a6 : Current position in input, as negative offset from end of string.
  *        Please notice that this is the byte offset, not the character offset!
  * - a7 : Currently loaded character. Must be loaded using
  *        LoadCurrentCharacter before using any of the dispatch methods.
  * - t0 : Points to tip of backtrack stack
  * - t1 : Unused.
  * - t2 : End of input (points to byte after last character in input).
  * - fp : Frame pointer. Used to access arguments, local variables and
  *         RegExp registers.
  * - sp : Points to tip of C stack.
  *
  * The remaining registers are free for computations.
  * Each call to a public method should retain this convention.
  *
  * TODO(plind): O32 documented here with intent of having single 32/64 codebase
  *              in the future.
  *
  * The O32 stack will have the following structure:
  *
- *  - fp[72]  Isolate* isolate   (address of the current isolate)
- *  - fp[68]  direct_call  (if 1, direct call from JavaScript code,
+ *  - fp[76]  Isolate* isolate   (address of the current isolate)
+ *  - fp[72]  direct_call  (if 1, direct call from JavaScript code,
  *                          if 0, call through the runtime system).
- *  - fp[64]  stack_area_base (High end of the memory area to use as
+ *  - fp[68]  stack_area_base (High end of the memory area to use as
  *                             backtracking stack).
- *  - fp[60]  capture array size (may fit multiple sets of matches)
+ *  - fp[64]  capture array size (may fit multiple sets of matches)
+ *  - fp[60]  int* capture_array (int[num_saved_registers_], for output).
  *  - fp[44..59]  MIPS O32 four argument slots
- *  - fp[40]  int* capture_array (int[num_saved_registers_], for output).
+ *  - fp[40]  secondary link/return address used by native call.
  *  --- sp when called ---
  *  - fp[36]  return address      (lr).
  *  - fp[32]  old frame pointer   (r11).
  *  - fp[0..31]  backup of registers s0..s7.
  *  --- frame pointer ----
  *  - fp[-4]  end of input       (address of end of string).
  *  - fp[-8]  start of input     (address of first character in string).
  *  - fp[-12] start index        (character index of start).
  *  - fp[-16] void* input_string (location of a handle containing the string).
  *  - fp[-20] success counter    (only for global regexps to count matches).
  *  - fp[-24] Offset of location before start of input (effectively character
  *            string start - 1). Used to initialize capture registers to a
  *            non-position.
  *  - fp[-28] At start (if 1, we are starting at the start of the
  *    string, otherwise 0)
  *  - fp[-32] register 0         (Only positions must be stored in the first
  *  -         register 1          num_saved_registers_ registers)
  *  -         ...
  *  -         register num_registers-1
  *  --- sp ---
  *
  *
  * The N64 stack will have the following structure:
  *
- *  - fp[80]  Isolate* isolate   (address of the current isolate)               kIsolate
- *                                                                              kStackFrameHeader
+ *  - fp[88]  Isolate* isolate   (address of the current isolate)               kIsolate
+ *  - fp[80]  secondary link/return address used by exit frame on native call.  kSecondaryReturnAddress
+                                                                                kStackFrameHeader
  *  --- sp when called ---
  *  - fp[72]  ra                 Return from RegExp code (ra).                  kReturnAddress
  *  - fp[64]  s9, old-fp         Old fp, callee saved(s9).
  *  - fp[0..63]  s0..s7          Callee-saved registers s0..s7.
  *  --- frame pointer ----
  *  - fp[-8]  direct_call        (1 = direct call from JS, 0 = from runtime)    kDirectCall
  *  - fp[-16] stack_base         (Top of backtracking stack).                   kStackHighEnd
  *  - fp[-24] capture array size (may fit multiple sets of matches)             kNumOutputRegisters
  *  - fp[-32] int* capture_array (int[num_saved_registers_], for output).       kRegisterOutput
  *  - fp[-40] end of input       (address of end of string).                    kInputEnd
@@ skipping 15 matching lines @@
  * "character -1" in the string (i.e., char_size() bytes before the first
  * character of the string). The remaining registers start out as garbage.
  *
  * The data up to the return address must be placed there by the calling
  * code and the remaining arguments are passed in registers, e.g. by calling the
  * code entry as cast to a function with the signature:
  * int (*match)(String* input_string,
  *              int start_index,
  *              Address start,
  *              Address end,
+ *              Address secondary_return_address,  // Only used by native call.
  *              int* capture_output_array,
- *              int num_capture_registers,
  *              byte* stack_area_base,
  *              bool direct_call = false,
+ *              void* return_address,
  *              Isolate* isolate);
  * The call is performed by NativeRegExpMacroAssembler::Execute()
  * (in regexp-macro-assembler.cc) via the CALL_GENERATED_REGEXP_CODE macro
  * in mips/simulator-mips.h.
- *
- * clang-format on
+ * When calling as a non-direct call (i.e., from C++ code), the return address
+ * area is overwritten with the ra register by the RegExp code. When doing a
+ * direct call from generated code, the return address is placed there by
+ * the calling code, as in a normal exit frame.
  */
 
 #define __ ACCESS_MASM(masm_)
 
 RegExpMacroAssemblerMIPS::RegExpMacroAssemblerMIPS(Isolate* isolate, Zone* zone,
                                                    Mode mode,
                                                    int registers_to_save)
     : NativeRegExpMacroAssembler(isolate, zone),
       masm_(new MacroAssembler(isolate, NULL, kRegExpCodeSize,
                                CodeObjectRequired::kYes)),
@@ skipping 1190 matching lines @@
 }
 
 #undef __
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64