VM: Re-format to use at most one newline between functions

runtime/vm/regexp_assembler_ir.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_ir.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 22 matching lines @@
 #define PRINT(arg)                                                             \
   if (FLAG_trace_irregexp) {                                                   \
     Print(arg);                                                                \
   }
 
 namespace dart {
 
 static const intptr_t kInvalidTryIndex = CatchClauseNode::kInvalidTryIndex;
 static const intptr_t kMinStackSize = 512;
 
-
 /*
  * This assembler uses the following main local variables:
  * - stack_: A pointer to a growable list which we use as an all-purpose stack
  *           storing backtracking offsets, positions & stored register values.
  * - current_character_: Stores the currently loaded characters (possibly more
  *                       than one).
  * - current_position_: The current position within the string, stored as a
  *                      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
@@ skipping 81 matching lines @@
   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::~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());
   stack_pointer_ = Local(Symbols::stack_pointer());
   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(),
                             RegExpMacroAssembler::kParamStringIndex);
   start_index_param_ = Parameter(Symbols::start_index_param(),
                                  RegExpMacroAssembler::kParamStartOffsetIndex);
 }
 
-
 void IRRegExpMacroAssembler::GenerateEntryBlock() {
   set_current_instruction(entry_block_->normal_entry());
   TAG();
 
   // Store string.length.
   PushArgumentInstr* string_push = PushLocal(string_param_);
 
   StoreLocal(string_param_length_,
              Bind(InstanceCall(InstanceCallDescriptor(String::ZoneHandle(
                                    Field::GetterSymbol(Symbols::Length()))),
@@ skipping 17 matching lines @@
   StoreLocal(stack_,
              Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                                stack_cell_push,
                                PushArgument(Bind(Uint64Constant(0))))));
   StoreLocal(stack_pointer_, Bind(Int64Constant(-1)));
 
   // Jump to the start block.
   current_instruction_->Goto(start_block_);
 }
 
-
 void IRRegExpMacroAssembler::GenerateBacktrackBlock() {
   set_current_instruction(backtrack_block_);
   TAG();
   CheckPreemption(/*is_backtrack=*/true);
 
   const intptr_t entries_count = entry_block_->indirect_entries().length();
 
   TypedData& offsets = TypedData::ZoneHandle(
       Z, TypedData::New(kTypedDataInt32ArrayCid, entries_count, Heap::kOld));
 
   PushArgumentInstr* block_offsets_push =
       PushArgument(Bind(new (Z) ConstantInstr(offsets)));
   PushArgumentInstr* block_id_push = PushArgument(Bind(PopStack()));
 
   Value* offset_value =
       Bind(InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                         block_offsets_push, block_id_push));
 
   backtrack_goto_ = new (Z) IndirectGotoInstr(&offsets, offset_value);
   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)));
   }
 }
 
-
 void IRRegExpMacroAssembler::GenerateSuccessBlock() {
   set_current_instruction(success_block_);
   TAG();
 
   Value* type = Bind(new (Z) ConstantInstr(
       TypeArguments::ZoneHandle(Z, TypeArguments::null())));
   Value* length = Bind(Uint64Constant(saved_registers_count_));
   Value* array = Bind(new (Z) CreateArrayInstr(TokenPosition::kNoSource, type,
                                                length, GetNextDeoptId()));
   StoreLocal(result_, array);
@@ skipping 15 matching lines @@
   }
 
   // Print the result if tracing.
   PRINT(PushLocal(result_));
 
   // Return true on success.
   AppendInstruction(new (Z) ReturnInstr(
       TokenPosition::kNoSource, Bind(LoadLocal(result_)), GetNextDeoptId()));
 }
 
-
 void IRRegExpMacroAssembler::GenerateExitBlock() {
   set_current_instruction(exit_block_);
   TAG();
 
   // Return false on failure.
   AppendInstruction(new (Z) ReturnInstr(
       TokenPosition::kNoSource, Bind(LoadLocal(result_)), GetNextDeoptId()));
 }
 
-
 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)
 // 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
 static const bool kEnableUnalignedAccesses = true;
 #endif
 bool IRRegExpMacroAssembler::CanReadUnaligned() {
   return kEnableUnalignedAccesses && !slow_safe();
 }
 
-
 RawArray* IRRegExpMacroAssembler::Execute(const RegExp& regexp,
                                           const String& input,
                                           const Smi& start_offset,
                                           bool sticky,
                                           Zone* zone) {
   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 =
@@ skipping 14 matching lines @@
   }
 
   if (retval.IsNull()) {
     return Array::null();
   }
 
   ASSERT(retval.IsArray());
   return Array::Cast(retval).raw();
 }
 
-
 LocalVariable* IRRegExpMacroAssembler::Parameter(const String& name,
                                                  intptr_t index) const {
   LocalVariable* local =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             name, Object::dynamic_type());
 
   intptr_t param_frame_index = kParamEndSlotFromFp + kParamCount - index;
   local->set_index(param_frame_index);
 
   return local;
 }
 
-
 LocalVariable* IRRegExpMacroAssembler::Local(const String& name) {
   LocalVariable* local =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             name, Object::dynamic_type());
   local->set_index(GetNextLocalIndex());
 
   return local;
 }
 
-
 ConstantInstr* IRRegExpMacroAssembler::Int64Constant(int64_t value) const {
   return new (Z)
       ConstantInstr(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
 
-
 ConstantInstr* IRRegExpMacroAssembler::Uint64Constant(uint64_t value) const {
   return new (Z) ConstantInstr(
       Integer::ZoneHandle(Z, Integer::NewFromUint64(value, Heap::kOld)));
 }
 
-
 ConstantInstr* IRRegExpMacroAssembler::BoolConstant(bool value) const {
   return new (Z) ConstantInstr(value ? Bool::True() : Bool::False());
 }
 
-
 ConstantInstr* IRRegExpMacroAssembler::StringConstant(const char* value) const {
   return new (Z)
       ConstantInstr(String::ZoneHandle(Z, String::New(value, Heap::kOld)));
 }
 
-
 ConstantInstr* IRRegExpMacroAssembler::WordCharacterMapConstant() const {
   const Library& lib = Library::Handle(Z, Library::CoreLibrary());
   const Class& regexp_class =
       Class::Handle(Z, lib.LookupClassAllowPrivate(Symbols::_RegExp()));
   const Field& word_character_field = Field::ZoneHandle(
       Z,
       regexp_class.LookupStaticFieldAllowPrivate(Symbols::_wordCharacterMap()));
   ASSERT(!word_character_field.IsNull());
 
   if (word_character_field.IsUninitialized()) {
     ASSERT(!Compiler::IsBackgroundCompilation());
     word_character_field.EvaluateInitializer();
   }
   ASSERT(!word_character_field.IsUninitialized());
 
   return new (Z) ConstantInstr(
       Instance::ZoneHandle(Z, word_character_field.StaticValue()));
 }
 
-
 ComparisonInstr* IRRegExpMacroAssembler::Comparison(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:
@@ skipping 28 matching lines @@
 }
 
 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 (Z) ZoneGrowableArray<PushArgumentInstr*>(0);
   return StaticCall(function, arguments);
 }
 
-
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     PushArgumentInstr* arg1) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(arg1);
 
   return StaticCall(function, arguments);
 }
 
-
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     PushArgumentInstr* arg1,
     PushArgumentInstr* arg2) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(arg1);
   arguments->Add(arg2);
 
   return StaticCall(function, arguments);
 }
 
-
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
   const intptr_t kTypeArgsLen = 0;
   return new (Z) StaticCallInstr(TokenPosition::kNoSource, function,
                                  kTypeArgsLen, Object::null_array(), arguments,
                                  ic_data_array_, GetNextDeoptId());
 }
 
-
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(arg1);
 
   return InstanceCall(desc, arguments);
 }
 
-
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1,
     PushArgumentInstr* arg2) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(arg1);
   arguments->Add(arg2);
 
   return InstanceCall(desc, arguments);
 }
 
-
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1,
     PushArgumentInstr* arg2,
     PushArgumentInstr* arg3) const {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(arg1);
   arguments->Add(arg2);
   arguments->Add(arg3);
 
   return InstanceCall(desc, arguments);
 }
 
-
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
   const intptr_t kTypeArgsLen = 0;
   return new (Z) InstanceCallInstr(
       TokenPosition::kNoSource, desc.name, desc.token_kind, arguments,
       kTypeArgsLen, Object::null_array(), desc.checked_argument_count,
       ic_data_array_, GetNextDeoptId());
 }
 
-
 LoadLocalInstr* IRRegExpMacroAssembler::LoadLocal(LocalVariable* local) const {
   return new (Z) LoadLocalInstr(*local, TokenPosition::kNoSource);
 }
 
-
 void IRRegExpMacroAssembler::StoreLocal(LocalVariable* local, Value* value) {
   Do(new (Z) StoreLocalInstr(*local, value, TokenPosition::kNoSource));
 }
 
-
 void IRRegExpMacroAssembler::set_current_instruction(Instruction* instruction) {
   current_instruction_ = instruction;
 }
 
-
 Value* IRRegExpMacroAssembler::Bind(Definition* definition) {
   AppendInstruction(definition);
   definition->set_temp_index(temp_id_.Alloc());
 
   return new (Z) Value(definition);
 }
 
-
 void IRRegExpMacroAssembler::Do(Definition* definition) {
   AppendInstruction(definition);
 }
 
-
 Value* IRRegExpMacroAssembler::BindLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return Bind(new (Z) ConstantInstr(*local.ConstValue()));
   }
   ASSERT(!local.is_captured());
   return Bind(new (Z) LoadLocalInstr(local, TokenPosition::kNoSource));
 }
 
-
 // In some cases, the V8 irregexp engine generates unreachable code by emitting
 // a jmp not followed by a bind. We cannot do the same, since it is impossible
 // to append to a block following a jmp. In such cases, assume that we are doing
 // the correct thing, but output a warning when tracing.
 #define HANDLE_DEAD_CODE_EMISSION()                                            \
   if (current_instruction_ == NULL) {                                          \
     if (FLAG_trace_irregexp) {                                                 \
       OS::Print(                                                               \
           "WARNING: Attempting to append to a closed assembler. "              \
           "This could be either a bug or generation of dead code "             \
           "inherited from V8.\n");                                             \
     }                                                                          \
     BlockLabel dummy;                                                          \
     BindBlock(&dummy);                                                         \
   }
 
 void IRRegExpMacroAssembler::AppendInstruction(Instruction* instruction) {
   HANDLE_DEAD_CODE_EMISSION();
 
   ASSERT(current_instruction_ != NULL);
   ASSERT(current_instruction_->next() == NULL);
 
   temp_id_.Dealloc(instruction->InputCount());
   arg_id_.Dealloc(instruction->ArgumentCount());
 
   current_instruction_->LinkTo(instruction);
   set_current_instruction(instruction);
 }
 
-
 void IRRegExpMacroAssembler::CloseBlockWith(Instruction* instruction) {
   HANDLE_DEAD_CODE_EMISSION();
 
   ASSERT(current_instruction_ != NULL);
   ASSERT(current_instruction_->next() == NULL);
 
   temp_id_.Dealloc(instruction->InputCount());
   arg_id_.Dealloc(instruction->ArgumentCount());
 
   current_instruction_->LinkTo(instruction);
   set_current_instruction(NULL);
 }
 
-
 void IRRegExpMacroAssembler::GoTo(BlockLabel* to) {
   if (to == NULL) {
     Backtrack();
   } else {
     to->SetLinked();
     GoTo(to->block());
   }
 }
 
-
 // Closes the current block with a goto, and unsets current_instruction_.
 // BindBlock() must be called before emission can continue.
 void IRRegExpMacroAssembler::GoTo(JoinEntryInstr* to) {
   HANDLE_DEAD_CODE_EMISSION();
 
   ASSERT(current_instruction_ != NULL);
   ASSERT(current_instruction_->next() == NULL);
   current_instruction_->Goto(to);
   set_current_instruction(NULL);
 }
 
-
 PushArgumentInstr* IRRegExpMacroAssembler::PushArgument(Value* value) {
   arg_id_.Alloc();
   PushArgumentInstr* push = new (Z) PushArgumentInstr(value);
   // Do *not* use Do() for push argument instructions.
   AppendInstruction(push);
   return push;
 }
 
-
 PushArgumentInstr* IRRegExpMacroAssembler::PushLocal(LocalVariable* local) {
   return PushArgument(Bind(LoadLocal(local)));
 }
 
-
 void IRRegExpMacroAssembler::Print(const char* str) {
   Print(PushArgument(Bind(new (Z) ConstantInstr(
       String::ZoneHandle(Z, String::New(str, Heap::kOld))))));
 }
 
-
 void IRRegExpMacroAssembler::Print(PushArgumentInstr* argument) {
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Function& print_fn =
       Function::ZoneHandle(Z, lib.LookupFunctionAllowPrivate(Symbols::print()));
   Do(StaticCall(print_fn, argument));
 }
 
-
 void IRRegExpMacroAssembler::PrintBlocks() {
   for (intptr_t i = 0; i < blocks_.length(); i++) {
     FlowGraphPrinter::PrintBlock(blocks_[i], false);
   }
 }
 
-
 intptr_t IRRegExpMacroAssembler::stack_limit_slack() {
   return 32;
 }
 
-
 void IRRegExpMacroAssembler::AdvanceCurrentPosition(intptr_t by) {
   TAG();
   if (by != 0) {
     PushArgumentInstr* cur_pos_push = PushLocal(current_position_);
     PushArgumentInstr* by_push = PushArgument(Bind(Int64Constant(by)));
 
     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 < registers_count_);
 
   if (by != 0) {
     PushArgumentInstr* registers_push = PushLocal(registers_);
     PushArgumentInstr* index_push = PushRegisterIndex(reg);
     PushArgumentInstr* reg_push = PushArgument(LoadRegister(reg));
     PushArgumentInstr* by_push = PushArgument(Bind(Int64Constant(by)));
     PushArgumentInstr* value_push = PushArgument(Bind(Add(reg_push, by_push)));
     StoreRegister(registers_push, index_push, value_push);
   }
 }
 
-
 void IRRegExpMacroAssembler::Backtrack() {
   TAG();
   GoTo(backtrack_block_);
 }
 
-
 // A BindBlock is analogous to assigning a label to a basic block.
 // If the BlockLabel does not yet contain a block, it is created.
 // If there is a current instruction, append a goto to the bound block.
 void IRRegExpMacroAssembler::BindBlock(BlockLabel* label) {
   ASSERT(!label->IsBound());
   ASSERT(label->block()->next() == NULL);
 
   label->SetBound(block_id_.Alloc());
   blocks_.Add(label->block());
 
   if (current_instruction_ != NULL) {
     GoTo(label);
   }
   set_current_instruction(label->block());
 
   // Print the id of the current block if tracing.
   PRINT(PushArgument(Bind(Uint64Constant(label->block()->block_id()))));
 }
 
-
 intptr_t IRRegExpMacroAssembler::GetNextLocalIndex() {
   intptr_t id = local_id_.Alloc();
   return kFirstLocalSlotFromFp - id;
 }
 
-
 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));
 }
 
 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,
                                               BlockLabel* on_greater) {
   TAG();
   BranchOrBacktrack(
       Comparison(kGT, LoadLocal(current_character_), Uint64Constant(limit)),
       on_greater);
 }
 
-
 void IRRegExpMacroAssembler::CheckAtStart(BlockLabel* on_at_start) {
   TAG();
 
   BlockLabel not_at_start;
 
   // Did we start the match at the start of the string at all?
   BranchOrBacktrack(
       Comparison(kNE, LoadLocal(start_index_param_), Uint64Constant(0)),
       &not_at_start);
 
   // If we did, are we still 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);
 
   BindBlock(&not_at_start);
 }
 
-
 void IRRegExpMacroAssembler::CheckNotAtStart(BlockLabel* on_not_at_start) {
   TAG();
 
   // Did we start the match at the start of the string at all?
   BranchOrBacktrack(
       Comparison(kNE, LoadLocal(start_index_param_), Uint64Constant(0)),
       on_not_at_start);
 
   // If we did, are we still 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(kNE, neg_len_def, offset_def), on_not_at_start);
 }
 
-
 void IRRegExpMacroAssembler::CheckCharacterLT(uint16_t limit,
                                               BlockLabel* on_less) {
   TAG();
   BranchOrBacktrack(
       Comparison(kLT, LoadLocal(current_character_), Uint64Constant(limit)),
       on_less);
 }
 
-
 void IRRegExpMacroAssembler::CheckGreedyLoop(BlockLabel* on_equal) {
   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(NULL, on_equal);
 
   BindBlock(&fallthrough);
 }
 
-
 void IRRegExpMacroAssembler::CheckNotBackReferenceIgnoreCase(
     intptr_t start_reg,
     BlockLabel* on_no_match) {
   TAG();
   ASSERT(start_reg + 1 <= registers_count_);
 
   BlockLabel fallthrough;
 
   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)),
       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);
 
-
   // Check that there are sufficient characters left in the input.
   PushArgumentInstr* pos_push = PushLocal(current_position_);
   PushArgumentInstr* len_push = PushLocal(capture_length_);
   BranchOrBacktrack(
       Comparison(kGT,
                  InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD),
                               pos_push, len_push),
                  Uint64Constant(0)),
       on_no_match);
 
@@ skipping 101 matching lines @@
   BindBlock(&success);
 
   // Move current character position to position after match.
   PushArgumentInstr* 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);
 }
 
-
 void IRRegExpMacroAssembler::CheckNotBackReference(intptr_t start_reg,
                                                    BlockLabel* on_no_match) {
   TAG();
   ASSERT(start_reg + 1 <= registers_count_);
 
   BlockLabel fallthrough;
   BlockLabel success;
 
   // Find length of back-referenced capture.
   PushArgumentInstr* end_push = PushArgument(LoadRegister(start_reg + 1));
@@ skipping 60 matching lines @@
   BindBlock(&success);
 
   // Move current character position to position after match.
   PushArgumentInstr* 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);
 }
 
-
 void IRRegExpMacroAssembler::CheckNotCharacter(uint32_t c,
                                                BlockLabel* on_not_equal) {
   TAG();
   BranchOrBacktrack(
       Comparison(kNE, LoadLocal(current_character_), Uint64Constant(c)),
       on_not_equal);
 }
 
-
 void IRRegExpMacroAssembler::CheckCharacterAfterAnd(uint32_t c,
                                                     uint32_t mask,
                                                     BlockLabel* on_equal) {
   TAG();
 
   Definition* actual_def = LoadLocal(current_character_);
   Definition* expected_def = Uint64Constant(c);
 
   PushArgumentInstr* actual_push = PushArgument(Bind(actual_def));
   PushArgumentInstr* mask_push = PushArgument(Bind(Uint64Constant(mask)));
   actual_def = InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                             actual_push, mask_push);
 
   BranchOrBacktrack(Comparison(kEQ, actual_def, expected_def), on_equal);
 }
 
-
 void IRRegExpMacroAssembler::CheckNotCharacterAfterAnd(
     uint32_t c,
     uint32_t mask,
     BlockLabel* on_not_equal) {
   TAG();
 
   Definition* actual_def = LoadLocal(current_character_);
   Definition* expected_def = Uint64Constant(c);
 
   PushArgumentInstr* actual_push = PushArgument(Bind(actual_def));
   PushArgumentInstr* mask_push = PushArgument(Bind(Uint64Constant(mask)));
   actual_def = InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                             actual_push, mask_push);
 
   BranchOrBacktrack(Comparison(kNE, actual_def, expected_def), on_not_equal);
 }
 
-
 void IRRegExpMacroAssembler::CheckNotCharacterAfterMinusAnd(
     uint16_t c,
     uint16_t minus,
     uint16_t mask,
     BlockLabel* on_not_equal) {
   TAG();
   ASSERT(minus < Utf16::kMaxCodeUnit);  // NOLINT
 
   Definition* actual_def = LoadLocal(current_character_);
   Definition* expected_def = Uint64Constant(c);
 
   PushArgumentInstr* actual_push = PushArgument(Bind(actual_def));
   PushArgumentInstr* minus_push = PushArgument(Bind(Uint64Constant(minus)));
 
   actual_push = PushArgument(Bind(Sub(actual_push, minus_push)));
   PushArgumentInstr* mask_push = PushArgument(Bind(Uint64Constant(mask)));
   actual_def = InstanceCall(InstanceCallDescriptor::FromToken(Token::kBIT_AND),
                             actual_push, mask_push);
 
   BranchOrBacktrack(Comparison(kNE, actual_def, expected_def), on_not_equal);
 }
 
-
 void IRRegExpMacroAssembler::CheckCharacterInRange(uint16_t from,
                                                    uint16_t to,
                                                    BlockLabel* on_in_range) {
   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(NULL, on_in_range);
 
   BindBlock(&on_not_in_range);
 }
 
-
 void IRRegExpMacroAssembler::CheckCharacterNotInRange(
     uint16_t from,
     uint16_t to,
     BlockLabel* on_not_in_range) {
   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);
 }
 
-
 void IRRegExpMacroAssembler::CheckBitInTable(const TypedData& table,
                                              BlockLabel* on_bit_set) {
   TAG();
 
   PushArgumentInstr* table_push =
       PushArgument(Bind(new (Z) ConstantInstr(table)));
   PushArgumentInstr* index_push = PushLocal(current_character_);
 
   if (mode_ != ASCII || kTableMask != Symbols::kMaxOneCharCodeSymbol) {
     PushArgumentInstr* mask_push =
         PushArgument(Bind(Uint64Constant(kTableSize - 1)));
     index_push = PushArgument(
         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);
 }
 
-
 bool IRRegExpMacroAssembler::CheckSpecialCharacterClass(
     uint16_t type,
     BlockLabel* on_no_match) {
   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
@@ skipping 116 matching lines @@
       BranchOrBacktrack(NULL, on_no_match);
       BindBlock(&success);
       return true;
     }
     // No custom implementation (yet): s(uint16_t), S(uint16_t).
     default:
       return false;
   }
 }
 
-
 void IRRegExpMacroAssembler::Fail() {
   TAG();
   ASSERT(FAILURE == 0);  // Return value for failure is zero.
   if (!global()) {
     UNREACHABLE();  // Dart regexps are always global.
   }
   GoTo(exit_block_);
 }
 
-
 void IRRegExpMacroAssembler::IfRegisterGE(intptr_t reg,
                                           intptr_t comparand,
                                           BlockLabel* if_ge) {
   TAG();
   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();
   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();
   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_, Bind(PopStack()));
 }
 
-
 void IRRegExpMacroAssembler::PopRegister(intptr_t reg) {
   TAG();
   ASSERT(reg < registers_count_);
   PushArgumentInstr* registers_push = PushLocal(registers_);
   PushArgumentInstr* index_push = PushRegisterIndex(reg);
   PushArgumentInstr* pop_push = PushArgument(Bind(PopStack()));
   StoreRegister(registers_push, index_push, pop_push);
 }
 
-
 void IRRegExpMacroAssembler::PushStack(Definition* definition) {
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* stack_pointer_push = PushLocal(stack_pointer_);
   StoreLocal(stack_pointer_, Bind(Add(stack_pointer_push,
                                       PushArgument(Bind(Uint64Constant(1))))));
   stack_pointer_push = PushLocal(stack_pointer_);
   // TODO(zerny): bind value and push could break stack discipline.
   PushArgumentInstr* value_push = PushArgument(Bind(definition));
   Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                   stack_push, stack_pointer_push, value_push));
 }
 
-
 Definition* IRRegExpMacroAssembler::PopStack() {
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* stack_pointer_push1 = PushLocal(stack_pointer_);
   PushArgumentInstr* stack_pointer_push2 = PushLocal(stack_pointer_);
   StoreLocal(stack_pointer_, Bind(Sub(stack_pointer_push2,
                                       PushArgument(Bind(Uint64Constant(1))))));
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                       stack_push, stack_pointer_push1);
 }
 
-
 Definition* IRRegExpMacroAssembler::PeekStack() {
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* stack_pointer_push = PushLocal(stack_pointer_);
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kINDEX),
                       stack_push, stack_pointer_push);
 }
 
-
 // Pushes the location corresponding to label to the backtracking stack.
 void IRRegExpMacroAssembler::PushBacktrack(BlockLabel* label) {
   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();
 }
 
-
 void IRRegExpMacroAssembler::PushCurrentPosition() {
   TAG();
   PushStack(LoadLocal(current_position_));
 }
 
-
 void IRRegExpMacroAssembler::PushRegister(intptr_t reg) {
   TAG();
   // TODO(zerny): Refactor PushStack so it can be reused here.
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* stack_pointer_push = PushLocal(stack_pointer_);
   StoreLocal(stack_pointer_, Bind(Add(stack_pointer_push,
                                       PushArgument(Bind(Uint64Constant(1))))));
   stack_pointer_push = PushLocal(stack_pointer_);
   // TODO(zerny): bind value and push could break stack discipline.
   PushArgumentInstr* value_push = PushArgument(LoadRegister(reg));
   Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                   stack_push, stack_pointer_push, value_push));
   CheckStackLimit();
 }
 
-
 // Checks that (stack.capacity - stack_limit_slack) > stack_pointer.
 // This ensures that up to stack_limit_slack stack pushes can be
 // done without exhausting the stack space. If the check fails the
 // stack will be grown.
 void IRRegExpMacroAssembler::CheckStackLimit() {
   TAG();
   PushArgumentInstr* stack_push = PushLocal(stack_);
   PushArgumentInstr* length_push = PushArgument(
       Bind(InstanceCall(InstanceCallDescriptor(String::ZoneHandle(
                             Field::GetterSymbol(Symbols::Length()))),
                         stack_push)));
   PushArgumentInstr* capacity_push = PushArgument(Bind(Sub(
       length_push, PushArgument(Bind(Uint64Constant(stack_limit_slack()))))));
   PushArgumentInstr* stack_pointer_push = PushLocal(stack_pointer_);
   BranchInstr* branch = new (Z) BranchInstr(
       Comparison(kGT, capacity_push, stack_pointer_push), GetNextDeoptId());
   CloseBlockWith(branch);
 
   BlockLabel grow_stack;
   BlockLabel fallthrough;
   *branch->true_successor_address() = TargetWithJoinGoto(fallthrough.block());
   *branch->false_successor_address() = TargetWithJoinGoto(grow_stack.block());
 
   BindBlock(&grow_stack);
   GrowStack();
 
   BindBlock(&fallthrough);
 }
 
-
 void IRRegExpMacroAssembler::GrowStack() {
   TAG();
   const Library& lib = Library::Handle(Library::InternalLibrary());
   const Function& grow_function = Function::ZoneHandle(
       Z, lib.LookupFunctionAllowPrivate(Symbols::GrowRegExpStack()));
   StoreLocal(stack_, Bind(StaticCall(grow_function, PushLocal(stack_))));
 
   // Note: :stack and stack_array_cell content might diverge because each
   // instance of :matcher code has its own stack_array_cell embedded into it
   // as a constant but :stack is a local variable and its value might be
   // comming from OSR or deoptimization. This means we should never use
   // stack_array_cell in the body of the :matcher to reload the :stack.
   PushArgumentInstr* stack_cell_push =
       PushArgument(Bind(new (Z) ConstantInstr(stack_array_cell_)));
   PushArgumentInstr* index_push = PushArgument(Bind(Uint64Constant(0)));
   PushArgumentInstr* stack_push = PushLocal(stack_);
   Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                   stack_cell_push, index_push, stack_push));
 }
 
-
 void IRRegExpMacroAssembler::ReadCurrentPositionFromRegister(intptr_t reg) {
   TAG();
   StoreLocal(current_position_, LoadRegister(reg));
 }
 
 // Resets the tip of the stack to the value stored in reg.
 void IRRegExpMacroAssembler::ReadStackPointerFromRegister(intptr_t reg) {
   TAG();
   ASSERT(reg < registers_count_);
   StoreLocal(stack_pointer_, LoadRegister(reg));
@@ skipping 13 matching lines @@
   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);
 }
 
-
 void IRRegExpMacroAssembler::SetRegister(intptr_t reg, intptr_t to) {
   TAG();
   // Reserved for positions!
   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* 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.
   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);
 
   // 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_);
     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* tip_push = PushLocal(stack_pointer_);
   StoreRegister(registers_push, index_push, tip_push);
 }
 
-
 // Private methods:
 
-
 void IRRegExpMacroAssembler::CheckPosition(intptr_t cp_offset,
                                            BlockLabel* on_outside_input) {
   TAG();
   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);
 }
 
-
 void IRRegExpMacroAssembler::BranchOrBacktrack(ComparisonInstr* comparison,
                                                BlockLabel* true_successor) {
   if (comparison == NULL) {  // No condition
     if (true_successor == NULL) {
       Backtrack();
       return;
     }
     GoTo(true_successor);
     return;
   }
@@ skipping 10 matching lines @@
   BlockLabel fallthrough;
 
   BranchInstr* branch = new (Z) BranchInstr(comparison, GetNextDeoptId());
   *branch->true_successor_address() = TargetWithJoinGoto(true_successor_block);
   *branch->false_successor_address() = TargetWithJoinGoto(fallthrough.block());
 
   CloseBlockWith(branch);
   BindBlock(&fallthrough);
 }
 
