#include <jsregexp.h>

Collaboration diagram for v8::internal::Trace:

Classes
class	DeferredAction

class	DeferredCapture

class	DeferredClearCaptures

class	DeferredIncrementRegister

class	DeferredSetRegister

Public Types
enum	TriBool { UNKNOWN = -1 , FALSE_VALUE = 0 , TRUE_VALUE = 1 }

Public Member Functions
	Trace ()

void	Flush (RegExpCompiler compiler, RegExpNode successor)

int	cp_offset ()

DeferredAction *	actions ()

bool	is_trivial ()

TriBool	at_start ()

void	set_at_start (bool at_start)

Label *	backtrack ()

Label *	loop_label ()

RegExpNode *	stop_node ()

int	characters_preloaded ()

int	bound_checked_up_to ()

int	flush_budget ()

QuickCheckDetails *	quick_check_performed ()

bool	mentions_reg (int reg)

bool	GetStoredPosition (int reg, int *cp_offset)

void	add_action (DeferredAction *new_action)

void	set_backtrack (Label *backtrack)

void	set_stop_node (RegExpNode *node)

void	set_loop_label (Label *label)

void	set_characters_preloaded (int count)

void	set_bound_checked_up_to (int to)

void	set_flush_budget (int to)

void	set_quick_check_performed (QuickCheckDetails *d)

void	InvalidateCurrentCharacter ()

void	AdvanceCurrentPositionInTrace (int by, RegExpCompiler *compiler)

Private Member Functions
int	FindAffectedRegisters (OutSet affected_registers, Zone zone)

void	PerformDeferredActions (RegExpMacroAssembler macro, int max_register, const OutSet &affected_registers, OutSet registers_to_pop, OutSet registers_to_clear, Zone zone)

void	RestoreAffectedRegisters (RegExpMacroAssembler *macro, int max_register, const OutSet &registers_to_pop, const OutSet &registers_to_clear)

Private Attributes
int	cp_offset_

DeferredAction *	actions_

Label *	backtrack_

RegExpNode *	stop_node_

Label *	loop_label_

int	characters_preloaded_

int	bound_checked_up_to_

QuickCheckDetails	quick_check_performed_

int	flush_budget_

TriBool	at_start_

Detailed Description

Definition at line 1356 of file jsregexp.h.

Member Enumeration Documentation

◆ TriBool

enum v8::internal::Trace::TriBool

Enumerator
UNKNOWN
FALSE_VALUE
TRUE_VALUE

Definition at line 1360 of file jsregexp.h.

                {
     UNKNOWN = -1, FALSE_VALUE = 0, TRUE_VALUE = 1
   };

Constructor & Destructor Documentation

◆ Trace()

v8::internal::Trace::Trace ( )

inline

Definition at line 1419 of file jsregexp.h.

       : cp_offset_(0),
         actions_(NULL),
         backtrack_(NULL),
         stop_node_(NULL),
         loop_label_(NULL),
         characters_preloaded_(0),
         bound_checked_up_to_(0),
         flush_budget_(100),
         at_start_(UNKNOWN) { }

Member Function Documentation

◆ actions()

DeferredAction* v8::internal::Trace::actions ( )

inline

Definition at line 1436 of file jsregexp.h.

1436 { return actions_; }

References actions_.

Referenced by v8::internal::ChoiceNode::Emit(), and v8::internal::ChoiceNode::EmitChoices().

Here is the caller graph for this function:

◆ add_action()

void v8::internal::Trace::add_action ( DeferredAction * new_action )

inline

Definition at line 1474 of file jsregexp.h.

                                               {
     DCHECK(new_action->next_ == NULL);
     new_action->next_ = actions_;
     actions_ = new_action;
   }

References actions_, DCHECK, v8::internal::Trace::DeferredAction::next_, and NULL.

Referenced by v8::internal::ActionNode::Emit().

Here is the caller graph for this function:

◆ AdvanceCurrentPositionInTrace()

void v8::internal::Trace::AdvanceCurrentPositionInTrace	(	int	by,
		RegExpCompiler *	compiler
	)

Definition at line 3374 of file jsregexp.cc.

                                                                           {
   DCHECK(by > 0);
   // We don't have an instruction for shifting the current character register
   // down or for using a shifted value for anything so lets just forget that
   // we preloaded any characters into it.
   characters_preloaded_ = 0;
   // Adjust the offsets of the quick check performed information.  This
   // information is used to find out what we already determined about the
   // characters by means of mask and compare.
   quick_check_performed_.Advance(by, compiler->one_byte());
   cp_offset_ += by;
   if (cp_offset_ > RegExpMacroAssembler::kMaxCPOffset) {
     compiler->SetRegExpTooBig();
     cp_offset_ = 0;
   }
   bound_checked_up_to_ = Max(0, bound_checked_up_to_ - by);
 }

References v8::internal::QuickCheckDetails::Advance(), bound_checked_up_to_, characters_preloaded_, cp_offset_, DCHECK, v8::internal::RegExpMacroAssembler::kMaxCPOffset, v8::internal::Max(), v8::internal::RegExpCompiler::one_byte(), quick_check_performed_, and v8::internal::RegExpCompiler::SetRegExpTooBig().

Referenced by v8::internal::TextNode::Emit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ at_start()

TriBool v8::internal::Trace::at_start ( )

inline

Definition at line 1456 of file jsregexp.h.

1456 { return at_start_; }

References at_start_.

Referenced by v8::internal::AssertionNode::Emit(), v8::internal::AssertionNode::EmitBoundaryCheck(), v8::internal::RegExpNode::EmitQuickCheck(), set_at_start(), and v8::internal::ChoiceNode::SetUpPreLoad().

Here is the caller graph for this function:

◆ backtrack()

Label* v8::internal::Trace::backtrack ( )

inline

Definition at line 1460 of file jsregexp.h.

1460 { return backtrack_; }

References backtrack_.

Referenced by v8::internal::AssertionNode::BacktrackIfPrevious(), v8::internal::ActionNode::Emit(), v8::internal::AssertionNode::Emit(), v8::internal::BackReferenceNode::Emit(), v8::internal::EndNode::Emit(), v8::internal::ChoiceNode::EmitChoices(), v8::internal::ChoiceNode::EmitGreedyLoop(), v8::internal::EmitHat(), v8::internal::RegExpNode::EmitQuickCheck(), Flush(), v8::internal::ChoiceNode::GenerateGuard(), set_backtrack(), and v8::internal::TextNode::TextEmitPass().

Here is the caller graph for this function:

◆ bound_checked_up_to()

int v8::internal::Trace::bound_checked_up_to ( )

inline

Definition at line 1464 of file jsregexp.h.

1464 { return bound_checked_up_to_; }

References bound_checked_up_to_.

Referenced by v8::internal::TextNode::Emit().

Here is the caller graph for this function:

◆ characters_preloaded()

int v8::internal::Trace::characters_preloaded ( )

inline

Definition at line 1463 of file jsregexp.h.

1463 { return characters_preloaded_; }

References characters_preloaded_.

Referenced by v8::internal::TextNode::Emit(), v8::internal::AssertionNode::EmitBoundaryCheck(), v8::internal::RegExpNode::EmitQuickCheck(), and v8::internal::ChoiceNode::SetUpPreLoad().

Here is the caller graph for this function:

◆ cp_offset()

int v8::internal::Trace::cp_offset ( )

inline

Definition at line 1435 of file jsregexp.h.

1435 { return cp_offset_; }

References cp_offset_.

Referenced by v8::internal::AssertionNode::BacktrackIfPrevious(), v8::internal::ActionNode::Emit(), v8::internal::TextNode::Emit(), v8::internal::AssertionNode::Emit(), v8::internal::LoopChoiceNode::Emit(), v8::internal::EmitAtomLetter(), v8::internal::EmitAtomNonLetter(), v8::internal::AssertionNode::EmitBoundaryCheck(), v8::internal::EmitCharClass(), v8::internal::EmitHat(), v8::internal::ChoiceNode::EmitOutOfLineContinuation(), v8::internal::RegExpNode::EmitQuickCheck(), v8::internal::EmitSimpleCharacter(), GetStoredPosition(), and v8::internal::TextNode::TextEmitPass().

Here is the caller graph for this function:

◆ FindAffectedRegisters()

int v8::internal::Trace::FindAffectedRegisters	(	OutSet *	affected_registers,
		Zone *	zone
	)

private

Definition at line 1182 of file jsregexp.cc.

                                              {
   int max_register = RegExpCompiler::kNoRegister;
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
     if (action->action_type() == ActionNode::CLEAR_CAPTURES) {
       Interval range = static_cast<DeferredClearCaptures*>(action)->range();
       for (int i = range.from(); i <= range.to(); i++)
         affected_registers->Set(i, zone);
       if (range.to() > max_register) max_register = range.to();
     } else {
       affected_registers->Set(action->reg(), zone);
       if (action->reg() > max_register) max_register = action->reg();
     }
   }
   return max_register;
 }

References actions_, v8::internal::ActionNode::CLEAR_CAPTURES, v8::internal::Interval::from(), v8::internal::RegExpCompiler::kNoRegister, NULL, v8::internal::OutSet::Set(), and v8::internal::Interval::to().

Referenced by Flush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Flush()

void v8::internal::Trace::Flush	(	RegExpCompiler *	compiler,
		RegExpNode *	successor
	)

Definition at line 1353 of file jsregexp.cc.

                                                                  {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
  
   DCHECK(!is_trivial());
  
   if (actions_ == NULL && backtrack() == NULL) {
     // Here we just have some deferred cp advances to fix and we are back to
     // a normal situation.  We may also have to forget some information gained
     // through a quick check that was already performed.
     if (cp_offset_ != 0) assembler->AdvanceCurrentPosition(cp_offset_);
     // Create a new trivial state and generate the node with that.
     Trace new_state;
     successor->Emit(compiler, &new_state);
     return;
   }
  
   // Generate deferred actions here along with code to undo them again.
   OutSet affected_registers;
  
   if (backtrack() != NULL) {
     // Here we have a concrete backtrack location.  These are set up by choice
     // nodes and so they indicate that we have a deferred save of the current
     // position which we may need to emit here.
     assembler->PushCurrentPosition();
   }
  
   int max_register = FindAffectedRegisters(&affected_registers,
                                            compiler->zone());
   OutSet registers_to_pop;
   OutSet registers_to_clear;
   PerformDeferredActions(assembler,
                          max_register,
                          affected_registers,
                          &registers_to_pop,
                          &registers_to_clear,
                          compiler->zone());
   if (cp_offset_ != 0) {
     assembler->AdvanceCurrentPosition(cp_offset_);
   }
  
   // Create a new trivial state and generate the node with that.
   Label undo;
   assembler->PushBacktrack(&undo);
   Trace new_state;
   successor->Emit(compiler, &new_state);
  
   // On backtrack we need to restore state.
   assembler->Bind(&undo);
   RestoreAffectedRegisters(assembler,
                            max_register,
                            registers_to_pop,
                            registers_to_clear);
   if (backtrack() == NULL) {
     assembler->Backtrack();
   } else {
     assembler->PopCurrentPosition();
     assembler->GoTo(backtrack());
   }
 }

Referenced by v8::internal::ActionNode::Emit(), v8::internal::BackReferenceNode::Emit(), v8::internal::EndNode::Emit(), v8::internal::ChoiceNode::Emit(), v8::internal::LoopChoiceNode::Emit(), and v8::internal::RegExpNode::LimitVersions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_budget()

int v8::internal::Trace::flush_budget ( )

inline

Definition at line 1465 of file jsregexp.h.

1465 { return flush_budget_; }

References flush_budget_.

Referenced by v8::internal::ChoiceNode::Emit(), and v8::internal::ChoiceNode::EmitChoices().

Here is the caller graph for this function:

◆ GetStoredPosition()

bool v8::internal::Trace::GetStoredPosition	(	int	reg,
		int *	cp_offset
	)

Definition at line 1164 of file jsregexp.cc.

                                                      {
   DCHECK_EQ(0, *cp_offset);
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
     if (action->Mentions(reg)) {
       if (action->action_type() == ActionNode::STORE_POSITION) {
         *cp_offset = static_cast<DeferredCapture*>(action)->cp_offset();
         return true;
       } else {
         return false;
       }
     }
   }
   return false;
 }

References actions_, cp_offset(), DCHECK_EQ, NULL, and v8::internal::ActionNode::STORE_POSITION.

Referenced by v8::internal::ActionNode::Emit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InvalidateCurrentCharacter()

void v8::internal::Trace::InvalidateCurrentCharacter ( )

Definition at line 3369 of file jsregexp.cc.

                                        {
   characters_preloaded_ = 0;
 }

References characters_preloaded_.

Referenced by v8::internal::AssertionNode::BacktrackIfPrevious(), v8::internal::ChoiceNode::EmitChoices(), and v8::internal::EmitHat().

Here is the caller graph for this function:

◆ is_trivial()

bool v8::internal::Trace::is_trivial ( )

inline

Definition at line 1447 of file jsregexp.h.

                     {
     return backtrack_ == NULL &&
            actions_ == NULL &&
            cp_offset_ == 0 &&
            characters_preloaded_ == 0 &&
            bound_checked_up_to_ == 0 &&
            quick_check_performed_.characters() == 0 &&
            at_start_ == UNKNOWN;
   }

References actions_, at_start_, backtrack_, bound_checked_up_to_, v8::internal::QuickCheckDetails::characters(), characters_preloaded_, cp_offset_, NULL, quick_check_performed_, and UNKNOWN.

Referenced by v8::internal::ActionNode::Emit(), v8::internal::BackReferenceNode::Emit(), v8::internal::EndNode::Emit(), v8::internal::LoopChoiceNode::Emit(), v8::internal::ChoiceNode::EmitOptimizedUnanchoredSearch(), Flush(), and v8::internal::RegExpNode::LimitVersions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loop_label()

Label* v8::internal::Trace::loop_label ( )

inline

Definition at line 1461 of file jsregexp.h.

1461 { return loop_label_; }

References loop_label_.

Referenced by v8::internal::LoopChoiceNode::Emit().

Here is the caller graph for this function:

◆ mentions_reg()

bool v8::internal::Trace::mentions_reg ( int reg )

Definition at line 1153 of file jsregexp.cc.

                                 {
   for (DeferredAction* action = actions_;
        action != NULL;
        action = action->next()) {
     if (action->Mentions(reg))
       return true;
   }
   return false;
 }

References actions_, and NULL.

Referenced by v8::internal::ChoiceNode::AssertGuardsMentionRegisters(), and v8::internal::ChoiceNode::GenerateGuard().

Here is the caller graph for this function:

◆ PerformDeferredActions()

void v8::internal::Trace::PerformDeferredActions	(	RegExpMacroAssembler *	macro,
		int	max_register,
		const OutSet &	affected_registers,
		OutSet *	registers_to_pop,
		OutSet *	registers_to_clear,
		Zone *	zone
	)

private

