js引擎v8源码解析之对象第二篇（基于v8 0.1.5）开发者社区

js引擎v8源码解析之对象第二篇（基于v8 0.1.5）

// The HeapNumber class describes heap allocated numbers that cannot be
// represented in a Smi (small integer)
// 存储了数字的堆对象
class HeapNumber: public HeapObject {
 public:
  // [value]: number value.
  inline double value();
  inline void set_value(double value);
  // Casting.
  static inline HeapNumber* cast(Object* obj);
  // Dispatched behavior.
  Object* HeapNumberToBoolean();
  // Layout description.
  // kSize之前的空间存储map对象的指针
  static const int kValueOffset = HeapObject::kSize;
  // kValueOffset - kSize之间存储数字的值
  static const int kSize = kValueOffset + kDoubleSize;
 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(HeapNumber);
};

// 读出double类型的值
#define READ_DOUBLE_FIELD(p, offset) \
  (*reinterpret_cast<double*>(FIELD_ADDR(p, offset)))
// 写入double类型的值
#define WRITE_DOUBLE_FIELD(p, offset, value) \
  (*reinterpret_cast<double*>(FIELD_ADDR(p, offset)) = value)
// 读写属性的值
double HeapNumber::value() {
  return READ_DOUBLE_FIELD(this, kValueOffset);
// 写double值到对象
void HeapNumber::set_value(double value) {
  WRITE_DOUBLE_FIELD(this, kValueOffset, value);
Object* HeapNumber::HeapNumberToBoolean() {
  // NaN, +0, and -0 should return the false object
  switch (fpclassify(value())) {
    case FP_NAN:  // fall through
    case FP_ZERO: return Heap::false_value();
    default: return Heap::true_value();
}

CAST_ACCESSOR(HeapNumber)
#define CAST_ACCESSOR(type)                     \
  type* type::cast(Object* object) {            \
    ASSERT(object->Is##type());                 \
    return reinterpret_cast<type*>(object);     \
CAST_ACCESSOR(HeapNumber);
HeapNumber* HeapNumber::cast(Object* object) {            \
    ASSERT(object->IsHeapNumber());                 \
    return reinterpret_cast<HeapNumber*>(object);     \

// Abstract super class arrays. It provides length behavior.
class Array: public HeapObject {
 public:
  // [length]: length of the array.
  inline int length();
  inline void set_length(int value);
  // Convert an object to an array index.
  // Returns true if the conversion succeeded.
  static inline bool IndexFromObject(Object* object, uint32_t* index);
  // Layout descriptor.
  static const int kLengthOffset = HeapObject::kSize;
  static const int kHeaderSize = kLengthOffset + kIntSize;
 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(Array);
};

#define INT_ACCESSORS(holder, name, offset)                             \
  int holder::name() { return READ_INT_FIELD(this, offset); }           \
  void holder::set_##name(int value) { WRITE_INT_FIELD(this, offset, value); }
// 定义数组的length和set_length函数，属性在对象的偏移的kLengthOffset,紧跟着map指针
INT_ACCESSORS(Array, length, kLengthOffset);

bool Array::IndexFromObject(Object* object, uint32_t* index) {
  if (object->IsSmi()) {
    int value = Smi::cast(object)->value();
    if (value < 0) return false;
    *index = value;
    return true;
  if (object->IsHeapNumber()) {
    double value = HeapNumber::cast(object)->value();
    uint32_t uint_value = static_cast<uint32_t>(value);
    if (value == static_cast<double>(uint_value)) {
      *index = uint_value;
      return true;
  return false;
}

// ByteArray represents fixed sized byte arrays.  Used by the outside world,
// such as PCRE, and also by the memory allocator and garbage collector to
// fill in free blocks in the heap.
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);
    ByteArray类没有定义自己的属性，他是根据length算出对象的大小，
    然后在分配内存的时候，多分配一块存储数组元素的内存
    const int kObjectAlignmentBits = 2;
    const int kObjectAlignmentMask = (1 << kObjectAlignmentBits) - 1;
    #define OBJECT_SIZE_ALIGN(value)  ((value + kObjectAlignmentMask) & ~kObjectAlignmentMask)
    由此可知，按四个字节对齐。OBJECT_SIZE_ALIGN的作用的是不够4字节的，会多分配几个字节，使得按四字节对齐。~kObjectAlignmentMask是低两位是0，即按四字节对齐。比如value已经4字节对齐了，则(4 + 0 +3) & ~3 =4，如果value没有对齐，假设是5，则（4 + 1 +3） & ~3 = 8;如果value等于6，（4 + 2 + 3） & ~3 = 8;以此类推。
  static int SizeFor(int length) {
    return kHeaderSize + OBJECT_SIZE_ALIGN(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;
  // Returns data start address.
  inline Address GetDataStartAddress();
  // Returns a pointer to the ByteArray object for a given data start address.
  static inline ByteArray* FromDataStartAddress(Address address);
  // Casting.
  static inline ByteArray* cast(Object* obj);
  // Dispatched behavior.
  int ByteArraySize() { return SizeFor(length()); }
 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(ByteArray);
};

Handle<ByteArray> Factory::NewByteArray(int length) {
  ASSERT(0 <= length);
  CALL_HEAP_FUNCTION(Heap::AllocateByteArray(length), ByteArray);
Object* Heap::AllocateByteArray(int length) {
  int size = ByteArray::SizeFor(length);
  AllocationSpace space = size > MaxHeapObjectSize() ? LO_SPACE : NEW_SPACE;
  Object* result = AllocateRaw(size, space);
  if (result->IsFailure()) return result;
  reinterpret_cast<Array*>(result)->set_map(byte_array_map());
  reinterpret_cast<Array*>(result)->set_length(length);
  return result;
}

byte ByteArray::get(int index) {
  ASSERT(index >= 0 && index < this->length());
  // 根据索引返回数组中对应元素的值，kHeaderSize是第一个元素的地址，kCharSize是1，即一个字节
  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
void ByteArray::set(int index, byte value) {
  ASSERT(index >= 0 && index < this->length());
  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
// 把四个元素（四个字节）的内容作为一个值。即ByteArray变成IntArray
int ByteArray::get_int(int index) {
  ASSERT(index >= 0 && (index * kIntSize) < this->length());
  return READ_INT_FIELD(this, kHeaderSize + index * kIntSize);
ByteArray* ByteArray::FromDataStartAddress(Address address) {
  ASSERT_TAG_ALIGNED(address);
  return reinterpret_cast<ByteArray*>(address - kHeaderSize + kHeapObjectTag);
// 返回数组元素的首地址，地址的低位是用作标记，要先减掉。kHeaderSize是第一个元素在对象内存空间的偏移
Address ByteArray::GetDataStartAddress() {

js引擎v8源码解析之对象第二篇（基于v8 0.1.5）

js引擎v8源码解析之对象第二篇（基于v8 0.1.5）

1 HeadNumber

2 Array

3 ByteArray