Specialize instance calls when the call receiver is the method receiver and the method class has a …

runtime/vm/flow_graph_compiler_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 1533 matching lines @@
 #endif
 
 
 void FlowGraphCompiler::EmitTestAndCall(const ICData& ic_data,
                                         intptr_t argument_count,
                                         const Array& argument_names,
                                         Label* failed,
                                         Label* match_found,
                                         intptr_t deopt_id,
                                         TokenPosition token_index,
-                                        LocationSummary* locs) {
+                                        LocationSummary* locs,
+                                        bool complete) {
   ASSERT(is_optimizing());
 
   __ Comment("EmitTestAndCall");
   const Array& arguments_descriptor =
       Array::ZoneHandle(zone(), ArgumentsDescriptor::New(argument_count,
                                                          argument_names));
 
   // Load receiver into R0.
   __ LoadFromOffset(R0, SP, (argument_count - 1) * kWordSize);
   __ LoadObject(R4, arguments_descriptor);
 
   const bool kFirstCheckIsSmi = ic_data.GetReceiverClassIdAt(0) == kSmiCid;
   const intptr_t kNumChecks = ic_data.NumberOfChecks();
 
   ASSERT(!ic_data.IsNull() && (kNumChecks > 0));
 
   Label after_smi_test;
-  __ tsti(R0, Immediate(kSmiTagMask));
   if (kFirstCheckIsSmi) {
+    __ tsti(R0, Immediate(kSmiTagMask));
     // Jump if receiver is not Smi.
     if (kNumChecks == 1) {
       __ b(failed, NE);
     } else {
       __ b(&after_smi_test, NE);
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     const Function& function = Function::ZoneHandle(
         zone(), ic_data.GetTargetAt(0));
     GenerateStaticDartCall(deopt_id,
                            token_index,
                            *StubCode::CallStaticFunction_entry(),
                            RawPcDescriptors::kOther,
                            locs,
                            function);
     __ Drop(argument_count);
     if (kNumChecks > 1) {
       __ b(match_found);
     }
   } else {
     // Receiver is Smi, but Smi is not a valid class therefore fail.
     // (Smi class must be first in the list).
-    __ b(failed, EQ);
+    if (!complete) {
+      __ tsti(R0, Immediate(kSmiTagMask));
+      __ b(failed, EQ);
+    }
   }
   __ Bind(&after_smi_test);
 
   ASSERT(!ic_data.IsNull() && (kNumChecks > 0));
   GrowableArray<CidTarget> sorted(kNumChecks);
   SortICDataByCount(ic_data, &sorted, /* drop_smi = */ true);
 
   // Value is not Smi,
   const intptr_t kSortedLen = sorted.length();
   // If kSortedLen is 0 then only a Smi check was needed; the Smi check above
   // will fail if there was only one check and receiver is not Smi.
   if (kSortedLen == 0) return;
 
   __ LoadClassId(R2, R0);
   for (intptr_t i = 0; i < kSortedLen; i++) {
     const bool kIsLastCheck = (i == (kSortedLen - 1));
     ASSERT(sorted[i].cid != kSmiCid);
     Label next_test;
-    __ CompareImmediate(R2, sorted[i].cid);
-    if (kIsLastCheck) {
-      __ b(failed, NE);
+    if (!complete) {
+      __ CompareImmediate(R2, sorted[i].cid);
+      if (kIsLastCheck) {
+        __ b(failed, NE);
+      } else {
+        __ b(&next_test, NE);
+      }
     } else {
-      __ b(&next_test, NE);
+      if (!kIsLastCheck) {
+        __ CompareImmediate(R2, sorted[i].cid);
+        __ b(&next_test, NE);
+      }
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     const Function& function = *sorted[i].target;
     GenerateStaticDartCall(deopt_id,
                            token_index,
                            *StubCode::CallStaticFunction_entry(),
                            RawPcDescriptors::kOther,
                            locs,
                            function);
@@ skipping 283 matching lines @@
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   __ PopDouble(reg);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64