1 files changed, 42 insertions, 22 deletions
diff --git a/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h b/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h
index 3801591b64..a5164472b7 100644
--- a/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h
+++ b/deps/v8/src/regexp/arm64/regexp-macro-assembler-arm64.h
@@ -98,41 +98,58 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM64
                                   const byte** input_end);
 
  private:
+  static constexpr int kFramePointerOffset = 0;
+
   // Above the frame pointer - Stored registers and stack passed parameters.
-  static const int kFramePointer = 0;
-  static const int kReturnAddress = kFramePointer + kSystemPointerSize;
+  static constexpr int kReturnAddressOffset =
+      kFramePointerOffset + kSystemPointerSize;
   // Callee-saved registers (x19-x28).
-  static const int kNumCalleeSavedRegisters = 10;
-  static const int kCalleeSavedRegisters = kReturnAddress + kSystemPointerSize;
-
-  // Below the frame pointer.
+  static constexpr int kNumCalleeSavedRegisters = 10;
+  static constexpr int kCalleeSavedRegistersOffset =
+      kReturnAddressOffset + kSystemPointerSize;
+
+  // Below the frame pointer - the stack frame type marker and locals.
+  static constexpr int kFrameTypeOffset =
+      kFramePointerOffset - kSystemPointerSize;
+  static_assert(kFrameTypeOffset ==
+                CommonFrameConstants::kContextOrFrameTypeOffset);
+  static constexpr int kPaddingAfterFrameType = kSystemPointerSize;
   // Register parameters stored by setup code.
-  static const int kIsolate = -kSystemPointerSize;
-  static const int kDirectCall = kIsolate - kSystemPointerSize;
-  static const int kOutputSize = kDirectCall - kSystemPointerSize;
-  static const int kInput = kOutputSize - kSystemPointerSize;
+  static constexpr int kIsolateOffset =
+      kFrameTypeOffset - kPaddingAfterFrameType - kSystemPointerSize;
+  static constexpr int kDirectCallOffset = kIsolateOffset - kSystemPointerSize;
+  // For the case of global regular expression, we have room to store at least
+  // one set of capture results.  For the case of non-global regexp, we ignore
+  // this value.
+  static constexpr int kNumOutputRegistersOffset =
+      kDirectCallOffset - kSystemPointerSize;
+  static constexpr int kInputStringOffset =
+      kNumOutputRegistersOffset - kSystemPointerSize;
   // When adding local variables remember to push space for them in
   // the frame in GetCode.
-  static const int kSuccessCounter = kInput - kSystemPointerSize;
-  static const int kBacktrackCount = kSuccessCounter - kSystemPointerSize;
+  static constexpr int kSuccessfulCapturesOffset =
+      kInputStringOffset - kSystemPointerSize;
+  static constexpr int kBacktrackCountOffset =
+      kSuccessfulCapturesOffset - kSystemPointerSize;
   // Stores the initial value of the regexp stack pointer in a
   // position-independent representation (in case the regexp stack grows and
   // thus moves).
-  static const int kRegExpStackBasePointer =
-      kBacktrackCount - kSystemPointerSize;
+  static constexpr int kRegExpStackBasePointerOffset =
+      kBacktrackCountOffset - kSystemPointerSize;
   // A padding slot to preserve alignment.
-  static const int kStackLocalPadding =
-      kRegExpStackBasePointer - kSystemPointerSize;
+  static constexpr int kStackLocalPadding =
+      kRegExpStackBasePointerOffset - kSystemPointerSize;
   static constexpr int kNumberOfStackLocals = 4;
 
   // First position register address on the stack. Following positions are
   // below it. A position is a 32 bit value.
-  static const int kFirstRegisterOnStack = kStackLocalPadding - kWRegSize;
+  static constexpr int kFirstRegisterOnStackOffset =
+      kStackLocalPadding - kWRegSize;
   // A capture is a 64 bit value holding two position.
-  static const int kFirstCaptureOnStack = kStackLocalPadding - kXRegSize;
+  static constexpr int kFirstCaptureOnStackOffset =
+      kStackLocalPadding - kXRegSize;
 
-  // Initial size of code buffer.
-  static const int kRegExpCodeSize = 1024;
+  static constexpr int kInitialBufferSize = 1024;
 
   // Registers x0 to x7 are used to store the first captures, they need to be
   // retained over calls to C++ code.
@@ -141,12 +158,15 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM64
 
   // When initializing registers to a non-position value we can unroll
   // the loop. Set the limit of registers to unroll.
-  static const int kNumRegistersToUnroll = 16;
+  static constexpr int kNumRegistersToUnroll = 16;
 
   // We are using x0 to x7 as a register cache. Each hardware register must
   // contain one capture, that is two 32 bit registers. We can cache at most
   // 16 registers.
-  static const int kNumCachedRegisters = 16;
+  static constexpr int kNumCachedRegisters = 16;
+
+  void CallCFunctionFromIrregexpCode(ExternalReference function,
+                                     int num_arguments);
 
   // Check whether preemption has been requested.
   void CheckPreemption();