Fix performance regressions due to lazy initialization.

src/platform.h

 // Copyright 2011 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 101 matching lines @@
 //
 // This class has static methods for the different platform specific
 // functions. Add methods here to cope with differences between the
 // supported platforms.
 
 class OS {
  public:
   // Initializes the platform OS support. Called once at VM startup.
   static void SetUp();
 
+  // Initializes the platform OS support that depend on CPU features. This is
+  // called after CPU initialization.
+  static void PostSetUp();
+
   // Returns the accumulated user time for thread. This routine
   // can be used for profiling. The implementation should
   // strive for high-precision timer resolution, preferable
   // micro-second resolution.
   static int GetUserTime(uint32_t* secs,  uint32_t* usecs);
 
   // Get a tick counter normalized to one tick per microsecond.
   // Used for calculating time intervals.
   static int64_t Ticks();
 
@@ skipping 406 matching lines @@
 
 // POD Mutex initialized lazily (i.e. the first time Pointer() is called).
 // Usage:
 //   static LazyMutex my_mutex = LAZY_MUTEX_INITIALIZER;
 //
 //   void my_function() {
 //     ScopedLock my_lock(my_mutex.Pointer());
 //     // Do something.
 //   }
 //
-typedef LazyDynamicInstance<Mutex, CreateMutexTrait>::type LazyMutex;
+typedef LazyDynamicInstance<
+    Mutex, CreateMutexTrait, ThreadSafeInitOnceTrait>::type LazyMutex;
 
 #define LAZY_MUTEX_INITIALIZER LAZY_DYNAMIC_INSTANCE_INITIALIZER
 
 // ----------------------------------------------------------------------------
 // ScopedLock
 //
 // Stack-allocated ScopedLocks provide block-scoped locking and
 // unlocking of a mutex.
 class ScopedLock {
  public:
@@ skipping 50 matching lines @@
 //   // The following semaphore starts at 0.
 //   static LazySemaphore<0>::type my_semaphore = LAZY_SEMAPHORE_INITIALIZER;
 //
 //   void my_function() {
 //     // Do something with my_semaphore.Pointer().
 //   }
 //
 template <int InitialValue>
 struct LazySemaphore {
   typedef typename LazyDynamicInstance<
-      Semaphore, CreateSemaphoreTrait<InitialValue> >::type type;
+      Semaphore, CreateSemaphoreTrait<InitialValue>,
+      ThreadSafeInitOnceTrait>::type type;
 };
 
 #define LAZY_SEMAPHORE_INITIALIZER LAZY_DYNAMIC_INSTANCE_INITIALIZER
 
 
 // ----------------------------------------------------------------------------
 // Socket
 //
 
 class Socket {
@@ skipping 117 matching lines @@
   Atomic32 active_;
   PlatformData* data_;  // Platform specific data.
   int samples_taken_;  // Counts stack samples taken.
   DISALLOW_IMPLICIT_CONSTRUCTORS(Sampler);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_