Revert of [regexp] Remove remainder of native RegExpExecStub

src/arm/code-stubs-arm.cc

Index: src/arm/code-stubs-arm.cc
diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc
index 2459f987672488293393aa825d6ab719af4bf23a..9bdc4851a1e9b7fe9a0601a8b42f80780c1f0ae8 100644
--- a/src/arm/code-stubs-arm.cc
+++ b/src/arm/code-stubs-arm.cc
@@ -1145,6 +1145,75 @@
   __ ldm(ia_w, sp, kCalleeSaved | pc.bit());
 }
 
+void RegExpExecStub::Generate(MacroAssembler* masm) {
+#ifdef V8_INTERPRETED_REGEXP
+  // This case is handled prior to the RegExpExecStub call.
+  __ Abort(kUnexpectedRegExpExecCall);
+#else  // V8_INTERPRETED_REGEXP
+  // Isolates: note we add an additional parameter here (isolate pointer).
+  const int kRegExpExecuteArguments = 9;
+  const int kParameterRegisters = 4;
+  __ EnterExitFrame(false, kRegExpExecuteArguments - kParameterRegisters);
+
+  // Stack pointer now points to cell where return address is to be written.
+  // Arguments are before that on the stack or in registers.
+
+  // Argument 9 (sp[20]): Pass current isolate address.
+  __ mov(r5, Operand(ExternalReference::isolate_address(isolate())));
+  __ str(r5, MemOperand(sp, 5 * kPointerSize));
+
+  // Argument 8 (sp[16]): Indicate that this is a direct call from JavaScript.
+  __ mov(r5, Operand(1));
+  __ str(r5, MemOperand(sp, 4 * kPointerSize));
+
+  // Argument 7 (sp[12]): Start (high end) of backtracking stack memory area.
+  ExternalReference address_of_regexp_stack_memory_address =
+      ExternalReference::address_of_regexp_stack_memory_address(isolate());
+  ExternalReference address_of_regexp_stack_memory_size =
+      ExternalReference::address_of_regexp_stack_memory_size(isolate());
+  __ mov(r5, Operand(address_of_regexp_stack_memory_address));
+  __ ldr(r5, MemOperand(r5, 0));
+  __ mov(r6, Operand(address_of_regexp_stack_memory_size));
+  __ ldr(r6, MemOperand(r6, 0));
+  __ add(r5, r5, Operand(r6));
+  __ str(r5, MemOperand(sp, 3 * kPointerSize));
+
+  // Argument 6: Set the number of capture registers to zero to force global
+  // regexps to behave as non-global.  This does not affect non-global regexps.
+  __ mov(r5, Operand::Zero());
+  __ str(r5, MemOperand(sp, 2 * kPointerSize));
+
+  // Argument 5 (sp[4]): static offsets vector buffer.
+  __ mov(
+      r5,
+      Operand(ExternalReference::address_of_static_offsets_vector(isolate())));
+  __ str(r5, MemOperand(sp, 1 * kPointerSize));
+
+  // Argument 4: End of string data
+  // Argument 3: Start of string data
+  CHECK(r3.is(RegExpExecDescriptor::StringEndRegister()));
+  CHECK(r2.is(RegExpExecDescriptor::StringStartRegister()));
+
+  // Argument 2 (r1): Previous index.
+  CHECK(r1.is(RegExpExecDescriptor::LastIndexRegister()));
+
+  // Argument 1 (r0): Subject string.
+  CHECK(r0.is(RegExpExecDescriptor::StringRegister()));
+
+  // Locate the code entry and call it.
+  Register code_reg = RegExpExecDescriptor::CodeRegister();
+  __ add(code_reg, code_reg, Operand(Code::kHeaderSize - kHeapObjectTag));
+
+  DirectCEntryStub stub(isolate());
+  stub.GenerateCall(masm, code_reg);
+
+  __ LeaveExitFrame(false, no_reg, true);
+
+  __ SmiTag(r0);
+  __ Ret();
+#endif  // V8_INTERPRETED_REGEXP
+}
+
 static void CallStubInRecordCallTarget(MacroAssembler* masm, CodeStub* stub) {
   // r0 : number of arguments to the construct function
   // r1 : the function to call