dart::IRRegExpMacroAssembler Class Reference

#include <regexp_assembler_ir.h>

Inheritance diagram for dart::IRRegExpMacroAssembler:

Public Types
enum	Mode { ASCII = 1 , UC16 = 2 }
enum	Result { RETRY = -2 , EXCEPTION = -1 , FAILURE = 0 , SUCCESS = 1 }
Public Types inherited from dart::RegExpMacroAssembler
enum	{ kParamRegExpIndex = 0 , kParamStringIndex , kParamStartOffsetIndex , kParamCount }
enum	IrregexpImplementation { kBytecodeImplementation , kIRImplementation }
enum	GlobalMode { NOT_GLOBAL , GLOBAL , GLOBAL_NO_ZERO_LENGTH_CHECK , GLOBAL_UNICODE }

Public Member Functions
	IRRegExpMacroAssembler (intptr_t specialization_cid, intptr_t capture_count, const ParsedFunction *parsed_function, const ZoneGrowableArray< const ICData * > &ic_data_array, intptr_t osr_id, Zone *zone)
virtual	~IRRegExpMacroAssembler ()
virtual bool	CanReadUnaligned ()
virtual bool	IsClosed () const
virtual intptr_t	stack_limit_slack ()
virtual void	AdvanceCurrentPosition (intptr_t by)
virtual void	AdvanceRegister (intptr_t reg, intptr_t by)
virtual void	Backtrack ()
virtual void	BindBlock (BlockLabel *label)
virtual void	CheckAtStart (BlockLabel *on_at_start)
virtual void	CheckCharacter (uint32_t c, BlockLabel *on_equal)
virtual void	CheckCharacterAfterAnd (uint32_t c, uint32_t mask, BlockLabel *on_equal)
virtual void	CheckCharacterGT (uint16_t limit, BlockLabel *on_greater)
virtual void	CheckCharacterLT (uint16_t limit, BlockLabel *on_less)
virtual void	CheckGreedyLoop (BlockLabel *on_tos_equals_current_position)
virtual void	CheckNotAtStart (intptr_t cp_offset, BlockLabel *on_not_at_start)
virtual void	CheckNotBackReference (intptr_t start_reg, bool read_backward, BlockLabel *on_no_match)
virtual void	CheckNotBackReferenceIgnoreCase (intptr_t start_reg, bool read_backward, bool unicode, BlockLabel *on_no_match)
virtual void	CheckNotCharacter (uint32_t c, BlockLabel *on_not_equal)
virtual void	CheckNotCharacterAfterAnd (uint32_t c, uint32_t mask, BlockLabel *on_not_equal)
virtual void	CheckNotCharacterAfterMinusAnd (uint16_t c, uint16_t minus, uint16_t mask, BlockLabel *on_not_equal)
virtual void	CheckCharacterInRange (uint16_t from, uint16_t to, BlockLabel *on_in_range)
virtual void	CheckCharacterNotInRange (uint16_t from, uint16_t to, BlockLabel *on_not_in_range)
virtual void	CheckBitInTable (const TypedData &table, BlockLabel *on_bit_set)
virtual void	CheckPosition (intptr_t cp_offset, BlockLabel *on_outside_input)
virtual bool	CheckSpecialCharacterClass (uint16_t type, BlockLabel *on_no_match)
virtual void	Fail ()
virtual void	IfRegisterGE (intptr_t reg, intptr_t comparand, BlockLabel *if_ge)
virtual void	IfRegisterLT (intptr_t reg, intptr_t comparand, BlockLabel *if_lt)
virtual void	IfRegisterEqPos (intptr_t reg, BlockLabel *if_eq)
virtual IrregexpImplementation	Implementation ()
virtual void	GoTo (BlockLabel *to)
virtual void	LoadCurrentCharacter (intptr_t cp_offset, BlockLabel *on_end_of_input, bool check_bounds=true, intptr_t characters=1)
virtual void	PopCurrentPosition ()
virtual void	PopRegister (intptr_t register_index)
virtual void	Print (const char *str)
virtual void	PushBacktrack (BlockLabel *label)
virtual void	PushCurrentPosition ()
virtual void	PushRegister (intptr_t register_index)
virtual void	ReadCurrentPositionFromRegister (intptr_t reg)
virtual void	ReadStackPointerFromRegister (intptr_t reg)
virtual void	SetCurrentPositionFromEnd (intptr_t by)
virtual void	SetRegister (intptr_t register_index, intptr_t to)
virtual bool	Succeed ()
virtual void	WriteCurrentPositionToRegister (intptr_t reg, intptr_t cp_offset)
virtual void	ClearRegisters (intptr_t reg_from, intptr_t reg_to)
virtual void	WriteStackPointerToRegister (intptr_t reg)
virtual void	PrintBlocks ()
IndirectGotoInstr *	backtrack_goto () const
GraphEntryInstr *	graph_entry () const
intptr_t	num_stack_locals () const
intptr_t	num_blocks () const
void	GenerateBacktrackBlock ()
void	FinalizeRegistersArray ()
Public Member Functions inherited from dart::RegExpMacroAssembler
	RegExpMacroAssembler (Zone *zone)
virtual	~RegExpMacroAssembler ()
virtual void	CheckCharacter (unsigned c, BlockLabel *on_equal)=0
virtual void	CheckCharacterAfterAnd (unsigned c, unsigned and_with, BlockLabel *on_equal)=0
virtual void	CheckNotCharacter (unsigned c, BlockLabel *on_not_equal)=0
virtual void	CheckNotCharacterAfterAnd (unsigned c, unsigned and_with, BlockLabel *on_not_equal)=0
void	CheckNotInSurrogatePair (intptr_t cp_offset, BlockLabel *on_failure)
void	set_slow_safe (bool ssc)
bool	slow_safe ()
void	set_global_mode (GlobalMode mode)
bool	global ()
bool	global_with_zero_length_check ()
bool	global_unicode ()
Zone *	zone () const
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static ArrayPtr	Execute (const RegExp &regexp, const String &input, const Smi &start_offset, bool sticky, Zone *zone)

Additional Inherited Members
Static Public Attributes inherited from dart::RegExpMacroAssembler
static constexpr intptr_t	kMaxRegister = (1 << 16) - 1
static constexpr intptr_t	kMaxCPOffset = (1 << 15) - 1
static constexpr intptr_t	kMinCPOffset = -(1 << 15)
static constexpr intptr_t	kTableSizeBits = 7
static constexpr intptr_t	kTableSize = 1 << kTableSizeBits
static constexpr intptr_t	kTableMask = kTableSize - 1

Detailed Description

Definition at line 15 of file regexp_assembler_ir.h.

Member Enumeration Documentation

Mode

enum dart::IRRegExpMacroAssembler::Mode

Enumerator
ASCII
UC16

Definition at line 18 of file regexp_assembler_ir.h.

{ ASCII = 1, UC16 = 2 };

Result

enum dart::IRRegExpMacroAssembler::Result

Enumerator
RETRY
EXCEPTION
FAILURE
SUCCESS

Definition at line 29 of file regexp_assembler_ir.h.

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

Constructor & Destructor Documentation

IRRegExpMacroAssembler()

dart::IRRegExpMacroAssembler::IRRegExpMacroAssembler	(	intptr_t	specialization_cid,
		intptr_t	capture_count,
		const ParsedFunction *	parsed_function,
		const ZoneGrowableArray< const ICData * > &	ic_data_array,
		intptr_t	osr_id,
		Zone *	zone
	)

Definition at line 66 of file regexp_assembler_ir.cc.

    : RegExpMacroAssembler(zone),
      thread_(Thread::Current()),
      specialization_cid_(specialization_cid),
      parsed_function_(parsed_function),
      ic_data_array_(ic_data_array),
      current_instruction_(nullptr),
      stack_(nullptr),
      stack_pointer_(nullptr),
      current_character_(nullptr),
      current_position_(nullptr),
      string_param_(nullptr),
      string_param_length_(nullptr),
      start_index_param_(nullptr),
      registers_count_(0),
      saved_registers_count_((capture_count + 1) * 2),
      // B0 is taken by GraphEntry thus block ids must start at 1.
      block_id_(1) {
  switch (specialization_cid) {
    case kOneByteStringCid:
      mode_ = ASCII;
      break;
    case kTwoByteStringCid:
      mode_ = UC16;
      break;
    default:
      UNREACHABLE();
  }
 
  InitializeLocals();
 
  // Create and generate all preset blocks.
  entry_block_ = new (zone) GraphEntryInstr(*parsed_function_, osr_id);
 
  auto function_entry = new (zone) FunctionEntryInstr(
      entry_block_, block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
  entry_block_->set_normal_entry(function_entry);
 
  start_block_ = new (zone)
      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
  success_block_ = new (zone)
      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
  backtrack_block_ = new (zone)
      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
  exit_block_ = new (zone)
      JoinEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
 
  GenerateEntryBlock();
  GenerateSuccessBlock();
  GenerateExitBlock();
 
  blocks_.Add(entry_block_);
  blocks_.Add(entry_block_->normal_entry());
  blocks_.Add(start_block_);
  blocks_.Add(success_block_);
  blocks_.Add(backtrack_block_);
  blocks_.Add(exit_block_);
 
  // Begin emission at the start_block_.
  set_current_instruction(start_block_);
}

~IRRegExpMacroAssembler()

dart::IRRegExpMacroAssembler::~IRRegExpMacroAssembler ( )

virtual

Definition at line 134 of file regexp_assembler_ir.cc.

{}

Member Function Documentation

AdvanceCurrentPosition()

void dart::IRRegExpMacroAssembler::AdvanceCurrentPosition ( intptr_t  by )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 631 of file regexp_assembler_ir.cc.

                                                               {
  TAG();
  if (by != 0) {
    Value* cur_pos_push = PushLocal(current_position_);
    Value* by_push = Bind(Int64Constant(by));
 
    Value* new_pos_value = Bind(Add(cur_pos_push, by_push));
    StoreLocal(current_position_, new_pos_value);
  }
}

AdvanceRegister()

void dart::IRRegExpMacroAssembler::AdvanceRegister ( intptr_t  reg, intptr_t  by  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 642 of file regexp_assembler_ir.cc.

                                                                      {
  TAG();
  ASSERT(reg >= 0);
  ASSERT(reg < registers_count_);
 
  if (by != 0) {
    Value* registers_push = PushLocal(registers_);
    Value* index_push = PushRegisterIndex(reg);
    Value* reg_push = LoadRegister(reg);
    Value* by_push = Bind(Int64Constant(by));
    Value* value_push = Bind(Add(reg_push, by_push));
    StoreRegister(registers_push, index_push, value_push);
  }
}

Backtrack()

void dart::IRRegExpMacroAssembler::Backtrack ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 657 of file regexp_assembler_ir.cc.

                                       {
  TAG();
  GoTo(backtrack_block_);
}

backtrack_goto()

IndirectGotoInstr * dart::IRRegExpMacroAssembler::backtrack_goto ( ) const

inline

Definition at line 124 of file regexp_assembler_ir.h.

{ return backtrack_goto_; }

BindBlock()

void dart::IRRegExpMacroAssembler::BindBlock ( BlockLabel *  label )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 665 of file regexp_assembler_ir.cc.

                                                        {
  ASSERT(!label->is_bound());
  ASSERT(label->block()->next() == nullptr);
 
  label->BindTo(block_id_.Alloc());
  blocks_.Add(label->block());
 
  if (current_instruction_ != nullptr) {
    GoTo(label);
  }
  set_current_instruction(label->block());
 
  // Print the id of the current block if tracing.
  PRINT(Bind(Uint64Constant(label->block()->block_id())));
}

CanReadUnaligned()

bool dart::IRRegExpMacroAssembler::CanReadUnaligned ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 281 of file regexp_assembler_ir.cc.

                                              {
  return !slow_safe();
}

CheckAtStart()

void dart::IRRegExpMacroAssembler::CheckAtStart ( BlockLabel *  on_at_start )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 731 of file regexp_assembler_ir.cc.

                                                                 {
  TAG();
 
  // Are we at the start of the input, i.e. is (offset == string_length * -1)?
  Definition* neg_len_def =
      InstanceCall(InstanceCallDescriptor::FromToken(Token::kNEGATE),
                   PushLocal(string_param_length_));
  Definition* offset_def = LoadLocal(current_position_);
  BranchOrBacktrack(Comparison(kEQ, neg_len_def, offset_def), on_at_start);
}

CheckBitInTable()

void dart::IRRegExpMacroAssembler::CheckBitInTable ( const TypedData &  table, BlockLabel *  on_bit_set  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1166 of file regexp_assembler_ir.cc.

                                                                     {
  TAG();
 
  Value* table_push = Bind(new (Z) ConstantInstr(table));
  Value* index_push = PushLocal(current_character_);
 
  if (mode_ != ASCII || kTableMask != Symbols::kMaxOneCharCodeSymbol) {
    Value* mask_push = Bind(Uint64Constant(kTableSize - 1));
    index_push =
        Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                          index_push, mask_push));
  }
 
  Definition* byte_def = InstanceCall(
      InstanceCallDescriptor::FromToken(Token::kINDEX), table_push, index_push);
  Definition* zero_def = Int64Constant(0);
 
  BranchOrBacktrack(Comparison(kNE, byte_def, zero_def), on_bit_set);
}

CheckCharacter()

void dart::IRRegExpMacroAssembler::CheckCharacter ( uint32_t  c, BlockLabel *  on_equal  )

virtual

Definition at line 715 of file regexp_assembler_ir.cc.

                                                                            {
  TAG();
  Definition* cur_char_def = LoadLocal(current_character_);
  Definition* char_def = Uint64Constant(c);
 
  BranchOrBacktrack(Comparison(kEQ, cur_char_def, char_def), on_equal);
}

CheckCharacterAfterAnd()

void dart::IRRegExpMacroAssembler::CheckCharacterAfterAnd ( uint32_t  c, uint32_t  mask, BlockLabel *  on_equal  )

virtual

Definition at line 1074 of file regexp_assembler_ir.cc.

                                                                          {
  TAG();
 
  Definition* actual_def = LoadLocal(current_character_);
 
  Value* actual_push = Bind(actual_def);
  Value* mask_push = Bind(Uint64Constant(mask));
  actual_def = InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                            actual_push, mask_push);
  Definition* expected_def = Uint64Constant(c);
 
  BranchOrBacktrack(Comparison(kEQ, actual_def, expected_def), on_equal);
}

CheckCharacterGT()

void dart::IRRegExpMacroAssembler::CheckCharacterGT ( uint16_t  limit, BlockLabel *  on_greater  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 723 of file regexp_assembler_ir.cc.

                                                                      {
  TAG();
  BranchOrBacktrack(
      Comparison(kGT, LoadLocal(current_character_), Uint64Constant(limit)),
      on_greater);
}

CheckCharacterInRange()

void dart::IRRegExpMacroAssembler::CheckCharacterInRange ( uint16_t  from, uint16_t  to, BlockLabel *  on_in_range  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1129 of file regexp_assembler_ir.cc.

                                                                            {
  TAG();
  ASSERT(from <= to);
 
  // TODO(zerny): All range comparisons could be done cheaper with unsigned
  // compares. This pattern repeats in various places.
 
  BlockLabel on_not_in_range;
  BranchOrBacktrack(
      Comparison(kLT, LoadLocal(current_character_), Uint64Constant(from)),
      &on_not_in_range);
  BranchOrBacktrack(
      Comparison(kGT, LoadLocal(current_character_), Uint64Constant(to)),
      &on_not_in_range);
  BranchOrBacktrack(nullptr, on_in_range);
 
  BindBlock(&on_not_in_range);
}

CheckCharacterLT()

void dart::IRRegExpMacroAssembler::CheckCharacterLT ( uint16_t  limit, BlockLabel *  on_less  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 758 of file regexp_assembler_ir.cc.

                                                                   {
  TAG();
  BranchOrBacktrack(
      Comparison(kLT, LoadLocal(current_character_), Uint64Constant(limit)),
      on_less);
}

CheckCharacterNotInRange()

void dart::IRRegExpMacroAssembler::CheckCharacterNotInRange ( uint16_t  from, uint16_t  to, BlockLabel *  on_not_in_range  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1150 of file regexp_assembler_ir.cc.

                                 {
  TAG();
  ASSERT(from <= to);
 
  BranchOrBacktrack(
      Comparison(kLT, LoadLocal(current_character_), Uint64Constant(from)),
      on_not_in_range);
 
  BranchOrBacktrack(
      Comparison(kGT, LoadLocal(current_character_), Uint64Constant(to)),
      on_not_in_range);
}

CheckGreedyLoop()

void dart::IRRegExpMacroAssembler::CheckGreedyLoop ( BlockLabel *  on_tos_equals_current_position )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 766 of file regexp_assembler_ir.cc.

                                                                 {
  TAG();
 
  BlockLabel fallthrough;
 
  Definition* head = PeekStack();
  Definition* cur_pos_def = LoadLocal(current_position_);
  BranchOrBacktrack(Comparison(kNE, head, cur_pos_def), &fallthrough);
 
  // Pop, throwing away the value.
  Do(PopStack());
 
  BranchOrBacktrack(nullptr, on_equal);
 
  BindBlock(&fallthrough);
}

CheckNotAtStart()

void dart::IRRegExpMacroAssembler::CheckNotAtStart ( intptr_t  cp_offset, BlockLabel *  on_not_at_start  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 744 of file regexp_assembler_ir.cc.

                                                                          {
  TAG();
 
  // Are we at the start of the input, i.e. is (offset == string_length * -1)?
  auto neg_len_def =
      Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kNEGATE),
                        PushLocal(string_param_length_)));
  auto current_pos_def = PushLocal(current_position_);
  auto cp_offset_def = Bind(Int64Constant(cp_offset));
  auto offset_def = Bind(Add(current_pos_def, cp_offset_def));
  BranchOrBacktrack(Comparison(kNE, neg_len_def, offset_def), on_not_at_start);
}

CheckNotBackReference()

void dart::IRRegExpMacroAssembler::CheckNotBackReference ( intptr_t  start_reg, bool  read_backward, BlockLabel *  on_no_match  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 960 of file regexp_assembler_ir.cc.

                                                                            {
  TAG();
  ASSERT(start_reg + 1 <= registers_count_);
 
  BlockLabel fallthrough;
  BlockLabel success;
 
  // Find length of back-referenced capture.
  Value* end_push = LoadRegister(start_reg + 1);
  Value* start_push = LoadRegister(start_reg);
  StoreLocal(capture_length_, Bind(Sub(end_push, start_push)));
 
  // Fail on partial or illegal capture (start of capture after end of capture).
  BranchOrBacktrack(
      Comparison(kLT, LoadLocal(capture_length_), Uint64Constant(0)),
      on_no_match);
 
  // Succeed on empty capture (including no capture)
  BranchOrBacktrack(
      Comparison(kEQ, LoadLocal(capture_length_), Uint64Constant(0)),
      &fallthrough);
 
  Value* pos_push = nullptr;
  Value* len_push = nullptr;
 
  if (!read_backward) {
    // Check that there are sufficient characters left in the input.
    pos_push = PushLocal(current_position_);
    len_push = PushLocal(capture_length_);
    BranchOrBacktrack(
        Comparison(kGT,
                   InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD),
                                pos_push, len_push),
                   Uint64Constant(0)),
        on_no_match);
  }
 
  // Compute pointers to match string and capture string.
  pos_push = PushLocal(current_position_);
  len_push = PushLocal(string_param_length_);
  StoreLocal(match_start_index_, Bind(Add(pos_push, len_push)));
 
  if (read_backward) {
    // First check that there are enough characters before this point in
    // the string that we can match the backreference.
    BranchOrBacktrack(Comparison(kLT, LoadLocal(match_start_index_),
                                 LoadLocal(capture_length_)),
                      on_no_match);
 
    // The string to check is before the current position, not at it.
    pos_push = PushLocal(match_start_index_);
    len_push = PushLocal(capture_length_);
    StoreLocal(match_start_index_, Bind(Sub(pos_push, len_push)));
  }
 
  pos_push = LoadRegister(start_reg);
  len_push = PushLocal(string_param_length_);
  StoreLocal(capture_start_index_, Bind(Add(pos_push, len_push)));
 
  pos_push = PushLocal(match_start_index_);
  len_push = PushLocal(capture_length_);
  StoreLocal(match_end_index_, Bind(Add(pos_push, len_push)));
 
  BlockLabel loop;
  BindBlock(&loop);
 
  StoreLocal(char_in_capture_, CharacterAt(capture_start_index_));
  StoreLocal(char_in_match_, CharacterAt(match_start_index_));
 
  BranchOrBacktrack(
      Comparison(kNE, LoadLocal(char_in_capture_), LoadLocal(char_in_match_)),
      on_no_match);
 
  // Increment indexes into capture and match strings.
  Value* index_push = PushLocal(capture_start_index_);
  Value* inc_push = Bind(Uint64Constant(1));
  StoreLocal(capture_start_index_, Bind(Add(index_push, inc_push)));
 
  index_push = PushLocal(match_start_index_);
  inc_push = Bind(Uint64Constant(1));
  StoreLocal(match_start_index_, Bind(Add(index_push, inc_push)));
 
  // Check if we have reached end of match area.
  BranchOrBacktrack(Comparison(kLT, LoadLocal(match_start_index_),
                               LoadLocal(match_end_index_)),
                    &loop);
 
  BindBlock(&success);
 
  if (read_backward) {
    // Move current character position to start of match.
    pos_push = PushLocal(current_position_);
    len_push = PushLocal(capture_length_);
    StoreLocal(current_position_, Bind(Sub(pos_push, len_push)));
  } else {
    // Move current character position to position after match.
    Value* match_end_push = PushLocal(match_end_index_);
    len_push = PushLocal(string_param_length_);
    StoreLocal(current_position_, Bind(Sub(match_end_push, len_push)));
  }
 
  BindBlock(&fallthrough);
}

CheckNotBackReferenceIgnoreCase()

void dart::IRRegExpMacroAssembler::CheckNotBackReferenceIgnoreCase ( intptr_t  start_reg, bool  read_backward, bool  unicode, BlockLabel *  on_no_match  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 783 of file regexp_assembler_ir.cc.

                             {
  TAG();
  ASSERT(start_reg + 1 <= registers_count_);
 
  BlockLabel fallthrough;
 
  Value* end_push = LoadRegister(start_reg + 1);
  Value* start_push = LoadRegister(start_reg);
  StoreLocal(capture_length_, Bind(Sub(end_push, start_push)));
 
  // The length of a capture should not be negative. This can only happen
  // if the end of the capture is unrecorded, or at a point earlier than
  // the start of the capture.
  // BranchOrBacktrack(less, on_no_match);
 
  BranchOrBacktrack(
      Comparison(kLT, LoadLocal(capture_length_), Uint64Constant(0)),
      on_no_match);
 
  // If length is zero, either the capture is empty or it is completely
  // uncaptured. In either case succeed immediately.
  BranchOrBacktrack(
      Comparison(kEQ, LoadLocal(capture_length_), Uint64Constant(0)),
      &fallthrough);
 
  Value* pos_push = nullptr;
  Value* len_push = nullptr;
 
  if (!read_backward) {
    // Check that there are sufficient characters left in the input.
    pos_push = PushLocal(current_position_);
    len_push = PushLocal(capture_length_);
    BranchOrBacktrack(
        Comparison(kGT,
                   InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD),
                                pos_push, len_push),
                   Uint64Constant(0)),
        on_no_match);
  }
 
  pos_push = PushLocal(current_position_);
  len_push = PushLocal(string_param_length_);
  StoreLocal(match_start_index_, Bind(Add(pos_push, len_push)));
 
  if (read_backward) {
    // First check that there are enough characters before this point in
    // the string that we can match the backreference.
    BranchOrBacktrack(Comparison(kLT, LoadLocal(match_start_index_),
                                 LoadLocal(capture_length_)),
                      on_no_match);
 
    // The string to check is before the current position, not at it.
    pos_push = PushLocal(match_start_index_);
    len_push = PushLocal(capture_length_);
    StoreLocal(match_start_index_, Bind(Sub(pos_push, len_push)));
  }
 
  pos_push = LoadRegister(start_reg);
  len_push = PushLocal(string_param_length_);
  StoreLocal(capture_start_index_, Bind(Add(pos_push, len_push)));
 
  pos_push = PushLocal(match_start_index_);
  len_push = PushLocal(capture_length_);
  StoreLocal(match_end_index_, Bind(Add(pos_push, len_push)));
 
  BlockLabel success;
  if (mode_ == ASCII) {
    BlockLabel loop_increment;
    BlockLabel loop;
    BindBlock(&loop);
 
    StoreLocal(char_in_capture_, CharacterAt(capture_start_index_));
    StoreLocal(char_in_match_, CharacterAt(match_start_index_));
 
    BranchOrBacktrack(
        Comparison(kEQ, LoadLocal(char_in_capture_), LoadLocal(char_in_match_)),
        &loop_increment);
 
    // Mismatch, try case-insensitive match (converting letters to lower-case).
    Value* match_char_push = PushLocal(char_in_match_);
    Value* mask_push = Bind(Uint64Constant(0x20));
    StoreLocal(
        char_in_match_,
        Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_OR),
                          match_char_push, mask_push)));
 
    BlockLabel convert_capture;
    BlockLabel on_not_in_range;
    BranchOrBacktrack(
        Comparison(kLT, LoadLocal(char_in_match_), Uint64Constant('a')),
        &on_not_in_range);
    BranchOrBacktrack(
        Comparison(kGT, LoadLocal(char_in_match_), Uint64Constant('z')),
        &on_not_in_range);
    GoTo(&convert_capture);
    BindBlock(&on_not_in_range);
 
    // Latin-1: Check for values in range [224,254] but not 247.
    BranchOrBacktrack(
        Comparison(kLT, LoadLocal(char_in_match_), Uint64Constant(224)),
        on_no_match);
    BranchOrBacktrack(
        Comparison(kGT, LoadLocal(char_in_match_), Uint64Constant(254)),
        on_no_match);
 
    BranchOrBacktrack(
        Comparison(kEQ, LoadLocal(char_in_match_), Uint64Constant(247)),
        on_no_match);
 
    // Also convert capture character.
    BindBlock(&convert_capture);
 
    Value* capture_char_push = PushLocal(char_in_capture_);
    mask_push = Bind(Uint64Constant(0x20));
    StoreLocal(
        char_in_capture_,
        Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_OR),
                          capture_char_push, mask_push)));
 
    BranchOrBacktrack(
        Comparison(kNE, LoadLocal(char_in_match_), LoadLocal(char_in_capture_)),
        on_no_match);
 
    BindBlock(&loop_increment);
 
    // Increment indexes into capture and match strings.
    Value* index_push = PushLocal(capture_start_index_);
    Value* inc_push = Bind(Uint64Constant(1));
    StoreLocal(capture_start_index_, Bind(Add(index_push, inc_push)));
 
    index_push = PushLocal(match_start_index_);
    inc_push = Bind(Uint64Constant(1));
    StoreLocal(match_start_index_, Bind(Add(index_push, inc_push)));
 
    // Compare to end of match, and loop if not done.
    BranchOrBacktrack(Comparison(kLT, LoadLocal(match_start_index_),
                                 LoadLocal(match_end_index_)),
                      &loop);
  } else {
    ASSERT(mode_ == UC16);
 
    Value* string_value = Bind(LoadLocal(string_param_));
    Value* lhs_index_value = Bind(LoadLocal(match_start_index_));
    Value* rhs_index_value = Bind(LoadLocal(capture_start_index_));
    Value* length_value = Bind(LoadLocal(capture_length_));
 
    Definition* is_match_def;
 
    is_match_def = new (Z) CaseInsensitiveCompareInstr(
        string_value, lhs_index_value, rhs_index_value, length_value,
        /*handle_surrogates=*/unicode, specialization_cid_);
 
    BranchOrBacktrack(Comparison(kNE, is_match_def, BoolConstant(true)),
                      on_no_match);
  }
 
  BindBlock(&success);
 
  if (read_backward) {
    // Move current character position to start of match.
    pos_push = PushLocal(current_position_);
    len_push = PushLocal(capture_length_);
    StoreLocal(current_position_, Bind(Sub(pos_push, len_push)));
  } else {
    // Move current character position to position after match.
    Value* match_end_push = PushLocal(match_end_index_);
    len_push = PushLocal(string_param_length_);
    StoreLocal(current_position_, Bind(Sub(match_end_push, len_push)));
  }
 
  BindBlock(&fallthrough);
}

CheckNotCharacter()

void dart::IRRegExpMacroAssembler::CheckNotCharacter ( uint32_t  c, BlockLabel *  on_not_equal  )

virtual

Definition at line 1066 of file regexp_assembler_ir.cc.

                                                                         {
  TAG();
  BranchOrBacktrack(
      Comparison(kNE, LoadLocal(current_character_), Uint64Constant(c)),
      on_not_equal);
}

CheckNotCharacterAfterAnd()

void dart::IRRegExpMacroAssembler::CheckNotCharacterAfterAnd ( uint32_t  c, uint32_t  mask, BlockLabel *  on_not_equal  )

virtual

Definition at line 1090 of file regexp_assembler_ir.cc.

                              {
  TAG();
 
  Definition* actual_def = LoadLocal(current_character_);
 
  Value* actual_push = Bind(actual_def);
  Value* mask_push = Bind(Uint64Constant(mask));
  actual_def = InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                            actual_push, mask_push);
  Definition* expected_def = Uint64Constant(c);
 
  BranchOrBacktrack(Comparison(kNE, actual_def, expected_def), on_not_equal);
}

CheckNotCharacterAfterMinusAnd()

void dart::IRRegExpMacroAssembler::CheckNotCharacterAfterMinusAnd ( uint16_t  c, uint16_t  minus, uint16_t  mask, BlockLabel *  on_not_equal  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1107 of file regexp_assembler_ir.cc.

                              {
  TAG();
  ASSERT(minus < Utf16::kMaxCodeUnit);  // NOLINT
 
  Definition* actual_def = LoadLocal(current_character_);
 
  Value* actual_push = Bind(actual_def);
  Value* minus_push = Bind(Uint64Constant(minus));
 
  actual_push = Bind(Sub(actual_push, minus_push));
  Value* mask_push = Bind(Uint64Constant(mask));
  actual_def = InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                            actual_push, mask_push);
  Definition* expected_def = Uint64Constant(c);
 
  BranchOrBacktrack(Comparison(kNE, actual_def, expected_def), on_not_equal);
}

CheckPosition()

void dart::IRRegExpMacroAssembler::CheckPosition ( intptr_t  cp_offset, BlockLabel *  on_outside_input  )

virtual

Reimplemented from dart::RegExpMacroAssembler.

Definition at line 1589 of file regexp_assembler_ir.cc.

                                                                         {
  TAG();
  if (cp_offset >= 0) {
    Definition* curpos_def = LoadLocal(current_position_);
    Definition* cp_off_def = Int64Constant(-cp_offset);
    // If (current_position_ < -cp_offset), we are in bounds.
    // Remember, current_position_ is a negative offset from the string end.
 
    BranchOrBacktrack(Comparison(kGTE, curpos_def, cp_off_def),
                      on_outside_input);
  } else {
    // We need to see if there's enough characters left in the string to go
    // back cp_offset characters, so get the normalized position and then
    // make sure that (normalized_position >= -cp_offset).
    Value* pos_push = PushLocal(current_position_);
    Value* len_push = PushLocal(string_param_length_);
    BranchOrBacktrack(
        Comparison(kLT, Add(pos_push, len_push), Uint64Constant(-cp_offset)),
        on_outside_input);
  }
}

CheckSpecialCharacterClass()

bool dart::IRRegExpMacroAssembler::CheckSpecialCharacterClass ( uint16_t  type, BlockLabel *  on_no_match  )

virtual

Reimplemented from dart::RegExpMacroAssembler.

Definition at line 1187 of file regexp_assembler_ir.cc.

                             {
  TAG();
 
  // Range checks (c in min..max) are generally implemented by an unsigned
  // (c - min) <= (max - min) check
  switch (type) {
    case 's':
      // Match space-characters
      if (mode_ == ASCII) {
        // One byte space characters are '\t'..'\r', ' ' and \u00a0.
        BlockLabel success;
        // Space (' ').
        BranchOrBacktrack(
            Comparison(kEQ, LoadLocal(current_character_), Uint64Constant(' ')),
            &success);
        // Check range 0x09..0x0d.
        CheckCharacterInRange('\t', '\r', &success);
        // \u00a0 (NBSP).
        BranchOrBacktrack(Comparison(kNE, LoadLocal(current_character_),
                                     Uint64Constant(0x00a0)),
                          on_no_match);
        BindBlock(&success);
        return true;
      }
      return false;
    case 'S':
      // The emitted code for generic character classes is good enough.
      return false;
    case 'd':
      // Match ASCII digits ('0'..'9')
      CheckCharacterNotInRange('0', '9', on_no_match);
      return true;
    case 'D':
      // Match non ASCII-digits
      CheckCharacterInRange('0', '9', on_no_match);
      return true;
    case '.': {
      // Match non-newlines (not 0x0a('\n'), 0x0d('\r'), 0x2028 and 0x2029)
      BranchOrBacktrack(
          Comparison(kEQ, LoadLocal(current_character_), Uint64Constant('\n')),
          on_no_match);
      BranchOrBacktrack(
          Comparison(kEQ, LoadLocal(current_character_), Uint64Constant('\r')),
          on_no_match);
      if (mode_ == UC16) {
        BranchOrBacktrack(Comparison(kEQ, LoadLocal(current_character_),
                                     Uint64Constant(0x2028)),
                          on_no_match);
        BranchOrBacktrack(Comparison(kEQ, LoadLocal(current_character_),
                                     Uint64Constant(0x2029)),
                          on_no_match);
      }
      return true;
    }
    case 'w': {
      if (mode_ != ASCII) {
        // Table is 128 entries, so all ASCII characters can be tested.
        BranchOrBacktrack(
            Comparison(kGT, LoadLocal(current_character_), Uint64Constant('z')),
            on_no_match);
      }
 
      Value* table_push = Bind(WordCharacterMapConstant());
      Value* index_push = PushLocal(current_character_);
 
      Definition* byte_def =
          InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                       table_push, index_push);
      Definition* zero_def = Int64Constant(0);
 
      BranchOrBacktrack(Comparison(kEQ, byte_def, zero_def), on_no_match);
 
      return true;
    }
    case 'W': {
      BlockLabel done;
      if (mode_ != ASCII) {
        // Table is 128 entries, so all ASCII characters can be tested.
        BranchOrBacktrack(
            Comparison(kGT, LoadLocal(current_character_), Uint64Constant('z')),
            &done);
      }
 
      // TODO(zerny): Refactor to use CheckBitInTable if possible.
 
      Value* table_push = Bind(WordCharacterMapConstant());
      Value* index_push = PushLocal(current_character_);
 
      Definition* byte_def =
          InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                       table_push, index_push);
      Definition* zero_def = Int64Constant(0);
 
      BranchOrBacktrack(Comparison(kNE, byte_def, zero_def), on_no_match);
 
      if (mode_ != ASCII) {
        BindBlock(&done);
      }
      return true;
    }
    // Non-standard classes (with no syntactic shorthand) used internally.
    case '*':
      // Match any character.
      return true;
    case 'n': {
      // Match newlines (0x0a('\n'), 0x0d('\r'), 0x2028 or 0x2029).
      // The opposite of '.'.
      BlockLabel success;
      BranchOrBacktrack(
          Comparison(kEQ, LoadLocal(current_character_), Uint64Constant('\n')),
          &success);
      BranchOrBacktrack(
          Comparison(kEQ, LoadLocal(current_character_), Uint64Constant('\r')),
          &success);
      if (mode_ == UC16) {
        BranchOrBacktrack(Comparison(kEQ, LoadLocal(current_character_),
                                     Uint64Constant(0x2028)),
                          &success);
        BranchOrBacktrack(Comparison(kEQ, LoadLocal(current_character_),
                                     Uint64Constant(0x2029)),
                          &success);
      }
      BranchOrBacktrack(nullptr, on_no_match);
      BindBlock(&success);
      return true;
    }
    // No custom implementation (yet): s(uint16_t), S(uint16_t).
    default:
      return false;
  }
}

ClearRegisters()

void dart::IRRegExpMacroAssembler::ClearRegisters ( intptr_t  reg_from, intptr_t  reg_to  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1559 of file regexp_assembler_ir.cc.

                                                             {
  TAG();
 
  ASSERT(reg_from <= reg_to);
 
  // In order to clear registers to a final result value of -1, set them to
  // (-1 - string length), the offset of -1 from the end of the string.
 
  for (intptr_t reg = reg_from; reg <= reg_to; reg++) {
    Value* registers_push = PushLocal(registers_);
    Value* index_push = PushRegisterIndex(reg);
    Value* minus_one_push = Bind(Int64Constant(-1));
    Value* length_push = PushLocal(string_param_length_);
    Value* value_push = Bind(Sub(minus_one_push, length_push));
    StoreRegister(registers_push, index_push, value_push);
  }
}

Execute()

ArrayPtr dart::IRRegExpMacroAssembler::Execute ( const RegExp &  regexp, const String &  input, const Smi &  start_offset, bool  sticky, Zone *  zone  )

static

Definition at line 285 of file regexp_assembler_ir.cc.

                                                     {
  const intptr_t cid = input.GetClassId();
  const Function& fun = Function::Handle(regexp.function(cid, sticky));
  ASSERT(!fun.IsNull());
  // Create the argument list.
  const Array& args =
      Array::Handle(Array::New(RegExpMacroAssembler::kParamCount));
  args.SetAt(RegExpMacroAssembler::kParamRegExpIndex, regexp);
  args.SetAt(RegExpMacroAssembler::kParamStringIndex, input);
  args.SetAt(RegExpMacroAssembler::kParamStartOffsetIndex, start_offset);
 
  // And finally call the generated code.
 
  const Object& retval =
      Object::Handle(zone, DartEntry::InvokeFunction(fun, args));
  if (retval.IsLanguageError()) {
    Exceptions::ThrowCompileTimeError(LanguageError::Cast(retval));
    UNREACHABLE();
  }
  if (retval.IsError()) {
    Exceptions::PropagateError(Error::Cast(retval));
  }
 
  if (retval.IsNull()) {
    return Array::null();
  }
 
  ASSERT(retval.IsArray());
  return Array::Cast(retval).ptr();
}

Fail()

void dart::IRRegExpMacroAssembler::Fail ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1321 of file regexp_assembler_ir.cc.

                                  {
  TAG();
  ASSERT(FAILURE == 0);  // Return value for failure is zero.
  if (!global()) {
    UNREACHABLE();  // Dart regexps are always global.
  }
  GoTo(exit_block_);
}

FinalizeRegistersArray()

void dart::IRRegExpMacroAssembler::FinalizeRegistersArray

(

)

Definition at line 273 of file regexp_assembler_ir.cc.

                                                    {
  ASSERT(registers_count_ >= saved_registers_count_);
 
  ConstantInstr* new_constant = Int64Constant(registers_count_);
  new_constant->set_temp_index(num_registers_constant_instr->temp_index());
  num_registers_constant_instr->ReplaceWith(new_constant, /*iterator=*/nullptr);
}

GenerateBacktrackBlock()

void dart::IRRegExpMacroAssembler::GenerateBacktrackBlock

(

)

Definition at line 212 of file regexp_assembler_ir.cc.

                                                    {
  set_current_instruction(backtrack_block_);
  TAG();
  CheckPreemption(/*is_backtrack=*/true);
 
  const intptr_t entries_count = entry_block_->indirect_entries().length();
 
  Value* block_id_push = Bind(PopStack());
  backtrack_goto_ = new (Z) IndirectGotoInstr(entries_count, block_id_push);
  CloseBlockWith(backtrack_goto_);
 
  // Add an edge from the "indirect" goto to each of the targets.
  for (intptr_t j = 0; j < entries_count; j++) {
    backtrack_goto_->AddSuccessor(
        TargetWithJoinGoto(entry_block_->indirect_entries().At(j)));
  }
}

GoTo()

void dart::IRRegExpMacroAssembler::GoTo ( BlockLabel *  to )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 585 of file regexp_assembler_ir.cc.

                                                {
  if (to == nullptr) {
    Backtrack();
  } else {
    to->SetLinked();
    GoTo(to->block());
  }
}

graph_entry()

GraphEntryInstr * dart::IRRegExpMacroAssembler::graph_entry ( ) const

inline

Definition at line 125 of file regexp_assembler_ir.h.

{ return entry_block_; }

IfRegisterEqPos()

void dart::IRRegExpMacroAssembler::IfRegisterEqPos ( intptr_t  reg, BlockLabel *  if_eq  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1348 of file regexp_assembler_ir.cc.

                                                                            {
  TAG();
  Value* reg_push = LoadRegister(reg);
  Value* pos = Bind(LoadLocal(current_position_));
  BranchOrBacktrack(Comparison(kEQ, reg_push, pos), if_eq);
}

IfRegisterGE()

void dart::IRRegExpMacroAssembler::IfRegisterGE ( intptr_t  reg, intptr_t  comparand, BlockLabel *  if_ge  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1330 of file regexp_assembler_ir.cc.

                                                             {
  TAG();
  Value* reg_push = LoadRegister(reg);
  Value* pos = Bind(Int64Constant(comparand));
  BranchOrBacktrack(Comparison(kGTE, reg_push, pos), if_ge);
}

IfRegisterLT()

void dart::IRRegExpMacroAssembler::IfRegisterLT ( intptr_t  reg, intptr_t  comparand, BlockLabel *  if_lt  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1339 of file regexp_assembler_ir.cc.

                                                             {
  TAG();
  Value* reg_push = LoadRegister(reg);
  Value* pos = Bind(Int64Constant(comparand));
  BranchOrBacktrack(Comparison(kLT, reg_push, pos), if_lt);
}

Implementation()

RegExpMacroAssembler::IrregexpImplementation dart::IRRegExpMacroAssembler::Implementation ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1356 of file regexp_assembler_ir.cc.

                                       {
  return kIRImplementation;
}

IsClosed()

virtual bool dart::IRRegExpMacroAssembler::IsClosed ( ) const

inlinevirtual

Implements dart::RegExpMacroAssembler.

Definition at line 47 of file regexp_assembler_ir.h.

{ return (current_instruction_ == nullptr); }

LoadCurrentCharacter()

void dart::IRRegExpMacroAssembler::LoadCurrentCharacter ( intptr_t  cp_offset, BlockLabel *  on_end_of_input, bool  check_bounds = true, intptr_t  characters = 1  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1360 of file regexp_assembler_ir.cc.

                                                                       {
  TAG();
  ASSERT(cp_offset < (1 << 30));  // Be sane! (And ensure negation works)
  if (check_bounds) {
    if (cp_offset >= 0) {
      CheckPosition(cp_offset + characters - 1, on_end_of_input);
    } else {
      CheckPosition(cp_offset, on_end_of_input);
    }
  }
  LoadCurrentCharacterUnchecked(cp_offset, characters);
}

num_blocks()

intptr_t dart::IRRegExpMacroAssembler::num_blocks ( ) const

inline

Definition at line 128 of file regexp_assembler_ir.h.

{ return block_id_.Count(); }

num_stack_locals()

intptr_t dart::IRRegExpMacroAssembler::num_stack_locals ( ) const

inline

Definition at line 127 of file regexp_assembler_ir.h.

{ return local_id_.Count(); }

PopCurrentPosition()

void dart::IRRegExpMacroAssembler::PopCurrentPosition ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1376 of file regexp_assembler_ir.cc.

                                                {
  TAG();
  StoreLocal(current_position_, Bind(PopStack()));
}

PopRegister()

void dart::IRRegExpMacroAssembler::PopRegister ( intptr_t  register_index )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1381 of file regexp_assembler_ir.cc.

                                                     {
  TAG();
  ASSERT(reg < registers_count_);
  Value* registers_push = PushLocal(registers_);
  Value* index_push = PushRegisterIndex(reg);
  Value* pop_push = Bind(PopStack());
  StoreRegister(registers_push, index_push, pop_push);
}

Print()

void dart::IRRegExpMacroAssembler::Print ( const char *  str )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 609 of file regexp_assembler_ir.cc.

                                                  {
  Print(Bind(new (Z) ConstantInstr(
      String::ZoneHandle(Z, String::New(str, Heap::kOld)))));
}

PrintBlocks()

void dart::IRRegExpMacroAssembler::PrintBlocks ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 621 of file regexp_assembler_ir.cc.

                                         {
  for (intptr_t i = 0; i < blocks_.length(); i++) {
    FlowGraphPrinter::PrintBlock(blocks_[i], false);
  }
}

PushBacktrack()

void dart::IRRegExpMacroAssembler::PushBacktrack ( BlockLabel *  label )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1420 of file regexp_assembler_ir.cc.

                                                            {
  TAG();
 
  // Ensure that targets of indirect jumps are never accessed through a
  // normal control flow instructions by creating a new block for each backtrack
  // target.
  IndirectEntryInstr* indirect_target = IndirectWithJoinGoto(label->block());
 
  // Add a fake edge from the graph entry for data flow analysis.
  entry_block_->AddIndirectEntry(indirect_target);
 
  ConstantInstr* offset = Uint64Constant(indirect_target->indirect_id());
  PushStack(offset);
  CheckStackLimit();
}

PushCurrentPosition()

void dart::IRRegExpMacroAssembler::PushCurrentPosition ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1436 of file regexp_assembler_ir.cc.

                                                 {
  TAG();
  PushStack(LoadLocal(current_position_));
}

PushRegister()

void dart::IRRegExpMacroAssembler::PushRegister ( intptr_t  register_index )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1441 of file regexp_assembler_ir.cc.

                                                      {
  TAG();
  // TODO(zerny): Refactor PushStack so it can be reused here.
  Value* stack_push = PushLocal(stack_);
  Value* stack_pointer_push = PushLocal(stack_pointer_);
  StoreLocal(stack_pointer_,
             Bind(Add(stack_pointer_push, Bind(Uint64Constant(1)))));
  stack_pointer_push = PushLocal(stack_pointer_);
  // TODO(zerny): bind value and push could break stack discipline.
  Value* value_push = LoadRegister(reg);
  Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                  stack_push, stack_pointer_push, value_push));
  CheckStackLimit();
}

ReadCurrentPositionFromRegister()

void dart::IRRegExpMacroAssembler::ReadCurrentPositionFromRegister ( intptr_t  reg )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1498 of file regexp_assembler_ir.cc.

                                                                         {
  TAG();
  StoreLocal(current_position_, LoadRegister(reg));
}

ReadStackPointerFromRegister()

void dart::IRRegExpMacroAssembler::ReadStackPointerFromRegister ( intptr_t  reg )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1504 of file regexp_assembler_ir.cc.

                                                                      {
  TAG();
  ASSERT(reg < registers_count_);
  StoreLocal(stack_pointer_, LoadRegister(reg));
}

SetCurrentPositionFromEnd()

void dart::IRRegExpMacroAssembler::SetCurrentPositionFromEnd ( intptr_t  by )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1510 of file regexp_assembler_ir.cc.

                                                                  {
  TAG();
 
  BlockLabel after_position;
 
  Definition* cur_pos_def = LoadLocal(current_position_);
  Definition* by_value_def = Int64Constant(-by);
 
  BranchOrBacktrack(Comparison(kGTE, cur_pos_def, by_value_def),
                    &after_position);
 
  StoreLocal(current_position_, Bind(Int64Constant(-by)));
 
  // On RegExp code entry (where this operation is used), the character before
  // the current position is expected to be already loaded.
  // We have advanced the position, so it's safe to read backwards.
  LoadCurrentCharacterUnchecked(-1, 1);
 
  BindBlock(&after_position);
}

SetRegister()

void dart::IRRegExpMacroAssembler::SetRegister ( intptr_t  register_index, intptr_t  to  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1531 of file regexp_assembler_ir.cc.

                                                                  {
  TAG();
  // Reserved for positions!
  ASSERT(reg >= saved_registers_count_);
  StoreRegister(reg, to);
}

stack_limit_slack()

intptr_t dart::IRRegExpMacroAssembler::stack_limit_slack ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 627 of file regexp_assembler_ir.cc.

                                                   {
  return 32;
}

Succeed()

bool dart::IRRegExpMacroAssembler::Succeed ( )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1538 of file regexp_assembler_ir.cc.

                                     {
  TAG();
  GoTo(success_block_);
  return global();
}

WriteCurrentPositionToRegister()

void dart::IRRegExpMacroAssembler::WriteCurrentPositionToRegister ( intptr_t  reg, intptr_t  cp_offset  )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1544 of file regexp_assembler_ir.cc.

                        {
  TAG();
 
  Value* registers_push = PushLocal(registers_);
  Value* index_push = PushRegisterIndex(reg);
  Value* pos_push = PushLocal(current_position_);
  Value* off_push = Bind(Int64Constant(cp_offset));
  Value* neg_off_push = Bind(Add(pos_push, off_push));
  // Push the negative offset; these are converted to positive string positions
  // within the success block.
  StoreRegister(registers_push, index_push, neg_off_push);
}

WriteStackPointerToRegister()

void dart::IRRegExpMacroAssembler::WriteStackPointerToRegister ( intptr_t  reg )

virtual

Implements dart::RegExpMacroAssembler.

Definition at line 1578 of file regexp_assembler_ir.cc.

                                                                     {
  TAG();
 
  Value* registers_push = PushLocal(registers_);
  Value* index_push = PushRegisterIndex(reg);
  Value* tip_push = PushLocal(stack_pointer_);
  StoreRegister(registers_push, index_push, tip_push);
}

---

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

• third_party/dart-lang/sdk/runtime/vm/regexp_assembler_ir.h
• third_party/dart-lang/sdk/runtime/vm/regexp_assembler_ir.cc