MIPS: Ensure proper alignment of LazyInstance objects.

src/lazy-instance.h

 // Copyright 2012 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 86 matching lines @@
 
 
 template <typename T>
 struct LeakyInstanceTrait {
   static void Destroy(T* /* instance */) {}
 };
 
 
 // Traits that define how an instance is allocated and accessed.
 
+#if V8_HOST_ARCH_MIPS

[danno, 2012/03/16 12:40:08]

I'd prefer avoiding the platform-specific define. Is there a more general test
about the target architecture that can determine if this is needed? Is it
harmful to have this always present for GCC-based builds?

+#define LAZY_ALIGN(x) __attribute__((aligned(__alignof__(x))))
+#else  // V8_HOST_ARCH_MIPS
+#define LAZY_ALIGN(x)
+#endif
+
 template <typename T>
 struct StaticallyAllocatedInstanceTrait {
-  typedef char StorageType[sizeof(T)];
+  typedef char StorageType[sizeof(T)] LAZY_ALIGN(T);
 
   static T* MutableInstance(StorageType* storage) {
     return reinterpret_cast<T*>(storage);
   }
 
   template <typename ConstructTrait>
   static void InitStorageUsingTrait(StorageType* storage) {
     ConstructTrait::Construct(MutableInstance(storage));
   }
 };
@@ skipping 52 matching lines @@
     Init();
     return AllocationTrait::MutableInstance(&storage_);
   }
 
   const T& Get() const {
     Init();
     return *AllocationTrait::MutableInstance(&storage_);
   }
 
   mutable OnceType once_;
   // Note that the previous field, OnceType, is an AtomicWord which guarantees

[Philippe, 2012/03/16 12:24:30]

We noticed this issue and thought that we could temporarily rely on the
AtomicWord field (once_) to guarantee the correct alignment. Does this issue
apply to architectures other than MIPS? Should we always use the alignof
attribute (with GCC)? You could probably update the comment here.

Thanks for fixing this.

[danno, 2012/03/16 12:40:08]

Done.

   // the correct alignment of the storage field below.
   mutable StorageType storage_;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultConstructTrait<T>,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyStaticInstance {
   typedef LazyInstanceImpl<T, StaticallyAllocatedInstanceTrait<T>, CreateTrait,
@@ skipping 14 matching lines @@
           typename CreateTrait = DefaultConstructTrait<T>,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyDynamicInstance {
   typedef LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>, CreateTrait,
       DestroyTrait> type;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_LAZY_INSTANCE_H_