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

runtime/vm/flow_graph_compiler_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/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 467 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 129 matching lines @@
 
 void FlowGraphCompiler::VisitCreateClosure(CreateClosureComp* comp) {
   const Function& function = comp->function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(function));
   const ExternalLabel label(function.ToCString(), stub.EntryPoint());
   GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
 
   const Class& cls = Class::Handle(function.signature_class());
   if (cls.HasTypeArguments()) {
+    UNIMPLEMENTED();  // We should have bailed out.
     __ popq(RCX);  // Discard type arguments.
   }
   if (function.IsImplicitInstanceClosureFunction()) {
     __ popq(RCX);  // Discard receiver.
   }
 }
 
 
 void FlowGraphCompiler::VisitNativeLoadField(NativeLoadFieldComp* comp) {
   __ popq(RAX);
   __ movq(RAX, FieldAddress(RAX, comp->offset_in_bytes()));
 }
 
 
 void FlowGraphCompiler::VisitExtractFactoryTypeArguments(
     ExtractFactoryTypeArgumentsComp* comp) {
   __ popq(RAX);  // 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.
-  const Immediate raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  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 = comp->type_arguments().Length();
+  if (comp->type_arguments().IsRawInstantiatedRaw(len)) {
+    const Immediate raw_null =
+        Immediate(reinterpret_cast<intptr_t>(Object::null()));
+    __ cmpq(RAX, raw_null);
+    __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
+  }
   // Instantiate non-null type arguments.
   if (comp->type_arguments().IsUninstantiatedIdentity()) {
+    Label type_arguments_uninstantiated;
     // 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 the instantiator (RAX) for null here, because a null
+    // instantiator will have the wrong class (Null instead of TypeArguments).
     __ 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(comp->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);
   // A runtime call to instantiate the type arguments is required before
   // calling the factory.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(comp->type_arguments());
   __ pushq(RAX);  // Push instantiator type arguments.
   GenerateCallRuntime(comp->node_id(),
                       comp->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);
   // RAX: Instantiated type arguments.
 }
 
 
 void FlowGraphCompiler::VisitExtractConstructorTypeArguments(
     ExtractConstructorTypeArgumentsComp* comp) {
   __ popq(RAX);  // 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.
-  // TODO(regis): The above sentence is actually not correct. If the type
-  // arguments are only partially uninstantiated, we are losing type information
-  // by allocating a raw type. The code needs to be fixed here and in the
-  // unoptimized version (both ia32 and x64).
-  const Immediate raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  Label type_arguments_instantiated, type_arguments_uninstantiated;
-  __ cmpq(RAX, raw_null);
-  __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
-
-  // Check if type arguments represent the uninstantiated identity vector.
+  // 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 = comp->type_arguments().Length();
+  if (comp->type_arguments().IsRawInstantiatedRaw(len)) {
+    const Immediate raw_null =
+        Immediate(reinterpret_cast<intptr_t>(Object::null()));
+    __ cmpq(RAX, raw_null);
+    __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
+  }
+  // Instantiate non-null type arguments.
   if (comp->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 the instantiator (RAX) for null here, because a null
+    // instantiator 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(comp->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);
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
   __ LoadObject(RAX, comp->type_arguments());
   // RAX: uninstantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   // RAX: uninstantiated or instantiated type arguments.
 }
 
 
 void FlowGraphCompiler::VisitExtractConstructorInstantiator(
     ExtractConstructorInstantiatorComp* comp) {
   __ popq(RCX);  // Discard value.
   __ popq(RAX);  // 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.
-  // TODO(regis): The above sentence is actually not correct. If the type
-  // arguments are only partially uninstantiated, we are losing type information
-  // by allocating a raw type. The code needs to be fixed here and in the
-  // unoptimized version (both ia32 and x64).
-
-  // If type arguments represent the uninstantiated identity vector and if the
-  // instantiator is not null, the instantiator was used as type arguments,
-  // therefore, the instantiator must be reset to null here to indicate to the
-  // allocator that the type arguments are instantiated.
+  // 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 and do not pass the instantiator.
+  Label done;
+  const intptr_t len = comp->type_arguments().Length();
+  if (comp->type_arguments().IsRawInstantiatedRaw(len)) {
+    const Immediate raw_null =
+        Immediate(reinterpret_cast<intptr_t>(Object::null()));
+    Label instantiator_not_null;
+    __ cmpq(RAX, raw_null);
+    __ j(NOT_EQUAL, &instantiator_not_null, Assembler::kNearJump);
+    // Null was used in VisitExtractConstructorTypeArguments as the
+    // instantiated type arguments, no proper instantiator needed.
+    __ movq(RAX, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
+    __ jmp(&done);
+    __ Bind(&instantiator_not_null);
+  }
+  // Instantiate non-null type arguments.
   if (comp->type_arguments().IsUninstantiatedIdentity()) {
     // TODO(regis): The following emitted code is duplicated in
     // VisitExtractConstructorTypeArguments above. The reason is that the code
     // is split between two computations, so that each one produces a
     // single value, rather than producing a pair of values.
     // If this becomes an issue, we should expose these tests at the IL level.
-    // Note that this code will still change, because bounds checking is not
+    // TODO(regis): This code will still change, because bounds checking is not
     // implemented yet.
-    const Immediate raw_null =
-          Immediate(reinterpret_cast<intptr_t>(Object::null()));
-    Label use_instantiator;
-    __ cmpq(RAX, raw_null);
-    __ j(EQUAL, &use_instantiator, Assembler::kNearJump);  // Already null.
 
     // 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 the instantiator (RAX) for null here, because a null
+    // instantiator will have the wrong class (Null instead of TypeArguments).
     __ LoadObject(RCX, Class::ZoneHandle(Object::type_arguments_class()));
     __ cmpq(RCX, FieldAddress(RAX, Object::class_offset()));
-    __ j(NOT_EQUAL, &use_instantiator, Assembler::kNearJump);
+    __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     Immediate arguments_length = Immediate(reinterpret_cast<int64_t>(
         Smi::New(comp->type_arguments().Length())));
     __ cmpq(FieldAddress(RAX, TypeArguments::length_offset()),
         arguments_length);
-    __ j(NOT_EQUAL, &use_instantiator, Assembler::kNearJump);
+    __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     // The instantiator was used in VisitExtractConstructorTypeArguments as the
-    // instantiated type arguments, reset instantiator to null.
-    __ movq(RAX, raw_null);  // Null instantiator.
-    __ Bind(&use_instantiator);  // Use instantiator in RAX.
+    // instantiated type arguments, no proper instantiator needed.
+    __ movq(RAX, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
-  // In the non-factory case, we rely on the allocation stub to
-  // instantiate the type arguments.
-  // RAX: instantiator or null.
+  __ Bind(&done);
+  // RAX: instantiator or kNoInstantiator.
 }
 
 
 void FlowGraphCompiler::VisitAllocateContext(AllocateContextComp* comp) {
   __ movq(R10, Immediate(comp->num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
 }
 
@@ skipping 476 matching lines @@
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
   // We don't compile exception handlers yet.
   code.set_exception_handlers(
       ExceptionHandlers::Handle(ExceptionHandlers::New(0)));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64