deps: V8: cherry-pick 6bb32bd2c194

Original commit message:

    [regexp] Clean up state for fixed length loop.

    Also reduces the on-stack Trace size by one word,
    adds some comments, renames some variables for
    more clarity.

    Change-Id: I9ec105cd9cebbaba65e9801c47dd0574cc81f967
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/6512896
    Reviewed-by: Patrick Thier <pthier@chromium.org>
    Commit-Queue: Erik Corry <erikcorry@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#100117}

Refs: v8/v8@6bb32bd
PR-URL: #60732
Fixes: #60030
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>

Author: Erik Corry

common.gypi

@@ -38,7 +38,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.35',
+    'v8_embedder_string': '-node.36',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/src/regexp/regexp-compiler.cc

@@ -1337,7 +1337,7 @@ RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,
                                                   Trace* trace) {
   // If we are generating a fixed length loop then don't stop and don't reuse
   // code.
-  if (trace->stop_node() != nullptr) {
+  if (trace->fixed_length_loop_state() != nullptr) {
     return CONTINUE;
   }
 
@@ -2692,7 +2692,8 @@ void LoopChoiceNode::AddContinueAlternative(GuardedAlternative alt) {
 
 void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
-  if (trace->stop_node() == this) {
+  if (trace->fixed_length_loop_state() != nullptr &&
+      trace->fixed_length_loop_state()->loop_choice_node() == this) {
     // Back edge of fixed length optimized loop node graph.
     int text_length =
         FixedLengthLoopLengthForAlternative(&(alternatives_->at(0)));
@@ -2701,10 +2702,10 @@ void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
     // optimization for fixed length loops (see below).
     DCHECK(trace->cp_offset() == text_length);
     macro_assembler->AdvanceCurrentPosition(text_length);
-    macro_assembler->GoTo(trace->loop_label());
+    trace->fixed_length_loop_state()->GoToLoopTopLabel(macro_assembler);
     return;
   }
-  DCHECK_NULL(trace->stop_node());
+  DCHECK_NULL(trace->fixed_length_loop_state());
   if (!trace->is_trivial()) {
     trace->Flush(compiler, this);
     return;
@@ -3136,11 +3137,28 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
  *        S2--/
  */
 
-FixedLengthLoopState::FixedLengthLoopState(bool not_at_start) {
-  counter_backtrack_trace_.set_backtrack(&label_);
+FixedLengthLoopState::FixedLengthLoopState(bool not_at_start,
+                                           ChoiceNode* loop_choice_node)
+    : loop_choice_node_(loop_choice_node) {
+  counter_backtrack_trace_.set_backtrack(&step_backwards_label_);
   if (not_at_start) counter_backtrack_trace_.set_at_start(Trace::FALSE_VALUE);
 }
 
+void FixedLengthLoopState::BindStepBackwardsLabel(
+    RegExpMacroAssembler* macro_assembler) {
+  macro_assembler->Bind(&step_backwards_label_);
+}
+
+void FixedLengthLoopState::BindLoopTopLabel(
+    RegExpMacroAssembler* macro_assembler) {
+  macro_assembler->Bind(&loop_top_label_);
+}
+
+void FixedLengthLoopState::GoToLoopTopLabel(
+    RegExpMacroAssembler* macro_assembler) {
+  macro_assembler->GoTo(&loop_top_label_);
+}
+
 void ChoiceNode::AssertGuardsMentionRegisters(Trace* trace) {
 #ifdef DEBUG
   int choice_count = alternatives_->length();
@@ -3195,7 +3213,9 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
 
   PreloadState preload;
   preload.init();
-  FixedLengthLoopState fixed_length_loop_state(not_at_start());
+  // This must be outside the 'if' because the trace we use for what
+  // comes after the fixed_length_loop is inside it and needs the lifetime.
+  FixedLengthLoopState fixed_length_loop_state(not_at_start(), this);
 
   int text_length = FixedLengthLoopLengthForAlternative(&alternatives_->at(0));
   AlternativeGenerationList alt_gens(choice_count, zone());
@@ -3242,32 +3262,32 @@ Trace* ChoiceNode::EmitFixedLengthLoop(
   // decrement the current position and check it against the pushed value.
   // This avoids pushing backtrack information for each iteration of the loop,
   // which could take up a lot of space.
-  DCHECK(trace->stop_node() == nullptr);
+  DCHECK(trace->fixed_length_loop_state() == nullptr);
   macro_assembler->PushCurrentPosition();
-  Label fixed_length_match_failed;
+  // This is the label for trying to match what comes after the greedy
+  // quantifier, either because the body of the quantifier failed, or because
+  // we have stepped back to try again with one iteration fewer.
+  Label after_body_match_attempt;
   Trace fixed_length_match_trace;
   if (not_at_start()) fixed_length_match_trace.set_at_start(Trace::FALSE_VALUE);
-  fixed_length_match_trace.set_backtrack(&fixed_length_match_failed);
-  Label loop_label;
-  macro_assembler->Bind(&loop_label);
-  fixed_length_match_trace.set_stop_node(this);
-  fixed_length_match_trace.set_loop_label(&loop_label);
+  fixed_length_match_trace.set_backtrack(&after_body_match_attempt);
+  fixed_length_loop_state->BindLoopTopLabel(macro_assembler);
+  fixed_length_match_trace.set_fixed_length_loop_state(fixed_length_loop_state);
   alternatives_->at(0).node()->Emit(compiler, &fixed_length_match_trace);
-  macro_assembler->Bind(&fixed_length_match_failed);
-
-  Label second_choice;  // For use in fixed length matches.
-  macro_assembler->Bind(&second_choice);
+  macro_assembler->Bind(&after_body_match_attempt);
 
   Trace* new_trace = fixed_length_loop_state->counter_backtrack_trace();
 
+  // In a fixed length loop there is only one other choice, which is what
+  // comes after the greedy quantifer.  Try to match that now.
   EmitChoices(compiler, alt_gens, 1, new_trace, preload);
 
-  macro_assembler->Bind(fixed_length_loop_state->label());
+  fixed_length_loop_state->BindStepBackwardsLabel(macro_assembler);
   // If we have unwound to the bottom then backtrack.
   macro_assembler->CheckFixedLengthLoop(trace->backtrack());
   // Otherwise try the second priority at an earlier position.
   macro_assembler->AdvanceCurrentPosition(-text_length);
-  macro_assembler->GoTo(&second_choice);
+  macro_assembler->GoTo(&after_body_match_attempt);
   return new_trace;
 }
 

deps/v8/src/regexp/regexp-compiler.h

@@ -17,6 +17,7 @@ namespace internal {
 
 class DynamicBitSet;
 class Isolate;
+class FixedLengthLoopState;
 
 namespace regexp_compiler_constants {
 
@@ -246,8 +247,7 @@ class Trace {
         has_any_actions_(false),
         action_(nullptr),
         backtrack_(nullptr),
-        stop_node_(nullptr),
-        loop_label_(nullptr),
+        fixed_length_loop_state_(nullptr),
         characters_preloaded_(0),
         bound_checked_up_to_(0),
         next_(nullptr) {}
@@ -259,8 +259,7 @@ class Trace {
         has_any_actions_(other.has_any_actions_),
         action_(nullptr),
         backtrack_(other.backtrack_),
-        stop_node_(other.stop_node_),
-        loop_label_(other.loop_label_),
+        fixed_length_loop_state_(other.fixed_length_loop_state_),
         characters_preloaded_(other.characters_preloaded_),
         bound_checked_up_to_(other.bound_checked_up_to_),
         next_(&other) {}
@@ -294,8 +293,9 @@ class Trace {
   TriBool at_start() const { return at_start_; }
   void set_at_start(TriBool at_start) { at_start_ = at_start; }
   Label* backtrack() const { return backtrack_; }
-  Label* loop_label() const { return loop_label_; }
-  RegExpNode* stop_node() const { return stop_node_; }
+  FixedLengthLoopState* fixed_length_loop_state() const {
+    return fixed_length_loop_state_;
+  }
   int characters_preloaded() const { return characters_preloaded_; }
   int bound_checked_up_to() const { return bound_checked_up_to_; }
   int flush_budget() const { return flush_budget_; }
@@ -313,8 +313,9 @@ class Trace {
     has_any_actions_ = true;
   }
   void set_backtrack(Label* backtrack) { backtrack_ = backtrack; }
-  void set_stop_node(RegExpNode* node) { stop_node_ = node; }
-  void set_loop_label(Label* label) { loop_label_ = label; }
+  void set_fixed_length_loop_state(FixedLengthLoopState* state) {
+    fixed_length_loop_state_ = state;
+  }
   void set_characters_preloaded(int count) { characters_preloaded_ = count; }
   void set_bound_checked_up_to(int to) { bound_checked_up_to_ = to; }
   void set_flush_budget(int to) {
@@ -365,8 +366,7 @@ class Trace {
   bool has_any_actions_ : 8;  // Whether any trace in the chain has an action.
   ActionNode* action_;
   Label* backtrack_;
-  RegExpNode* stop_node_;
-  Label* loop_label_;
+  FixedLengthLoopState* fixed_length_loop_state_;
   int characters_preloaded_;
   int bound_checked_up_to_;
   QuickCheckDetails quick_check_performed_;
@@ -375,13 +375,19 @@ class Trace {
 
 class FixedLengthLoopState {
  public:
-  explicit FixedLengthLoopState(bool not_at_start);
+  explicit FixedLengthLoopState(bool not_at_start,
+                                ChoiceNode* loop_choice_node);
 
-  Label* label() { return &label_; }
+  void BindStepBackwardsLabel(RegExpMacroAssembler* macro_assembler);
+  void BindLoopTopLabel(RegExpMacroAssembler* macro_assembler);
+  void GoToLoopTopLabel(RegExpMacroAssembler* macro_assembler);
+  ChoiceNode* loop_choice_node() const { return loop_choice_node_; }
   Trace* counter_backtrack_trace() { return &counter_backtrack_trace_; }
 
  private:
-  Label label_;
+  Label step_backwards_label_;
+  Label loop_top_label_;
+  ChoiceNode* loop_choice_node_;
   Trace counter_backtrack_trace_;
 };