Removing more IC calls in optimized code.

runtime/vm/intermediate_language_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 297 matching lines @@
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           EqualityCompareComp* comp,
                                           Register left,
                                           Register right) {
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   ASSERT(ic_data.NumberOfChecks() > 0);
+  ASSERT(ic_data.num_args_tested() == 1);
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_index(),
                                         comp->try_index(),
                                         kDeoptEquality);
   __ testq(left, Immediate(kSmiTagMask));
   Register temp = comp->locs()->temp(0).reg();
   if (ic_data.GetReceiverClassIdAt(0) == kSmi) {
     Label done, load_class_id;
     __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
     __ movq(temp, Immediate(kSmi));
@@ skipping 316 matching lines @@
     return locs;
   } else if (receiver_type() == kArray || receiver_type() == kImmutableArray) {
     return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
 
 
+static void EmitLoadIndexedPolymorphic(FlowGraphCompiler* compiler,
+                                        LoadIndexedComp* comp) {
+  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+                                        comp->token_index(),
+                                        comp->try_index(),
+                                        kDeoptLoadIndexedPolymorphic);
+  if (comp->ic_data()->NumberOfChecks() == 0) {
+    __ jmp(deopt);
+    return;
+  }
+  ASSERT(comp->HasICData());
+  const ICData& ic_data = *comp->ic_data();
+  ASSERT(ic_data.num_args_tested() == 1);
+  // No indexed access on Smi.
+  ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmi);
+  // Load receiver into RAX.
+  const intptr_t kNumArguments = 2;
+  __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
+  __ testq(RAX, Immediate(kSmiTagMask));
+  __ j(ZERO, deopt);
+  Label done;
+  __ LoadClassId(RDI, RAX);
+  compiler->EmitTestAndCall(ic_data,
+                            RDI,  // Class id register.
+                            kNumArguments,
+                            Array::Handle(),  // No named arguments.
+                            deopt, &done,  // Labels.
+                            comp->cid(),
+                            comp->token_index(),
+                            comp->try_index());
+  __ Bind(&done);
+}
+
+
+
 void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalObjectKind) {
-    compiler->EmitLoadIndexedGeneric(this);
+    if (HasICData()) {
+      EmitLoadIndexedPolymorphic(compiler, this);
+    } else {
+      compiler->EmitLoadIndexedGeneric(this);
+    }
     ASSERT(locs()->out().reg() == RAX);
     return;
   }
 
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason = (receiver_type() == kGrowableObjectArray) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
@@ skipping 74 matching lines @@
                                  comp->token_index(),
                                  comp->try_index());
 
   const intptr_t kNumArguments = 3;
   const intptr_t kNumArgsChecked = 1;  // Type-feedback.
   compiler->GenerateInstanceCall(comp->cid(),
                                  comp->token_index(),
                                  comp->try_index(),
                                  function_name,
                                  kNumArguments,
-                                 Array::ZoneHandle(),  // No optional arguments.
+                                 Array::ZoneHandle(),  // No names arguments.
                                  kNumArgsChecked);
 }
 
 
+static void EmitStoreIndexedPolymorphic(FlowGraphCompiler* compiler,
+                                        StoreIndexedComp* comp) {
+  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+                                        comp->token_index(),
+                                        comp->try_index(),
+                                        kDeoptStoreIndexedPolymorphic);
+  if (comp->ic_data()->NumberOfChecks() == 0) {
+    __ jmp(deopt);
+    return;
+  }
+  ASSERT(comp->HasICData());
+  const ICData& ic_data = *comp->ic_data();
+  ASSERT(ic_data.num_args_tested() == 1);
+  // No indexed access on Smi.
+  ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmi);
+  // Load receiver into RAX.
+  const intptr_t kNumArguments = 3;
+  __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
+  __ testq(RAX, Immediate(kSmiTagMask));
+  __ j(ZERO, deopt);
+  Label done;
+  __ LoadClassId(RDI, RAX);
+  compiler->EmitTestAndCall(ic_data,
+                            RDI,  // Class id register.
+                            kNumArguments,
+                            Array::Handle(),  // No named arguments.
+                            deopt, &done,  // Labels.
+                            comp->cid(),
+                            comp->token_index(),
+                            comp->try_index());
+  __ Bind(&done);
+}
+
+
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalObjectKind) {
-    EmitStoreIndexedGeneric(compiler, this);
+    if (HasICData()) {
+      EmitStoreIndexedPolymorphic(compiler, this);
+    } else {
+      EmitStoreIndexedGeneric(compiler, this);
+    }
     return;
   }
 
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
   const Class& receiver_class =
       Class::ZoneHandle(Isolate::Current()->class_table()->At(
           receiver_type()));
@@ skipping 998 matching lines @@
 }
 
 
 LocationSummary* PolymorphicInstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(instance_call()->VerifyComputation());
-  ASSERT(HasICData());
-  ASSERT(ic_data()->num_args_tested() == 1);
   Label* deopt = compiler->AddDeoptStub(instance_call()->cid(),
                                         instance_call()->token_index(),
                                         instance_call()->try_index(),
                                         kDeoptPolymorphicInstanceCallTestFail);
+  if (!HasICData() || (ic_data()->NumberOfChecks() == 0)) {
+    __ jmp(deopt);
+    return;
+  }
+  ASSERT(HasICData());
+  ASSERT(ic_data()->num_args_tested() == 1);
   Label handle_smi;
   Label* is_smi_label =
       ic_data()->GetReceiverClassIdAt(0) == kSmi ?  &handle_smi : deopt;
   // Load receiver into RAX.
   __ movq(RAX,
       Address(RSP, (instance_call()->ArgumentCount() - 1) * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi_label);
   Label done;
   __ LoadClassId(RDI, RAX);
-  for (intptr_t i = 0; i < ic_data()->NumberOfChecks(); i++) {
-    Label next_test;
-    __ cmpq(RDI, Immediate(ic_data()->GetReceiverClassIdAt(i)));
-    __ j(NOT_EQUAL, &next_test);
-    const Function& target = Function::ZoneHandle(ic_data()->GetTargetAt(i));
-    compiler->GenerateStaticCall(instance_call()->cid(),
-                                 instance_call()->token_index(),
-                                 instance_call()->try_index(),
-                                 target,
-                                 instance_call()->ArgumentCount(),
-                                 instance_call()->argument_names());
-    __ jmp(&done);
-    __ Bind(&next_test);
-  }
-  __ jmp(deopt);
+  compiler->EmitTestAndCall(*ic_data(),
+                            RDI,  // Class id register.
+                            instance_call()->ArgumentCount(),
+                            instance_call()->argument_names(),
+                            deopt, &done,  // Labels.
+                            instance_call()->cid(),
+                            instance_call()->token_index(),
+                            instance_call()->try_index());
   if (is_smi_label == &handle_smi) {
     __ Bind(&handle_smi);
     ASSERT(ic_data()->GetReceiverClassIdAt(0) == kSmi);
     const Function& target = Function::ZoneHandle(ic_data()->GetTargetAt(0));
     compiler->GenerateStaticCall(instance_call()->cid(),
                                  instance_call()->token_index(),
                                  instance_call()->try_index(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names());
   }
   __ Bind(&done);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64