[VM] Allow the inlining code to inline implicit getters even if a StaticCallInstr is used

We have devirtualization logic which turns [InstanceCallInst]s to
[StaticCallInstr]s (which are subject to different optimizations).

This makes the inlining decisions done in dart-aot-v2 a little
bit closer to dart-aot.

Issue #31798

Change-Id: If7961ad8f05ac2544f04044d05541a86a8074984
Reviewed-on: https://dart-review.googlesource.com/34000
Reviewed-by: Vyacheslav Egorov <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: mkustermann

runtime/vm/compiler/aot/aot_call_specializer.cc

@@ -251,6 +251,17 @@ bool AotCallSpecializer::TryInlineFieldAccess(InstanceCallInstr* call) {
   return false;
 }
 
+bool AotCallSpecializer::TryInlineFieldAccess(StaticCallInstr* call) {
+  if (call->function().IsImplicitGetterFunction()) {
+    const Field& field =
+        Field::Handle(call->function().LookupImplicitGetterSetterField());
+    InlineImplicitInstanceGetter(call, field);
+    return true;
+  }
+
+  return false;
+}
+
 Value* AotCallSpecializer::PrepareStaticOpInput(Value* input,
                                                 intptr_t cid,
                                                 Instruction* call) {
@@ -825,6 +836,13 @@ void AotCallSpecializer::VisitInstanceCall(InstanceCallInstr* instr) {
   }
 }
 
+void AotCallSpecializer::VisitStaticCall(StaticCallInstr* instr) {
+  if (TryInlineFieldAccess(instr)) {
+    return;
+  }
+  CallSpecializer::VisitStaticCall(instr);
+}
+
 bool AotCallSpecializer::TryExpandCallThroughGetter(const Class& receiver_class,
                                                     InstanceCallInstr* call) {
   // If it's an accessor call it can't be a call through getter.

runtime/vm/compiler/aot/aot_call_specializer.h

@@ -26,6 +26,7 @@ class AotCallSpecializer : public CallSpecializer {
   void ReplaceArrayBoundChecks();
 
   virtual void VisitInstanceCall(InstanceCallInstr* instr);
+  virtual void VisitStaticCall(StaticCallInstr* instr);
   virtual void VisitPolymorphicInstanceCall(
       PolymorphicInstanceCallInstr* instr);
 
@@ -44,6 +45,7 @@ class AotCallSpecializer : public CallSpecializer {
   bool TryReplaceWithHaveSameRuntimeType(InstanceCallInstr* call);
 
   bool TryInlineFieldAccess(InstanceCallInstr* call);
+  bool TryInlineFieldAccess(StaticCallInstr* call);
 
   Value* PrepareStaticOpInput(Value* input, intptr_t cid, Instruction* call);
 

runtime/vm/compiler/backend/inliner.cc

@@ -1069,6 +1069,8 @@ class CallSiteInliner : public ValueObject {
             // before 'SelectRepresentations' which inserts conversion nodes.
             callee_graph->TryOptimizePatterns();
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
+
+            callee_graph->Canonicalize();
 #else
             UNREACHABLE();
 #endif  // DART_PRECOMPILER

runtime/vm/compiler/call_specializer.cc

@@ -878,6 +878,12 @@ bool CallSpecializer::TryInlineImplicitInstanceGetter(InstanceCallInstr* call) {
 
     AddReceiverCheck(call);
   }
+  InlineImplicitInstanceGetter(call, field);
+  return true;
+}
+
+void CallSpecializer::InlineImplicitInstanceGetter(Definition* call,
+                                                   const Field& field) {
   LoadFieldInstr* load = new (Z) LoadFieldInstr(
       new (Z) Value(call->ArgumentAt(0)), &field,
       AbstractType::ZoneHandle(Z, field.type()), call->token_pos(),
@@ -895,7 +901,6 @@ bool CallSpecializer::TryInlineImplicitInstanceGetter(InstanceCallInstr* call) {
       it.Current()->SetReachingType(NULL);
     }
   }
-  return true;
 }
 
 bool CallSpecializer::TryInlineInstanceSetter(InstanceCallInstr* instr,

runtime/vm/compiler/call_specializer.h

@@ -111,6 +111,8 @@ class CallSpecializer : public FlowGraphVisitor {
   virtual bool TryOptimizeStaticCallUsingStaticTypes(StaticCallInstr* call) = 0;
 
  protected:
+  void InlineImplicitInstanceGetter(Definition* call, const Field& field);
+
   SpeculativeInliningPolicy* speculative_policy_;
 
  private: