- Add a class index to the classes.

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 606 matching lines @@
 //   EDX : Array length as Smi.
 //   ECX : array element type (either NULL or an instantiated type).
 // Uses EAX, EBX, ECX, EDI  as temporary registers.
 // NOTE: EDX cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in EAX.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
-  if (FLAG_inline_alloc) {
+  if (0 && FLAG_inline_alloc) {
     // Compute the size to be allocated, it is based on the array length
     // and it computed as:
     // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
     // Assert that length is a Smi.
     __ testl(EDX, Immediate(kSmiTagSize));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
     } else {
       __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);
     }
@@ skipping 333 matching lines @@
 
 // Called for inline allocation of contexts.
 // Input:
 // EDX: number of context variables.
 // Output:
 // EAX: new allocated RawContext object.
 // EBX and EDX are destroyed.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  if (FLAG_inline_alloc) {
+  if (0 && FLAG_inline_alloc) {
     const Class& context_class = Class::ZoneHandle(Object::context_class());
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     // First compute the rounded instance size.
     // EDX: number of context variables.
     intptr_t fixed_size = (sizeof(RawContext) + kObjectAlignment - 1);
     __ leal(EBX, Address(EDX, TIMES_4, fixed_size));
     __ andl(EBX, Immediate(-kObjectAlignment));
 
     // Now allocate the object.
@@ skipping 29 matching lines @@
     // Calculate the size tag.
     // EAX: new object.
     // EDX: number of context variables.
     {
       Label size_tag_overflow, done;
       __ leal(EBX, Address(EDX, TIMES_4, fixed_size));
       __ andl(EBX, Immediate(-kObjectAlignment));
       __ cmpl(EBX, Immediate(RawObject::SizeTag::kMaxSizeTag));
       __ j(ABOVE, &size_tag_overflow, Assembler::kNearJump);
       __ shll(EBX, Immediate(RawObject::kSizeTagBit - kObjectAlignmentLog2));
-      __ movl(FieldAddress(EAX, Context::tags_offset()), EBX);  // Tags.
       __ jmp(&done);
 
       __ Bind(&size_tag_overflow);
       // Set overflow size tag value.
-      __ movl(FieldAddress(EAX, Context::tags_offset()), Immediate(0));
+      __ movl(EBX, Immediate(0));
+
       __ Bind(&done);
+      // EAX: new object.
+      // EDX: number of context variables.
+      // EBX: size and bit tags.
+      __ orl(EBX,
+             Immediate(RawObject::ClassTag::encode(context_class.index())));
+      __ movl(FieldAddress(EAX, Context::tags_offset()), EBX);  // Tags.
     }
 
     // Setup up number of context variables field.
     // EAX: new object.
     // EDX: number of context variables as integer value (not object).
     __ movl(FieldAddress(EAX, Context::num_variables_offset()), EDX);
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into EBX.
     // EAX: new object.
@@ skipping 135 matching lines @@
       // EDI: new object type arguments.
     }
 
     // Initialize the class field in the object.
     // EAX: new object start.
     // EBX: next object start.
     // EDI: new object type arguments (if is_cls_parameterized).
     __ LoadObject(EDX, cls);  // Load class of object to be allocated.
     __ movl(Address(EAX, Instance::class_offset()), EDX);
     // Set the tags.
-    __ movl(Address(EAX, Instance::tags_offset()),
-            Immediate(RawObject::SizeTag::encode(instance_size)));
+    intptr_t tags = 0;
+    tags = RawObject::SizeTag::update(instance_size, tags);
+    ASSERT(cls.index() != kIllegalObjectKind);
+    tags = RawObject::ClassTag::update(cls.index(), tags);
+    __ movl(Address(EAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the remaining words of the object.
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
     // EAX: new object start.
     // EBX: next object start.
     // EDX: class of the object to be allocated.
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize) &&
@@ skipping 97 matching lines @@
   const bool is_implicit_static_closure =
       func.IsImplicitStaticClosureFunction();
   const bool is_implicit_instance_closure =
       func.IsImplicitInstanceClosureFunction();
   const Class& cls = Class::ZoneHandle(func.signature_class());
   const bool has_type_arguments = cls.HasTypeArguments();
   const intptr_t kTypeArgumentsOffset = 1 * kWordSize;
   const intptr_t kReceiverOffset = (has_type_arguments ? 2 : 1) * kWordSize;
   const intptr_t closure_size = Closure::InstanceSize();
   const intptr_t context_size = Context::InstanceSize(1);  // Captured receiver.
-  if (FLAG_inline_alloc &&
+  if (0 && FLAG_inline_alloc &&
       PageSpace::IsPageAllocatableSize(closure_size + context_size)) {
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     __ movl(EAX, Address::Absolute(heap->TopAddress()));
     __ leal(EBX, Address(EAX, closure_size));
     if (is_implicit_instance_closure) {
       __ movl(ECX, EBX);  // ECX: new context address.
       __ addl(EBX, Immediate(context_size));
     }
     // Check if the allocation fits into the remaining space.
@@ skipping 507 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