[vm/bytecode] Recognize list factories and set result type for static calls

alexmarkov · commit-bot@chromium.org · commit d3a09dda1598 · 2019-07-22T21:50:34.000Z
Sudoku +15.62% Issue: #36429 Change-Id: I58cde03ffc9788b2eebe889fcc1a98a82698c39a Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/109887 Reviewed-by: Aart Bik <ajcbik@google.com> Reviewed-by: Ryan Macnak <rmacnak@google.com> Commit-Queue: Alexander Markov <alexmarkov@google.com>
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
@@ -4620,6 +4620,23 @@ bool PolymorphicInstanceCallInstr::IsSureToCallSingleRecognizedTarget() const {
   return targets_.HasSingleRecognizedTarget();
 }
 
+bool StaticCallInstr::InitResultType(Zone* zone) {
+  const intptr_t list_cid = FactoryRecognizer::GetResultCidOfListFactory(
+      zone, function(), ArgumentCount());
+  if (list_cid != kDynamicCid) {
+    SetResultType(zone, CompileType::FromCid(list_cid));
+    set_is_known_list_constructor(true);
+    return true;
+  } else if (function().has_pragma()) {
+    intptr_t recognized_cid = MethodRecognizer::ResultCidFromPragma(function());
+    if (recognized_cid != kDynamicCid) {
+      SetResultType(zone, CompileType::FromCid(recognized_cid));
+      return true;
+    }
+  }
+  return false;
+}
+
 Definition* StaticCallInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!FLAG_precompiled_mode) {
     return this;
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
@@ -4067,6 +4067,11 @@ class StaticCallInstr : public TemplateDartCall<0> {
 
   virtual bool HasUnknownSideEffects() const { return true; }
 
+  // Initialize result type of this call instruction if target is a recognized
+  // method or has pragma annotation.
+  // Returns true on success, false if result type is still unknown.
+  bool InitResultType(Zone* zone);
+
   void SetResultType(Zone* zone, CompileType new_type) {
     result_type_ = new (zone) CompileType(new_type);
   }
diff --git a/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.cc b/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.cc
@@ -827,8 +827,7 @@ void BytecodeFlowGraphBuilder::BuildDirectCall() {
     call->set_entry_kind(Code::EntryKind::kUnchecked);
   }
 
-  // TODO(alexmarkov): add type info
-  // SetResultTypeForStaticCall(call, target, argument_count, result_type);
+  call->InitResultType(Z);
 
   code_ <<= call;
   B->Push(call);
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -470,50 +470,16 @@ Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                     rebind_rule);
 }
 
-static intptr_t GetResultCidOfListFactory(Zone* zone,
-                                          const Function& function,
-                                          intptr_t argument_count) {
-  if (!function.IsFactory()) {
-    return kDynamicCid;
-  }
-
-  const Class& owner = Class::Handle(zone, function.Owner());
-  if ((owner.library() != Library::CoreLibrary()) &&
-      (owner.library() != Library::TypedDataLibrary())) {
-    return kDynamicCid;
-  }
-
-  if ((owner.Name() == Symbols::List().raw()) &&
-      (function.name() == Symbols::ListFactory().raw())) {
-    ASSERT(argument_count == 1 || argument_count == 2);
-    return (argument_count == 1) ? kGrowableObjectArrayCid : kArrayCid;
-  }
-  return FactoryRecognizer::ResultCid(function);
-}
-
 void FlowGraphBuilder::SetResultTypeForStaticCall(
     StaticCallInstr* call,
     const Function& target,
     intptr_t argument_count,
     const InferredTypeMetadata* result_type) {
-  const intptr_t list_cid =
-      GetResultCidOfListFactory(Z, target, argument_count);
-  if (list_cid != kDynamicCid) {
+  if (call->InitResultType(Z)) {
     ASSERT((result_type == NULL) || (result_type->cid == kDynamicCid) ||
-           (result_type->cid == list_cid));
-    call->SetResultType(Z, CompileType::FromCid(list_cid));
-    call->set_is_known_list_constructor(true);
+           (result_type->cid == call->result_cid()));
     return;
   }
-  if (target.has_pragma()) {
-    intptr_t recognized_cid = MethodRecognizer::ResultCidFromPragma(target);
-    if (recognized_cid != kDynamicCid) {
-      ASSERT((result_type == NULL) || (result_type->cid == kDynamicCid) ||
-             (result_type->cid == recognized_cid));
-      call->SetResultType(Z, CompileType::FromCid(recognized_cid));
-      return;
-    }
-  }
   if ((result_type != NULL) && !result_type->IsTrivial()) {
     call->SetResultType(Z, result_type->ToCompileType(Z));
   }
diff --git a/runtime/vm/compiler/method_recognizer.cc b/runtime/vm/compiler/method_recognizer.cc
@@ -355,4 +355,26 @@ intptr_t FactoryRecognizer::ResultCid(const Function& factory) {
   return kDynamicCid;
 }
 
+intptr_t FactoryRecognizer::GetResultCidOfListFactory(Zone* zone,
+                                                      const Function& function,
+                                                      intptr_t argument_count) {
+  if (!function.IsFactory()) {
+    return kDynamicCid;
+  }
+
+  const Class& owner = Class::Handle(zone, function.Owner());
+  if ((owner.library() != Library::CoreLibrary()) &&
+      (owner.library() != Library::TypedDataLibrary())) {
+    return kDynamicCid;
+  }
+
+  if ((owner.Name() == Symbols::List().raw()) &&
+      (function.name() == Symbols::ListFactory().raw())) {
+    ASSERT(argument_count == 1 || argument_count == 2);
+    return (argument_count == 1) ? kGrowableObjectArrayCid : kArrayCid;
+  }
+
+  return ResultCid(function);
+}
+
 }  // namespace dart
diff --git a/runtime/vm/compiler/method_recognizer.h b/runtime/vm/compiler/method_recognizer.h
@@ -84,8 +84,16 @@ class MethodTokenRecognizer : public AllStatic {
 // Class that recognizes factories and returns corresponding result cid.
 class FactoryRecognizer : public AllStatic {
  public:
+  // Return result cid of 'factory' if it is recognized.
   // Return kDynamicCid if factory is not recognized.
   static intptr_t ResultCid(const Function& factory);
+
+  // Return result cid of 'function' called with 'argument_count' arguments,
+  // if function is a recognized list factory constructor.
+  // Return kDynamicCid if function is not recognized.
+  static intptr_t GetResultCidOfListFactory(Zone* zone,
+                                            const Function& function,
+                                            intptr_t argument_count);
 };
 
 }  // namespace dart

Original file line number	Diff line number	Diff line change
`@@ -827,8 +827,7 @@ void BytecodeFlowGraphBuilder::BuildDirectCall() {`
`827`	`827`	`call->set_entry_kind(Code::EntryKind::kUnchecked);`
`828`	`828`	`}`
`829`	`829`
`830`		`- // TODO(alexmarkov): add type info`
`831`		`- // SetResultTypeForStaticCall(call, target, argument_count, result_type);`
	`830`	`+ call->InitResultType(Z);`
`832`	`831`
`833`	`832`	`code_ <<= call;`
`834`	`833`	`B->Push(call);`