Properly set the element type of literal lists.

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 "lib/error.h"
@@ skipping 905 matching lines @@
   __ popq(RCX);  // Pop type arguments.
   __ popq(RCX);  // Pop class.
   __ popq(RCX);  // Pop source location.
   __ popq(RAX);  // Pop new instance.
 }
 
 
 void FlowGraphCompiler::VisitCreateArray(CreateArrayComp* comp) {
   // 1. Allocate the array.  R10 = length, RBX = element type.
   __ movq(R10, Immediate(Smi::RawValue(comp->ElementCount())));
-  const AbstractTypeArguments& element_type = comp->type_arguments();
-  ASSERT(element_type.IsNull() || element_type.IsInstantiated());
-  __ LoadObject(RBX, element_type);
+  LoadValue(RBX, comp->element_type());
   GenerateCall(comp->token_index(),
                comp->try_index(),
                &StubCode::AllocateArrayLabel(),
                PcDescriptors::kOther);
 
   // 2. Initialize the array in RAX with the element values.
   __ leaq(RCX, FieldAddress(RAX, Array::data_offset()));
   for (int i = comp->ElementCount() - 1; i >= 0; --i) {
     if (comp->ElementAt(i)->IsTemp()) {
       __ popq(Address(RCX, i * kWordSize));
@@ skipping 22 matching lines @@
   }
 }
 
 
 void FlowGraphCompiler::VisitNativeLoadField(NativeLoadFieldComp* comp) {
   __ popq(RAX);
   __ movq(RAX, FieldAddress(RAX, comp->offset_in_bytes()));
 }
 
 
-void FlowGraphCompiler::VisitExtractFactoryTypeArguments(
-    ExtractFactoryTypeArgumentsComp* comp) {
+void FlowGraphCompiler::VisitInstantiateTypeArguments(
+    InstantiateTypeArgumentsComp* comp) {
   __ popq(RAX);  // Instantiator.
 
   // RAX is the instantiator AbstractTypeArguments object (or null).
   // 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 =
@@ skipping 11 matching lines @@
     __ 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(Smi::RawValue(comp->type_arguments().Length()));
     __ cmpq(FieldAddress(RAX, TypeArguments::length_offset()),
         arguments_length);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
-  // A runtime call to instantiate the type arguments is required before
-  // calling the factory.
+  // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(comp->type_arguments());
   __ pushq(RAX);  // Push instantiator type arguments.
   GenerateCallRuntime(comp->cid(),
                       comp->token_index(),
                       comp->try_index(),
                       kInstantiateTypeArgumentsRuntimeEntry);
   __ popq(RAX);  // Pop instantiator type arguments.
   __ popq(RAX);  // Pop uninstantiated type arguments.
   __ popq(RAX);  // Pop instantiated type arguments.
@@ skipping 67 matching lines @@
     __ 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.
-    // TODO(regis): This code will still change, because bounds checking is not
-    // implemented yet.
 
     // 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, &done, Assembler::kNearJump);
     Immediate arguments_length =
         Immediate(Smi::RawValue(comp->type_arguments().Length()));
@@ skipping 623 matching lines @@
   ASSERT(exception_handlers_list_ != NULL);
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64