Replace the use of local variables for irregexp registers by a typed array.

runtime/vm/regexp_assembler.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp_assembler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 44 matching lines @@
  *                      negative offset from the end of the string (i.e. the
  *                      position corresponding to str[0] is -str.length).
  *                      Note that current_position_ is *not* byte-based, unlike
  *                      original V8 code.
  *
  * Results are returned though an array of capture indices, stored at
  * matches_param_. A null array specifies a failure to match. The match indices
  * [start_inclusive, end_exclusive] for capture group i are stored at positions
  * matches_param_[i * 2] and matches_param_[i * 2 + 1], respectively. Match
  * indices of -1 denote non-matched groups. Note that we store these indices
- * as a negative offset from the end of the string in position_registers_
+ * as a negative offset from the end of the string in registers_array_
  * during processing, and convert them to standard indexes when copying them
  * to matches_param_ on successful match.
  */
 
 RegExpMacroAssembler::RegExpMacroAssembler(Isolate* isolate)
   : slow_safe_compiler_(false),
     global_mode_(NOT_GLOBAL),
     isolate_(isolate) {
 }
 
@@ skipping 12 matching lines @@
       specialization_cid_(specialization_cid),
       parsed_function_(parsed_function),
       ic_data_array_(ic_data_array),
       current_instruction_(NULL),
       stack_(NULL),
       current_character_(NULL),
       current_position_(NULL),
       string_param_(NULL),
       string_param_length_(NULL),
       start_index_param_(NULL),
-      position_registers_count_((capture_count + 1) * 2),
+      registers_count_(0),
+      saved_registers_count_((capture_count + 1) * 2),
       stack_array_(GrowableObjectArray::ZoneHandle(
-          isolate, GrowableObjectArray::New(16, Heap::kOld))) {
+          isolate, GrowableObjectArray::New(16, Heap::kOld))),
+      // The registers array is allocated at a fixed size after assembly.
+      registers_array_(TypedData::ZoneHandle(isolate, TypedData::null())) {
   switch (specialization_cid) {
     case kOneByteStringCid:
     case kExternalOneByteStringCid: mode_ = ASCII; break;
     case kTwoByteStringCid:
     case kExternalTwoByteStringCid: mode_ = UC16; break;
     default: UNREACHABLE();
   }
 
   InitializeLocals();
 
@@ skipping 31 matching lines @@
 IRRegExpMacroAssembler::~IRRegExpMacroAssembler() { }
 
 
 void IRRegExpMacroAssembler::InitializeLocals() {
   // All generated functions are expected to have a current-context variable.
   // This variable is unused in irregexp functions.
   parsed_function_->current_context_var()->set_index(GetNextLocalIndex());
 
   // Create local variables and parameters.
   stack_ = Local(Symbols::stack());
+  registers_ = Local(Symbols::position_registers());
   current_character_ = Local(Symbols::current_character());
   current_position_ = Local(Symbols::current_position());
   string_param_length_ = Local(Symbols::string_param_length());
   capture_length_ = Local(Symbols::capture_length());
   match_start_index_ = Local(Symbols::match_start_index());
   capture_start_index_ = Local(Symbols::capture_start_index());
   match_end_index_ = Local(Symbols::match_end_index());
   char_in_capture_ = Local(Symbols::char_in_capture());
   char_in_match_ = Local(Symbols::char_in_match());
   index_temp_ = Local(Symbols::index_temp());
   result_ = Local(Symbols::result());
 
   string_param_ = Parameter(Symbols::string_param(), 0);
   start_index_param_ = Parameter(Symbols::start_index_param(), 1);
-
-  // Reserve space for all captured group positions. Note that more might
-  // be created on the fly for internal use.
-  for (intptr_t i = 0; i < position_registers_count_; i++) {
-    position_register(i);
-  }
 }
 
 
 void IRRegExpMacroAssembler::GenerateEntryBlock() {
   set_current_instruction(entry_block_->normal_entry());
   TAG();
 
-  // Generate a local list variable which we will use as a backtracking stack.
-
-  StoreLocal(stack_, Bind(new(I) ConstantInstr(stack_array_)));
-  Do(InstanceCall(InstanceCallDescriptor(Symbols::clear()), PushLocal(stack_)));
-
   // Store string.length.
   PushArgumentInstr* string_push = PushLocal(string_param_);
 
   StoreLocal(
       string_param_length_,
       Bind(InstanceCall(
           InstanceCallDescriptor(
               String::ZoneHandle(Field::GetterSymbol(Symbols::Length()))),
           string_push)));
 
-  // Initialize all capture registers.
-  ClearRegisters(0, position_registers_count_ - 1);
-
   // Store (start_index - string.length) as the current position (since it's a
   // negative offset from the end of the string).
   PushArgumentInstr* start_index_push = PushLocal(start_index_param_);
   PushArgumentInstr* length_push = PushLocal(string_param_length_);
 
   StoreLocal(current_position_, Bind(Sub(start_index_push, length_push)));
 
+  // Generate a local list variable to represent "registers" and
+  // initialize capture registers (others remain garbage).
+  StoreLocal(registers_, Bind(new(I) ConstantInstr(registers_array_)));
+  ClearRegisters(0, saved_registers_count_ - 1);
+
+  // Generate a local list variable to represent the backtracking stack.
+  StoreLocal(stack_, Bind(new(I) ConstantInstr(stack_array_)));
+  PushArgumentInstr* stack_push = PushLocal(stack_);
+  Do(InstanceCall(InstanceCallDescriptor(Symbols::clear()), stack_push));
+
   // Jump to the start block.
   current_instruction_->Goto(start_block_);
 }
 
 
 void IRRegExpMacroAssembler::GenerateBacktrackBlock() {
   set_current_instruction(backtrack_block_);
   TAG();
   CheckPreemption();
 
@@ skipping 19 matching lines @@
     backtrack_goto_->AddSuccessor(
         TargetWithJoinGoto(entry_block_->indirect_entries().At(j)));
   }
 }
 
 
 void IRRegExpMacroAssembler::GenerateSuccessBlock() {
   set_current_instruction(success_block_);
   TAG();
 
-  Definition* type_args_null_def = new(I) ConstantInstr(
-        TypeArguments::ZoneHandle(I, TypeArguments::null()));
-  PushArgumentInstr* type_arg_push = PushArgument(Bind(type_args_null_def));
-  PushArgumentInstr* length_push =
-      PushArgument(Bind(Uint64Constant(position_registers_count_)));
-
-  const Library& lib = Library::Handle(Library::CoreLibrary());
-  const Class& list_class = Class::Handle(
-        lib.LookupCoreClass(Symbols::List()));
-  const Function& list_ctor =
-      Function::ZoneHandle(I, list_class.LookupFactory(Symbols::ListFactory()));
-
-  // TODO(zerny): Use CreateArrayInstr and StoreIndexed instead.
-  StoreLocal(result_, Bind(StaticCall(list_ctor, type_arg_push, length_push)));
+  Value* type = Bind(new(I) ConstantInstr(
+      TypeArguments::ZoneHandle(I, TypeArguments::null())));
+  Value* length = Bind(Uint64Constant(saved_registers_count_));
+  Value* array = Bind(new(I) CreateArrayInstr(kNoSourcePos, type, length));
+  StoreLocal(result_, array);
 
   // Store captured offsets in the `matches` parameter.
-  // TODO(zerny): Eliminate position_register locals and access `matches`
-  // directly.
-  for (intptr_t i = 0; i < position_registers_count_; i++) {
+  for (intptr_t i = 0; i < saved_registers_count_; i++) {
     PushArgumentInstr* matches_push = PushLocal(result_);
     PushArgumentInstr* index_push = PushArgument(Bind(Uint64Constant(i)));
 
     // Convert negative offsets from the end of the string to string indices.
-    PushArgumentInstr* offset_push = PushLocal(position_register(i));
+    // TODO(zerny): use positive offsets from the get-go.
+    PushArgumentInstr* offset_push = PushArgument(LoadRegister(i));
     PushArgumentInstr* len_push = PushLocal(string_param_length_);
     PushArgumentInstr* value_push =
         PushArgument(Bind(Add(offset_push, len_push)));
 
     Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                     matches_push,
                     index_push,
                     value_push));
   }
 
   // Print the result if tracing.
   PRINT(PushLocal(result_));
 
   // Return true on success.
   AppendInstruction(new(I) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
 }
 
 
 void IRRegExpMacroAssembler::GenerateExitBlock() {
   set_current_instruction(exit_block_);
   TAG();
 
   // Return false on failure.
   AppendInstruction(new(I) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
 }
 
 
+void IRRegExpMacroAssembler::FinalizeRegistersArray() {
+  ASSERT(registers_count_ >= saved_registers_count_);
+  registers_array_ =
+      TypedData::New(kTypedDataInt32ArrayCid, registers_count_, Heap::kOld);
+}
+
+
 #if defined(TARGET_ARCH_ARM64) ||                                              \
     defined(TARGET_ARCH_ARM) ||                                                \
     defined(TARGET_ARCH_MIPS)
 // Disabling unaligned accesses forces the regexp engine to load characters one
 // by one instead of up to 4 at once, along with the associated performance hit.
 // TODO(zerny): Be less conservative about disabling unaligned accesses.
 // For instance, ARMv6 supports unaligned accesses. Once it is enabled here,
 // update LoadCodeUnitsInstr methods for the appropriate architectures.
 static const bool kEnableUnalignedAccesses = false;
 #else
@@ skipping 125 matching lines @@
     word_character_field.EvaluateInitializer();
   }
   ASSERT(!word_character_field.IsUninitialized());
 
   return new(I) ConstantInstr(
         Instance::ZoneHandle(I, word_character_field.value()));
 }
 
 
 ComparisonInstr* IRRegExpMacroAssembler::Comparison(
-    ComparisonKind kind, Definition* lhs, Definition* rhs) {
+    ComparisonKind kind, PushArgumentInstr* lhs, PushArgumentInstr* rhs) {
   Token::Kind strict_comparison = Token::kEQ_STRICT;
   Token::Kind intermediate_operator = Token::kILLEGAL;
   switch (kind) {
   case kEQ:
     intermediate_operator = Token::kEQ;
     break;
   case kNE:
     intermediate_operator = Token::kEQ;
     strict_comparison = Token::kNE_STRICT;
     break;
   case kLT:
     intermediate_operator = Token::kLT;
     break;
   case kGT:
     intermediate_operator = Token::kGT;
     break;
   case kLTE:
     intermediate_operator = Token::kLTE;
     break;
   case kGTE:
     intermediate_operator = Token::kGTE;
     break;
   default:
     UNREACHABLE();
   }
 
   ASSERT(intermediate_operator != Token::kILLEGAL);
 
-  PushArgumentInstr* lhs_push = PushArgument(Bind(lhs));
-  PushArgumentInstr* rhs_push = PushArgument(Bind(rhs));
-
   Value* lhs_value =
       Bind(InstanceCall(
              InstanceCallDescriptor::FromToken(intermediate_operator),
-             lhs_push,
-             rhs_push));
+             lhs,
+             rhs));
   Value* rhs_value = Bind(BoolConstant(true));
 
   return new(I) StrictCompareInstr(
       kNoSourcePos, strict_comparison, lhs_value, rhs_value, true);
 }
 
