Use null type argument vector instead of vector of Dynamic for a generic raw

runtime/vm/code_generator_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 693 matching lines @@
     } else {
       __ LoadObject(RAX, literal);
     }
   } else {
     // Pop the previously evaluated result value into RAX.
     __ popq(RAX);
   }
 
   // Generate type check.
   if (FLAG_enable_type_checks) {
-    const RawFunction::Kind  kind = parsed_function().function().kind();
+    const bool returns_null = node->value()->IsLiteralNode() &&
+       node->value()->AsLiteralNode()->literal().IsNull();
+    const RawFunction::Kind kind = parsed_function().function().kind();
     // Implicit getters do not need a type check at return.
-    if ((kind != RawFunction::kImplicitGetter) &&
+    if (!returns_null &&
+        (kind != RawFunction::kImplicitGetter) &&
         (kind != RawFunction::kConstImplicitGetter)) {
       GenerateAssertAssignable(
           node->id(),
           node->value()->token_index(),
           AbstractType::ZoneHandle(parsed_function().function().result_type()),
           String::ZoneHandle(String::NewSymbol("function result")));
     }
   }
   GenerateReturnEpilog(node);
 }
@@ skipping 592 matching lines @@
 
     const Class& type_class = Class::ZoneHandle(type.type_class());
     const bool requires_type_arguments = type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (requires_type_arguments) {
       const AbstractTypeArguments& type_arguments =
           AbstractTypeArguments::Handle(type.arguments());
       const bool is_raw_type = type_arguments.IsNull() ||
-          type_arguments.IsDynamicTypes(type_arguments.Length());
+          type_arguments.IsRaw(type_arguments.Length());
       Label runtime_call;
       __ testq(RAX, Immediate(kSmiTagMask));
       __ j(ZERO, &runtime_call, Assembler::kNearJump);
       // Object not Smi.
       if (is_raw_type) {
         if (type.IsListInterface()) {
           Label push_result;
           // TODO(srdjan) also accept List<Object>.
           __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
           __ CompareObject(RCX, *CoreClass("ObjectArray"));
@@ skipping 158 matching lines @@
   if (dst_type.IsInstantiated()) {
     const Class& dst_type_class = Class::ZoneHandle(dst_type.type_class());
     const bool dst_class_has_type_arguments = dst_type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (dst_class_has_type_arguments) {
       const AbstractTypeArguments& dst_type_arguments =
           AbstractTypeArguments::Handle(dst_type.arguments());
       const bool is_raw_dst_type = dst_type_arguments.IsNull() ||
-          dst_type_arguments.IsDynamicTypes(dst_type_arguments.Length());
+          dst_type_arguments.IsRaw(dst_type_arguments.Length());
       if (is_raw_dst_type) {
         // Dynamic type argument, check only classes.
         if (dst_type.IsListInterface()) {
           // TODO(srdjan) also accept List<Object>.
           __ testq(RAX, Immediate(kSmiTagMask));
           __ j(ZERO, &runtime_call);
           __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
           TestClassAndJump(*CoreClass("ObjectArray"), &done);
           TestClassAndJump(*CoreClass("GrowableObjectArray"), &done);
         } else if (!dst_type_class.is_interface()) {
@@ skipping 738 matching lines @@
                                           bool requires_type_arguments) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Instantiate the type arguments if necessary.
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
     if (requires_type_arguments) {
       // A factory requires the type arguments as first parameter.
       __ PushObject(node->type_arguments());
       if (!node->constructor().IsFactory()) {
-        // The allocator additionally requires the instantiator type arguments.
-        __ pushq(raw_null);  // Null instantiator.
+        // The non-factory allocator additionally requires the instantiator
+        // type arguments which are not needed here, since the type arguments
+        // are instantiated.
+        __ pushq(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
       }
     }
   } else {
     // The type arguments are uninstantiated.
     ASSERT(requires_type_arguments);
     GenerateInstantiatorTypeArguments(node->token_index());
     __ popq(RAX);  // Pop instantiator.
     // RAX is the instantiator AbstractTypeArguments object (or null).
-    // If RAX is null, no need to instantiate the type arguments, use null, and
-    // allocate an object of a raw type.
-    Label type_arguments_instantiated, type_arguments_uninstantiated;
-    __ cmpq(RAX, raw_null);
-    __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
-
+    // If the instantiator is null and if the type argument vector
+    // instantiated from null becomes a vector of Dynamic, then use null as
+    // the type arguments.
+    Label type_arguments_instantiated;
+    const intptr_t len = node->type_arguments().Length();
+    if (node->type_arguments().IsRawInstantiatedRaw(len)) {
+      __ cmpq(RAX, raw_null);
+      __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
+    }
     // Instantiate non-null type arguments.
     if (node->type_arguments().IsUninstantiatedIdentity()) {
       // Check if the instantiator type argument vector is a TypeArguments of a
       // matching length and, if so, use it as the instantiated type_arguments.
+      // No need to check RAX for null (again), because a null instance will
+      // have the wrong class (Null instead of TypeArguments).
+      Label type_arguments_uninstantiated;
       __ LoadObject(RCX, Class::ZoneHandle(Object::type_arguments_class()));
       __ cmpq(RCX, FieldAddress(RAX, Object::class_offset()));
       __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
       Immediate arguments_length = Immediate(reinterpret_cast<int64_t>(
           Smi::New(node->type_arguments().Length())));
       __ cmpq(FieldAddress(RAX, TypeArguments::length_offset()),
           arguments_length);
       __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
+      __ Bind(&type_arguments_uninstantiated);
     }
-    __ Bind(&type_arguments_uninstantiated);
     if (node->constructor().IsFactory()) {
       // A runtime call to instantiate the type arguments is required before
       // calling the factory.
       __ PushObject(Object::ZoneHandle());  // Make room for the result.
       __ PushObject(node->type_arguments());
       __ pushq(RAX);  // Push instantiator type arguments.
       GenerateCallRuntime(node->id(),
                           node->token_index(),
                           kInstantiateTypeArgumentsRuntimeEntry);
       __ popq(RAX);  // Pop instantiator type arguments.
       __ popq(RAX);  // Pop uninstantiated type arguments.
       __ popq(RAX);  // Pop instantiated type arguments.
       __ Bind(&type_arguments_instantiated);
       __ pushq(RAX);  // Instantiated type arguments.
     } else {
       // In the non-factory case, we rely on the allocation stub to
       // instantiate the type arguments.
       __ PushObject(node->type_arguments());
       __ pushq(RAX);  // Instantiator type arguments.
       Label type_arguments_pushed;
       __ jmp(&type_arguments_pushed, Assembler::kNearJump);
 
       __ Bind(&type_arguments_instantiated);
       __ pushq(RAX);  // Instantiated type arguments.
-      __ pushq(raw_null);  // Null instantiator.
+      __ pushq(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
       __ Bind(&type_arguments_pushed);
     }
   }
 }
 
 
 void CodeGenerator::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     const bool requires_type_arguments = true;  // Always first arg to factory.
     GenerateTypeArguments(node, requires_type_arguments);
@@ skipping 31 matching lines @@
   }
 
   if (IsResultNeeded(node)) {
     __ pushq(RAX);  // Set up return value from allocate.
   }
 
   // First argument(this) for constructor call which follows.
   __ pushq(RAX);
   // Second argument is the implicit construction phase parameter.
   // Run both the constructor initializer list and the constructor body.
-  __ PushObject(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
-
+  __ pushq(Immediate(Smi::RawValue(Function::kCtorPhaseAll)));
 
   // Now setup rest of the arguments for the constructor call.
   node->arguments()->Visit(this);
 
   // Call the constructor.
   // +2 to include implicit receiver and phase arguments.
   int num_args = node->arguments()->length() + 2;
   __ LoadObject(RBX, node->constructor());
   __ LoadObject(R10, ArgumentsDescriptor(num_args, node->arguments()->names()));
   GenerateCall(node->token_index(),
@@ skipping 320 matching lines @@
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64