VM: Fix receiver type propagation in presence of try-catch.

runtime/vm/flow_graph.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/flow_graph.h"
 
 #include "vm/bit_vector.h"
+#include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/growable_array.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
@@ skipping 347 matching lines @@
       ASSERT(instr->IsBlockEntry() ||
              (instr->IsPhi() && instr->AsPhi()->is_alive()) ||
              (instr->previous() != NULL));
       prev = curr;
       curr = curr->next_use();
     }
   }
 }
 
 
+static bool IsReceiver(Definition* def, BitVector* processed) {
+  if (def->IsParameter() && (def->AsParameter()->index() == 0)) return true;

[Vyacheslav Egorov (Google), 2016/03/30 16:59:20]

Maybe

if (def->IsParameter() return (def->AsParameter()->index() == 0);

? 

[Florian Schneider, 2016/03/30 21:03:57]

Done.

+  if (!def->IsPhi()) return false;
+  PhiInstr* phi = def->AsPhi();
+  if (processed->Contains(phi->ssa_temp_index())) return true;
+  processed->Add(phi->ssa_temp_index());
+  for (intptr_t i = 0; i < phi->InputCount(); ++i) {
+    if (!IsReceiver(phi->InputAt(i)->definition(), processed)) return false;

[Vyacheslav Egorov (Google), 2016/03/30 16:59:20]

Please add a comment that we are not reusing processed between IsReceiver
invocations.

[Florian Schneider, 2016/03/30 21:03:57]

Done. Rewrote computation to store the result at each phi.

+  }
+  return true;
+}
+
+
+// Use CHA to determine if the call needs a class check: if the callee's
+// receiver is the same as the caller's receiver and there are no overriden
+// callee functions, then no class check is needed.
+bool FlowGraph::InstanceCallNeedsClassCheck(InstanceCallInstr* call,
+                                            RawFunction::Kind kind) const {
+  if (!FLAG_use_cha_deopt && !isolate()->all_classes_finalized()) {
+    // Even if class or function are private, lazy class finalization
+    // may later add overriding methods.
+    return true;
+  }
+  Definition* callee_receiver = call->ArgumentAt(0);
+  ASSERT(callee_receiver != NULL);
+  if (function().IsDynamicFunction() &&
+      IsReceiver(callee_receiver,

[Vyacheslav Egorov (Google), 2016/03/30 16:59:20]

I find it somewhat expensive not only to repeat this analysis again and again
for phis but also to allocate processed even if it is certainly not needed (e.g.
callee_receiver is not a Phi or Parameter).

PhiInstr has bool is_alive_; - so maybe put a uint8_t is_receiver next to it and
have it UNKNOWN, RECEIVER, NOT_RECEIVER :)

[Florian Schneider, 2016/03/30 21:03:57]

Good point. It should not take extra space anyway. I only need to do the
analysis when try-catch is present, too.

+                 new(zone()) BitVector(zone(),
+                     max_virtual_register_number()))) {
+    const String& name = (kind == RawFunction::kMethodExtractor)
+        ? String::Handle(zone(), Field::NameFromGetter(call->function_name()))
+        : call->function_name();
+    const Class& cls = Class::Handle(zone(), function().Owner());
+    if (!thread()->cha()->HasOverride(cls, name)) {
+      if (FLAG_trace_cha) {
+        THR_Print("  **(CHA) Instance call needs no check, "
+            "no overrides of '%s' '%s'\n",
+            name.ToCString(), cls.ToCString());
+      }
+      thread()->cha()->AddToLeafClasses(cls);
+      return false;
+    }
+  }
+  return true;
+}
+
+
+
 bool FlowGraph::VerifyUseLists() {
   // Verify the initial definitions.
   for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
     VerifyUseListsInInstruction((*graph_entry_->initial_definitions())[i]);
   }
 
   // Verify phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
@@ skipping 1588 matching lines @@
         ReplaceCurrentInstruction(&it, current, replacement);
         changed = true;
       }
     }
   }
   return changed;
 }
 
 
 }  // namespace dart