Definition at line 1220 of file jsregexp.cc.

                                                {
   // The "+1" is to avoid a push_limit of zero if stack_limit_slack() is 1.
   const int push_limit = (assembler->stack_limit_slack() + 1) / 2;
  
   // Count pushes performed to force a stack limit check occasionally.
   int pushes = 0;
  
   for (int reg = 0; reg <= max_register; reg++) {
     if (!affected_registers.Get(reg)) {
       continue;
     }
  
     // The chronologically first deferred action in the trace
     // is used to infer the action needed to restore a register
     // to its previous state (or not, if it's safe to ignore it).
     enum DeferredActionUndoType { IGNORE, RESTORE, CLEAR };
     DeferredActionUndoType undo_action = IGNORE;
  
     int value = 0;
     bool absolute = false;
     bool clear = false;
     int store_position = -1;
     // This is a little tricky because we are scanning the actions in reverse
     // historical order (newest first).
     for (DeferredAction* action = actions_;
          action != NULL;
          action = action->next()) {
       if (action->Mentions(reg)) {
         switch (action->action_type()) {
           case ActionNode::SET_REGISTER: {
             Trace::DeferredSetRegister* psr =
                 static_cast<Trace::DeferredSetRegister*>(action);
             if (!absolute) {
               value += psr->value();
               absolute = true;
             }
             // SET_REGISTER is currently only used for newly introduced loop
             // counters. They can have a significant previous value if they
             // occour in a loop. TODO(lrn): Propagate this information, so
             // we can set undo_action to IGNORE if we know there is no value to
             // restore.
             undo_action = RESTORE;
             DCHECK_EQ(store_position, -1);
             DCHECK(!clear);
             break;
           }
           case ActionNode::INCREMENT_REGISTER:
             if (!absolute) {
               value++;
             }
             DCHECK_EQ(store_position, -1);
             DCHECK(!clear);
             undo_action = RESTORE;
             break;
           case ActionNode::STORE_POSITION: {
             Trace::DeferredCapture* pc =
                 static_cast<Trace::DeferredCapture*>(action);
             if (!clear && store_position == -1) {
               store_position = pc->cp_offset();
             }
  
             // For captures we know that stores and clears alternate.
             // Other register, are never cleared, and if the occur
             // inside a loop, they might be assigned more than once.
             if (reg <= 1) {
               // Registers zero and one, aka "capture zero", is
               // always set correctly if we succeed. There is no
               // need to undo a setting on backtrack, because we
               // will set it again or fail.
               undo_action = IGNORE;
             } else {
               undo_action = pc->is_capture() ? CLEAR : RESTORE;
             }
             DCHECK(!absolute);
             DCHECK_EQ(value, 0);
             break;
           }
           case ActionNode::CLEAR_CAPTURES: {
             // Since we're scanning in reverse order, if we've already
             // set the position we have to ignore historically earlier
             // clearing operations.
             if (store_position == -1) {
               clear = true;
             }
             undo_action = RESTORE;
             DCHECK(!absolute);
             DCHECK_EQ(value, 0);
             break;
           }
           default:
             UNREACHABLE();
             break;
         }
       }
     }
     // Prepare for the undo-action (e.g., push if it's going to be popped).
     if (undo_action == RESTORE) {
       pushes++;
       RegExpMacroAssembler::StackCheckFlag stack_check =
           RegExpMacroAssembler::kNoStackLimitCheck;
       if (pushes == push_limit) {
         stack_check = RegExpMacroAssembler::kCheckStackLimit;
         pushes = 0;
       }
  
       assembler->PushRegister(reg, stack_check);
       registers_to_pop->Set(reg, zone);
     } else if (undo_action == CLEAR) {
       registers_to_clear->Set(reg, zone);
     }
     // Perform the chronologically last action (or accumulated increment)
     // for the register.
     if (store_position != -1) {
       assembler->WriteCurrentPositionToRegister(reg, store_position);
     } else if (clear) {
       assembler->ClearRegisters(reg, reg);
     } else if (absolute) {
       assembler->SetRegister(reg, value);
     } else if (value != 0) {
       assembler->AdvanceRegister(reg, value);
     }
   }
 }

Referenced by Flush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ quick_check_performed()

QuickCheckDetails* v8::internal::Trace::quick_check_performed ( )

inline

Definition at line 1466 of file jsregexp.h.

1466 { return &quick_check_performed_; }

References quick_check_performed_.

Referenced by v8::internal::ChoiceNode::EmitChoices(), and v8::internal::TextNode::TextEmitPass().

Here is the caller graph for this function:

◆ RestoreAffectedRegisters()

void v8::internal::Trace::RestoreAffectedRegisters	(	RegExpMacroAssembler *	macro,
		int	max_register,
		const OutSet &	registers_to_pop,
		const OutSet &	registers_to_clear
	)

private

Definition at line 1202 of file jsregexp.cc.

                                                                        {
   for (int reg = max_register; reg >= 0; reg--) {
     if (registers_to_pop.Get(reg)) {
       assembler->PopRegister(reg);
     } else if (registers_to_clear.Get(reg)) {
       int clear_to = reg;
       while (reg > 0 && registers_to_clear.Get(reg - 1)) {
         reg--;
       }
       assembler->ClearRegisters(reg, clear_to);
     }
   }
 }

References v8::internal::RegExpMacroAssembler::ClearRegisters(), v8::internal::OutSet::Get(), and v8::internal::RegExpMacroAssembler::PopRegister().

Referenced by Flush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_at_start()

void v8::internal::Trace::set_at_start ( bool at_start )

inline

Definition at line 1457 of file jsregexp.h.

                                    {
     at_start_ = at_start ? TRUE_VALUE : FALSE_VALUE;
   }

References at_start(), at_start_, FALSE_VALUE, and TRUE_VALUE.

Referenced by v8::internal::TextNode::Emit(), v8::internal::AssertionNode::Emit(), v8::internal::ChoiceNode::EmitChoices(), v8::internal::ChoiceNode::EmitGreedyLoop(), v8::internal::ChoiceNode::EmitOutOfLineContinuation(), and v8::internal::GreedyLoopState::GreedyLoopState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_backtrack()

void v8::internal::Trace::set_backtrack ( Label * backtrack )

inline

Definition at line 1479 of file jsregexp.h.

1479 { backtrack_ = backtrack; }

References backtrack(), and backtrack_.

Referenced by v8::internal::ActionNode::Emit(), v8::internal::ChoiceNode::EmitChoices(), v8::internal::ChoiceNode::EmitGreedyLoop(), v8::internal::ChoiceNode::EmitOutOfLineContinuation(), and v8::internal::GreedyLoopState::GreedyLoopState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_bound_checked_up_to()

void v8::internal::Trace::set_bound_checked_up_to ( int to )

inline

Definition at line 1483 of file jsregexp.h.

1483 { bound_checked_up_to_ = to; }

to

enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long enable alignment of csp to bytes on platforms which prefer the register to always be expose gc extension under the specified name show built in functions in stack traces use random jit cookie to mask large constants minimum length for automatic enable preparsing CPU profiler sampling interval in microseconds trace out of bounds accesses to external arrays default size of stack region v8 is allowed to maximum length of function source code printed in a stack trace min size of a semi the new space consists of two semi spaces print one trace line following each garbage collection do not print trace line after scavenger collection print cumulative GC statistics in only print modified registers Trace simulator debug messages Implied by trace sim abort randomize hashes to avoid predictable hash Fixed seed to use to hash property Print the time it takes to deserialize the snapshot A filename with extra code to be included in the A file to write the raw snapshot bytes to(mksnapshot only)") DEFINE_STRING(raw_context_file

References bound_checked_up_to_, and to().

Referenced by v8::internal::ChoiceNode::EmitChoices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_characters_preloaded()

void v8::internal::Trace::set_characters_preloaded ( int count )

inline

Definition at line 1482 of file jsregexp.h.

1482 { characters_preloaded_ = count; }

References characters_preloaded_.

Referenced by v8::internal::ChoiceNode::EmitChoices(), and v8::internal::ChoiceNode::EmitOutOfLineContinuation().

Here is the caller graph for this function:

◆ set_flush_budget()

void v8::internal::Trace::set_flush_budget ( int to )

inline

Definition at line 1484 of file jsregexp.h.

1484 { flush_budget_ = to; }

References flush_budget_, and to().

Referenced by v8::internal::ChoiceNode::Emit(), and v8::internal::ChoiceNode::EmitChoices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_loop_label()

void v8::internal::Trace::set_loop_label ( Label * label )

inline

Definition at line 1481 of file jsregexp.h.

1481 { loop_label_ = label; }

References loop_label_.

Referenced by v8::internal::ChoiceNode::EmitGreedyLoop().

Here is the caller graph for this function:

◆ set_quick_check_performed()

void v8::internal::Trace::set_quick_check_performed ( QuickCheckDetails * d )

inline

Definition at line 1485 of file jsregexp.h.

                                                        {
     quick_check_performed_ = *d;
   }

References quick_check_performed_.

Referenced by v8::internal::ChoiceNode::EmitChoices(), and v8::internal::ChoiceNode::EmitOutOfLineContinuation().

Here is the caller graph for this function:

◆ set_stop_node()

void v8::internal::Trace::set_stop_node ( RegExpNode * node )

inline

Definition at line 1480 of file jsregexp.h.

1480 { stop_node_ = node; }

References stop_node_.

Referenced by v8::internal::ChoiceNode::EmitGreedyLoop().

Here is the caller graph for this function:

◆ stop_node()

RegExpNode* v8::internal::Trace::stop_node ( )

inline

Definition at line 1462 of file jsregexp.h.

1462 { return stop_node_; }

References stop_node_.

Referenced by v8::internal::LoopChoiceNode::Emit(), v8::internal::ChoiceNode::EmitGreedyLoop(), and v8::internal::RegExpNode::LimitVersions().

Here is the caller graph for this function:

Member Data Documentation

◆ actions_

DeferredAction* v8::internal::Trace::actions_

private

Definition at line 1504 of file jsregexp.h.

Referenced by actions(), add_action(), FindAffectedRegisters(), Flush(), GetStoredPosition(), is_trivial(), mentions_reg(), and PerformDeferredActions().

◆ at_start_

TriBool v8::internal::Trace::at_start_

private

Definition at line 1512 of file jsregexp.h.

Referenced by at_start(), is_trivial(), and set_at_start().

◆ backtrack_

Label* v8::internal::Trace::backtrack_

private

Definition at line 1505 of file jsregexp.h.

Referenced by backtrack(), is_trivial(), and set_backtrack().

◆ bound_checked_up_to_

int v8::internal::Trace::bound_checked_up_to_

private

Definition at line 1509 of file jsregexp.h.

Referenced by AdvanceCurrentPositionInTrace(), bound_checked_up_to(), is_trivial(), and set_bound_checked_up_to().

◆ characters_preloaded_

int v8::internal::Trace::characters_preloaded_

private

Definition at line 1508 of file jsregexp.h.

Referenced by AdvanceCurrentPositionInTrace(), characters_preloaded(), InvalidateCurrentCharacter(), is_trivial(), and set_characters_preloaded().

◆ cp_offset_

int v8::internal::Trace::cp_offset_

private

Definition at line 1503 of file jsregexp.h.

Referenced by AdvanceCurrentPositionInTrace(), cp_offset(), Flush(), and is_trivial().

◆ flush_budget_

int v8::internal::Trace::flush_budget_

private

Definition at line 1511 of file jsregexp.h.

Referenced by flush_budget(), and set_flush_budget().

◆ loop_label_

Label* v8::internal::Trace::loop_label_

private

Definition at line 1507 of file jsregexp.h.

Referenced by loop_label(), and set_loop_label().

◆ quick_check_performed_

QuickCheckDetails v8::internal::Trace::quick_check_performed_

private

Definition at line 1510 of file jsregexp.h.

Referenced by AdvanceCurrentPositionInTrace(), is_trivial(), quick_check_performed(), and set_quick_check_performed().

◆ stop_node_

RegExpNode* v8::internal::Trace::stop_node_

private

Definition at line 1506 of file jsregexp.h.

Referenced by set_stop_node(), and stop_node().

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/jsregexp.h
/mnt/V8SourceCode/src/jsregexp.cc

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TriBool

Constructor & Destructor Documentation

◆ Trace()

Member Function Documentation

◆ actions()

◆ add_action()

◆ AdvanceCurrentPositionInTrace()

◆ at_start()

◆ backtrack()

◆ bound_checked_up_to()

◆ characters_preloaded()

◆ cp_offset()

◆ FindAffectedRegisters()

◆ Flush()

◆ flush_budget()

◆ GetStoredPosition()

◆ InvalidateCurrentCharacter()

◆ is_trivial()

◆ loop_label()

◆ mentions_reg()

◆ PerformDeferredActions()

◆ quick_check_performed()

◆ RestoreAffectedRegisters()

◆ set_at_start()

◆ set_backtrack()

◆ set_bound_checked_up_to()

◆ set_characters_preloaded()

◆ set_flush_budget()

◆ set_loop_label()

◆ set_quick_check_performed()

◆ set_stop_node()

◆ stop_node()

Member Data Documentation

◆ actions_

◆ at_start_

◆ backtrack_

◆ bound_checked_up_to_

◆ characters_preloaded_

◆ cp_offset_

◆ flush_budget_

◆ loop_label_

◆ quick_check_performed_

◆ stop_node_