+ComparisonInstr* IRRegExpMacroAssembler::Comparison(
+    ComparisonKind kind, Definition* lhs, Definition* rhs) {
+  PushArgumentInstr* lhs_push = PushArgument(Bind(lhs));
+  PushArgumentInstr* rhs_push = PushArgument(Bind(rhs));
+  return Comparison(kind, lhs_push, rhs_push);
+}
+
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(I) ZoneGrowableArray<PushArgumentInstr*>(0);
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
@@ skipping 236 matching lines @@
 
     Value* new_pos_value = Bind(Add(cur_pos_push, by_push));
     StoreLocal(current_position_, new_pos_value);
   }
 }
 
 
 void IRRegExpMacroAssembler::AdvanceRegister(intptr_t reg, intptr_t by) {
   TAG();
   ASSERT(reg >= 0);
-  ASSERT(reg < position_registers_.length());
+  ASSERT(reg < registers_count_);
 
   if (by != 0) {
-    PushArgumentInstr* reg_push = PushLocal(position_register(reg));
+    PushArgumentInstr* registers_push = PushLocal(registers_);
+    PushArgumentInstr* index_push = PushRegisterIndex(reg);
+    PushArgumentInstr* reg_push = PushArgument(LoadRegister(reg));
     PushArgumentInstr* by_push = PushArgument(Bind(Int64Constant(by)));
-    StoreLocal(position_register(reg), Bind(Add(reg_push, by_push)));
+    PushArgumentInstr* value_push = PushArgument(Bind(Add(reg_push, by_push)));
+    StoreRegister(registers_push, index_push, value_push);
   }
 }
 
 
 void IRRegExpMacroAssembler::Backtrack() {
   TAG();
   GoTo(backtrack_block_);
 }
 
 
@@ skipping 16 matching lines @@
   PRINT(PushArgument(Bind(Uint64Constant(label->block()->block_id()))));
 }
 
 
 intptr_t IRRegExpMacroAssembler::GetNextLocalIndex() {
   intptr_t id = local_id_.Alloc();
   return kFirstLocalSlotFromFp - id;
 }
 
 
-LocalVariable* IRRegExpMacroAssembler::position_register(intptr_t index) {
-  // Create position registers as needed.
-  for (intptr_t i = position_registers_.length(); i < index + 1; i++) {
-    position_registers_.Add(Local(Symbols::position_registers()));
-  }
+Value* IRRegExpMacroAssembler::LoadRegister(intptr_t index) {
+  PushArgumentInstr* registers_push = PushLocal(registers_);
+  PushArgumentInstr* index_push = PushRegisterIndex(index);
+  return Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
+                           registers_push,
+                           index_push));
+}
 
-  return position_registers_[index];
+void IRRegExpMacroAssembler::StoreRegister(intptr_t index, intptr_t value) {
+  PushArgumentInstr* registers_push = PushLocal(registers_);
+  PushArgumentInstr* index_push = PushRegisterIndex(index);
+  PushArgumentInstr* value_push = PushArgument(Bind(Uint64Constant(value)));
+  StoreRegister(registers_push, index_push, value_push);
 }
 
 
+void IRRegExpMacroAssembler::StoreRegister(PushArgumentInstr* registers,
+                                           PushArgumentInstr* index,
+                                           PushArgumentInstr* value) {
+  TAG();
+  Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
+                  registers,
+                  index,
+                  value));
+}
+
+PushArgumentInstr* IRRegExpMacroAssembler::PushRegisterIndex(intptr_t index) {
+  if (registers_count_ <= index) {
+    registers_count_ = index + 1;
+  }
+  return PushArgument(Bind(Uint64Constant(index)));
+}
+
+
 void IRRegExpMacroAssembler::CheckCharacter(uint32_t c, BlockLabel* on_equal) {
   TAG();
   Definition* cur_char_def = LoadLocal(current_character_);
   Definition* char_def = Uint64Constant(c);
 
   BranchOrBacktrack(Comparison(kEQ, cur_char_def, char_def), on_equal);
 }
 
 
 void IRRegExpMacroAssembler::CheckCharacterGT(uint16_t limit,
@@ skipping 83 matching lines @@
   BranchOrBacktrack(NULL, on_equal);
 
   BindBlock(&fallthrough);
 }
 
 
 void IRRegExpMacroAssembler::CheckNotBackReferenceIgnoreCase(
     intptr_t start_reg,
     BlockLabel* on_no_match) {
   TAG();
-  ASSERT(start_reg + 1 <= position_registers_.length());
+  ASSERT(start_reg + 1 <= registers_count_);
 
   BlockLabel fallthrough;
 
-  PushArgumentInstr* end_push = PushLocal(position_register(start_reg + 1));
-  PushArgumentInstr* start_push = PushLocal(position_register(start_reg));
+  PushArgumentInstr* end_push = PushArgument(LoadRegister(start_reg + 1));
+  PushArgumentInstr* start_push = PushArgument(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)),
@@ skipping 15 matching lines @@
                    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)));
 
-  pos_push = PushLocal(position_register(start_reg));
+  pos_push = PushArgument(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;
@@ skipping 105 matching lines @@
   StoreLocal(current_position_, Bind(Sub(match_end_push, len_push)));
 
   BindBlock(&fallthrough);
 }
 
 
 void IRRegExpMacroAssembler::CheckNotBackReference(
     intptr_t start_reg,
     BlockLabel* on_no_match) {
   TAG();
-  ASSERT(start_reg + 1 <= position_registers_.length());
+  ASSERT(start_reg + 1 <= registers_count_);
 
   BlockLabel fallthrough;
   BlockLabel success;
 
   // Find length of back-referenced capture.
-  PushArgumentInstr* end_push = PushLocal(position_register(start_reg + 1));
-  PushArgumentInstr* start_push = PushLocal(position_register(start_reg));
+  PushArgumentInstr* end_push = PushArgument(LoadRegister(start_reg + 1));
+  PushArgumentInstr* start_push = PushArgument(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,
@@ skipping 10 matching lines @@
                                 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)));
 
-  pos_push = PushLocal(position_register(start_reg));
+  pos_push = PushArgument(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);
 
@@ skipping 332 matching lines @@
     UNREACHABLE();  // Dart regexps are always global.
   }
   GoTo(exit_block_);
 }
 
 
 void IRRegExpMacroAssembler::IfRegisterGE(intptr_t reg,
                                           intptr_t comparand,
                                           BlockLabel* if_ge) {
   TAG();
-  BranchOrBacktrack(Comparison(kGTE,
-                               LoadLocal(position_register(reg)),
-                               Int64Constant(comparand)),
-                    if_ge);
+  PushArgumentInstr* reg_push = PushArgument(LoadRegister(reg));
+  PushArgumentInstr* pos = PushArgument(Bind(Int64Constant(comparand)));
+  BranchOrBacktrack(Comparison(kGTE, reg_push, pos), if_ge);
 }
 
 
 void IRRegExpMacroAssembler::IfRegisterLT(intptr_t reg,
                                           intptr_t comparand,
                                           BlockLabel* if_lt) {
   TAG();
-  BranchOrBacktrack(Comparison(kLT,
-                               LoadLocal(position_register(reg)),
-                               Int64Constant(comparand)),
-                    if_lt);
+  PushArgumentInstr* reg_push = PushArgument(LoadRegister(reg));
+  PushArgumentInstr* pos = PushArgument(Bind(Int64Constant(comparand)));
+  BranchOrBacktrack(Comparison(kLT, reg_push, pos), if_lt);
 }
 
 
 void IRRegExpMacroAssembler::IfRegisterEqPos(intptr_t reg,
                                              BlockLabel* if_eq) {
   TAG();
-  BranchOrBacktrack(Comparison(kEQ,
-                               LoadLocal(position_register(reg)),
-                               LoadLocal(current_position_)),
-                    if_eq);
+  PushArgumentInstr* reg_push = PushArgument(LoadRegister(reg));
+  PushArgumentInstr* pos = PushArgument(Bind(LoadLocal(current_position_)));
+  BranchOrBacktrack(Comparison(kEQ, reg_push, pos), if_eq);
 }
 
 
 RegExpMacroAssembler::IrregexpImplementation
     IRRegExpMacroAssembler::Implementation() {
   return kIRImplementation;
 }
 
 
 void IRRegExpMacroAssembler::LoadCurrentCharacter(intptr_t cp_offset,
                                                   BlockLabel* on_end_of_input,
                                                   bool check_bounds,
                                                   intptr_t characters) {
   TAG();
   ASSERT(cp_offset >= -1);      // ^ and \b can look behind one character.
   ASSERT(cp_offset < (1<<30));  // Be sane! (And ensure negation works)
   if (check_bounds) {
     CheckPosition(cp_offset + characters - 1, on_end_of_input);
   }
   LoadCurrentCharacterUnchecked(cp_offset, characters);
 }
 
 
 void IRRegExpMacroAssembler::PopCurrentPosition() {
   TAG();
   StoreLocal(current_position_, PopStack());
 }
 
 
-void IRRegExpMacroAssembler::PopRegister(intptr_t register_index) {
+void IRRegExpMacroAssembler::PopRegister(intptr_t reg) {
   TAG();
-  ASSERT(register_index < position_registers_.length());
-  StoreLocal(position_register(register_index), PopStack());
+  ASSERT(reg < registers_count_);
+  PushArgumentInstr* registers_push = PushLocal(registers_);
+  PushArgumentInstr* index_push = PushRegisterIndex(reg);
+  PushArgumentInstr* pop_push = PushArgument(PopStack());
+  StoreRegister(registers_push, index_push, pop_push);
 }
 
 
 void IRRegExpMacroAssembler::PushStack(Definition *definition) {
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* value_push = PushArgument(Bind(definition));
   Do(InstanceCall(InstanceCallDescriptor(Symbols::add()),
                   stack_push,
                   value_push));
 }
@@ skipping 22 matching lines @@
   PushStack(offset);
 }
 
 
 void IRRegExpMacroAssembler::PushCurrentPosition() {
   TAG();
   PushStack(LoadLocal(current_position_));
 }
 
 
-void IRRegExpMacroAssembler::PushRegister(intptr_t register_index) {
+void IRRegExpMacroAssembler::PushRegister(intptr_t reg) {
   TAG();
-  PushStack(LoadLocal(position_register(register_index)));
+  PushArgumentInstr* stack_push = PushLocal(stack_);
+  PushArgumentInstr* value_push = PushArgument(LoadRegister(reg));
+  Do(InstanceCall(InstanceCallDescriptor(Symbols::add()),
+                  stack_push,
+                  value_push));
 }
 
 
 void IRRegExpMacroAssembler::ReadCurrentPositionFromRegister(intptr_t reg) {
   TAG();
-  StoreLocal(current_position_, Bind(LoadLocal(position_register(reg))));
+  StoreLocal(current_position_, LoadRegister(reg));
 }
 
 // Resets the size of the stack to the value stored in reg.
 void IRRegExpMacroAssembler::ReadStackPointerFromRegister(intptr_t reg) {
   TAG();
-  ASSERT(reg < position_registers_.length());
+  ASSERT(reg < registers_count_);
 
   PushArgumentInstr* stack_push = PushLocal(stack_);
-  PushArgumentInstr* length_push = PushLocal(position_register(reg));
+  PushArgumentInstr* length_push = PushArgument(LoadRegister(reg));
 
   Do(InstanceCall(
       InstanceCallDescriptor(
           String::ZoneHandle(I, Field::SetterSymbol(Symbols::Length()))),
       stack_push,
       length_push));
 }
 
 void IRRegExpMacroAssembler::SetCurrentPositionFromEnd(intptr_t by)  {
   TAG();
@@ skipping 10 matching lines @@
 
   // 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);
 }
 
 
-void IRRegExpMacroAssembler::SetRegister(intptr_t register_index, intptr_t to) {
+void IRRegExpMacroAssembler::SetRegister(intptr_t reg, intptr_t to) {
   TAG();
   // Reserved for positions!
-  ASSERT(register_index >= position_registers_count_);
-  StoreLocal(position_register(register_index), Bind(Int64Constant(to)));
+  ASSERT(reg >= saved_registers_count_);
+  StoreRegister(reg, to);
 }
 
 
 bool IRRegExpMacroAssembler::Succeed() {
   TAG();
   GoTo(success_block_);
   return global();
 }
 
 
 void IRRegExpMacroAssembler::WriteCurrentPositionToRegister(
     intptr_t reg, intptr_t cp_offset) {
   TAG();
 
+  PushArgumentInstr* registers_push = PushLocal(registers_);
+  PushArgumentInstr* index_push = PushRegisterIndex(reg);
   PushArgumentInstr* pos_push = PushLocal(current_position_);
-  PushArgumentInstr* off_push =
-      PushArgument(Bind(Int64Constant(cp_offset)));
-
+  PushArgumentInstr* off_push = PushArgument(Bind(Int64Constant(cp_offset)));
+  PushArgumentInstr* neg_off_push = PushArgument(Bind(Add(pos_push, off_push)));
   // Push the negative offset; these are converted to positive string positions
   // within the success block.
-  StoreLocal(position_register(reg), Bind(Add(pos_push, off_push)));
+  StoreRegister(registers_push, index_push, neg_off_push);
 }
 
 
 void IRRegExpMacroAssembler::ClearRegisters(
     intptr_t reg_from, intptr_t reg_to) {
   TAG();
 
   ASSERT(reg_from <= reg_to);
-  ASSERT(reg_to < position_registers_.length());
 
   // 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++) {
+    PushArgumentInstr* registers_push = PushLocal(registers_);
+    PushArgumentInstr* index_push = PushRegisterIndex(reg);
     PushArgumentInstr* minus_one_push =
         PushArgument(Bind(Int64Constant(-1)));
     PushArgumentInstr* length_push = PushLocal(string_param_length_);
-
-    StoreLocal(position_register(reg), Bind(Sub(minus_one_push, length_push)));
+    PushArgumentInstr* value_push =
+        PushArgument(Bind(Sub(minus_one_push, length_push)));
+    StoreRegister(registers_push, index_push, value_push);
   }
 }
 
 
 void IRRegExpMacroAssembler::WriteStackPointerToRegister(intptr_t reg) {
   TAG();
 
+  PushArgumentInstr* registers_push = PushLocal(registers_);
+  PushArgumentInstr* index_push = PushRegisterIndex(reg);
   PushArgumentInstr* stack_push = PushLocal(stack_);
-  Value* length_value =
-      Bind(InstanceCall(InstanceCallDescriptor(
-                          String::ZoneHandle(
-                            I, Field::GetterSymbol(Symbols::Length()))),
-                        stack_push));
-
-  StoreLocal(position_register(reg), length_value);
+  PushArgumentInstr* length_push =
+      PushArgument(Bind(InstanceCall(InstanceCallDescriptor(
+          String::ZoneHandle(I, Field::GetterSymbol(Symbols::Length()))),
+                                     stack_push)));
+  StoreRegister(registers_push, index_push, length_push);
 }
 
 
 // Private methods:
 
 
 void IRRegExpMacroAssembler::CheckPosition(intptr_t cp_offset,
                                            BlockLabel* on_outside_input) {
   TAG();
   Definition* curpos_def = LoadLocal(current_position_);
@@ skipping 157 matching lines @@
       index_val,
       characters,
       specialization_cid_,
       Scanner::kNoSourcePos));
 }
 
 
 #undef __
 
 }  // namespace dart