Fix warnings on Win64.

src/serialize.cc

 // 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 327 matching lines @@
         page_index++;
       }
       current_ = RelativeAddress(space,
                                  page_index,
                                  top_page->Offset(top));
       break;
     }
     case NEW_SPACE:
       current_ = RelativeAddress(space,
                                  0,
-                                 Heap::NewSpaceTop() - Heap::NewSpaceStart());
+                                 static_cast<int>(Heap::NewSpaceTop()
+                                     - Heap::NewSpaceStart()));
       break;
     case LO_SPACE:
       int page_index = 0;
       for (LargeObjectIterator it(Heap::lo_space()); it.has_next(); it.next()) {
         page_index++;
       }
       current_ = RelativeAddress(space, page_index, 0);
       break;
   }
 }
@@ skipping 210 matching lines @@
   // Debug addresses
   Add(Debug_Address(Debug::k_after_break_target_address).address(),
       DEBUG_ADDRESS,
       Debug::k_after_break_target_address << kDebugIdShift,
       "Debug::after_break_target_address()");
   Add(Debug_Address(Debug::k_debug_break_return_address).address(),
       DEBUG_ADDRESS,
       Debug::k_debug_break_return_address << kDebugIdShift,
       "Debug::debug_break_return_address()");
   const char* debug_register_format = "Debug::register_address(%i)";
-  size_t dr_format_length = strlen(debug_register_format);
+  int dr_format_length = StrLength(debug_register_format);
   for (int i = 0; i < kNumJSCallerSaved; ++i) {
     Vector<char> name = Vector<char>::New(dr_format_length + 1);
     OS::SNPrintF(name, debug_register_format, i);
     Add(Debug_Address(Debug::k_register_address, i).address(),
         DEBUG_ADDRESS,
         Debug::k_register_address << kDebugIdShift | i,
         name.start());
   }
 #endif
 
@@ skipping 27 matching lines @@
   const char* top_address_format = "Top::%s";
 
   const char* AddressNames[] = {
 #define C(name) #name,
     TOP_ADDRESS_LIST(C)
     TOP_ADDRESS_LIST_PROF(C)
     NULL
 #undef C
   };
 
-  size_t top_format_length = strlen(top_address_format) - 2;
+  int top_format_length = StrLength(top_address_format) - 2;
   for (uint16_t i = 0; i < Top::k_top_address_count; ++i) {
     const char* address_name = AddressNames[i];
     Vector<char> name =
-        Vector<char>::New(top_format_length + strlen(address_name) + 1);
+        Vector<char>::New(top_format_length + StrLength(address_name) + 1);
     const char* chars = name.start();
     OS::SNPrintF(name, top_address_format, address_name);
     Add(Top::get_address_from_id((Top::AddressId)i), TOP_ADDRESS, i, chars);
   }
 
   // Extensions
   Add(FUNCTION_ADDR(GCExtension::GC), EXTENSION, 1,
       "GCExtension::GC");
 
   // Accessors
@@ skipping 275 matching lines @@
   if (pos < len_) {
     byte* old = str_;
     str_ = NewArray<byte>(max_);
     memcpy(str_, old, pos);
     memcpy(str_ + pos + bytes, old + pos, len_ - pos);
     DeleteArray(old);
   }
 }
 
 int SnapshotWriter::InsertString(const char* s, int pos) {
-  int size = strlen(s);
+  int size = StrLength(s);
   pos = InsertC('[', pos);
   pos = InsertInt(size, pos);
   pos = InsertC(']', pos);
   return InsertBytes(reinterpret_cast<const byte*>(s), pos, size);
 }
 
 
 class ReferenceUpdater: public ObjectVisitor {
  public:
   ReferenceUpdater(HeapObject* obj, Serializer* serializer)
     : obj_address_(obj->address()),
       serializer_(serializer),
       reference_encoder_(serializer->reference_encoder_),
       offsets_(8),
       addresses_(8),
       offsets_32_bit_(0),
       data_32_bit_(0) {
   }
 
   virtual void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; ++p) {
       if ((*p)->IsHeapObject()) {
-        offsets_.Add(reinterpret_cast<Address>(p) - obj_address_);
+        offsets_.Add(
+            static_cast<int>(reinterpret_cast<Address>(p) - obj_address_));
         Address a = serializer_->GetSavedAddress(HeapObject::cast(*p));
         addresses_.Add(a);
       }
     }
   }
 
   virtual void VisitCodeTarget(RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
     Address encoded_target = serializer_->GetSavedAddress(target);
     // All calls and jumps are to code objects that encode into 32 bits.
-    offsets_32_bit_.Add(rinfo->target_address_address() - obj_address_);
+    offsets_32_bit_.Add(
+        static_cast<int>(rinfo->target_address_address() - obj_address_));
     uint32_t small_target =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(encoded_target));
     ASSERT(reinterpret_cast<uintptr_t>(encoded_target) == small_target);
     data_32_bit_.Add(small_target);
   }
 
 
   virtual void VisitExternalReferences(Address* start, Address* end) {
     for (Address* p = start; p < end; ++p) {
       uint32_t code = reference_encoder_->Encode(*p);
       CHECK(*p == NULL ? code == 0 : code != 0);
-      offsets_.Add(reinterpret_cast<Address>(p) - obj_address_);
+      offsets_.Add(
+          static_cast<int>(reinterpret_cast<Address>(p) - obj_address_));
       addresses_.Add(reinterpret_cast<Address>(code));
     }
   }
 
   virtual void VisitRuntimeEntry(RelocInfo* rinfo) {
     Address target = rinfo->target_address();
     uint32_t encoding = reference_encoder_->Encode(target);
     CHECK(target == NULL ? encoding == 0 : encoding != 0);
-    offsets_.Add(rinfo->target_address_address() - obj_address_);
+    offsets_.Add(
+        static_cast<int>(rinfo->target_address_address() - obj_address_));
     addresses_.Add(reinterpret_cast<Address>(encoding));
   }
 
   void Update(Address start_address) {
     for (int i = 0; i < offsets_.length(); i++) {
       memcpy(start_address + offsets_[i], &addresses_[i], sizeof(Address));
     }
     for (int i = 0; i < offsets_32_bit_.length(); i++) {
       memcpy(start_address + offsets_32_bit_[i], &data_32_bit_[i],
              sizeof(uint32_t));
@@ skipping 49 matching lines @@
 
 
 bool Serializer::serialization_enabled_ = false;
 
 
 #ifdef DEBUG
 static const int kMaxTagLength = 32;
 
 void Serializer::Synchronize(const char* tag) {
   if (FLAG_debug_serialization) {
-    int length = strlen(tag);
+    int length = StrLength(tag);
     ASSERT(length <= kMaxTagLength);
     writer_->PutC('S');
     writer_->PutInt(length);
     writer_->PutBytes(reinterpret_cast<const byte*>(tag), length);
   }
 }
 #endif
 
 
 void Serializer::InitializeAllocators() {
@@ skipping 344 matching lines @@
 
 
 #ifdef DEBUG
 void Deserializer::Synchronize(const char* tag) {
   if (expect_debug_information_) {
     char buf[kMaxTagLength];
     reader_.ExpectC('S');
     int length = reader_.GetInt();
     ASSERT(length <= kMaxTagLength);
     reader_.GetBytes(reinterpret_cast<Address>(buf), length);
-    ASSERT_EQ(strlen(tag), length);
+    ASSERT_EQ(StrLength(tag), length);
     ASSERT(strncmp(tag, buf, length) == 0);
   }
 }
 #endif
 
 
 class NoGlobalHandlesChecker : public ObjectVisitor {
  public:
   virtual void VisitPointers(Object** start, Object** end) {
     ASSERT(false);
@@ skipping 495 matching lines @@
       case RAW_DATA_SERIALIZATION: {
         int size = source_->GetInt();
         byte* raw_data_out = reinterpret_cast<byte*>(current);
         source_->CopyRaw(raw_data_out, size);
         current = reinterpret_cast<Object**>(raw_data_out + size);
         break;
       }
       case OBJECT_SERIALIZATION + NEW_SPACE: {
         ReadObject(NEW_SPACE, Heap::new_space(), current);
         if (space != NEW_SPACE) {
-          Heap::RecordWrite(address,
-                            reinterpret_cast<Address>(current) - address);
+          Heap::RecordWrite(address, static_cast<int>(
+              reinterpret_cast<Address>(current) - address));
         }
         current++;
         break;
       }
       case OBJECT_SERIALIZATION + OLD_DATA_SPACE:
         ReadObject(OLD_DATA_SPACE, Heap::old_data_space(), current++);
         break;
       case OBJECT_SERIALIZATION + OLD_POINTER_SPACE:
         ReadObject(OLD_POINTER_SPACE, Heap::old_pointer_space(), current++);
         break;
@@ skipping 36 matching lines @@
         Assembler::set_target_at(location_of_branch_data,
                                  code_object->instruction_start());
         location_of_branch_data += Assembler::kCallTargetSize;
         current = reinterpret_cast<Object**>(location_of_branch_data);
         break;
       }
       ONE_CASE_PER_SPACE(BACKREF_SERIALIZATION) {
         // Write a backreference to an object we unpacked earlier.
         int backref_space = (data & kSpaceMask);
         if (backref_space == NEW_SPACE && space != NEW_SPACE) {
-          Heap::RecordWrite(address,
-                            reinterpret_cast<Address>(current) - address);
+          Heap::RecordWrite(address, static_cast<int>(
+              reinterpret_cast<Address>(current) - address));
         }
         *current++ = GetAddressFromEnd(backref_space);
         break;
       }
       ONE_CASE_PER_SPACE(REFERENCE_SERIALIZATION) {
         // Write a reference to an object we unpacked earlier.
         int reference_space = (data & kSpaceMask);
         if (reference_space == NEW_SPACE && space != NEW_SPACE) {
-          Heap::RecordWrite(address,
-                            reinterpret_cast<Address>(current) - address);
+          Heap::RecordWrite(address, static_cast<int>(
+              reinterpret_cast<Address>(current) - address));
         }
         *current++ = GetAddressFromStart(reference_space);
         break;
       }
 #define COMMON_REFS_CASE(index, reference_space, address)                      \
       case REFERENCE_SERIALIZATION + index: {                                  \
         ASSERT(SpaceIsPaged(reference_space));                                 \
         Address object_address =                                               \
             pages_[reference_space][0] + (address << kObjectAlignmentBits);    \
         *current++ = HeapObject::FromAddress(object_address);                  \
@@ skipping 61 matching lines @@
         UNREACHABLE();
     }
   }
   ASSERT(current == limit);
 }
 
 
 void SnapshotByteSink::PutInt(uintptr_t integer, const char* description) {
   const int max_shift = ((kPointerSize * kBitsPerByte) / 7) * 7;
   for (int shift = max_shift; shift > 0; shift -= 7) {
-    if (integer >= 1u << shift) {
+    if (integer >= static_cast<uintptr_t>(1u) << shift) {
       Put(((integer >> shift) & 0x7f) | 0x80, "IntPart");
     }
   }
   PutSection(integer & 0x7f, "IntLastPart");
 }
 
 #ifdef DEBUG
 
 void Deserializer2::Synchronize(const char* tag) {
   int data = source_->Get();
@@ skipping 180 matching lines @@
 void Serializer2::ObjectSerializer::VisitExternalReferences(Address* start,
                                                             Address* end) {
   Address references_start = reinterpret_cast<Address>(start);
   OutputRawData(references_start);
 
   for (Address* current = start; current < end; current++) {
     sink_->Put(EXTERNAL_REFERENCE_SERIALIZATION, "ExternalReference");
     int reference_id = serializer_->EncodeExternalReference(*current);
     sink_->PutInt(reference_id, "reference id");
   }
-  bytes_processed_so_far_ += (end - start) * kPointerSize;
+  bytes_processed_so_far_ += static_cast<int>((end - start) * kPointerSize);
 }
 
 
 void Serializer2::ObjectSerializer::VisitRuntimeEntry(RelocInfo* rinfo) {
   Address target_start = rinfo->target_address_address();
   OutputRawData(target_start);
   Address target = rinfo->target_address();
   uint32_t encoding = serializer_->EncodeExternalReference(target);
   CHECK(target == NULL ? encoding == 0 : encoding != 0);
   sink_->Put(EXTERNAL_BRANCH_TARGET_SERIALIZATION, "ExternalReference");
@@ skipping 34 matching lines @@
     }
   }
   // One of the strings in the natives cache should match the resource.  We
   // can't serialize any other kinds of external strings.
   UNREACHABLE();
 }
 
 
 void Serializer2::ObjectSerializer::OutputRawData(Address up_to) {
   Address object_start = object_->address();
-  int up_to_offset = up_to - object_start;
+  int up_to_offset = static_cast<int>(up_to - object_start);
   int skipped = up_to_offset - bytes_processed_so_far_;
   // This assert will fail if the reloc info gives us the target_address_address
   // locations in a non-ascending order.  Luckily that doesn't happen.
   ASSERT(skipped >= 0);
   if (skipped != 0) {
     Address base = object_start + bytes_processed_so_far_;
 #define RAW_CASE(index, length)                                                \
     if (skipped == length) {                                                   \
       sink_->PutSection(RAW_DATA_SERIALIZATION + index, "RawDataFixed");       \
     } else  /* NOLINT */
@@ skipping 72 matching lines @@
       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
     }
   }
   int allocation_address = fullness_[space];
   fullness_[space] = allocation_address + size;
   return allocation_address;
 }
 
 
 } }  // namespace v8::internal