-
 TargetEntryInstr* IRRegExpMacroAssembler::TargetWithJoinGoto(
     JoinEntryInstr* dst) {
   TargetEntryInstr* target = new (Z)
       TargetEntryInstr(block_id_.Alloc(), kInvalidTryIndex, GetNextDeoptId());
   blocks_.Add(target);
 
   target->AppendInstruction(new (Z) GotoInstr(dst, GetNextDeoptId()));
 
   return target;
 }
 
-
 IndirectEntryInstr* IRRegExpMacroAssembler::IndirectWithJoinGoto(
     JoinEntryInstr* dst) {
   IndirectEntryInstr* target =
       new (Z) IndirectEntryInstr(block_id_.Alloc(), indirect_id_.Alloc(),
                                  kInvalidTryIndex, GetNextDeoptId());
   blocks_.Add(target);
 
   target->AppendInstruction(new (Z) GotoInstr(dst, GetNextDeoptId()));
 
   return target;
 }
 
-
 void IRRegExpMacroAssembler::CheckPreemption(bool is_backtrack) {
   TAG();
 
   // We don't have the loop_depth available when compiling regexps, but
   // we set loop_depth to a non-zero value because this instruction does
   // not act as an OSR entry outside loops.
   AppendInstruction(new (Z) CheckStackOverflowInstr(
       TokenPosition::kNoSource,
       /*loop_depth=*/1, GetNextDeoptId(),
       is_backtrack ? CheckStackOverflowInstr::kOsrAndPreemption
                    : CheckStackOverflowInstr::kOsrOnly));
 }
 
-
 Definition* IRRegExpMacroAssembler::Add(PushArgumentInstr* lhs,
                                         PushArgumentInstr* rhs) {
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD), lhs, rhs);
 }
 
-
 Definition* IRRegExpMacroAssembler::Sub(PushArgumentInstr* lhs,
                                         PushArgumentInstr* rhs) {
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kSUB), lhs, rhs);
 }
 
-
 void IRRegExpMacroAssembler::LoadCurrentCharacterUnchecked(
     intptr_t cp_offset,
     intptr_t characters) {
   TAG();
 
   ASSERT(characters == 1 || CanReadUnaligned());
   if (mode_ == ASCII) {
     ASSERT(characters == 1 || characters == 2 || characters == 4);
   } else {
     ASSERT(mode_ == UC16);
@@ skipping 10 matching lines @@
       PushArgument(BindLoadLocal(*string_param_length_));
   // Index is stored in a temporary local so that we can later load it safely.
   StoreLocal(index_temp_, Bind(Add(off_pos_arg, len_arg)));
 
   // Load and store the code units.
   Value* code_unit_value = LoadCodeUnitsAt(index_temp_, characters);
   StoreLocal(current_character_, code_unit_value);
   PRINT(PushLocal(current_character_));
 }
 
-
 Value* IRRegExpMacroAssembler::CharacterAt(LocalVariable* index) {
   return LoadCodeUnitsAt(index, 1);
 }
 
-
 Value* IRRegExpMacroAssembler::LoadCodeUnitsAt(LocalVariable* index,
                                                intptr_t characters) {
   // Bind the pattern as the load receiver.
   Value* pattern_val = BindLoadLocal(*string_param_);
   if (RawObject::IsExternalStringClassId(specialization_cid_)) {
     // The data of an external string is stored through two indirections.
     intptr_t external_offset = 0;
     intptr_t data_offset = 0;
     if (specialization_cid_ == kExternalOneByteStringCid) {
       external_offset = ExternalOneByteString::external_data_offset();
@@ skipping 13 matching lines @@
   }
 
   // Here pattern_val might be untagged so this must not trigger a GC.
   Value* index_val = BindLoadLocal(*index);
 
   return Bind(new (Z) LoadCodeUnitsInstr(pattern_val, index_val, characters,
                                          specialization_cid_,
                                          TokenPosition::kNoSource));
 }
 
-
 #undef __
 
 }  // namespace dart