Fix warnings on Win64.

test/cctest/test-log.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 //
 // Tests of logging functions from log.h
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 #ifdef __linux__
 #include <math.h>
 #include <pthread.h>
 #include <signal.h>
 #include <unistd.h>
 #endif  // __linux__
 
 #include "v8.h"
 #include "log.h"
 #include "v8threads.h"
 #include "cctest.h"
 
 using v8::internal::Address;
 using v8::internal::EmbeddedVector;
 using v8::internal::Logger;
+using v8::internal::StrLength;
 
 namespace i = v8::internal;
 
 static void SetUp() {
   // Log to memory buffer.
   i::FLAG_logfile = "*";
   i::FLAG_log = true;
   Logger::Setup();
 }
 
@@ skipping 16 matching lines @@
   SetUp();
   Logger::StringEvent("aaa", "bbb");
   Logger::StringEvent("cccc", "dddd");
   CHECK_EQ(0, Logger::GetLogLines(0, NULL, 0));
   char log_lines[100];
   memset(log_lines, 0, sizeof(log_lines));
   // Requesting data size which is smaller than first log message length.
   CHECK_EQ(0, Logger::GetLogLines(0, log_lines, 3));
   // See Logger::StringEvent.
   const char* line_1 = "aaa,\"bbb\"\n";
-  const int line_1_len = strlen(line_1);
+  const int line_1_len = StrLength(line_1);
   // Still smaller than log message length.
   CHECK_EQ(0, Logger::GetLogLines(0, log_lines, line_1_len - 1));
   // The exact size.
   CHECK_EQ(line_1_len, Logger::GetLogLines(0, log_lines, line_1_len));
   CHECK_EQ(line_1, log_lines);
   memset(log_lines, 0, sizeof(log_lines));
   // A bit more than the first line length.
   CHECK_EQ(line_1_len, Logger::GetLogLines(0, log_lines, line_1_len + 3));
   log_lines[line_1_len] = '\0';
   CHECK_EQ(line_1, log_lines);
   memset(log_lines, 0, sizeof(log_lines));
   const char* line_2 = "cccc,\"dddd\"\n";
-  const int line_2_len = strlen(line_2);
+  const int line_2_len = StrLength(line_2);
   // Now start with line_2 beginning.
   CHECK_EQ(0, Logger::GetLogLines(line_1_len, log_lines, 0));
   CHECK_EQ(0, Logger::GetLogLines(line_1_len, log_lines, 3));
   CHECK_EQ(0, Logger::GetLogLines(line_1_len, log_lines, line_2_len - 1));
   CHECK_EQ(line_2_len, Logger::GetLogLines(line_1_len, log_lines, line_2_len));
   CHECK_EQ(line_2, log_lines);
   memset(log_lines, 0, sizeof(log_lines));
   CHECK_EQ(line_2_len,
            Logger::GetLogLines(line_1_len, log_lines, line_2_len + 3));
   CHECK_EQ(line_2, log_lines);
   memset(log_lines, 0, sizeof(log_lines));
   // Now get entire buffer contents.
   const char* all_lines = "aaa,\"bbb\"\ncccc,\"dddd\"\n";
-  const int all_lines_len = strlen(all_lines);
+  const int all_lines_len = StrLength(all_lines);
   CHECK_EQ(all_lines_len, Logger::GetLogLines(0, log_lines, all_lines_len));
   CHECK_EQ(all_lines, log_lines);
   memset(log_lines, 0, sizeof(log_lines));
   CHECK_EQ(all_lines_len, Logger::GetLogLines(0, log_lines, all_lines_len + 3));
   CHECK_EQ(all_lines, log_lines);
   memset(log_lines, 0, sizeof(log_lines));
   TearDown();
 }
 
 
 static int GetLogLines(int start_pos, i::Vector<char>* buffer) {
   return Logger::GetLogLines(start_pos, buffer->start(), buffer->length());
 }
 
 
 TEST(BeyondWritePosition) {
   SetUp();
   Logger::StringEvent("aaa", "bbb");
   Logger::StringEvent("cccc", "dddd");
   // See Logger::StringEvent.
   const char* all_lines = "aaa,\"bbb\"\ncccc,\"dddd\"\n";
-  const int all_lines_len = strlen(all_lines);
+  const int all_lines_len = StrLength(all_lines);
   EmbeddedVector<char, 100> buffer;
   const int beyond_write_pos = all_lines_len;
   CHECK_EQ(0, Logger::GetLogLines(beyond_write_pos, buffer.start(), 1));
   CHECK_EQ(0, GetLogLines(beyond_write_pos, &buffer));
   CHECK_EQ(0, Logger::GetLogLines(beyond_write_pos + 1, buffer.start(), 1));
   CHECK_EQ(0, GetLogLines(beyond_write_pos + 1, &buffer));
   CHECK_EQ(0, Logger::GetLogLines(beyond_write_pos + 100, buffer.start(), 1));
   CHECK_EQ(0, GetLogLines(beyond_write_pos + 100, &buffer));
   CHECK_EQ(0, Logger::GetLogLines(10 * 1024 * 1024, buffer.start(), 1));
   CHECK_EQ(0, GetLogLines(10 * 1024 * 1024, &buffer));
@@ skipping 312 matching lines @@
 
 
 // Test for issue http://crbug.com/23768 in Chromium.
 // Heap can contain scripts with already disposed external sources.
 // We need to verify that LogCompiledFunctions doesn't crash on them.
 namespace {
 
 class SimpleExternalString : public v8::String::ExternalStringResource {
  public:
   explicit SimpleExternalString(const char* source)
-      : utf_source_(strlen(source)) {
+      : utf_source_(StrLength(source)) {
     for (int i = 0; i < utf_source_.length(); ++i)
       utf_source_[i] = source[i];
   }
   virtual ~SimpleExternalString() {}
   virtual size_t length() const { return utf_source_.length(); }
   virtual const uint16_t* data() const { return utf_source_.start(); }
  private:
   i::ScopedVector<uint16_t> utf_source_;
 };
 
@@ skipping 134 matching lines @@
     // Make sure that the test doesn't operate on a bogus log.
     CHECK_GT(max_entities, 0);
     CHECK_GT(bounds.GetMinAddr(), 0);
     CHECK_GT(bounds.GetMaxAddr(), bounds.GetMinAddr());
 
     entities = i::NewArray<CodeEntityInfo>(max_entities);
     for (int i = 0; i < max_entities; ++i) {
       entities[i] = NULL;
     }
     const size_t map_length = bounds.Length();
-    entities_map = i::NewArray<int>(map_length);
+    entities_map = i::NewArray<int>(static_cast<int>(map_length));
     for (size_t i = 0; i < map_length; ++i) {
       entities_map[i] = -1;
     }
   }
 
   bool HasIndexForAddress(Address addr) {
     return bounds.Contains(addr);
   }
 
   size_t GetIndexForAddress(Address addr) {
@@ skipping 155 matching lines @@
   // Pass 2: Fill in code entries data.
   ParserCycle(start, end, result,
               Pass2CodeCreation, Pass2CodeDelete, Pass2CodeMove);
 }
 
 
 static inline void PrintCodeEntityInfo(CodeEntityInfo entity) {
   const int max_len = 50;
   if (entity != NULL) {
     char* eol = strchr(entity, '\n');
-    int len = eol - entity;
+    int len = static_cast<int>(eol - entity);
     len = len <= max_len ? len : max_len;
     printf("%-*.*s ", max_len, len, entity);
   } else {
     printf("%*s", max_len + 1, "");
   }
 }
 
 
 static void PrintCodeEntitiesInfo(
     bool is_equal, Address addr,
     CodeEntityInfo l_entity, CodeEntityInfo r_entity) {
   printf("%c %p ", is_equal ? ' ' : '*', addr);
   PrintCodeEntityInfo(l_entity);
   PrintCodeEntityInfo(r_entity);
   printf("\n");
 }
 
 
 static inline int StrChrLen(const char* s, char c) {
-  return strchr(s, c) - s;
+  return static_cast<int>(strchr(s, c) - s);
 }
 
 
 static bool AreFuncSizesEqual(CodeEntityInfo ref_s, CodeEntityInfo new_s) {
   int ref_len = StrChrLen(ref_s, ',');
   int new_len = StrChrLen(new_s, ',');
   return ref_len == new_len && strncmp(ref_s, new_s, ref_len) == 0;
 }
 
 
@@ skipping 130 matching lines @@
   // Make sure that all log data is written prior crash due to CHECK failure.
   fflush(stdout);
   CHECK(results_equal);
 
   env->Exit();
   Logger::TearDown();
   i::FLAG_always_compact = saved_always_compact;
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING