Always 64-bit align floating point values in heap numbers....

src/heap.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 755 matching lines @@
     }
 
     // Promote and process all the to-be-promoted objects.
     while (!promotion_queue.is_empty()) {
       HeapObject* source;
       Map* map;
       promotion_queue.remove(&source, &map);
       // Copy the from-space object to its new location (given by the
       // forwarding address) and fix its map.
       HeapObject* target = source->map_word().ToForwardingAddress();
+      // We don't need to worry about alignment and HeapNumbers here because
+      // a heap number is put in data space directly and not queued up for
+      // copying and scanning for pointers here.
       CopyBlock(reinterpret_cast<Object**>(target->address()),
                 reinterpret_cast<Object**>(source->address()),
                 source->SizeFromMap(map));
       target->set_map(map);
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
       // Update NewSpace stats if necessary.
       RecordCopiedObject(target);
 #endif
       // Visit the newly copied object for pointers to new space.
@@ skipping 143 matching lines @@
       new_space_.RecordPromotion(obj);
     }
   }
 }
 #endif  // defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
 
 
 
 HeapObject* Heap::MigrateObject(HeapObject* source,
                                 HeapObject* target,
-                                int size) {
-  // Copy the content of source to target.
-  CopyBlock(reinterpret_cast<Object**>(target->address()),
-            reinterpret_cast<Object**>(source->address()),
-            size);
+                                int size,
+                                MapWord first_word) {
+  if (kObjectAlignment == 4 &&
+      size == HeapNumber::kSize &&
+      ((reinterpret_cast<intptr_t>(source) & 7) !=
+       (reinterpret_cast<intptr_t>(target) & 7)) &&
+      first_word.ToMap() == Heap::heap_number_map()) {
+    target->set_map_word(first_word);
+    reinterpret_cast<HeapNumber*>(source)->CopyBodyTo(target);
+  } else {
+    // Copy the content of source to target.
+    CopyBlock(reinterpret_cast<Object**>(target->address()),
+              reinterpret_cast<Object**>(source->address()),
+              size);
+  }
 
   // Set the forwarding address.
   source->set_map_word(MapWord::FromForwardingAddress(target));
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   // Update NewSpace stats if necessary.
   RecordCopiedObject(target);
 #endif
 
   return target;
@@ skipping 78 matching lines @@
           // list).
           FreeListNode* node = FreeListNode::FromAddress(target->address());
           node->set_size(object_size);
 
           *p = target;
         } else {
           // Objects promoted to the data space can be copied immediately
           // and not revisited---we will never sweep that space for
           // pointers and the copied objects do not contain pointers to
           // new space objects.
-          *p = MigrateObject(object, target, object_size);
+          *p = MigrateObject(object, target, object_size, first_word);
 #ifdef DEBUG
           VerifyNonPointerSpacePointersVisitor v;
           (*p)->Iterate(&v);
 #endif
         }
         return;
       }
     }
   }
   // The object should remain in new space or the old space allocation failed.
   Object* result = new_space_.AllocateRaw(object_size);
   // Failed allocation at this point is utterly unexpected.
   ASSERT(!result->IsFailure());
-  *p = MigrateObject(object, HeapObject::cast(result), object_size);
+  HeapObject* target = HeapObject::cast(result);
+  *p = MigrateObject(object,
+                     HeapObject::cast(target),
+                     object_size,
+                     first_word);
 }
 
 
 void Heap::ScavengePointer(HeapObject** p) {
   ScavengeObject(p, *p);
 }
 
 
 Object* Heap::AllocatePartialMap(InstanceType instance_type,
                                  int instance_size) {
@@ skipping 2898 matching lines @@
   for (int i = 0; i < kNumberOfCaches; i++) {
     if (caches_[i] != NULL) {
       delete caches_[i];
       caches_[i] = NULL;
     }
   }
 }
 
 
 } }  // namespace v8::internal