Inline String isEmpty, refactor inlining of intrinsics.

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/hash_map.h"
@@ skipping 608 matching lines @@
     ZoneGrowableArray<Function*>* overriding_functions =
         CHA::GetNamedInstanceFunctionsOf(*subclass_cids, call->function_name());
     if (overriding_functions->is_empty()) {
       // No overriding functions.
       return false;
     }
   }
   return true;
 }
 
+
+void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
+  ASSERT(call->HasICData());
+  const ICData& ic_data = *call->ic_data();
+  Function& target = Function::Handle();
+  GrowableArray<intptr_t> class_ids;
+  ic_data.GetCheckAt(0, &class_ids, &target);
+  ASSERT(class_ids.length() == 1);
+  // Inline implicit instance getter.
+  const String& field_name =
+      String::Handle(Field::NameFromGetter(call->function_name()));
+  const Field& field = Field::Handle(GetField(class_ids[0], field_name));
+  ASSERT(!field.IsNull());
+
+  if (InstanceCallNeedsClassCheck(call)) {
+    AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+  }
+  // Detach environment from the original instruction because it can't
+  // deoptimize.
+  call->set_env(NULL);
+  LoadFieldInstr* load = new LoadFieldInstr(
+      call->ArgumentAt(0)->value(),
+      field.Offset(),
+      AbstractType::ZoneHandle(field.type()));
+  call->ReplaceWith(load, current_iterator());
+  RemovePushArguments(call);
+}
+
+
+void FlowGraphOptimizer::InlineArrayLengthGetter(InstanceCallInstr* call,
+                                                 intptr_t length_offset,
+                                                 bool is_immutable) {
+  // Check receiver class.
+  AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+
+  LoadFieldInstr* load = new LoadFieldInstr(
+      call->ArgumentAt(0)->value(),
+      length_offset,
+      Type::ZoneHandle(Type::SmiType()),
+      is_immutable);
+  load->set_result_cid(kSmiCid);
+  call->ReplaceWith(load, current_iterator());
+  RemovePushArguments(call);
+}
+
+
+void FlowGraphOptimizer::InlineGArrayCapacityGetter(InstanceCallInstr* call) {
+  // Check receiver class.
+  AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+
+  // TODO(srdjan): type of load should be GrowableObjectArrayType.
+  LoadFieldInstr* data_load = new LoadFieldInstr(
+      call->ArgumentAt(0)->value(),
+      Array::data_offset(),
+      Type::ZoneHandle(Type::DynamicType()));
+  data_load->set_result_cid(kArrayCid);
+  InsertBefore(call, data_load, NULL, Definition::kValue);
+
+  LoadFieldInstr* length_load = new LoadFieldInstr(
+      new Value(data_load),
+      Array::length_offset(),
+      Type::ZoneHandle(Type::SmiType()));
+  length_load->set_result_cid(kSmiCid);
+
+  call->ReplaceWith(length_load, current_iterator());
+  RemovePushArguments(call);
+}
+
+
+void FlowGraphOptimizer::InlineStringLengthGetter(InstanceCallInstr* call) {
+  // Check receiver class.
+  AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+
+  const bool is_immutable = true;  // String length is immutable.
+  LoadFieldInstr* load = new LoadFieldInstr(
+      call->ArgumentAt(0)->value(),
+      String::length_offset(),
+      Type::ZoneHandle(Type::SmiType()),
+      is_immutable);
+  load->set_result_cid(kSmiCid);
+  call->ReplaceWith(load, current_iterator());
+  RemovePushArguments(call);
+}
+
+
+void FlowGraphOptimizer::InlineStringIsEmptyTester(InstanceCallInstr* call) {
+  // Check receiver class.
+  AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+  // Get string length.
+  const bool is_immutable = true;  // String length is immutable.
+  LoadFieldInstr* load = new LoadFieldInstr(
+      call->ArgumentAt(0)->value(),
+      String::length_offset(),
+      Type::ZoneHandle(Type::SmiType()),
+      is_immutable);
+  load->set_result_cid(kSmiCid);

[Florian Schneider, 2012/09/26 08:36:12]

Maybe you can even share the code for building the .length load between here and
InlineStringLengthGetter above using a helper BuildLoadStringLength.

[srdjan, 2012/09/28 16:56:56]

Done.

+  InsertBefore(call, load, NULL, Definition::kValue);
+
+  ConstantInstr* zero = new ConstantInstr(Smi::Handle(Smi::New(0)));
+  InsertBefore(call, zero, NULL, Definition::kValue);
+
+  StrictCompareInstr* compare =
+      new StrictCompareInstr(Token::kEQ_STRICT,
+                             new Value(load),
+                             new Value(zero));
+  call->ReplaceWith(compare, current_iterator());
+  RemovePushArguments(call);
+}
+
+
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
-  Function& target = Function::Handle();
-  GrowableArray<intptr_t> class_ids;
-  ic_data.GetCheckAt(0, &class_ids, &target);
-  ASSERT(class_ids.length() == 1);
-
+  Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (target.kind() == RawFunction::kImplicitGetter) {
     if (!ic_data.HasOneTarget()) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
-    // Inline implicit instance getter.
-    const String& field_name =
-        String::Handle(Field::NameFromGetter(call->function_name()));
-    const Field& field = Field::Handle(GetField(class_ids[0], field_name));
-    ASSERT(!field.IsNull());
-
-    if (InstanceCallNeedsClassCheck(call)) {
-      AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-    }
-    // Detach environment from the original instruction because it can't
-    // deoptimize.
-    call->set_env(NULL);
-    LoadFieldInstr* load = new LoadFieldInstr(
-        call->ArgumentAt(0)->value(),
-        field.Offset(),
-        AbstractType::ZoneHandle(field.type()));
-    call->ReplaceWith(load, current_iterator());
-    RemovePushArguments(call);
+    InlineImplicitInstanceGetter(call);
     return true;
   }
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
   if ((recognized_kind == MethodRecognizer::kObjectArrayLength) ||
       (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
       (recognized_kind == MethodRecognizer::kGrowableArrayLength)) {
     if (!ic_data.HasOneTarget()) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
-    intptr_t length_offset = -1;
-    bool is_immutable = false;
     switch (recognized_kind) {
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
-        length_offset = Array::length_offset();
-        is_immutable = true;
+        InlineArrayLengthGetter(call, Array::length_offset(), true);
         break;
       case MethodRecognizer::kGrowableArrayLength:
-        length_offset = GrowableObjectArray::length_offset();
+        InlineArrayLengthGetter(call,
+                                GrowableObjectArray::length_offset(),
+                                false);
         break;
       default:
         UNREACHABLE();
     }
-    // Check receiver class.
-    AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-
-    LoadFieldInstr* load = new LoadFieldInstr(
-        call->ArgumentAt(0)->value(),
-        length_offset,
-        Type::ZoneHandle(Type::SmiType()),
-        is_immutable);
-    load->set_result_cid(kSmiCid);
-    call->ReplaceWith(load, current_iterator());
-    RemovePushArguments(call);
     return true;
   }
 
   if (recognized_kind == MethodRecognizer::kGrowableArrayCapacity) {
-    // Check receiver class.
-    AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-
-    // TODO(srdjan): type of load should be GrowableObjectArrayType.
-    LoadFieldInstr* data_load = new LoadFieldInstr(
-        call->ArgumentAt(0)->value(),
-        Array::data_offset(),
-        Type::ZoneHandle(Type::DynamicType()));
-    data_load->set_result_cid(kArrayCid);
-    InsertBefore(call, data_load, NULL, Definition::kValue);
-
-    LoadFieldInstr* length_load = new LoadFieldInstr(
-        new Value(data_load),
-        Array::length_offset(),
-        Type::ZoneHandle(Type::SmiType()));
-    length_load->set_result_cid(kSmiCid);
-
-    call->ReplaceWith(length_load, current_iterator());
-    RemovePushArguments(call);
+    InlineGArrayCapacityGetter(call);
     return true;
   }
 
   if (recognized_kind == MethodRecognizer::kStringBaseLength) {
     if (!ic_data.HasOneTarget()) {
       // Target is not only StringBase_get_length.
       return false;
     }
-    // Check receiver class.
-    AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-
-    const bool is_immutable = true;  // String length is immutable.
-    LoadFieldInstr* load = new LoadFieldInstr(
-        call->ArgumentAt(0)->value(),
-        String::length_offset(),
-        Type::ZoneHandle(Type::SmiType()),
-        is_immutable);
-    load->set_result_cid(kSmiCid);
-    call->ReplaceWith(load, current_iterator());
-    RemovePushArguments(call);
+    InlineStringLengthGetter(call);
     return true;
   }
+
   return false;
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected.
     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::kDoubleToDouble) &&
       (class_ids[0] == kDoubleCid)) {
     DoubleToDoubleInstr* d2d_instr =
         new DoubleToDoubleInstr(call->ArgumentAt(0)->value(), call);
     call->ReplaceWith(d2d_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;
   }
+
+  if (recognized_kind == MethodRecognizer::kStringBaseIsEmpty) {
+    if (!ic_data.HasOneTarget()) {
+      // Target is not only StringBase_get_length.
+      return false;
+    }
+    InlineStringIsEmptyTester(call);
+    return true;
+  }
+
   return false;
 }
 
 
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (instr->HasICData() && (instr->ic_data()->NumberOfChecks() > 0)) {
     const Token::Kind op_kind = instr->token_kind();
     if (Token::IsIndexOperator(op_kind) &&
         TryReplaceWithArrayOp(instr, op_kind)) {
       return;
@@ skipping 2237 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart