Polymorphic inlining for some recognized methods in the optimizing compiler.

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
@@ skipping 2832 matching lines @@
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   BuildStaticSetter(node, false);  // Result not needed.
 }
 
 
 void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   BuildStaticSetter(node, true);  // Result needed.
 }
 
 
+static intptr_t OffsetForLengthGetter(MethodRecognizer::Kind kind) {
+  switch (kind) {
+    case MethodRecognizer::kObjectArrayLength:
+    case MethodRecognizer::kImmutableArrayLength:
+      return Array::length_offset();
+    case MethodRecognizer::kTypedDataLength:
+      // .length is defined in _TypedList which is the base class for internal
+      // and external typed data.
+      ASSERT(TypedData::length_offset() == ExternalTypedData::length_offset());
+      return TypedData::length_offset();
+    case MethodRecognizer::kGrowableArrayLength:
+      return GrowableObjectArray::length_offset();
+    default:
+      UNREACHABLE();
+      return 0;
+  }
+}
+
+
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
+  const Function& function = owner()->parsed_function()->function();
+  if (!function.IsClosureFunction()) {
+    MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(function);
+    switch (kind) {
+      case MethodRecognizer::kStringBaseLength: {
+        LocalVariable* receiver_var =
+            node->scope()->LookupVariable(Symbols::This(),
+                                          true);  // Test only.
+        Value* receiver = Bind(new LoadLocalInstr(*receiver_var));
+        // Treat length loads as mutable (i.e. affected by side effects) to
+        // avoid hoisting them since we can't hoist the preceding class-check.
+        // This is because of externalization of strings that affects their
+        // class-id.
+        const bool is_immutable = false;
+        LoadFieldInstr* load = new LoadFieldInstr(
+            receiver,
+            String::length_offset(),
+            Type::ZoneHandle(Type::SmiType()),
+            is_immutable);
+        load->set_result_cid(kSmiCid);
+        load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
+        return ReturnDefinition(load);
+      }
+      case MethodRecognizer::kGrowableArrayLength:
+      case MethodRecognizer::kObjectArrayLength:
+      case MethodRecognizer::kImmutableArrayLength:
+      case MethodRecognizer::kTypedDataLength: {
+        LocalVariable* receiver_var =
+            node->scope()->LookupVariable(Symbols::This(),
+                                          true);  // Test only.
+        Value* receiver = Bind(new LoadLocalInstr(*receiver_var));
+        const bool is_immutable =
+            (kind != MethodRecognizer::kGrowableArrayLength);
+        LoadFieldInstr* load = new LoadFieldInstr(
+            receiver,
+            OffsetForLengthGetter(kind),
+            Type::ZoneHandle(Type::SmiType()),
+            is_immutable);
+        load->set_result_cid(kSmiCid);
+        load->set_recognized_kind(kind);
+        return ReturnDefinition(load);
+      }
+      default:
+        break;
+    }
+  }
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
+  function.set_is_optimizable(false);
   NativeCallInstr* native_call = new NativeCallInstr(node);
   ReturnDefinition(native_call);
 }
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
@@ skipping 338 matching lines @@
         Bind(new AllocateContextInstr(node->token_pos(),
                                       num_context_variables));
     { LocalVariable* tmp_var = EnterTempLocalScope(allocated_context);
       // If this node_sequence is the body of the function being compiled, and
       // if this function allocates context variables, but none of its enclosing
       // functions do, the context on entry is not linked as parent of the
       // allocated context but saved on entry and restored on exit as to prevent
       // memory leaks.
       // In this case, the parser pre-allocates a variable to save the context.
       if (MustSaveRestoreContext(node)) {
-        Value* current_context = Bind(new CurrentContextInstr());
-        Do(BuildStoreTemp(
-            *owner()->parsed_function()->saved_entry_context_var(),
-            current_context));
+        BuildSaveContext(
+            *owner()->parsed_function()->saved_entry_context_var());
         Value* null_context = Bind(new ConstantInstr(Object::ZoneHandle()));
         AddInstruction(new StoreContextInstr(null_context));
       }
       Value* current_context = Bind(new CurrentContextInstr());
       Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
       Do(new StoreVMFieldInstr(tmp_val,
                                Context::parent_offset(),
                                current_context,
                                Type::ZoneHandle()));
       AddInstruction(
@@ skipping 396 matching lines @@
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(*parsed_function());
   }
   const Function& function = parsed_function()->function();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(AllocateBlockId(),
                            CatchClauseNode::kInvalidTryIndex);
   graph_entry_ = new GraphEntryInstr(*parsed_function(), normal_entry, osr_id_);
   EffectGraphVisitor for_effect(this, 0);
   // This check may be deleted if the generated code is leaf.
-  CheckStackOverflowInstr* check =
-      new CheckStackOverflowInstr(function.token_pos(), 0);
-  // If we are inlining don't actually attach the stack check. We must still
-  // create the stack check in order to allocate a deopt id.
-  if (!IsInlining()) for_effect.AddInstruction(check);
+  // Native functions don't need a stack check at entry.
+  if (!function.is_native()) {
+    CheckStackOverflowInstr* check =
+        new CheckStackOverflowInstr(function.token_pos(), 0);
+    // If we are inlining don't actually attach the stack check. We must still
+    // create the stack check in order to allocate a deopt id.
+    if (!IsInlining()) for_effect.AddInstruction(check);
+  }
   parsed_function()->node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry.  Catch entries are not (yet) properly
   // recognized as reachable.
   if (osr_id_ != Isolate::kNoDeoptId) {
     if (graph_entry_->SuccessorCount() > 1) {
@@ skipping 22 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart