v8::internal::NativeRegExpMacroAssembler Class Reference

#include <regexp-macro-assembler.h>

Inheritance diagram for v8::internal::NativeRegExpMacroAssembler:

Collaboration diagram for v8::internal::NativeRegExpMacroAssembler:

Public Types
enum	Mode { LATIN1 = 1 , UC16 = 2 }
enum	Result { RETRY = -2 , EXCEPTION = -1 , FAILURE = 0 , SUCCESS = 1 }
Public Types inherited from v8::internal::RegExpMacroAssembler
enum	IrregexpImplementation {   kIA32Implementation , kARMImplementation , kARM64Implementation , kMIPSImplementation ,   kX64Implementation , kX87Implementation , kBytecodeImplementation }
enum	StackCheckFlag { kNoStackLimitCheck = false , kCheckStackLimit = true }
enum	GlobalMode { NOT_GLOBAL , GLOBAL , GLOBAL_NO_ZERO_LENGTH_CHECK }

Public Member Functions
	NativeRegExpMacroAssembler (Zone *zone)
virtual	~NativeRegExpMacroAssembler ()
virtual bool	CanReadUnaligned ()
Public Member Functions inherited from v8::internal::RegExpMacroAssembler
	RegExpMacroAssembler (Zone *zone)
virtual	~RegExpMacroAssembler ()
virtual int	stack_limit_slack ()=0
virtual void	AdvanceCurrentPosition (int by)=0
virtual void	AdvanceRegister (int reg, int by)=0
virtual void	Backtrack ()=0
virtual void	Bind (Label *label)=0
virtual void	CheckAtStart (Label *on_at_start)=0
virtual void	CheckCharacter (unsigned c, Label *on_equal)=0
virtual void	CheckCharacterAfterAnd (unsigned c, unsigned and_with, Label *on_equal)=0
virtual void	CheckCharacterGT (uc16 limit, Label *on_greater)=0
virtual void	CheckCharacterLT (uc16 limit, Label *on_less)=0
virtual void	CheckGreedyLoop (Label *on_tos_equals_current_position)=0
virtual void	CheckNotAtStart (Label *on_not_at_start)=0
virtual void	CheckNotBackReference (int start_reg, Label *on_no_match)=0
virtual void	CheckNotBackReferenceIgnoreCase (int start_reg, Label *on_no_match)=0
virtual void	CheckNotCharacter (unsigned c, Label *on_not_equal)=0
virtual void	CheckNotCharacterAfterAnd (unsigned c, unsigned and_with, Label *on_not_equal)=0
virtual void	CheckNotCharacterAfterMinusAnd (uc16 c, uc16 minus, uc16 and_with, Label *on_not_equal)=0
virtual void	CheckCharacterInRange (uc16 from, uc16 to, Label *on_in_range)=0
virtual void	CheckCharacterNotInRange (uc16 from, uc16 to, Label *on_not_in_range)=0
virtual void	CheckBitInTable (Handle< ByteArray > table, Label *on_bit_set)=0
virtual void	CheckPosition (int cp_offset, Label *on_outside_input)
virtual bool	CheckSpecialCharacterClass (uc16 type, Label *on_no_match)
virtual void	Fail ()=0
virtual Handle< HeapObject >	GetCode (Handle< String > source)=0
virtual void	GoTo (Label *label)=0
virtual void	IfRegisterGE (int reg, int comparand, Label *if_ge)=0
virtual void	IfRegisterLT (int reg, int comparand, Label *if_lt)=0
virtual void	IfRegisterEqPos (int reg, Label *if_eq)=0
virtual IrregexpImplementation	Implementation ()=0
virtual void	LoadCurrentCharacter (int cp_offset, Label *on_end_of_input, bool check_bounds=true, int characters=1)=0
virtual void	PopCurrentPosition ()=0
virtual void	PopRegister (int register_index)=0
virtual void	PushBacktrack (Label *label)=0
virtual void	PushCurrentPosition ()=0
virtual void	PushRegister (int register_index, StackCheckFlag check_stack_limit)=0
virtual void	ReadCurrentPositionFromRegister (int reg)=0
virtual void	ReadStackPointerFromRegister (int reg)=0
virtual void	SetCurrentPositionFromEnd (int by)=0
virtual void	SetRegister (int register_index, int to)=0
virtual bool	Succeed ()=0
virtual void	WriteCurrentPositionToRegister (int reg, int cp_offset)=0
virtual void	ClearRegisters (int reg_from, int reg_to)=0
virtual void	WriteStackPointerToRegister (int reg)=0
void	set_slow_safe (bool ssc)
bool	slow_safe ()
void	set_global_mode (GlobalMode mode)
bool	global ()
bool	global_with_zero_length_check ()
Zone *	zone () const

Static Public Member Functions
static Result	Match (Handle< Code > regexp, Handle< String > subject, int *offsets_vector, int offsets_vector_length, int previous_index, Isolate *isolate)
static int	CaseInsensitiveCompareUC16 (Address byte_offset1, Address byte_offset2, size_t byte_length, Isolate *isolate)
static Address	GrowStack (Address stack_pointer, Address *stack_top, Isolate *isolate)
static const byte *	StringCharacterPosition (String *subject, int start_index)
static Address	word_character_map_address ()
static Result	Execute (Code *code, String *input, int start_offset, const byte *input_start, const byte *input_end, int *output, int output_size, Isolate *isolate)

Static Public Attributes
static const byte	word_character_map [256]
Static Public Attributes inherited from v8::internal::RegExpMacroAssembler
static const int	kMaxRegister = (1 << 16) - 1
static const int	kMaxCPOffset = (1 << 15) - 1
static const int	kMinCPOffset = -(1 << 15)
static const int	kTableSizeBits = 7
static const int	kTableSize = 1 << kTableSizeBits
static const int	kTableMask = kTableSize - 1

Detailed Description

Definition at line 171 of file regexp-macro-assembler.h.

Member Enumeration Documentation

Mode

enum v8::internal::NativeRegExpMacroAssembler::Mode

Enumerator
LATIN1
UC16

Definition at line 174 of file regexp-macro-assembler.h.

{ LATIN1 = 1, UC16 = 2 };

Result

enum v8::internal::NativeRegExpMacroAssembler::Result

Enumerator
RETRY
EXCEPTION
FAILURE
SUCCESS

Definition at line 185 of file regexp-macro-assembler.h.

{ RETRY = -2, EXCEPTION = -1, FAILURE = 0, SUCCESS = 1 };

Constructor & Destructor Documentation

NativeRegExpMacroAssembler()

v8::internal::NativeRegExpMacroAssembler::NativeRegExpMacroAssembler ( Zone *  zone )

explicit

Definition at line 29 of file regexp-macro-assembler.cc.

    : RegExpMacroAssembler(zone) {
}

~NativeRegExpMacroAssembler()

v8::internal::NativeRegExpMacroAssembler::~NativeRegExpMacroAssembler ( )

virtual

Definition at line 34 of file regexp-macro-assembler.cc.

                                                        {
}

Member Function Documentation

CanReadUnaligned()

bool v8::internal::NativeRegExpMacroAssembler::CanReadUnaligned ( )

virtual

Implements v8::internal::RegExpMacroAssembler.

Reimplemented in v8::internal::RegExpMacroAssemblerMIPS, v8::internal::RegExpMacroAssemblerMIPS, v8::internal::RegExpMacroAssemblerARM64, and v8::internal::RegExpMacroAssemblerARM.

Definition at line 38 of file regexp-macro-assembler.cc.

                                                  {
  return FLAG_enable_unaligned_accesses && !slow_safe();
}

References v8::internal::RegExpMacroAssembler::slow_safe().

Here is the call graph for this function:

CaseInsensitiveCompareUC16()

int v8::internal::NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16 ( Address  byte_offset1, Address  byte_offset2, size_t  byte_length, Isolate *  isolate  )

static

Definition at line 204 of file regexp-macro-assembler.cc.

                      {
  unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize =
      isolate->regexp_macro_assembler_canonicalize();
  // This function is not allowed to cause a garbage collection.
  // A GC might move the calling generated code and invalidate the
  // return address on the stack.
  DCHECK(byte_length % 2 == 0);
  uc16* substring1 = reinterpret_cast<uc16*>(byte_offset1);
  uc16* substring2 = reinterpret_cast<uc16*>(byte_offset2);
  size_t length = byte_length >> 1;
 
  for (size_t i = 0; i < length; i++) {
    unibrow::uchar c1 = substring1[i];
    unibrow::uchar c2 = substring2[i];
    if (c1 != c2) {
      unibrow::uchar s1[1] = { c1 };
      canonicalize->get(c1, '\0', s1);
      if (s1[0] != c2) {
        unibrow::uchar s2[1] = { c2 };
        canonicalize->get(c2, '\0', s2);
        if (s1[0] != s2[0]) {
          return 0;
        }
      }
    }
  }
  return 1;
}

References DCHECK, unibrow::Mapping< T, size >::get(), v8::internal::Isolate::regexp_macro_assembler_canonicalize(), v8::internal::s1, and v8::internal::s2.

Here is the call graph for this function:

Execute()

NativeRegExpMacroAssembler::Result v8::internal::NativeRegExpMacroAssembler::Execute ( Code *  code, String *  input, int  start_offset, const byte *  input_start, const byte *  input_end, int *  output, int  output_size, Isolate *  isolate  )

static

Definition at line 126 of file regexp-macro-assembler.cc.

                      {
  // Ensure that the minimum stack has been allocated.
  RegExpStackScope stack_scope(isolate);
  Address stack_base = stack_scope.stack()->stack_base();
 
  int direct_call = 0;
  int result = CALL_GENERATED_REGEXP_CODE(code->entry(),
                                          input,
                                          start_offset,
                                          input_start,
                                          input_end,
                                          output,
                                          output_size,
                                          stack_base,
                                          direct_call,
                                          isolate);
  DCHECK(result >= RETRY);
 
  if (result == EXCEPTION && !isolate->has_pending_exception()) {
    // We detected a stack overflow (on the backtrack stack) in RegExp code,
    // but haven't created the exception yet.
    isolate->StackOverflow();
  }
  return static_cast<Result>(result);
}

References CALL_GENERATED_REGEXP_CODE, DCHECK, v8::internal::Code::entry(), EXCEPTION, v8::internal::Isolate::has_pending_exception(), RETRY, v8::internal::RegExpStackScope::stack(), v8::internal::RegExpStack::stack_base(), and v8::internal::Isolate::StackOverflow().

Referenced by Match().

Here is the call graph for this function:

Here is the caller graph for this function:

GrowStack()

Address v8::internal::NativeRegExpMacroAssembler::GrowStack ( Address  stack_pointer, Address *  stack_top, Isolate *  isolate  )

static

Definition at line 238 of file regexp-macro-assembler.cc.

                                                                {
  RegExpStack* regexp_stack = isolate->regexp_stack();
  size_t size = regexp_stack->stack_capacity();
  Address old_stack_base = regexp_stack->stack_base();
  DCHECK(old_stack_base == *stack_base);
  DCHECK(stack_pointer <= old_stack_base);
  DCHECK(static_cast<size_t>(old_stack_base - stack_pointer) <= size);
  Address new_stack_base = regexp_stack->EnsureCapacity(size * 2);
  if (new_stack_base == NULL) {
    return NULL;
  }
  *stack_base = new_stack_base;
  intptr_t stack_content_size = old_stack_base - stack_pointer;
  return new_stack_base - stack_content_size;
}

References DCHECK, v8::internal::RegExpStack::EnsureCapacity(), NULL, v8::internal::Isolate::regexp_stack(), size, v8::internal::RegExpStack::stack_base(), and v8::internal::RegExpStack::stack_capacity().

Here is the call graph for this function:

Match()

NativeRegExpMacroAssembler::Result v8::internal::NativeRegExpMacroAssembler::Match ( Handle< Code >  regexp, Handle< String >  subject, int *  offsets_vector, int  offsets_vector_length, int  previous_index, Isolate *  isolate  )

static

Definition at line 72 of file regexp-macro-assembler.cc.

                      {
 
  DCHECK(subject->IsFlat());
  DCHECK(previous_index >= 0);
  DCHECK(previous_index <= subject->length());
 
  // No allocations before calling the regexp, but we can't use
  // DisallowHeapAllocation, since regexps might be preempted, and another
  // thread might do allocation anyway.
 
  String* subject_ptr = *subject;
  // Character offsets into string.
  int start_offset = previous_index;
  int char_length = subject_ptr->length() - start_offset;
  int slice_offset = 0;
 
  // The string has been flattened, so if it is a cons string it contains the
  // full string in the first part.
  if (StringShape(subject_ptr).IsCons()) {
    DCHECK_EQ(0, ConsString::cast(subject_ptr)->second()->length());
    subject_ptr = ConsString::cast(subject_ptr)->first();
  } else if (StringShape(subject_ptr).IsSliced()) {
    SlicedString* slice = SlicedString::cast(subject_ptr);
    subject_ptr = slice->parent();
    slice_offset = slice->offset();
  }
  // Ensure that an underlying string has the same representation.
  bool is_one_byte = subject_ptr->IsOneByteRepresentation();
  DCHECK(subject_ptr->IsExternalString() || subject_ptr->IsSeqString());
  // String is now either Sequential or External
  int char_size_shift = is_one_byte ? 0 : 1;
 
  const byte* input_start =
      StringCharacterPosition(subject_ptr, start_offset + slice_offset);
  int byte_length = char_length << char_size_shift;
  const byte* input_end = input_start + byte_length;
  Result res = Execute(*regexp_code,
                       *subject,
                       start_offset,
                       input_start,
                       input_end,
                       offsets_vector,
                       offsets_vector_length,
                       isolate);
  return res;
}

References DCHECK, DCHECK_EQ, Execute(), v8::internal::String::IsOneByteRepresentation(), v8::internal::String::length(), v8::internal::SlicedString::offset(), v8::internal::SlicedString::parent(), and StringCharacterPosition().

Referenced by v8::internal::RegExpImpl::IrregexpExecRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

StringCharacterPosition()

const byte * v8::internal::NativeRegExpMacroAssembler::StringCharacterPosition ( String *  subject, int  start_index  )

static

Definition at line 42 of file regexp-macro-assembler.cc.

                     {
  // Not just flat, but ultra flat.
  DCHECK(subject->IsExternalString() || subject->IsSeqString());
  DCHECK(start_index >= 0);
  DCHECK(start_index <= subject->length());
  if (subject->IsOneByteRepresentation()) {
    const byte* address;
    if (StringShape(subject).IsExternal()) {
      const uint8_t* data = ExternalOneByteString::cast(subject)->GetChars();
      address = reinterpret_cast<const byte*>(data);
    } else {
      DCHECK(subject->IsSeqOneByteString());
      const uint8_t* data = SeqOneByteString::cast(subject)->GetChars();
      address = reinterpret_cast<const byte*>(data);
    }
    return address + start_index;
  }
  const uc16* data;
  if (StringShape(subject).IsExternal()) {
    data = ExternalTwoByteString::cast(subject)->GetChars();
  } else {
    DCHECK(subject->IsSeqTwoByteString());
    data = SeqTwoByteString::cast(subject)->GetChars();
  }
  return reinterpret_cast<const byte*>(data + start_index);
}

References DCHECK, and v8::internal::String::IsOneByteRepresentation().

Referenced by Match().

Here is the call graph for this function:

Here is the caller graph for this function:

word_character_map_address()

static Address v8::internal::NativeRegExpMacroAssembler::word_character_map_address ( )

inlinestatic

Definition at line 220 of file regexp-macro-assembler.h.

                                              {
    return const_cast<Address>(&word_character_map[0]);
  }

References word_character_map.

Member Data Documentation

word_character_map

const byte v8::internal::NativeRegExpMacroAssembler::word_character_map

static

Definition at line 218 of file regexp-macro-assembler.h.

Referenced by word_character_map_address().

---

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

• /mnt/V8SourceCode/src/regexp-macro-assembler.h
• /mnt/V8SourceCode/src/regexp-macro-assembler.cc