Use off-heap data for type feedback in PolymorphicInstanceCallInstr

runtime/vm/aot_optimizer.cc

 // Copyright (c) 2013, 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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_inliner.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
+#include "vm/jit_optimizer.h"
 #include "vm/intermediate_language.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/precompiler.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ skipping 1684 matching lines @@
     // we don't have one target.
     const Function& target = Function::Handle(Z, unary_checks.GetTargetAt(0));
     const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
     has_one_target = !polymorphic_target;
   }
 
   if (has_one_target) {
     RawFunction::Kind function_kind =
         Function::Handle(Z, unary_checks.GetTargetAt(0)).kind();
     if (!flow_graph()->InstanceCallNeedsClassCheck(instr, function_kind)) {
+      PolymorphicTargets* targets =
+          JitOptimizer::CreatePolymorphicTargets(Z, unary_checks);
       PolymorphicInstanceCallInstr* call =
-          new (Z) PolymorphicInstanceCallInstr(instr, unary_checks,
+          new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                                /* with_checks = */ false,
                                                /* complete = */ true);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
   switch (instr->token_kind()) {
     case Token::kEQ:
     case Token::kLT:
     case Token::kLTE:
@@ skipping 40 matching lines @@
   const intptr_t receiver_cid =
       instr->PushArgumentAt(0)->value()->Type()->ToCid();
   if (receiver_cid != kDynamicCid) {
     const Class& receiver_class =
         Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
 
     const Array& args_desc_array =
         Array::Handle(Z, ArgumentsDescriptor::New(instr->ArgumentCount(),
                                                   instr->argument_names()));
     ArgumentsDescriptor args_desc(args_desc_array);
-    const Function& function = Function::Handle(
+    Function& function = Function::Handle(
         Z, Resolver::ResolveDynamicForReceiverClass(
                receiver_class, instr->function_name(), args_desc));
     if (!function.IsNull()) {
-      const ICData& ic_data = ICData::Handle(
-          ICData::New(flow_graph_->function(), instr->function_name(),
-                      args_desc_array, Thread::kNoDeoptId,
-                      /* args_tested = */ 1, false));
-      ic_data.AddReceiverCheck(receiver_class.id(), function);
+      PolymorphicTargets* targets = new (Z) PolymorphicTargets(Z);
+      Function& target = Function::ZoneHandle(Z, function.raw());
+      targets->Add(
+          CidRangeTarget(receiver_class.id(), receiver_class.id(), &target, 1));
       PolymorphicInstanceCallInstr* call =
-          new (Z) PolymorphicInstanceCallInstr(instr, ic_data,
+          new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                                /* with_checks = */ false,
                                                /* complete = */ true);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
   Definition* callee_receiver = instr->ArgumentAt(0);
   const Function& function = flow_graph_->function();
   Class& receiver_class = Class::Handle(Z);
@@ skipping 102 matching lines @@
         for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
           args->Add(instr->PushArgumentAt(i));
         }
         StaticCallInstr* call = new (Z) StaticCallInstr(
             instr->token_pos(), Function::ZoneHandle(Z, single_target.raw()),
             instr->argument_names(), args, instr->deopt_id());
         instr->ReplaceWith(call, current_iterator());
         return;
       } else if ((ic_data.raw() != ICData::null()) &&
                  !ic_data.NumberOfChecksIs(0)) {
+        PolymorphicTargets* targets =
+            JitOptimizer::CreatePolymorphicTargets(Z, ic_data);
         PolymorphicInstanceCallInstr* call =
-            new (Z) PolymorphicInstanceCallInstr(instr, ic_data,
+            new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                                  /* with_checks = */ true,
                                                  /* complete = */ true);
         instr->ReplaceWith(call, current_iterator());
         return;
       }
     }
   }
 
   // More than one target. Generate generic polymorphic call without
   // deoptimization.
   if (instr->ic_data()->NumberOfUsedChecks() > 0) {
     ASSERT(!FLAG_polymorphic_with_deopt);
     // OK to use checks with PolymorphicInstanceCallInstr since no
     // deoptimization is allowed.
+    PolymorphicTargets* targets =
+        JitOptimizer::CreatePolymorphicTargets(Z, *instr->ic_data());
     PolymorphicInstanceCallInstr* call =
-        new (Z) PolymorphicInstanceCallInstr(instr, unary_checks,
+        new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                              /* with_checks = */ true,
                                              /* complete = */ false);
     instr->ReplaceWith(call, current_iterator());
     return;
   }
 }
 
 
 void AotOptimizer::VisitPolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
@@ skipping 185 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart