[regexp] Remove remainder of native RegExpExecStub

src/builtins/builtins-regexp-gen.cc

 // Copyright 2017 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/builtins/builtins-regexp-gen.h"
 
 #include "src/builtins/builtins-constructor-gen.h"
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 213 matching lines @@
 
   Node* const from_offset = ElementOffsetFromIndex(
       IntPtrAdd(offset, last_index), kind, INTPTR_PARAMETERS);
   var_string_start->Bind(IntPtrAdd(string_data, from_offset));
 
   Node* const to_offset = ElementOffsetFromIndex(
       IntPtrAdd(offset, string_length), kind, INTPTR_PARAMETERS);
   var_string_end->Bind(IntPtrAdd(string_data, to_offset));
 }
 
-Node* RegExpBuiltinsAssembler::IrregexpExec(Node* const context,
-                                            Node* const regexp,
-                                            Node* const string,
-                                            Node* const last_index,
-                                            Node* const match_info) {
+Node* RegExpBuiltinsAssembler::RegExpExecInternal(Node* const context,
+                                                  Node* const regexp,
+                                                  Node* const string,
+                                                  Node* const last_index,
+                                                  Node* const match_info) {
 // Just jump directly to runtime if native RegExp is not selected at compile
 // time or if regexp entry in generated code is turned off runtime switch or
 // at compilation.
 #ifdef V8_INTERPRETED_REGEXP
   return CallRuntime(Runtime::kRegExpExec, context, regexp, string, last_index,
                      match_info);
 #else   // V8_INTERPRETED_REGEXP
   CSA_ASSERT(this, TaggedIsNotSmi(regexp));
   CSA_ASSERT(this, IsJSRegExp(regexp));
 
   CSA_ASSERT(this, TaggedIsNotSmi(string));
   CSA_ASSERT(this, IsString(string));
 
   CSA_ASSERT(this, IsNumber(last_index));
   CSA_ASSERT(this, IsFixedArrayMap(LoadReceiverMap(match_info)));
 
   Node* const int_zero = IntPtrConstant(0);
 
   ToDirectStringAssembler to_direct(state(), string);
 
   VARIABLE(var_result, MachineRepresentation::kTagged);
   Label out(this), runtime(this, Label::kDeferred);
 
   // External constants.
+  Node* const isolate_address =
+      ExternalConstant(ExternalReference::isolate_address(isolate()));
+  Node* const regexp_stack_memory_address_address = ExternalConstant(
+      ExternalReference::address_of_regexp_stack_memory_address(isolate()));
   Node* const regexp_stack_memory_size_address = ExternalConstant(
       ExternalReference::address_of_regexp_stack_memory_size(isolate()));
   Node* const static_offsets_vector_address = ExternalConstant(
       ExternalReference::address_of_static_offsets_vector(isolate()));
-  Node* const pending_exception_address = ExternalConstant(
-      ExternalReference(Isolate::kPendingExceptionAddress, isolate()));
 
   // Ensure that a RegExp stack is allocated.
   {
     Node* const stack_size =
         Load(MachineType::IntPtr(), regexp_stack_memory_size_address);
     GotoIf(IntPtrEqual(stack_size, int_zero), &runtime);
   }
 
   Node* const data = LoadObjectField(regexp, JSRegExp::kDataOffset);
   {
@@ skipping 75 matching lines @@
 
   Node* const code = var_code.value();
   GotoIf(TaggedIsSmi(code), &runtime);
   CSA_ASSERT(this, HasInstanceType(code, CODE_TYPE));
 
   Label if_success(this), if_failure(this),
       if_exception(this, Label::kDeferred);
   {
     IncrementCounter(isolate()->counters()->regexp_entry_native(), 1);
 
-    Callable exec_callable = CodeFactory::RegExpExec(isolate());
-    Node* const result = CallStub(
-        exec_callable, context, string, TruncateWordToWord32(int_last_index),
-        var_string_start.value(), var_string_end.value(), code);
+    // Set up args for the final call into generated Irregexp code.
+
+    MachineType type_int32 = MachineType::Int32();
+    MachineType type_tagged = MachineType::AnyTagged();
+    MachineType type_ptr = MachineType::Pointer();
+
+    // Result: A NativeRegExpMacroAssembler::Result return code.
+    MachineType retval_type = type_int32;
+
+    // Argument 0: Original subject string.
+    MachineType arg0_type = type_tagged;
+    Node* const arg0 = string;
+
+    // Argument 1: Previous index.
+    MachineType arg1_type = type_int32;
+    Node* const arg1 = TruncateWordToWord32(int_last_index);
+
+    // Argument 2: Start of string data.
+    MachineType arg2_type = type_ptr;
+    Node* const arg2 = var_string_start.value();
+
+    // Argument 3: End of string data.
+    MachineType arg3_type = type_ptr;
+    Node* const arg3 = var_string_end.value();
+
+    // Argument 4: static offsets vector buffer.
+    MachineType arg4_type = type_ptr;
+    Node* const arg4 = static_offsets_vector_address;
+
+    // Argument 5: Set the number of capture registers to zero to force global
+    // regexps to behave as non-global.  This does not affect non-global
+    // regexps.
+    MachineType arg5_type = type_int32;
+    Node* const arg5 = Int32Constant(0);
+
+    // Argument 6: Start (high end) of backtracking stack memory area.
+    Node* const stack_start =
+        Load(MachineType::Pointer(), regexp_stack_memory_address_address);
+    Node* const stack_size =
+        Load(MachineType::IntPtr(), regexp_stack_memory_size_address);
+    Node* const stack_end = IntPtrAdd(stack_start, stack_size);
+
+    MachineType arg6_type = type_ptr;
+    Node* const arg6 = stack_end;
+
+    // Argument 7: Indicate that this is a direct call from JavaScript.
+    MachineType arg7_type = type_int32;
+    Node* const arg7 = Int32Constant(1);
+
+    // Argument 8: Pass current isolate address.
+    MachineType arg8_type = type_ptr;
+    Node* const arg8 = isolate_address;
+
+    Node* const code_entry =
+        IntPtrAdd(BitcastTaggedToWord(code),
+                  IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));
+
+    Node* const result = CallCFunction9(
+        retval_type, arg0_type, arg1_type, arg2_type, arg3_type, arg4_type,
+        arg5_type, arg6_type, arg7_type, arg8_type, code_entry, arg0, arg1,
+        arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 
     // Check the result.
-    // We expect exactly one result since the stub forces the called regexp to
-    // behave as non-global.
-    GotoIf(SmiEqual(result, SmiConstant(1)), &if_success);
-    GotoIf(SmiEqual(result, SmiConstant(NativeRegExpMacroAssembler::FAILURE)),
+    // We expect exactly one result since we force the called regexp to behave
+    // as non-global.
+    Node* const int_result = ChangeInt32ToIntPtr(result);
+    GotoIf(IntPtrEqual(int_result,
+                       IntPtrConstant(NativeRegExpMacroAssembler::SUCCESS)),
+           &if_success);
+    GotoIf(IntPtrEqual(int_result,
+                       IntPtrConstant(NativeRegExpMacroAssembler::FAILURE)),
            &if_failure);
-    GotoIf(SmiEqual(result, SmiConstant(NativeRegExpMacroAssembler::EXCEPTION)),
+    GotoIf(IntPtrEqual(int_result,
+                       IntPtrConstant(NativeRegExpMacroAssembler::EXCEPTION)),
            &if_exception);
 
-    CSA_ASSERT(
-        this, SmiEqual(result, SmiConstant(NativeRegExpMacroAssembler::RETRY)));
+    CSA_ASSERT(this,
+               IntPtrEqual(int_result,
+                           IntPtrConstant(NativeRegExpMacroAssembler::RETRY)));
     Goto(&runtime);
   }
 
   BIND(&if_success);
   {
     // Check that the last match info has space for the capture registers and
     // the additional information. Ensure no overflow in add.
     STATIC_ASSERT(FixedArray::kMaxLength < kMaxInt - FixedArray::kLengthOffset);
     Node* const available_slots =
         SmiSub(LoadFixedArrayBaseLength(match_info),
@@ skipping 43 matching lines @@
   }
 
   BIND(&if_failure);
   {
     var_result.Bind(NullConstant());
     Goto(&out);
   }
 
   BIND(&if_exception);
   {
-    Node* const pending_exception =
-        Load(MachineType::AnyTagged(), pending_exception_address);
-
-    // If there is no pending exception, a
-    // stack overflow (on the backtrack stack) was detected in RegExp code.
-
-    Label stack_overflow(this), rethrow(this);
-    Branch(IsTheHole(pending_exception), &stack_overflow, &rethrow);
-
-    BIND(&stack_overflow);
+// A stack overflow was detected in RegExp code.
+#ifdef DEBUG
+    Node* const pending_exception_address = ExternalConstant(
+        ExternalReference(Isolate::kPendingExceptionAddress, isolate()));
+    CSA_ASSERT(this, IsTheHole(Load(MachineType::AnyTagged(),
+                                    pending_exception_address)));
+#endif  // DEBUG
     CallRuntime(Runtime::kThrowStackOverflow, context);
     Unreachable();
-
-    BIND(&rethrow);
-    CallRuntime(Runtime::kRegExpExecReThrow, context);
-    Unreachable();
   }
 
   BIND(&runtime);
   {
     Node* const result = CallRuntime(Runtime::kRegExpExec, context, regexp,
                                      string, last_index, match_info);
     var_result.Bind(result);
     Goto(&out);
   }
 
@@ skipping 95 matching lines @@
   Node* match_indices;
   Label successful_match(this);
   BIND(&run_exec);
   {
     // Get last match info from the context.
     Node* const native_context = LoadNativeContext(context);
     Node* const last_match_info = LoadContextElement(
         native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
     // Call the exec stub.
-    match_indices = IrregexpExec(context, regexp, string, var_lastindex.value(),
-                                 last_match_info);
+    match_indices = RegExpExecInternal(context, regexp, string,
+                                       var_lastindex.value(), last_match_info);
     var_result.Bind(match_indices);
 
     // {match_indices} is either null or the RegExpMatchInfo array.
     // Return early if exec failed, possibly updating last index.
     GotoIfNot(WordEqual(match_indices, null), &successful_match);
 
     GotoIfNot(should_update_last_index, if_didnotmatch);
 
     StoreLastIndex(context, regexp, smi_zero, is_fastpath);
     Goto(if_didnotmatch);
@@ skipping 1511 matching lines @@
   // array depending on whether the {regexp} matches.
   {
     Label next(this), if_stringisempty(this, Label::kDeferred);
     Branch(SmiEqual(string_length, smi_zero), &if_stringisempty, &next);
 
     BIND(&if_stringisempty);
     {
       Node* const last_match_info = LoadContextElement(
           native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
-      Node* const match_indices =
-          IrregexpExec(context, regexp, string, smi_zero, last_match_info);
+      Node* const match_indices = RegExpExecInternal(context, regexp, string,
+                                                     smi_zero, last_match_info);
 
       Label return_singleton_array(this);
       Branch(WordEqual(match_indices, null), &return_singleton_array,
              &return_empty_array);
 
       BIND(&return_singleton_array);
       {
         Node* const length = SmiConstant(1);
         Node* const capacity = IntPtrConstant(1);
         Node* const result = AllocateJSArray(kind, array_map, capacity, length,
@@ skipping 40 matching lines @@
       Branch(SmiEqual(next_search_from, string_length), &push_suffix_and_out,
              &next);
       BIND(&next);
     }
 
     // Search for the given {regexp}.
 
     Node* const last_match_info = LoadContextElement(
         native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
-    Node* const match_indices = IrregexpExec(context, regexp, string,
-                                             next_search_from, last_match_info);
+    Node* const match_indices = RegExpExecInternal(
+        context, regexp, string, next_search_from, last_match_info);
 
     // We're done if no match was found.
     {
       Label next(this);
       Branch(WordEqual(match_indices, null), &push_suffix_and_out, &next);
       BIND(&next);
     }
 
     Node* const match_from = LoadFixedArrayElement(
         match_indices, RegExpMatchInfo::kFirstCaptureIndex);
@@ skipping 660 matching lines @@
   Node* const null = NullConstant();
   Node* const smi_zero = SmiConstant(0);
 
   CSA_ASSERT(this, IsJSRegExp(regexp));
   CSA_ASSERT(this, IsString(string));
 
   Node* const native_context = LoadNativeContext(context);
   Node* const internal_match_info = LoadContextElement(
       native_context, Context::REGEXP_INTERNAL_MATCH_INFO_INDEX);
 
-  Node* const match_indices =
-      IrregexpExec(context, regexp, string, smi_zero, internal_match_info);
+  Node* const match_indices = RegExpExecInternal(context, regexp, string,
+                                                 smi_zero, internal_match_info);
 
   Label if_matched(this), if_didnotmatch(this);
   Branch(WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
 
   BIND(&if_didnotmatch);
   Return(null);
 
   BIND(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8