Hook ByteArrayViewLoad operations into polymorphic inliner

runtime/vm/flow_graph_inliner.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/flow_graph_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 345 matching lines @@
  public:
   PolymorphicInliner(CallSiteInliner* owner,
                      PolymorphicInstanceCallInstr* call);
 
   void Inline();
 
  private:
   bool CheckInlinedDuplicate(const Function& target);
   bool CheckNonInlinedDuplicate(const Function& target);
 
-  bool TryInlining(const Function& target);
-  bool TryInlineRecognizedMethod(const Function& target);
+  bool TryInlining(intptr_t receiver_cid, const Function& target);
+  bool TryInlineRecognizedMethod(intptr_t receiver_cid, const Function& target);
 
   TargetEntryInstr* BuildDecisionGraph();
 
   CallSiteInliner* const owner_;
   PolymorphicInstanceCallInstr* const call_;
   const intptr_t num_variants_;
   GrowableArray<CidTarget> variants_;
 
   GrowableArray<CidTarget> inlined_variants_;
   GrowableArray<CidTarget> non_inlined_variants_;
@@ skipping 648 matching lines @@
 // inlined target.  This sharing is represented by using three different
 // types of entries in the inlined_entries_ array:
 //
 //   * GraphEntry: the inlined body is not shared.
 //
 //   * TargetEntry: the inlined body is shared and this is the first variant.
 //
 //   * JoinEntry: the inlined body is shared and this is a subsequent variant.
 bool PolymorphicInliner::CheckInlinedDuplicate(const Function& target) {
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
-    if (target.raw() == inlined_variants_[i].target->raw()) {
+    if ((target.raw() == inlined_variants_[i].target->raw()) &&
+        !MethodRecognizer::PolymorphicTarget(target)) {
       // The call target is shared with a previous inlined variant.  Share
       // the graph.  This requires a join block at the entry, and edge-split
       // form requires a target for each branch.
       //
       // Represent the sharing by recording a fresh target for the first
       // variant and the shared join for all later variants.
       if (inlined_entries_[i]->IsGraphEntry()) {
         // Convert the old target entry to a new join entry.
         TargetEntryInstr* old_target =
             inlined_entries_[i]->AsGraphEntry()->normal_entry();
@@ skipping 35 matching lines @@
   for (intptr_t i = 0; i < non_inlined_variants_.length(); ++i) {
     if (target.raw() == non_inlined_variants_[i].target->raw()) {
       return true;
     }
   }
 
   return false;
 }
 
 
-bool PolymorphicInliner::TryInlining(const Function& target) {
+bool PolymorphicInliner::TryInlining(intptr_t receiver_cid,
+                                     const Function& target) {
   if (!target.is_optimizable()) {
-    if (TryInlineRecognizedMethod(target)) {
+    if (TryInlineRecognizedMethod(receiver_cid, target)) {
       owner_->inlined_ = true;
       return true;
     }
     return false;
   }
 
   GrowableArray<Value*> arguments(call_->ArgumentCount());
   for (int i = 0; i < call_->ArgumentCount(); ++i) {
     arguments.Add(call_->PushArgumentAt(i)->value());
   }
@@ skipping 45 matching lines @@
                                       Instruction* second) {
   for (intptr_t i = second->InputCount() - 1; i >= 0; --i) {
     Value* input = second->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   first->LinkTo(second);
   return second;
 }
 
 
-bool PolymorphicInliner::TryInlineRecognizedMethod(const Function& target) {
+bool PolymorphicInliner::TryInlineRecognizedMethod(intptr_t receiver_cid,
+                                                   const Function& target) {
   FlowGraphOptimizer optimizer(owner_->caller_graph());
   TargetEntryInstr* entry;
   Definition* last;
-  if (optimizer.TryInlineRecognizedMethod(target,
+  if (optimizer.TryInlineRecognizedMethod(receiver_cid,
+                                          target,
                                           call_,
                                           call_->instance_call()->token_pos(),
                                           *call_->instance_call()->ic_data(),
                                           &entry, &last)) {
     // Create a graph fragment.
     InlineExitCollector* exit_collector =
         new InlineExitCollector(owner_->caller_graph(), call_);
 
     ReturnInstr* result =
         new ReturnInstr(call_->instance_call()->token_pos(),
@@ skipping 230 matching lines @@
   }
   return entry;
 }
 
 
 void PolymorphicInliner::Inline() {
   // Consider the polymorphic variants in order by frequency.
   FlowGraphCompiler::SortICDataByCount(call_->ic_data(), &variants_);
   for (intptr_t var_idx = 0; var_idx < variants_.length(); ++var_idx) {
     const Function& target = *variants_[var_idx].target;
+    const intptr_t receiver_cid = variants_[var_idx].cid;
 
     // First check if this is the same target as an earlier inlined variant.
     if (CheckInlinedDuplicate(target)) {
       inlined_variants_.Add(variants_[var_idx]);
       continue;
     }
 
     // Also check if this is the same target as an earlier non-inlined
     // variant.  If so and since inlining decisions are costly, do not try
     // to inline this variant.
     if (CheckNonInlinedDuplicate(target)) {
       non_inlined_variants_.Add(variants_[var_idx]);
       continue;
     }
 
     // Make an inlining decision.
-    if (TryInlining(target)) {
+    if (TryInlining(receiver_cid, target)) {
       inlined_variants_.Add(variants_[var_idx]);
     } else {
       non_inlined_variants_.Add(variants_[var_idx]);
     }
   }
 
   // If there are no inlined variants, leave the call in place.
   if (inlined_variants_.is_empty()) return;
 
   // Now build a decision tree (a DAG because of shared inline variants) and
@@ skipping 49 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart