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

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2011, 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"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/object_store.h"
@@ skipping 726 matching lines @@
     __ ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   __ EnterFrame(0);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDX);  // Array length as Smi.
   __ pushl(ECX);  // Element type.
-  __ pushl(raw_null);  // Null instantiator.
   __ CallRuntimeFromStub(kAllocateArrayRuntimeEntry);
-  __ popl(EAX);  // Pop instantiator.
   __ popl(EAX);  // Pop element type argument.
   __ popl(EDX);  // Pop array length argument.
   __ popl(EAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   EDX: Arguments descriptor array (num_args is first Smi element, closure
@@ skipping 358 matching lines @@
   const intptr_t type_args_size = InstantiatedTypeArguments::InstanceSize();
   if (FLAG_inline_alloc &&
       PageSpace::IsPageAllocatableSize(instance_size + type_args_size)) {
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     __ movl(EAX, Address::Absolute(heap->TopAddress()));
     __ leal(EBX, Address(EAX, instance_size));
     if (is_cls_parameterized) {
       __ movl(ECX, EBX);
       // A new InstantiatedTypeArguments object only needs to be allocated if
-      // the instantiator is non-null.
-      Label null_instantiator;
-      __ cmpl(Address(ESP, kInstantiatorTypeArgumentsOffset), raw_null);
-      __ j(EQUAL, &null_instantiator, Assembler::kNearJump);
+      // the instantiator is provided (not kNoInstantiator, but may be null).
+      Label no_instantiator;
+      __ cmpl(Address(ESP, kInstantiatorTypeArgumentsOffset),
+              Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
+      __ j(EQUAL, &no_instantiator, Assembler::kNearJump);
       __ addl(EBX, Immediate(type_args_size));
-      __ Bind(&null_instantiator);
+      __ Bind(&no_instantiator);
       // ECX: potential new object end and, if ECX != EBX, potential new
       // InstantiatedTypeArguments object start.
     }
     // Check if the allocation fits into the remaining space.
     // EAX: potential new object start.
     // EBX: potential next object start.
     __ cmpl(EBX, Address::Absolute(heap->EndAddress()));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
     } else {
@@ skipping 121 matching lines @@
   }
   // Create a stub frame.
   __ EnterFrame(0);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushl(EAX);  // Push type arguments of object to be allocated.
     __ pushl(EDX);  // Push type arguments of instantiator.
   } else {
     __ pushl(raw_null);  // Push null type arguments.
-    __ pushl(raw_null);  // Push null instantiator.
+    __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ CallRuntimeFromStub(kAllocateObjectRuntimeEntry);  // Allocate object.
   __ popl(EAX);  // Pop argument (instantiator).
   __ popl(EAX);  // Pop argument (type arguments of object).
   __ popl(EAX);  // Pop argument (class of object).
   __ popl(EAX);  // Pop result (newly allocated object).
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
@@ skipping 545 matching lines @@
   __ movl(ECX, FieldAddress(ECX, Type::type_class_offset()));
   __ cmpl(EDX, ECX);
   __ j(NOT_EQUAL, &super_loop, Assembler::kNearJump);
   __ jmp(&found, Assembler::kNearJump);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32