Allow inlining of methods that have an intrinsic translation.

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 2861 matching lines @@
       return TypedData::length_offset();
     case MethodRecognizer::kGrowableArrayLength:
       return GrowableObjectArray::length_offset();
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
+static LoadLocalInstr* BuildLoadThisVar(LocalScope* scope) {
+  LocalVariable* receiver_var = scope->LookupVariable(Symbols::This(),
+                                                      true);  // Test only.
+  return new LoadLocalInstr(*receiver_var);
+}
+
+
 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));
+      case MethodRecognizer::kStringBaseLength:
+      case MethodRecognizer::kStringBaseIsEmpty: {
+        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         // 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);
+        if (kind == MethodRecognizer::kStringBaseLength) {
+          return ReturnDefinition(load);
+        }
+        ASSERT(kind == MethodRecognizer::kStringBaseIsEmpty);
+        Value* zero_val = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(0))));
+        Value* load_val = Bind(load);
+        StrictCompareInstr* compare =
+            new StrictCompareInstr(node->token_pos(),
+                                   Token::kEQ_STRICT,
+                                   load_val,
+                                   zero_val);
+        return ReturnDefinition(compare);
       }
       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));
+        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         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);
       }
+      case MethodRecognizer::kObjectCid: {
+        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
+        LoadClassIdInstr* load = new LoadClassIdInstr(receiver);
+        return ReturnDefinition(load);
+      }
+      case MethodRecognizer::kGrowableArrayCapacity: {
+        Value* receiver = Bind(BuildLoadThisVar(node->scope()));
+        LoadFieldInstr* data_load = new LoadFieldInstr(
+            receiver,
+            Array::data_offset(),
+            Type::ZoneHandle(Type::DynamicType()));
+        data_load->set_result_cid(kArrayCid);
+        Value* data = Bind(data_load);
+        LoadFieldInstr* length_load = new LoadFieldInstr(
+            data,
+            Array::length_offset(),
+            Type::ZoneHandle(Type::SmiType()));
+        length_load->set_result_cid(kSmiCid);
+        length_load->set_recognized_kind(MethodRecognizer::kObjectArrayLength);
+        return ReturnDefinition(length_load);
+      }
       default:
         break;
     }
   }
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
   function.set_is_optimizable(false);
   NativeCallInstr* native_call = new NativeCallInstr(node);
   ReturnDefinition(native_call);
 }
 
@@ skipping 833 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