Fix warnings on Win64.

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 48 matching lines @@
 static inline intptr_t OffsetFrom(T x) {
   return x - static_cast<T>(0);
 }
 
 
 // Compute the absolute value of type T for some 0-relative offset x.
 // This allows conversion of 0-relative int offsets into Addresses and
 // integral types.
 template <typename T>
 static inline T AddressFrom(intptr_t x) {
-  return static_cast<T>(0) + x;
+  return static_cast<T>(static_cast<T>(0) + x);
 }
 
 
 // Return the largest multiple of m which is <= x.
 template <typename T>
 static inline T RoundDown(T x, int m) {
   ASSERT(IsPowerOf2(m));
   return AddressFrom<T>(OffsetFrom(x) & -m);
 }
 
@@ skipping 50 matching lines @@
 }
 
 
 // Returns the minimum of the two parameters.
 template <typename T>
 static T Min(T a, T b) {
   return a < b ? a : b;
 }
 
 
+inline int StrLength(const char* string) {
+  size_t length = strlen(string);
+  ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
+  return static_cast<int>(length);
+}
+
+
 // ----------------------------------------------------------------------------
 // BitField is a help template for encoding and decode bitfield with
 // unsigned content.
 template<class T, int shift, int size>
 class BitField {
  public:
   // Tells whether the provided value fits into the bit field.
   static bool is_valid(T value) {
     return (static_cast<uint32_t>(value) & ~((1U << (size)) - 1)) == 0;
   }
@@ skipping 292 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, static_cast<int>(strlen(data)));
+  return Vector<const char>(data, StrLength(data));
 }
 
 inline Vector<char> MutableCStrVector(char* data) {
-  return Vector<char>(data, static_cast<int>(strlen(data)));
+  return Vector<char>(data, StrLength(data));
 }
 
 inline Vector<char> MutableCStrVector(char* data, int max) {
-  int length = static_cast<int>(strlen(data));
+  int length = StrLength(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_