Support use of external strings as inputs to LoadCodeUnitsInstr.

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 140 matching lines @@
   stack_ = Local(Symbols::stack());
   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);
   }
@@ skipping 766 matching lines @@
   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(LoadLocal(capture_start_index_)));
-    StoreLocal(char_in_match_, CharacterAt(LoadLocal(match_start_index_)));
+    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).
     PushArgumentInstr* match_char_push = PushLocal(char_in_match_);
     PushArgumentInstr* mask_push = PushArgument(Bind(Uint64Constant(0x20)));
     StoreLocal(char_in_match_,
@@ skipping 139 matching lines @@
   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(LoadLocal(capture_start_index_)));
-  StoreLocal(char_in_match_, CharacterAt(LoadLocal(match_start_index_)));
+  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.
   PushArgumentInstr* index_push = PushLocal(capture_start_index_);
   PushArgumentInstr* inc_push = PushArgument(Bind(Uint64Constant(1)));
   StoreLocal(capture_start_index_, Bind(Add(index_push, inc_push)));
@@ skipping 638 matching lines @@
   TAG();
 
   ASSERT(characters == 1 || CanReadUnaligned());
   if (mode_ == ASCII) {
     ASSERT(characters == 1 || characters == 2 || characters == 4);
   } else {
     ASSERT(mode_ == UC16);
     ASSERT(characters == 1 || characters == 2);
   }
 
-  // Bind the pattern as the load receiver.
-  Value* pattern = BindLoadLocal(*string_param_);
-
   // Calculate the addressed string index as:
   //    cp_offset + current_position_ + string_param_length_
   // TODO(zerny): Avoid generating 'add' instance-calls here.
   PushArgumentInstr* off_arg =
       PushArgument(Bind(Int64Constant(cp_offset)));
   PushArgumentInstr* pos_arg =
       PushArgument(BindLoadLocal(*current_position_));
   PushArgumentInstr* off_pos_arg =
       PushArgument(Bind(Add(off_arg, pos_arg)));
   PushArgumentInstr* len_arg =
       PushArgument(BindLoadLocal(*string_param_length_));
-  Value* index = Bind(Add(off_pos_arg, len_arg));
+  // 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(pattern, index, characters);
+  Value* code_unit_value = LoadCodeUnitsAt(index_temp_, characters);
   StoreLocal(current_character_, code_unit_value);
   PRINT(PushLocal(current_character_));
 }
 
 
-Value* IRRegExpMacroAssembler::CharacterAt(Definition* index) {
-  Value* pattern_val = BindLoadLocal(*string_param_);
-  Value* index_val = Bind(index);
-  return LoadCodeUnitsAt(pattern_val, index_val, 1);
+Value* IRRegExpMacroAssembler::CharacterAt(LocalVariable* index) {
+  return LoadCodeUnitsAt(index, 1);
 }
 
 
-// Note: We can't replace pattern with a load-local of string_param_
-// because we need to maintain the stack discipline in unoptimized code.
-Value* IRRegExpMacroAssembler::LoadCodeUnitsAt(Value* pattern,
-                                               Value* index,
+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;
+    intptr_t data_offset;
+    if (specialization_cid_ == kExternalOneByteStringCid) {
+      external_offset = ExternalOneByteString::external_data_offset();
+      data_offset = RawExternalOneByteString::ExternalData::data_offset();
+    } else if (specialization_cid_ == kExternalTwoByteStringCid) {
+      external_offset = ExternalTwoByteString::external_data_offset();
+      data_offset = RawExternalTwoByteString::ExternalData::data_offset();
+    } else {
+      UNREACHABLE();
+    }
+    // This pushes untagged values on the stack which are immediately consumed:
+    // the first value is consumed to obtain the second value which is consumed
+    // by LoadCodeUnitsAtInstr below.
+    Value* external_val =
+        Bind(new(I) LoadUntaggedInstr(pattern_val, external_offset));
+    pattern_val =
+        Bind(new(I) LoadUntaggedInstr(external_val, data_offset));
+  }
+
+  // Here pattern_val might be untagged so this must not trigger a GC.
+  Value* index_val = BindLoadLocal(*index);
+
   return Bind(new(I) LoadCodeUnitsInstr(
-      pattern,
-      index,
+      pattern_val,
+      index_val,
       characters,
       specialization_cid_,
       Scanner::kNoSourcePos));
 }
 
 
 #undef __
 
 }  // namespace dart