MIPS: Increase external array allocation header size to 8 bytes.

src/d8.cc

 // 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 300 matching lines @@
     ThrowException(
         String::New("Array length exceeds maximum length."));
   }
   return static_cast<size_t>(raw_value);
 }
 
 
 const char kArrayBufferReferencePropName[] = "_is_array_buffer_";
 const char kArrayBufferMarkerPropName[] = "_array_buffer_ref_";
 
+static const int kExternalArrayAllocationHeaderSize = 2;
 
 Handle<Value> Shell::CreateExternalArray(const Arguments& args,
                                          ExternalArrayType type,
                                          size_t element_size) {
   TryCatch try_catch;
   bool is_array_buffer_construct = element_size == 0;
   if (is_array_buffer_construct) {
     type = v8::kExternalByteArray;
     element_size = 1;
   }
@@ skipping 95 matching lines @@
   }
 
   Persistent<Object> persistent_array = Persistent<Object>::New(array);
   if (data == NULL && length != 0) {
     // Make sure the total size fits into a (signed) int.
     static const int kMaxSize = 0x7fffffff;
     if (length > (kMaxSize - sizeof(size_t)) / element_size) {
       return ThrowException(String::New("Array exceeds maximum size (2G)"));
     }
     // Prepend the size of the allocated chunk to the data itself.
-    int total_size = length * element_size + sizeof(size_t);
+    int total_size = length * element_size +
+        kExternalArrayAllocationHeaderSize * sizeof(size_t);
     data = malloc(total_size);
     if (data == NULL) {
       return ThrowException(String::New("Memory allocation failed."));
     }
     *reinterpret_cast<size_t*>(data) = total_size;
-    data = reinterpret_cast<size_t*>(data) + 1;
+    data = reinterpret_cast<size_t*>(data) + kExternalArrayAllocationHeaderSize;
     memset(data, 0, length * element_size);
     V8::AdjustAmountOfExternalAllocatedMemory(total_size);
   }
   persistent_array.MakeWeak(data, ExternalArrayWeakCallback);
   persistent_array.MarkIndependent();
 
   array->SetIndexedPropertiesToExternalArrayData(
       reinterpret_cast<uint8_t*>(data) + offset, type,
       static_cast<int>(length));
   array->Set(String::New("length"),
              Int32::New(static_cast<int32_t>(length)), ReadOnly);
   array->Set(String::New("BYTES_PER_ELEMENT"),
              Int32::New(static_cast<int32_t>(element_size)));
   return array;
 }
 
 
 void Shell::ExternalArrayWeakCallback(Persistent<Value> object, void* data) {
   HandleScope scope;
   Handle<String> prop_name = String::New(kArrayBufferReferencePropName);
   Handle<Object> converted_object = object->ToObject();
   Local<Value> prop_value = converted_object->Get(prop_name);
   if (data != NULL && !prop_value->IsObject()) {
-    data = reinterpret_cast<size_t*>(data) - 1;
+    data = reinterpret_cast<size_t*>(data) - kExternalArrayAllocationHeaderSize;
     V8::AdjustAmountOfExternalAllocatedMemory(
         -static_cast<int>(*reinterpret_cast<size_t*>(data)));
     free(data);
   }
   object.Dispose();
 }
 
 
 Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
   return CreateExternalArray(args, v8::kExternalByteArray, 0);
@@ skipping 1076 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif