Field layout in class Arguments is incompatible w\ 64-bit archs.

src/arguments.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ARGUMENTS_H_
 #define V8_ARGUMENTS_H_
 
 #include "src/allocation.h"
 
 namespace v8 {
 namespace internal {
 
 // Arguments provides access to runtime call parameters.
 //
 // It uses the fact that the instance fields of Arguments
 // (length_, arguments_) are "overlayed" with the parameters
 // (no. of parameters, and the parameter pointer) passed so
 // that inside the C++ function, the parameters passed can
 // be accessed conveniently:
 //
 //   Object* Runtime_function(Arguments args) {
 //     ... use args[i] here ...
 //   }
+//
+// Note that length_ (whose value is in the integer range) is defined
+// as intptr_t to provide endian-neutrality on 64-bit archs.
 
 class Arguments BASE_EMBEDDED {
  public:
   Arguments(int length, Object** arguments)
       : length_(length), arguments_(arguments) { }
 
   Object*& operator[] (int index) {
     ASSERT(0 <= index && index < length_);
     return *(reinterpret_cast<Object**>(reinterpret_cast<intptr_t>(arguments_) -
                                         index * kPointerSize));
   }
 
   template <class S> Handle<S> at(int index) {
     Object** value = &((*this)[index]);
     // This cast checks that the object we're accessing does indeed have the
     // expected type.
     S::cast(*value);
     return Handle<S>(reinterpret_cast<S**>(value));
   }
 
   int smi_at(int index) {
     return Smi::cast((*this)[index])->value();
   }
 
   double number_at(int index) {
     return (*this)[index]->Number();
   }
 
   // Get the total number of arguments including the receiver.
-  int length() const { return length_; }
+  int length() const { return static_cast<int>(length_); }
 
   Object** arguments() { return arguments_; }
 
  private:
-  int length_;
+  intptr_t length_;
   Object** arguments_;
 };
 
 
 // For each type of callback, we have a list of arguments
 // They are used to generate the Call() functions below
 // These aren't included in the list as they have duplicate signatures
 // F(NamedPropertyEnumeratorCallback, ...)
 // F(NamedPropertyGetterCallback, ...)
 
@@ skipping 223 matching lines @@
 #define RUNTIME_FUNCTION(Name) RUNTIME_FUNCTION_RETURNS_TYPE(Object*, Name)
 #define RUNTIME_FUNCTION_RETURN_PAIR(Name) \
     RUNTIME_FUNCTION_RETURNS_TYPE(ObjectPair, Name)
 
 #define RUNTIME_ARGUMENTS(isolate, args) \
   args.length(), args.arguments(), isolate
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARGUMENTS_H_