Fix warnings on Win64.

src/log-utils.cc

 // Copyright 2009 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 137 matching lines @@
   output_handle_ = OS::FOpen(name, OS::LogFileOpenMode);
   Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenMemoryBuffer() {
   ASSERT(!IsEnabled());
   output_buffer_ = new LogDynamicBuffer(
       kDynamicBufferBlockSize, kMaxDynamicBufferSize,
-      kDynamicBufferSeal, strlen(kDynamicBufferSeal));
+      kDynamicBufferSeal, StrLength(kDynamicBufferSeal));
   Write = WriteToMemory;
   Init();
 }
 
 
 void Log::Close() {
   if (Write == WriteToFile) {
     if (output_handle_ != NULL) fclose(output_handle_);
     output_handle_ = NULL;
   } else if (Write == WriteToMemory) {
@@ skipping 19 matching lines @@
   ASSERT(output_buffer_ != NULL);
   ASSERT(from_pos >= 0);
   ASSERT(max_size >= 0);
   int actual_size = output_buffer_->Read(from_pos, dest_buf, max_size);
   ASSERT(actual_size <= max_size);
   if (actual_size == 0) return 0;
 
   // Find previous log line boundary.
   char* end_pos = dest_buf + actual_size - 1;
   while (end_pos >= dest_buf && *end_pos != '\n') --end_pos;
-  actual_size = end_pos - dest_buf + 1;
+  actual_size = static_cast<int>(end_pos - dest_buf + 1);
   ASSERT(actual_size <= max_size);
   return actual_size;
 }
 
 
 LogMessageBuilder::WriteFailureHandler
     LogMessageBuilder::write_failure_handler = NULL;
 
 
 LogMessageBuilder::LogMessageBuilder(): sl(Log::mutex_), pos_(0) {
@@ skipping 136 matching lines @@
 void LogMessageBuilder::WriteToLogFile() {
   ASSERT(pos_ <= Log::kMessageBufferSize);
   const int written = Log::Write(Log::message_buffer_, pos_);
   if (written != pos_ && write_failure_handler != NULL) {
     write_failure_handler();
   }
 }
 
 
 void LogMessageBuilder::WriteCStringToLogFile(const char* str) {
-  const int len = strlen(str);
+  const int len = StrLength(str);
   const int written = Log::Write(str, len);
   if (written != len && write_failure_handler != NULL) {
     write_failure_handler();
   }
 }
 
 
 // Formatting string for back references to the whole line. E.g. "#2" means
 // "the second line above".
 const char* LogRecordCompressor::kLineBackwardReferenceFormat = "#%d";
@@ skipping 88 matching lines @@
     const char* const data_end = data.start() + data.length();
     const char* prev_ptr = prev_end;
     const char* data_ptr = data_end;
     // Compare strings backwards, stop on the last matching character.
     while (prev_ptr != prev_start && data_ptr != data.start()
           && *(prev_ptr - 1) == *(data_ptr - 1)) {
       --prev_ptr;
       --data_ptr;
     }
     const intptr_t truncated_len = prev_end - prev_ptr;
-    const int copy_from_pos = data_ptr - data.start();
+    const int copy_from_pos = static_cast<int>(data_ptr - data.start());
     // Check if the length of compressed tail is enough.
     if (truncated_len <= kMaxBackwardReferenceSize
         && truncated_len <= GetBackwardReferenceSize(distance, copy_from_pos)) {
       continue;
     }
 
     // Record compression results.
     if (truncated_len > best.truncated_len) {
       best.truncated_len = truncated_len;
       best.distance = distance;
@@ skipping 11 matching lines @@
     // Copy the uncompressible part unchanged.
     const intptr_t unchanged_len = prev.length() - best.truncated_len;
     // + 1 for '\0'.
     ASSERT(prev_record->length() >= unchanged_len + best.backref_size + 1);
     memcpy(prev_record->start(), prev.start(), unchanged_len);
     // Append the backward reference.
     Vector<char> backref(
         prev_record->start() + unchanged_len, best.backref_size + 1);
     PrintBackwardReference(backref, best.distance, best.copy_from_pos);
     ASSERT(strlen(backref.start()) - best.backref_size == 0);
-    prev_record->Truncate(unchanged_len + best.backref_size);
+    prev_record->Truncate(static_cast<int>(unchanged_len + best.backref_size));
   }
   return true;
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal