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

src/mark-compact.cc

 // Copyright 2006-2008 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 1680 matching lines @@
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("relocate %p -> %p\n", obj->address(), new_addr);
   }
 #endif
 
   return obj_size;
 }
 
 
+// Not used for objects in data space as it doesn't handle heap number alignment
+// issues.
 int MarkCompactCollector::RelocateOldNonCodeObject(HeapObject* obj,
                                                    PagedSpace* space) {
   // Recover map pointer.
   MapWord encoding = obj->map_word();
   Address map_addr = encoding.DecodeMapAddress(Heap::map_space());
   ASSERT(Heap::map_space()->Contains(map_addr));
 
   // Get forwarding address before resetting map pointer.
   Address new_addr = GetForwardingAddressInOldSpace(obj);
 
   // Reset the map pointer.
   int obj_size = RestoreMap(obj, space, new_addr, map_addr);
 
   Address old_addr = obj->address();
 
   if (new_addr != old_addr) {
-    memmove(new_addr, old_addr, obj_size);  // Copy contents
+    memmove(new_addr, old_addr, obj_size);  // Copy contents.
   }
 
   ASSERT(!HeapObject::FromAddress(new_addr)->IsCode());
 
   return obj_size;
 }
 
 
 int MarkCompactCollector::RelocateOldPointerObject(HeapObject* obj) {
   return RelocateOldNonCodeObject(obj, Heap::old_pointer_space());
 }
 
 
 int MarkCompactCollector::RelocateOldDataObject(HeapObject* obj) {
-  return RelocateOldNonCodeObject(obj, Heap::old_data_space());
+  // Recover map pointer.
+  MapWord encoding = obj->map_word();
+  Address map_addr = encoding.DecodeMapAddress(Heap::map_space());
+  ASSERT(Heap::map_space()->Contains(map_addr));
+
+  // Get forwarding address before resetting map pointer.
+  Address new_addr = GetForwardingAddressInOldSpace(obj);
+
+  // Reset the map pointer.
+  int obj_size = RestoreMap(obj, Heap::old_data_space(), new_addr, map_addr);
+
+  Address old_addr = obj->address();
+
+  if (new_addr != old_addr) {
+    if (HeapNumber::NeedsSpecialCopying(obj_size, new_addr, old_addr)) {
+      memmove(new_addr, old_addr, kPointerSize);  // Copy map.
+      HeapNumber::cast(HeapObject::FromAddress(new_addr))->set_value(
+          HeapNumber::cast(obj)->value());
+    } else {
+      memmove(new_addr, old_addr, obj_size);  // Copy contents.
+    }
+  }
+
+  ASSERT(!HeapObject::FromAddress(new_addr)->IsCode());
+
+  return obj_size;
 }
 
 
 int MarkCompactCollector::RelocateCellObject(HeapObject* obj) {
   return RelocateOldNonCodeObject(obj, Heap::cell_space());
 }
 
 
 int MarkCompactCollector::RelocateCodeObject(HeapObject* obj) {
   // Recover map pointer.
@@ skipping 21 matching lines @@
     LOG(CodeMoveEvent(old_addr, new_addr));
   }
 
   return obj_size;
 }
 
 
 int MarkCompactCollector::RelocateNewObject(HeapObject* obj) {
   int obj_size = obj->Size();
 
-  // Get forwarding address
+  // Get forwarding address.
   Address old_addr = obj->address();
   int offset = Heap::new_space()->ToSpaceOffsetForAddress(old_addr);
 
   Address new_addr =
     Memory::Address_at(Heap::new_space()->FromSpaceLow() + offset);
 
 #ifdef DEBUG
   if (Heap::new_space()->FromSpaceContains(new_addr)) {
     ASSERT(Heap::new_space()->FromSpaceOffsetForAddress(new_addr) <=
            Heap::new_space()->ToSpaceOffsetForAddress(old_addr));
   } else {
     ASSERT(Heap::TargetSpace(obj) == Heap::old_pointer_space() ||
            Heap::TargetSpace(obj) == Heap::old_data_space());
   }
 #endif
 
-  // New and old addresses cannot overlap.
-  memcpy(reinterpret_cast<void*>(new_addr),
-         reinterpret_cast<void*>(old_addr),
-         obj_size);
+  if (HeapNumber::NeedsSpecialCopying(obj_size, new_addr, old_addr)) {
+    memcpy(reinterpret_cast<void*>(new_addr),
+           reinterpret_cast<void*>(old_addr),
+           kPointerSize);
+    HeapNumber::cast(HeapObject::FromAddress(new_addr))->set_value(
+        HeapNumber::cast(obj)->value());
+  } else {
+    // New and old addresses cannot overlap.
+    memcpy(reinterpret_cast<void*>(new_addr),
+           reinterpret_cast<void*>(old_addr),
+           obj_size);
+  }
 
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("relocate %p -> %p\n", old_addr, new_addr);
   }
 #endif
 
   return obj_size;
 }
 
 
 // -------------------------------------------------------------------------
 // Phase 5: rebuild remembered sets
 
 void MarkCompactCollector::RebuildRSets() {
 #ifdef DEBUG
   ASSERT(state_ == RELOCATE_OBJECTS);
   state_ = REBUILD_RSETS;
 #endif
   Heap::RebuildRSets();
 }
 
 } }  // namespace v8::internal