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 595 matching lines @@
 
 Value* IRRegExpMacroAssembler::BindLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return Bind(new(I) ConstantInstr(*local.ConstValue()));
   }
   ASSERT(!local.is_captured());
   return Bind(new(I) LoadLocalInstr(local));
 }
 
 
+Value* IRRegExpMacroAssembler::BindUntaggedExternalString(
+    const LocalVariable& str) {
+  Value* str_val = BindLoadLocal(str);
+  if (!RawObject::IsExternalStringClassId(specialization_cid_)) {
+    return str_val;
+  }
+  // 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 = RawExternalOneByteString::data_offset();
+    data_offset = RawExternalOneByteString::ExternalData::data_offset();
+  } else if (specialization_cid_ == kExternalTwoByteStringCid) {
+    external_offset = RawExternalTwoByteString::data_offset();
+    data_offset = RawExternalTwoByteString::ExternalData::data_offset();
+  } else {
+    UNREACHABLE();
+  }
+  Value* external_val =
+      Bind(new(I) LoadUntaggedInstr(str_val, external_offset));
+  Value* data_val =
+      Bind(new(I) LoadUntaggedInstr(external_val, data_offset));
+  return data_val;
+}
+
+
 // 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"); \
@@ skipping 1133 matching lines @@
 
   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_);
+  Value* pattern = BindUntaggedExternalString(*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));
 
   // Load and store the code units.
   Value* code_unit_value = LoadCodeUnitsAt(pattern, index, characters);
   StoreLocal(current_character_, code_unit_value);
   PRINT(PushLocal(current_character_));
 }
 
 
 Value* IRRegExpMacroAssembler::CharacterAt(Definition* index) {
-  Value* pattern_val = BindLoadLocal(*string_param_);
+  Value* pattern_val = BindUntaggedExternalString(*string_param_);
   Value* index_val = Bind(index);
   return LoadCodeUnitsAt(pattern_val, index_val, 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,
                                                intptr_t characters) {
   return Bind(new(I) LoadCodeUnitsInstr(
       pattern,
       index,
       characters,
       specialization_cid_,
       Scanner::kNoSourcePos));
 }
 
 
 #undef __
 
 }  // namespace dart