Change some integer types to make the x64 Win32 platform happier.

src/utils.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 96 matching lines @@
 
 
 template <typename T>
 static inline bool IsAligned(T value, T alignment) {
   ASSERT(IsPowerOf2(alignment));
   return (value & (alignment - 1)) == 0;
 }
 
 
 // Returns true if (addr + offset) is aligned.
-static inline bool IsAddressAligned(Address addr, int alignment, int offset) {
-  int offs = OffsetFrom(addr + offset);
+static inline bool IsAddressAligned(Address addr,
+                                    intptr_t alignment,
+                                    int offset) {
+  intptr_t offs = OffsetFrom(addr + offset);
   return IsAligned(offs, alignment);
 }
 
 
 // Returns the maximum of the two parameters.
 template <typename T>
 static T Max(T a, T b) {
   return a < b ? b : a;
 }
 
@@ skipping 310 matching lines @@
 class ScopedVector : public Vector<T> {
  public:
   explicit ScopedVector(int length) : Vector<T>(NewArray<T>(length), length) { }
   ~ScopedVector() {
     DeleteArray(this->start());
   }
 };
 
 
 inline Vector<const char> CStrVector(const char* data) {
-  return Vector<const char>(data, strlen(data));
+  return Vector<const char>(data, static_cast<int>(strlen(data)));
 }
 
 inline Vector<char> MutableCStrVector(char* data) {
-  return Vector<char>(data, strlen(data));
+  return Vector<char>(data, static_cast<int>(strlen(data)));
 }
 
 inline Vector<char> MutableCStrVector(char* data, int max) {
-  int length = strlen(data);
+  int length = static_cast<int>(strlen(data));
   return Vector<char>(data, (length < max) ? length : max);
 }
 
 template <typename T>
 inline Vector< Handle<Object> > HandleVector(v8::internal::Handle<T>* elms,
                                              int length) {
   return Vector< Handle<Object> >(
       reinterpret_cast<v8::internal::Handle<Object>*>(elms), length);
 }
 
@@ skipping 102 matching lines @@
 #endif
   while (dest < limit) {
     *dest++ = static_cast<sinkchar>(*src++);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_