X64: Checked and slightly modified Object layouts to be compatible with 64-bit pointers.

src/objects.h

 // 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 32 matching lines @@
 //     - HeapObject   (superclass for everything allocated in the heap)
 //       - JSObject
 //         - JSArray
 //         - JSRegExp
 //         - JSFunction
 //         - GlobalObject
 //           - JSGlobalObject
 //           - JSBuiltinsObject
 //         - JSGlobalProxy
 //         - JSValue
-//         - Script
 //       - Array
 //         - ByteArray
 //         - FixedArray
 //           - DescriptorArray
 //           - HashTable
 //             - Dictionary
 //             - SymbolTable
 //             - CompilationCacheTable
 //             - MapCache
 //             - LookupCache
@@ skipping 12 matching lines @@
 //       - Code
 //       - Map
 //       - Oddball
 //       - Proxy
 //       - SharedFunctionInfo
 //       - Struct
 //         - AccessorInfo
 //         - AccessCheckInfo
 //         - InterceptorInfo
 //         - CallHandlerInfo
-//         - FunctionTemplateInfo
-//         - ObjectTemplateInfo
+//         - TemplateInfo
+//           - FunctionTemplateInfo
+//           - ObjectTemplateInfo
+//         - Script
 //         - SignatureInfo
 //         - TypeSwitchInfo
 //         - DebugInfo
 //         - BreakPointInfo
 //
 // Formats of Object*:
 //  Smi:        [31 bit signed int] 0
 //  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01
 //  Failure:    [30 bit signed int] 11
 
@@ skipping 666 matching lines @@
 
   // Layout description.
   static const int kHeaderSize = 0;  // Object does not take up any space.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
 };
 
 
 // Smi represents integer Numbers that can be stored in 31 bits.
+// TODO(X64) Increase to 53 bits?
 // Smis are immediate which means they are NOT allocated in the heap.
 // The this pointer has the following format: [31 bit signed int] 0
+// TODO(X64): 31 bits signed int sign-extended to 63 bits.
 // Smi stands for small integer.
 class Smi: public Object {
  public:
   // Returns the integer value.
   inline int value();
 
   // Convert a value to a Smi object.
   static inline Smi* FromInt(int value);
 
   static inline Smi* FromIntptr(intptr_t value);
@@ skipping 803 matching lines @@
 
   // Copy a sub array from the receiver to dest.
   void CopyTo(int pos, FixedArray* dest, int dest_pos, int len);
 
   // Garbage collection support.
   static int SizeFor(int length) { return kHeaderSize + length * kPointerSize; }
 
   // Casting.
   static inline FixedArray* cast(Object* obj);
 
+  // Align data at kPointerSize, even if Array.kHeaderSize isn't aligned.
+  static const int kHeaderSize = OBJECT_SIZE_ALIGN(Array::kHeaderSize);
+
   // Dispatched behavior.
   int FixedArraySize() { return SizeFor(length()); }
   void FixedArrayIterateBody(ObjectVisitor* v);
 #ifdef DEBUG
   void FixedArrayPrint();
   void FixedArrayVerify();
   // Checks if two FixedArrays have identical contents.
   bool IsEqualTo(FixedArray* other);
 #endif
 
@@ skipping 531 matching lines @@
 class ByteArray: public Array {
  public:
   // Setter and getter.
   inline byte get(int index);
   inline void set(int index, byte value);
 
   // Treat contents as an int array.
   inline int get_int(int index);
 
   static int SizeFor(int length) {
-    return kHeaderSize + OBJECT_SIZE_ALIGN(length);
+    return OBJECT_SIZE_ALIGN(kHeaderSize + length);
   }
   // We use byte arrays for free blocks in the heap.  Given a desired size in
   // bytes that is a multiple of the word size and big enough to hold a byte
   // array, this function returns the number of elements a byte array should
   // have.
   static int LengthFor(int size_in_bytes) {
     ASSERT(IsAligned(size_in_bytes, kPointerSize));
     ASSERT(size_in_bytes >= kHeaderSize);
     return size_in_bytes - kHeaderSize;
   }
@@ skipping 176 matching lines @@
   // Casting.
   static inline Code* cast(Object* obj);
 
   // Dispatched behavior.
   int CodeSize() { return SizeFor(body_size(), sinfo_size()); }
   void CodeIterateBody(ObjectVisitor* v);
 #ifdef DEBUG
   void CodePrint();
   void CodeVerify();
 #endif
+  // Code entry points are aligned to 32 bytes.
+  static const int kCodeAlignment = 32;
+  static const int kCodeAlignmentMask = kCodeAlignment - 1;
 
   // Layout description.
   static const int kInstructionSizeOffset = HeapObject::kHeaderSize;
   static const int kRelocationSizeOffset = kInstructionSizeOffset + kIntSize;
   static const int kSInfoSizeOffset = kRelocationSizeOffset + kIntSize;
   static const int kFlagsOffset = kSInfoSizeOffset + kIntSize;
   static const int kKindSpecificFlagsOffset  = kFlagsOffset + kIntSize;
-  // Add filler objects to align the instruction start following right after
+  // Add padding to align the instruction start following right after
   // the Code object header.
-  static const int kFiller6Offset = kKindSpecificFlagsOffset + kIntSize;
-  static const int kFiller7Offset = kFiller6Offset + kIntSize;
-  static const int kHeaderSize = kFiller7Offset + kIntSize;
-
-  // Code entry points are aligned to 32 bytes.
-  static const int kCodeAlignment = 32;
+  static const int kHeaderSize =
+      (kKindSpecificFlagsOffset + kIntSize + kCodeAlignmentMask) &
+          ~kCodeAlignmentMask;
 
   // Byte offsets within kKindSpecificFlagsOffset.
   static const int kICFlagOffset = kKindSpecificFlagsOffset + 0;
   static const int kStubMajorKeyOffset = kKindSpecificFlagsOffset + 1;
 
   // Flags layout.
   static const int kFlagsICStateShift        = 0;
   static const int kFlagsKindShift           = 3;
   static const int kFlagsTypeShift           = 6;
   static const int kFlagsArgumentsCountShift = 9;
@@ skipping 188 matching lines @@
 #endif
 
   // Layout description.
   static const int kInstanceSizesOffset = HeapObject::kHeaderSize;
   static const int kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize;
   static const int kPrototypeOffset = kInstanceAttributesOffset + kIntSize;
   static const int kConstructorOffset = kPrototypeOffset + kPointerSize;
   static const int kInstanceDescriptorsOffset =
       kConstructorOffset + kPointerSize;
   static const int kCodeCacheOffset = kInstanceDescriptorsOffset + kPointerSize;
-  static const int kSize = kCodeCacheOffset + kIntSize;
+  static const int kSize = kCodeCacheOffset + kPointerSize;
 
   // Byte offsets within kInstanceSizesOffset.
   static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
   static const int kInObjectPropertiesOffset = kInstanceSizesOffset + 1;
   // The bytes at positions 2 and 3 are not in use at the moment.
 
   // Byte offsets within kInstanceAttributesOffset attributes.
   static const int kInstanceTypeOffset = kInstanceAttributesOffset + 0;
   static const int kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 1;
   static const int kBitFieldOffset = kInstanceAttributesOffset + 2;
@@ skipping 194 matching lines @@
   // Constants.
   static const int kDontAdaptArgumentsSentinel = -1;
 
   // Layout description.
   static const int kNameOffset = HeapObject::kHeaderSize;
   static const int kCodeOffset = kNameOffset + kPointerSize;
   static const int kLengthOffset = kCodeOffset + kPointerSize;
   static const int kFormalParameterCountOffset = kLengthOffset + kIntSize;
   static const int kExpectedNofPropertiesOffset =
       kFormalParameterCountOffset + kIntSize;
+  static const int kStartPositionAndTypeOffset =
+      kExpectedNofPropertiesOffset + kIntSize;
+  static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
+  static const int kFunctionTokenPositionOffset = kEndPositionOffset + kIntSize;
   static const int kInstanceClassNameOffset =

[William Hesse, 2009/05/18 11:41:30]

Are you depending on the fact that you have an even number of integer fields? 
Should you call pointer align macro before adding the ExternalReferenceData
field?

[Lasse Reichstein, 2009/05/18 12:08:23]

I am relying on that, but I think documentation should be enough.

-      kExpectedNofPropertiesOffset + kIntSize;
+      kFunctionTokenPositionOffset + kIntSize;
   static const int kExternalReferenceDataOffset =
       kInstanceClassNameOffset + kPointerSize;
   static const int kScriptOffset = kExternalReferenceDataOffset + kPointerSize;
-  static const int kStartPositionAndTypeOffset = kScriptOffset + kPointerSize;
-  static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
-  static const int kFunctionTokenPositionOffset = kEndPositionOffset + kIntSize;
-  static const int kDebugInfoOffset = kFunctionTokenPositionOffset + kIntSize;
+  static const int kDebugInfoOffset = kScriptOffset + kPointerSize;
   static const int kInferredNameOffset = kDebugInfoOffset + kPointerSize;
   static const int kSize = kInferredNameOffset + kPointerSize;
 
  private:
   // Bit positions in length_and_flg.
   // The least significant bit is used as the flag.
   static const int kFlagBit         = 0;
   static const int kLengthShift     = 1;
   static const int kLengthMask      = ~((1 << kLengthShift) - 1);
 
@@ skipping 289 matching lines @@
   inline void SetDataAt(int index, Object* value);
 
   static inline JSRegExp* cast(Object* obj);
 
   // Dispatched behavior.
 #ifdef DEBUG
   void JSRegExpVerify();
 #endif
 
   static const int kDataOffset = JSObject::kHeaderSize;
-  static const int kSize = kDataOffset + kIntSize;
+  static const int kSize = kDataOffset + kPointerSize;
 
   // Indices in the data array.
   static const int kTagIndex = 0;
   static const int kSourceIndex = kTagIndex + 1;
   static const int kFlagsIndex = kSourceIndex + 1;
   static const int kDataIndex = kFlagsIndex + 1;
   // The data fields are used in different ways depending on the
   // value of the tag.
   // Atom regexps (literal strings).
   static const int kAtomPatternIndex = kDataIndex;
@@ skipping 392 matching lines @@
   // Casting
   static inline SeqAsciiString* cast(Object* obj);
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of an AsciiString
   // instance.
   inline int SeqAsciiStringSize(InstanceType instance_type);
 
   // Computes the size for an AsciiString instance of a given length.
   static int SizeFor(int length) {
-    return kHeaderSize + OBJECT_SIZE_ALIGN(length * kCharSize);
+    return OBJECT_SIZE_ALIGN(kHeaderSize + length * kCharSize);
   }
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Support for StringInputBuffer.
   inline void SeqAsciiStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                                 unsigned* offset,
                                                 unsigned chars);
   inline const unibrow::byte* SeqAsciiStringReadBlock(unsigned* remaining,
@@ skipping 24 matching lines @@
   // Casting
   static inline SeqTwoByteString* cast(Object* obj);
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of a TwoByteString
   // instance.
   inline int SeqTwoByteStringSize(InstanceType instance_type);
 
   // Computes the size for a TwoByteString instance of a given length.
   static int SizeFor(int length) {
-    return kHeaderSize + OBJECT_SIZE_ALIGN(length * kShortSize);
+    return OBJECT_SIZE_ALIGN(kHeaderSize + length * kShortSize);
   }
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Support for StringInputBuffer.
   inline void SeqTwoByteStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                                   unsigned* offset_ptr,
                                                   unsigned chars);
 
@@ skipping 33 matching lines @@
 
   // Casting.
   static inline ConsString* cast(Object* obj);
 
   // Garbage collection support.  This method is called during garbage
   // collection to iterate through the heap pointers in the body of
   // the ConsString.
   void ConsStringIterateBody(ObjectVisitor* v);
 
   // Layout description.
-  static const int kFirstOffset = String::kSize;
+  static const int kFirstOffset = OBJECT_SIZE_ALIGN(String::kSize);
   static const int kSecondOffset = kFirstOffset + kPointerSize;
   static const int kSize = kSecondOffset + kPointerSize;
 
   // Support for StringInputBuffer.
   inline const unibrow::byte* ConsStringReadBlock(ReadBlockBuffer* buffer,
                                                   unsigned* offset_ptr,
                                                   unsigned chars);
   inline void ConsStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                             unsigned* offset_ptr,
                                             unsigned chars);
@@ skipping 23 matching lines @@
   // Dispatched behavior.
   uint16_t SlicedStringGet(int index);
 
   // Casting.
   static inline SlicedString* cast(Object* obj);
 
   // Garbage collection support.
   void SlicedStringIterateBody(ObjectVisitor* v);
 
   // Layout description
+#if V8_HOST_ARCH_64_BIT
+  // Optimizations expect buffer to be located at same offset as a ConsString's
+  // first substring. In 64 bit mode we have room for the size before the
+  // buffer.

[Erik Corry, 2009/05/18 11:52:11]

Clever.  I suggest the following comment:
Each character represents 32 bits.  M is the map, L is the length/hash, B and S
are the buffer and start in a sliced string.  1 and 2 are the first and second
parts of a cons string.
32 bit Slice: MLBS
32 bit Cons:  ML12
64 bit Slice: MMLSBB
64 bit Cons:  MML 1122  

[Lasse Reichstein, 2009/05/18 12:08:23]

Done.

+  static const int kStartOffset = String::kSize;
+  static const int kBufferOffset = kStartOffset + kIntSize;
+  static const int kSize = kBufferOffset + kPointerSize;
+#else
   static const int kBufferOffset = String::kSize;
   static const int kStartOffset = kBufferOffset + kPointerSize;
   static const int kSize = kStartOffset + kIntSize;
+#endif
 
   // Support for StringInputBuffer.
   inline const unibrow::byte* SlicedStringReadBlock(ReadBlockBuffer* buffer,
                                                     unsigned* offset_ptr,
                                                     unsigned chars);
   inline void SlicedStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                               unsigned* offset_ptr,
                                               unsigned chars);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SlicedString);
 };
 
 
 // The ExternalString class describes string values that are backed by
 // a string resource that lies outside the V8 heap.  ExternalStrings
 // consist of the length field common to all strings, a pointer to the
 // external resource.  It is important to ensure (externally) that the
 // resource is not deallocated while the ExternalString is live in the
 // V8 heap.
 //
 // The API expects that all ExternalStrings are created through the
 // API.  Therefore, ExternalStrings should not be used internally.
 class ExternalString: public String {
  public:
   // Casting
   static inline ExternalString* cast(Object* obj);
 
   // Layout description.
-  static const int kResourceOffset = String::kSize;
+  static const int kResourceOffset = OBJECT_SIZE_ALIGN(String::kSize);
   static const int kSize = kResourceOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
 };
 
 
 // The ExternalAsciiString class is an external string backed by an
 // ASCII string.
 class ExternalAsciiString: public ExternalString {
@@ skipping 439 matching lines @@
   static inline ObjectTemplateInfo* cast(Object* obj);
 
 #ifdef DEBUG
   void ObjectTemplateInfoPrint();
   void ObjectTemplateInfoVerify();
 #endif
 
   static const int kConstructorOffset = TemplateInfo::kHeaderSize;
   static const int kInternalFieldCountOffset =
       kConstructorOffset + kPointerSize;
-  static const int kSize = kInternalFieldCountOffset + kHeaderSize;
+  static const int kSize = kInternalFieldCountOffset + kPointerSize;

[Erik Corry, 2009/05/18 11:52:11]

Good catch.

 };
 
 
 class SignatureInfo: public Struct {
  public:
   DECL_ACCESSORS(receiver, Object)
   DECL_ACCESSORS(args, Object)
 
   static inline SignatureInfo* cast(Object* obj);
 
@@ skipping 210 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_