Support use of external strings as inputs to LoadCodeUnitsInstr.

runtime/vm/intermediate_language_mips.cc

 // Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 1004 matching lines @@
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(isolate,
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register object = locs()->in(0).reg();
+  Register obj = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
-  __ LoadFromOffset(result, object, offset() - kHeapObjectTag);
+  if (object()->definition()->representation() == kUntagged) {
+    __ LoadFromOffset(result, obj, offset());
+  } else {
+    ASSERT(object()->definition()->representation() == kTagged);
+    __ LoadFieldFromOffset(result, obj, offset());
+  }
 }
 
 
 LocationSummary* LoadClassIdInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(isolate,
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
@@ skipping 214 matching lines @@
 
   // TODO(zerny): Handle mints properly once possible.
   ASSERT(representation() == kTagged);
   summary->set_out(0, Location::RequiresRegister());
 
   return summary;
 }
 
 
 void LoadCodeUnitsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const Register array = locs()->in(0).reg();
+  // The string register points to the backing store for external strings.
+  const Register str = locs()->in(0).reg();
   const Location index = locs()->in(1);
 
   Address element_address = __ ElementAddressForRegIndex(
-        true, IsExternal(), class_id(), index_scale(), array, index.reg());
+        true, IsExternal(), class_id(), index_scale(), str, index.reg());
   // Warning: element_address may use register TMP as base.
 
   ASSERT(representation() == kTagged);
   Register result = locs()->out(0).reg();
   switch (class_id()) {
     case kOneByteStringCid:
+    case kExternalOneByteStringCid:
       switch (element_count()) {
         case 1: __ lbu(result, element_address); break;
         case 2: __ lhu(result, element_address); break;
         case 4:  // Loading multiple code units is disabled on MIPS.
         default: UNREACHABLE();
       }
       __ SmiTag(result);
       break;
     case kTwoByteStringCid:
+    case kExternalTwoByteStringCid:
       switch (element_count()) {
         case 1: __ lhu(result, element_address); break;
         case 2:  // Loading multiple code units is disabled on MIPS.
         default: UNREACHABLE();
       }
       __ SmiTag(result);
       break;
     default:
       UNREACHABLE();
       break;
@@ skipping 942 matching lines @@
       __ lw(temp, FieldAddress(instance_reg, offset_in_bytes()));
       __ LoadDFromOffset(value, temp, Double::value_offset() - kHeapObjectTag);
       __ StoreDToOffset(value,
                         result_reg,
                         Double::value_offset() - kHeapObjectTag);
       __ b(&done);
     }
 
     __ Bind(&load_pointer);
   }
-  __ LoadFromOffset(
-      result_reg, instance_reg, offset_in_bytes() - kHeapObjectTag);
+  __ LoadFieldFromOffset(result_reg, instance_reg, offset_in_bytes());
   __ Bind(&done);
 }
 
 
 LocationSummary* InstantiateTypeInstr::MakeLocationSummary(Isolate* isolate,
                                                            bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
@@ skipping 1058 matching lines @@
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 static void LoadInt32FromMint(FlowGraphCompiler* compiler,
                               Register mint,
                               Register result,
                               Label* deopt) {
-  __ LoadFromOffset(result,
-                    mint,
-                    Mint::value_offset() - kHeapObjectTag);
+  __ LoadFieldFromOffset(result, mint, Mint::value_offset());
   if (deopt != NULL) {
-    __ LoadFromOffset(CMPRES1,
-                      mint,
-                      Mint::value_offset() - kHeapObjectTag + kWordSize);
+    __ LoadFieldFromOffset(CMPRES1,
+                           mint,
+                           Mint::value_offset() + kWordSize);
     __ sra(CMPRES2, result, kBitsPerWord - 1);
     __ BranchNotEqual(CMPRES1, CMPRES2, deopt);
   }
 }
 
 
 void UnboxInteger32Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const Register out = locs()->out(0).reg();
@@ skipping 1618 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(S4, kInvalidObjectPointer);
   __ LoadImmediate(S5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS