Use off-heap data for class check instructions

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 1616 matching lines @@
 }
 
 
 ParallelMoveResolver::ScratchRegisterScope::~ScratchRegisterScope() {
   if (spilled_) {
     resolver_->RestoreScratch(reg_);
   }
 }
 
 
-template <typename T>
-static int HighestCountFirst(const T* a, const T* b) {
-  // Negative if 'a' should sort before 'b'.
-  return b->count - a->count;
-}
-
-
-static int LowestCidFirst(const CidRangeTarget* a, const CidRangeTarget* b) {
-  // Negative if 'a' should sort before 'b'.
-  return a->cid_start - b->cid_start;
-}
-
-
-// Returns 'sorted' array in decreasing count order.
-// The expected number of elements to sort is less than 10.
-void FlowGraphCompiler::SortICDataByCount(
-    const ICData& ic_data,
-    GrowableArray<CidRangeTarget>* sorted_arg,
-    bool drop_smi) {
-  GrowableArray<CidRangeTarget>& sorted = *sorted_arg;
-  ASSERT(ic_data.NumArgsTested() == 1);
-  const intptr_t len = ic_data.NumberOfChecks();
-  sorted.Clear();
-
-  for (int i = 0; i < len; i++) {
-    intptr_t receiver_cid = ic_data.GetReceiverClassIdAt(i);
-    if (drop_smi && (receiver_cid == kSmiCid)) continue;
-    Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
-    sorted.Add(CidRangeTarget(receiver_cid, receiver_cid, &target,
-                              ic_data.GetCountAt(i)));
-  }
-  sorted.Sort(LowestCidFirst);
-  int dest = 0;
-
-  // Merge adjacent ranges.
-  for (int src = 0; src < sorted.length(); src++) {
-    if (src > 0 && sorted[src - 1].cid_end + 1 == sorted[src].cid_start &&
-        sorted[src - 1].target->raw() == sorted[src].target->raw()) {
-      sorted[dest - 1].cid_end++;
-      sorted[dest - 1].count += sorted[dest].count;
-    } else {
-      sorted[dest++] = sorted[src];
-    }
-  }
-
-  sorted.SetLength(dest);
-  sorted.Sort(HighestCountFirst);
-}
-
-
 const ICData* FlowGraphCompiler::GetOrAddInstanceCallICData(
     intptr_t deopt_id,
     const String& target_name,
     const Array& arguments_descriptor,
     intptr_t num_args_tested) {
   if ((deopt_id_to_ic_data_ != NULL) &&
       ((*deopt_id_to_ic_data_)[deopt_id] != NULL)) {
     const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
     ASSERT(res->deopt_id() == deopt_id);
     ASSERT(res->target_name() == target_name.raw());
@@ skipping 99 matching lines @@
     intptr_t cid,
     const String& selector,
     const Array& args_desc_array) {
   Zone* zone = Thread::Current()->zone();
 
   ArgumentsDescriptor args_desc(args_desc_array);
 
   Function& fn = Function::ZoneHandle(zone);
   if (!LookupMethodFor(cid, selector, args_desc, &fn)) return NULL;
 
-  CallTargets* targets = new (zone) CallTargets();
-  targets->Add(CidRangeTarget(cid, cid, &fn, /* count = */ 1));
+  CallTargets* targets = new (zone) CallTargets(zone);
+  targets->Add(new (zone) TargetInfo(cid, cid, &fn, /* count = */ 1));
 
   return targets;
 }
 
 
 bool FlowGraphCompiler::LookupMethodFor(int class_id,
                                         const String& name,
                                         const ArgumentsDescriptor& args_desc,
                                         Function* fn_return) {
   Thread* thread = Thread::Current();
@@ skipping 106 matching lines @@
     }
   }
 
   if (smi_case != kNoCase) {
     Label after_smi_test;
     EmitTestAndCallSmiBranch(non_smi_length == 0 ? failed : &after_smi_test,
                              /* jump_if_smi= */ false);
 
     // 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 = *targets[smi_case].target;
+    const Function& function = *targets.TargetAt(smi_case)->target;
     GenerateStaticDartCall(deopt_id, token_index,
                            *StubCode::CallStaticFunction_entry(),
                            RawPcDescriptors::kOther, locs, function);
     __ Drop(argument_count);
     if (match_found != NULL) {
       __ Jump(match_found);
     }
     __ Bind(&after_smi_test);
   } else {
     if (!complete) {
@@ skipping 12 matching lines @@
   int bias = 0;
 
   // Value is not Smi.
   EmitTestAndCallLoadCid();
 
   int last_check = which_case_to_skip == length - 1 ? length - 2 : length - 1;
 
   for (intptr_t i = 0; i < length; i++) {
     if (i == which_case_to_skip) continue;
     const bool is_last_check = (i == last_check);
-    const int count = targets[i].count;
+    const int count = targets.TargetAt(i)->count;
     if (!is_last_check && !complete && count < (total_ic_calls >> 5)) {
       // This case is hit too rarely to be worth writing class-id checks inline
       // for.  Note that we can't do this for calls with only one target because
       // the type propagator may have made use of that and expects a deopt if
       // a new class is seen at this calls site.  See IsMonomorphic.
       add_megamorphic_call = true;
       break;
     }
     Label next_test;
     if (!complete || !is_last_check) {
       bias = EmitTestAndCallCheckCid(is_last_check ? failed : &next_test,
                                      targets[i], bias);
     }
     // 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 = *targets[i].target;
+    const Function& function = *targets.TargetAt(i)->target;
     GenerateStaticDartCall(deopt_id, token_index,
                            *StubCode::CallStaticFunction_entry(),
                            RawPcDescriptors::kOther, locs, function);
     __ Drop(argument_count);
     if (!is_last_check || add_megamorphic_call) {
       __ Jump(match_found);
     }
     __ Bind(&next_test);
   }
   if (add_megamorphic_call) {
@@ skipping 75 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart