Recognize more list factories. Recognizing list factories (Array, Bytearrays, etc) allows the type …

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 1958 matching lines @@
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
   Do(new StaticCallInstr(node->token_pos(),
                          node->constructor(),
                          node->arguments()->names(),
                          arguments));
 }
 
 
-// List of recognized factories in core lib (factories with known result-cid):
+// List of recognized list factories in core lib:
 // (factory-name-symbol, result-cid, fingerprint).
-#define RECOGNIZED_FACTORY_LIST(V)                                             \
-  V(ObjectArrayDot, kArrayCid, 97987288)                                       \
+// TODO(srdjan): Store the values in the snapshot instead.
+// TODO(srdjan): Add Float32x4List.
+#define RECOGNIZED_LIST_FACTORY_LIST(V)                                        \
+  V(ObjectArrayFactory, kArrayCid, 97987288)                                   \
   V(GrowableObjectArrayWithData, kGrowableObjectArrayCid, 816132033)           \
-  V(GrowableObjectArrayDot, kGrowableObjectArrayCid, 1896741574)               \
+  V(GrowableObjectArrayFactory, kGrowableObjectArrayCid, 1896741574)           \
+  V(Int8ListFactory, kInt8ArrayCid, 817410959)                                 \
+  V(Uint8ListFactory, kUint8ArrayCid, 220896178)                               \
+  V(Uint8ClampedListFactory, kUint8ClampedArrayCid, 422034060)                 \
+  V(Int16ListFactory, kInt16ArrayCid, 214246025)                               \
+  V(Uint16ListFactory, kUint16ArrayCid, 137929963)                             \
+  V(Int32ListFactory, kInt32ArrayCid, 1977571010)                              \
+  V(Uint32ListFactory, kUint32ArrayCid, 407638944)                             \
+  V(Int64ListFactory, kInt64ArrayCid, 885130273)                               \
+  V(Uint64ListFactory, kUint64ArrayCid, 1471017221)                            \
+  V(Float64ListFactory, kFloat64ArrayCid, 1037441059)                          \
+  V(Float32ListFactory, kFloat32ArrayCid, 2035252095)                          \
 
 
 // Class that recognizes factories and returns corresponding result cid.
 class FactoryRecognizer : public AllStatic {
  public:
   // Return kDynamicCid if factory is not recognized.
   static intptr_t ResultCid(const Function& factory) {
     ASSERT(factory.IsFactory());
     const Class& function_class = Class::Handle(factory.Owner());
     const Library& lib = Library::Handle(function_class.library());
-    if (lib.raw() != Library::CoreLibrary()) {
-      // Only core library factories recognized.
-      return kDynamicCid;
-    }
+    ASSERT((lib.raw() == Library::CoreLibrary()) ||
+        (lib.raw() == Library::ScalarlistLibrary()));
     const String& factory_name = String::Handle(factory.name());
 #define RECOGNIZE_FACTORY(test_factory_symbol, cid, fp)                        \
     if (String::EqualsIgnoringPrivateKey(                                      \
         factory_name, Symbols::test_factory_symbol())) {                       \
       ASSERT(factory.CheckSourceFingerprint(fp));                              \
       return cid;                                                              \
     }                                                                          \
 
-RECOGNIZED_FACTORY_LIST(RECOGNIZE_FACTORY);
+RECOGNIZED_LIST_FACTORY_LIST(RECOGNIZE_FACTORY);
 #undef RECOGNIZE_FACTORY
 
     return kDynamicCid;
   }
 };
 
 
-static intptr_t GetResultCidOfConstructor(ConstructorCallNode* node) {
+static intptr_t GetResultCidOfListFactory(ConstructorCallNode* node) {
   const Function& function = node->constructor();
   const Class& function_class = Class::Handle(function.Owner());
-  const Library& core_lib = Library::Handle(Library::CoreLibrary());
 
-  if (function_class.library() != core_lib.raw()) {
+  if ((function_class.library() != Library::CoreLibrary()) &&
+      (function_class.library() != Library::ScalarlistLibrary())) {
     return kDynamicCid;
   }
 
   if (node->constructor().IsFactory()) {
     if ((function_class.Name() == Symbols::List().raw()) &&
         (function.name() == Symbols::ListFactory().raw())) {
       // Special recognition of 'new List()' vs 'new List(n)'.
       if (node->arguments()->length() == 0) {
         return kGrowableObjectArrayCid;
       }
       return kArrayCid;
     }
     return FactoryRecognizer::ResultCid(function);
   }
-  return kDynamicCid;   // Result cid not known.
+  return kDynamicCid;   // Not a known list constructor.
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments = PushArgument(
         BuildInstantiatedTypeArguments(node->token_pos(),
                                        node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
     StaticCallInstr* call =
         new StaticCallInstr(node->token_pos(),
                             node->constructor(),
                             node->arguments()->names(),
                             arguments);
-    // List factories return kArrayCid or kGrowableObjectArrayCid.
-    const intptr_t result_cid = GetResultCidOfConstructor(node);
-    call->set_result_cid(result_cid);
-    call->set_is_known_constructor(result_cid != kDynamicCid);
+    const intptr_t result_cid = GetResultCidOfListFactory(node);
+    if (result_cid != kDynamicCid) {
+      call->set_result_cid(result_cid);
+      call->set_is_known_list_constructor(true);
+      // Recognized fixed length array factory must have two arguments:
+      // (0) type-arguments, (1) length.
+      ASSERT(!LoadFieldInstr::IsFixedLengthArrayCid(result_cid) ||
+             arguments->length() == 2);
+    }
     ReturnDefinition(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Value* allocated_value = BuildObjectAllocation(node);
@@ skipping 1207 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart