Inline native String.charCodeAt in optimized code.

runtime/vm/intermediate_language_x64.cc

 // Copyright (c) 2012, 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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 933 matching lines @@
 
 static bool CanBeImmediateIndex(Value* index) {
   if (!index->definition()->IsConstant()) return false;
   const Object& constant = index->definition()->AsConstant()->value();
   const Smi& smi_const = Smi::Cast(constant);
   int64_t disp = smi_const.AsInt64Value() * kWordSize + sizeof(RawArray);
   return Utils::IsInt(32, disp);
 }
 
 
+LocationSummary* StringCharCodeAtInstr::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, Location::RequiresRegister());
+  // TODO(fschneider): Allow immediate operands for the index.
+  locs->set_in(1, Location::RequiresRegister());
+  locs->set_out(Location::RequiresRegister());
+  return locs;
+}
+
+
+void StringCharCodeAtInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register str = locs()->in(0).reg();
+  Register index = locs()->in(1).reg();
+  Register result = locs()->out().reg();
+
+  ASSERT((class_id() == kOneByteStringCid) ||
+         (class_id() == kTwoByteStringCid));
+  if (class_id() == kOneByteStringCid) {
+    __ SmiUntag(index);
+    __ movzxb(result, FieldAddress(str,
+                                   index,
+                                   TIMES_1,
+                                   OneByteString::data_offset()));
+    __ SmiTag(index);  // Retag index.
+    __ SmiTag(result);
+  } else {
+    // Don't untag smi-index and use TIMES_1 for two byte strings.
+    __ movzxw(result, FieldAddress(str,
+                                   index,
+                                   TIMES_1,
+                                   TwoByteString::data_offset()));
+    __ SmiTag(result);
+  }
+}
+
+
 LocationSummary* LoadIndexedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_in(1, CanBeImmediateIndex(index())
                     ? Location::RegisterOrConstant(index())
                     : Location::RequiresRegister());
   if (representation() == kUnboxedDouble) {
@@ skipping 1260 matching lines @@
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_in(1, Location::RegisterOrConstant(index()));
   return locs;
 }
 
 
 void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const DeoptReasonId deopt_reason =
-      (array_type() == kGrowableObjectArrayCid) ?
-          kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        deopt_reason);
-  ASSERT((array_type() == kArrayCid) ||
-         (array_type() == kImmutableArrayCid) ||
-         (array_type() == kGrowableObjectArrayCid) ||
-         (array_type() == kFloat64ArrayCid) ||
-         (array_type() == kFloat32ArrayCid));
-  intptr_t length_offset = -1;
-  if (array_type() == kGrowableObjectArrayCid) {
-    length_offset = GrowableObjectArray::length_offset();
-  } else if (array_type() == kFloat64ArrayCid) {
-    length_offset = Float64Array::length_offset();
-  } else if (array_type() == kFloat32ArrayCid) {
-    length_offset = Float32Array::length_offset();
-  } else {
-    length_offset = Array::length_offset();
+                                        kDeoptCheckArrayBound);
+  if (locs()->in(0).IsConstant() && locs()->in(1).IsConstant()) {
+    // Unconditionally deoptimize for constant bounds checks because they
+    // only occur only when index is out-of-bounds.
+    __ jmp(deopt);
+    return;
   }
 
-  // This case should not have created a bound check instruction.
-  ASSERT(!(locs()->in(0).IsConstant() && locs()->in(1).IsConstant()));
 
+  intptr_t length_offset = LengthOffsetFor(array_type());
   if (locs()->in(1).IsConstant()) {
     Register receiver = locs()->in(0).reg();
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int64_t imm =
         reinterpret_cast<int64_t>(constant.raw());
     __ cmpq(FieldAddress(receiver, length_offset), Immediate(imm));
     __ j(BELOW_EQUAL, deopt);
   } else if (locs()->in(0).IsConstant()) {
-    const Object& constant = locs()->in(0).constant();
-    ASSERT(constant.IsArray());
-    const Array& array =  Array::Cast(constant);
+    ASSERT(locs()->in(0).constant().IsArray() ||
+           locs()->in(0).constant().IsString());
+    intptr_t length = locs()->in(0).constant().IsArray()
+        ? Array::Cast(locs()->in(0).constant()).Length()
+        : String::Cast(locs()->in(0).constant()).Length();
     Register index = locs()->in(1).reg();
     __ cmpq(index,
-        Immediate(reinterpret_cast<int64_t>(Smi::New(array.Length()))));
+        Immediate(reinterpret_cast<int64_t>(Smi::New(length))));
     __ j(ABOVE_EQUAL, deopt);
   } else {
     Register receiver = locs()->in(0).reg();
     Register index = locs()->in(1).reg();
     __ cmpq(index, FieldAddress(receiver, length_offset));
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
@@ skipping 49 matching lines @@
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64