Inline native String.charCodeAt in optimized code.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 452 matching lines @@
                                               Value** index) {
   *array = call->ArgumentAt(0)->value();
   *index = call->ArgumentAt(1)->value();
   // Insert class check and index smi checks and attach a copy of the
   // original environment because the operation can still deoptimize.
   AddCheckClass(call, (*array)->Copy());
   InsertBefore(call,
                new CheckSmiInstr((*index)->Copy(), call->deopt_id()),
                call->env(),
                Definition::kEffect);
-  // If both index and array are constants, then the bound check always
-  // succeeded.
-  // TODO(srdjan): Remove once constant propagation lands.
-  if (!((*array)->BindsToConstant() && (*index)->BindsToConstant())) {
+  // If both index and array are constants, then do a compile-time check.
+  // TODO(srdjan): Remove once constant propagation handles bounds checks.
+  bool skip_check = false;
+  if ((*array)->BindsToConstant() && (*index)->BindsToConstant()) {
+    ConstantInstr* array_def = (*array)->definition()->AsConstant();
+    const ImmutableArray& constant_array =
+        ImmutableArray::Cast(array_def->value());
+    ConstantInstr* index_def = (*index)->definition()->AsConstant();
+    intptr_t constant_index = Smi::Cast(index_def->value()).Value();
+    skip_check = (constant_index < constant_array.Length());
+  }

[srdjan, 2012/11/01 20:32:18]

I get a crash with following code. Can you please check if it works and add it
to your tests:

main() {
  for (int i = 0; i < 10000; i++) { foo(1); }
  foo(2);
}

foo(a) {
  if (a == 1) { return 2; }
  var aa = const [1, 2];
  return aa[2.3];
}

[Florian Schneider, 2012/11/01 22:58:56]

Good point. I added the test and fixed the non-smi index case for strings and
arrays.

+  if (!skip_check) {
     // Insert array bounds check.
     InsertBefore(call,
                  new CheckArrayBoundInstr((*array)->Copy(),
                                           (*index)->Copy(),
                                           class_id,
                                           call),
                  call->env(),
                  Definition::kEffect);
   }
   if (class_id == kGrowableObjectArrayCid) {
@@ skipping 602 matching lines @@
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
+  if ((recognized_kind == MethodRecognizer::kStringBaseCharCodeAt) &&
+      (ic_data.NumberOfChecks() == 1) &&
+      ((class_ids[0] == kOneByteStringCid) ||
+       (class_ids[0] == kTwoByteStringCid))) {
+    Value* str= call->ArgumentAt(0)->value();
+    Value* index = call->ArgumentAt(1)->value();
+    AddCheckClass(call, str->Copy());
+    InsertBefore(call,
+                 new CheckSmiInstr(index->Copy(), call->deopt_id()),
+                 call->env(),
+                 Definition::kEffect);
+    // If both index and string are constants, then do a compile-time check.
+    // TODO(srdjan): Remove once constant propagation handles bounds checks.
+    bool skip_check = false;
+    if (str->BindsToConstant() && index->BindsToConstant()) {
+      ConstantInstr* string_def = str->definition()->AsConstant();
+      const String& constant_string =
+          String::Cast(string_def->value());
+      ConstantInstr* index_def = index->definition()->AsConstant();
+      intptr_t constant_index = Smi::Cast(index_def->value()).Value();
+      skip_check = (constant_index < constant_string.Length());
+    }
+    if (!skip_check) {
+      // Insert bounds check.
+      InsertBefore(call,
+                   new CheckArrayBoundInstr(str->Copy(),
+                                            index->Copy(),
+                                            class_ids[0],
+                                            call),
+                   call->env(),
+                   Definition::kEffect);
+    }
+    StringCharCodeAtInstr* instr =
+        new StringCharCodeAtInstr(str, index, class_ids[0]);
+    call->ReplaceWith(instr, current_iterator());
+    RemovePushArguments(call);
+    return true;
+  }
 
   if ((recognized_kind == MethodRecognizer::kIntegerToDouble) &&
       (class_ids[0] == kSmiCid)) {
     SmiToDoubleInstr* s2d_instr = new SmiToDoubleInstr(call);
     call->ReplaceWith(s2d_instr, current_iterator());
     // Pushed arguments are not removed because SmiToDouble is implemented
     // as a call.
     return true;
   }
 
@@ skipping 2114 matching lines @@
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitNativeCall(NativeCallInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitStringCharCodeAt(StringCharCodeAtInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitLoadIndexed(LoadIndexedInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitStoreIndexed(StoreIndexedInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
@@ skipping 412 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart