Remove static initializers in v8.

src/lithium.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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_LITHIUM_H_
 #define V8_LITHIUM_H_
 
 #include "allocation.h"
 #include "hydrogen.h"
+#include "once.h"
 #include "safepoint-table.h"
 
 namespace v8 {
 namespace internal {
 
 class LOperand: public ZoneObject {
  public:
   enum Kind {
     INVALID,
     UNALLOCATED,
@@ skipping 26 matching lines @@
     ASSERT(this->index() == index);
   }
 
  protected:
   static const int kKindFieldWidth = 3;
   class KindField : public BitField<Kind, 0, kKindFieldWidth> { };
 
   LOperand(Kind kind, int index) { ConvertTo(kind, index); }
 
   unsigned value_;
+
+  // Function used by subclasses to populate their cache.
+  template <typename T, int Size, LOperand::Kind _Kind>
+  static void InitCache(T** cache) {
+    *cache = new T[Size];
+    for (int i = 0; i < Size; i++) {
+      (*cache)[i].ConvertTo(_Kind, i);
+    }
+  }
 };
 
 
 class LUnallocated: public LOperand {
  public:
   enum Policy {
     NONE,
     ANY,
     FIXED_REGISTER,
     FIXED_DOUBLE_REGISTER,
@@ skipping 149 matching lines @@
   void Eliminate() { source_ = destination_ = NULL; }
   bool IsEliminated() const {
     ASSERT(source_ != NULL || destination_ == NULL);
     return source_ == NULL;
   }
 
  private:
   LOperand* source_;
   LOperand* destination_;
 };
 

[fschneider, 2012/02/28 16:54:48]

Accidental edit?

-
 class LConstantOperand: public LOperand {
  public:
   static LConstantOperand* Create(int index) {
     ASSERT(index >= 0);
+    SetUpCache();

[fschneider, 2012/02/28 16:54:48]

Creation of LOperand is a really frequent operation. The call to SetupCache
should maybe moved to global V8 initialization in InitializeOncePerProcessImpl.

[Philippe, 2012/02/29 10:24:45]

Done.

     if (index < kNumCachedOperands) return &cache[index];
     return new LConstantOperand(index);
   }
 
   static LConstantOperand* cast(LOperand* op) {
     ASSERT(op->IsConstantOperand());
     return reinterpret_cast<LConstantOperand*>(op);
   }
 
   static void SetUpCache();
 
  private:
   static const int kNumCachedOperands = 128;
-  static LConstantOperand cache[];
+  static LConstantOperand* cache;
+  static OnceType init_cache_once_;
 
   LConstantOperand() : LOperand() { }
   explicit LConstantOperand(int index) : LOperand(CONSTANT_OPERAND, index) { }
+
+  friend void LOperand::InitCache<
+    LConstantOperand, kNumCachedOperands, CONSTANT_OPERAND>(
+        LConstantOperand** cache);
 };
 
 
 class LArgument: public LOperand {
  public:
   explicit LArgument(int index) : LOperand(ARGUMENT, index) { }
 
   static LArgument* cast(LOperand* op) {
     ASSERT(op->IsArgument());
     return reinterpret_cast<LArgument*>(op);
   }
 };
 
 
 class LStackSlot: public LOperand {
  public:
   static LStackSlot* Create(int index) {
     ASSERT(index >= 0);
+    SetUpCache();
     if (index < kNumCachedOperands) return &cache[index];
     return new LStackSlot(index);
   }
 
   static LStackSlot* cast(LOperand* op) {
     ASSERT(op->IsStackSlot());
     return reinterpret_cast<LStackSlot*>(op);
   }
 
   static void SetUpCache();
 
  private:
   static const int kNumCachedOperands = 128;
-  static LStackSlot cache[];
+  static LStackSlot* cache;
+  static OnceType init_cache_once_;
 
   LStackSlot() : LOperand() { }
   explicit LStackSlot(int index) : LOperand(STACK_SLOT, index) { }
+
+  friend void LOperand::InitCache<LStackSlot, kNumCachedOperands, STACK_SLOT>(
+      LStackSlot** cache);
 };
 
 
 class LDoubleStackSlot: public LOperand {
  public:
   static LDoubleStackSlot* Create(int index) {
     ASSERT(index >= 0);
+    SetUpCache();
     if (index < kNumCachedOperands) return &cache[index];
     return new LDoubleStackSlot(index);
   }
 
   static LDoubleStackSlot* cast(LOperand* op) {
     ASSERT(op->IsStackSlot());
     return reinterpret_cast<LDoubleStackSlot*>(op);
   }
 
   static void SetUpCache();
 
  private:
   static const int kNumCachedOperands = 128;
-  static LDoubleStackSlot cache[];
+  static LDoubleStackSlot* cache;
+  static OnceType init_cache_once_;
 
   LDoubleStackSlot() : LOperand() { }
   explicit LDoubleStackSlot(int index) : LOperand(DOUBLE_STACK_SLOT, index) { }
+
+  friend void LOperand::InitCache<
+      LDoubleStackSlot, kNumCachedOperands, DOUBLE_STACK_SLOT>(
+          LDoubleStackSlot** cache);
 };
 
 
 class LRegister: public LOperand {
  public:
   static LRegister* Create(int index) {
     ASSERT(index >= 0);
+    SetUpCache();
     if (index < kNumCachedOperands) return &cache[index];
     return new LRegister(index);
   }
 
   static LRegister* cast(LOperand* op) {
     ASSERT(op->IsRegister());
     return reinterpret_cast<LRegister*>(op);
   }
 
   static void SetUpCache();
 
  private:
   static const int kNumCachedOperands = 16;
-  static LRegister cache[];
+  static LRegister* cache;
+  static OnceType init_cache_once_;
 
   LRegister() : LOperand() { }
   explicit LRegister(int index) : LOperand(REGISTER, index) { }
+
+  friend void LOperand::InitCache<LRegister, kNumCachedOperands, REGISTER>(
+      LRegister** cache);
 };
 
 
 class LDoubleRegister: public LOperand {
  public:
   static LDoubleRegister* Create(int index) {
     ASSERT(index >= 0);
+    SetUpCache();
     if (index < kNumCachedOperands) return &cache[index];
     return new LDoubleRegister(index);
   }
 
   static LDoubleRegister* cast(LOperand* op) {
     ASSERT(op->IsDoubleRegister());
     return reinterpret_cast<LDoubleRegister*>(op);
   }
 
   static void SetUpCache();
 
  private:
   static const int kNumCachedOperands = 16;
-  static LDoubleRegister cache[];
+  static LDoubleRegister* cache;
+  static OnceType init_cache_once_;
 
   LDoubleRegister() : LOperand() { }
   explicit LDoubleRegister(int index) : LOperand(DOUBLE_REGISTER, index) { }
+
+  friend void LOperand::InitCache<
+      LDoubleRegister, kNumCachedOperands, DOUBLE_REGISTER>(
+          LDoubleRegister** cache);
 };
 
 
 class LParallelMove : public ZoneObject {
  public:
   LParallelMove() : move_operands_(4) { }
 
   void AddMove(LOperand* from, LOperand* to) {
     move_operands_.Add(LMoveOperands(from, to));
   }
@@ skipping 213 matching lines @@
   ShallowIterator current_iterator_;
 };
 
 
 int ElementsKindToShiftSize(ElementsKind elements_kind);
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_