Simplify the construction of virtual frame elements in preparation for...

src/virtual-frame.h

 // Copyright 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 36 matching lines @@
 
 class FrameElement BASE_EMBEDDED {
  public:
   enum SyncFlag {
     SYNCED,
     NOT_SYNCED
   };
 
   // The default constructor creates an invalid frame element.
   FrameElement() {
-    type_ = TypeField::encode(INVALID) | SyncField::encode(NOT_SYNCED);
-    data_.reg_ = no_reg;
+    Initialize(INVALID, no_reg, NOT_SYNCED);
   }
 
   // Factory function to construct an invalid frame element.
   static FrameElement InvalidElement() {
     FrameElement result;
     return result;
   }
 
   // Factory function to construct an in-memory frame element.
   static FrameElement MemoryElement() {
-    FrameElement result;
-    result.type_ = TypeField::encode(MEMORY) | SyncField::encode(SYNCED);
-    // In-memory elements have no useful data.
-    result.data_.reg_ = no_reg;
+    FrameElement result(MEMORY, no_reg, SYNCED);
     return result;
   }
 
   // Factory function to construct an in-register frame element.
   static FrameElement RegisterElement(Register reg, SyncFlag is_synced) {
-    FrameElement result;
-    result.type_ = TypeField::encode(REGISTER) | SyncField::encode(is_synced);
-    result.data_.reg_ = reg;
+    FrameElement result(REGISTER, reg, is_synced);
     return result;
   }
 
   // Factory function to construct a frame element whose value is known at
   // compile time.
   static FrameElement ConstantElement(Handle<Object> value,
                                       SyncFlag is_synced) {
-    FrameElement result;
-    result.type_ = TypeField::encode(CONSTANT) | SyncField::encode(is_synced);
-    result.data_.handle_ = value.location();
+    FrameElement result(value, is_synced);
     return result;
   }
 
   bool is_synced() const { return SyncField::decode(type_) == SYNCED; }
 
   void set_sync() {
     ASSERT(type() != MEMORY);
     type_ = (type_ & ~SyncField::mask()) | SyncField::encode(SYNCED);
   }
 
@@ skipping 44 matching lines @@
   // for non-memory elements to indicate that the element agrees with
   // the value in memory in the actual frame.
   int type_;
 
   union {
     Register reg_;
     Object** handle_;
     int index_;
   } data_;
 
+  // The index of the next element in a list of copies, or the frame's
+  // illegal index if there is no next element.
+  int next_;
+
+  // Used to construct memory and register elements.
+  FrameElement(Type type, Register reg, SyncFlag is_synced) {
+    Initialize(type, reg, is_synced);
+  }
+
+  // Used to construct constant elements.
+  inline FrameElement(Handle<Object> value, SyncFlag is_synced);
+
+  // Used to initialize invalid, memory, and register elements.
+  inline void Initialize(Type type, Register reg, SyncFlag is_synced);
+
   friend class VirtualFrame;
 };
 
 
 } }  // namespace v8::internal
 
 #ifdef ARM
 #include "virtual-frame-arm.h"
 #else  // ia32
 #include "virtual-frame-ia32.h"
 #endif
 
+
+namespace v8 { namespace internal {
+
+FrameElement::FrameElement(Handle<Object> value, SyncFlag is_synced) {
+  type_ = TypeField::encode(CONSTANT) | SyncField::encode(is_synced);
+  data_.handle_ = value.location();
+  next_ = VirtualFrame::kIllegalIndex;
+}
+
+
+void FrameElement::Initialize(Type type, Register reg, SyncFlag is_synced) {
+  type_ = TypeField::encode(type) | SyncField::encode(is_synced);
+  data_.reg_ = reg;
+  next_ = VirtualFrame::kIllegalIndex;
+}
+
+
+} }  // namespace v8::internal
+
 #endif  // V8_VIRTUAL_FRAME_H_