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

This also changes the implementation of Function::LookupImplicitGetterSetterField to **not** use
token positions for finding the right field, but rather the name.

Issue #31798

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

Author: mkustermann

runtime/vm/compiler/aot/aot_call_specializer.cc

@@ -251,6 +251,20 @@ bool AotCallSpecializer::TryInlineFieldAccess(InstanceCallInstr* call) {
   return false;
 }
 
+bool AotCallSpecializer::TryInlineFieldAccess(StaticCallInstr* call) {
+  if (call->function().IsImplicitGetterFunction()) {
+    Field& field =
+        Field::ZoneHandle(call->function().LookupImplicitGetterSetterField());
+    if (should_clone_fields_) {
+      field = field.CloneFromOriginal();
+    }
+    InlineImplicitInstanceGetter(call, field);
+    return true;
+  }
+
+  return false;
+}
+
 Value* AotCallSpecializer::PrepareStaticOpInput(Value* input,
                                                 intptr_t cid,
                                                 Instruction* call) {
@@ -825,6 +839,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

@@ -34,8 +34,8 @@ class CallSpecializer : public FlowGraphVisitor {
                   bool should_clone_fields)
       : FlowGraphVisitor(flow_graph->reverse_postorder()),
         speculative_policy_(speculative_policy),
-        flow_graph_(flow_graph),
-        should_clone_fields_(should_clone_fields) {}
+        should_clone_fields_(should_clone_fields),
+        flow_graph_(flow_graph) {}
 
   virtual ~CallSpecializer() {}
 
@@ -111,7 +111,10 @@ class CallSpecializer : public FlowGraphVisitor {
   virtual bool TryOptimizeStaticCallUsingStaticTypes(StaticCallInstr* call) = 0;
 
  protected:
+  void InlineImplicitInstanceGetter(Definition* call, const Field& field);
+
   SpeculativeInliningPolicy* speculative_policy_;
+  const bool should_clone_fields_;
 
  private:
   bool TypeCheckAsClassEquality(const AbstractType& type);
@@ -169,7 +172,6 @@ class CallSpecializer : public FlowGraphVisitor {
       const AbstractType& type);
 
   FlowGraph* flow_graph_;
-  const bool should_clone_fields_;
 };
 
 }  // namespace dart

runtime/vm/object.cc

@@ -5585,22 +5585,24 @@ void Function::set_saved_args_desc(const Array& value) const {
 }
 
 RawField* Function::LookupImplicitGetterSetterField() const {
-  ASSERT((kind() == RawFunction::kImplicitGetter) ||
-         (kind() == RawFunction::kImplicitSetter) ||
-         (kind() == RawFunction::kImplicitStaticFinalGetter));
-  const Class& owner = Class::Handle(Owner());
-  ASSERT(!owner.IsNull());
-  const Array& fields = Array::Handle(owner.fields());
-  ASSERT(!fields.IsNull());
-  Field& field = Field::Handle();
-  for (intptr_t i = 0; i < fields.Length(); i++) {
-    field ^= fields.At(i);
-    ASSERT(!field.IsNull());
-    if (field.token_pos() == token_pos()) {
-      return field.raw();
-    }
+  // TODO(27590) Store Field object inside RawFunction::data_ if possible.
+  Zone* Z = Thread::Current()->zone();
+  String& field_name = String::Handle(Z, name());
+  switch (kind()) {
+    case RawFunction::kImplicitGetter:
+    case RawFunction::kImplicitStaticFinalGetter:
+      field_name = Field::NameFromGetter(field_name);
+      break;
+    case RawFunction::kImplicitSetter:
+      field_name = Field::NameFromSetter(field_name);
+      break;
+    default:
+      UNREACHABLE();
   }
-  return Field::null();
+  ASSERT(field_name.IsSymbol());
+  const Class& owner = Class::Handle(Z, Owner());
+  ASSERT(!owner.IsNull());
+  return owner.LookupField(field_name);
 }
 
 RawFunction* Function::parent_function() const {