Use safe string utilities to fix Windows build error.

src/hydrogen.cc

 // Copyright 2012 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 1535 matching lines @@
       int header_id = block->parent_loop_header()->block_id();
       loop_side_effects_[header_id].Add(block->IsLoopHeader()
                                         ? loop_side_effects_[id]
                                         : side_effects);
     }
   }
 }
 
 
 SmartArrayPointer<char> GetGVNFlagsString(GVNFlagSet flags) {
+  char underlying_buffer[kLastFlag * 128];
+  Vector<char> buffer(underlying_buffer, sizeof(underlying_buffer));
 #if DEBUG
-  char buffer[kLastFlag * 128];
+  int offset = 0;
   const char* separator = "";
   const char* comma = ", ";
   buffer[0] = 0;
   uint32_t set_depends_on = 0;
   uint32_t set_changes = 0;
   for (int bit = 0; bit < kLastFlag; ++bit) {
     if ((flags.ToIntegral() & (1 << bit)) != 0) {
       if (bit % 2 == 0) {
         set_changes++;
       } else {
         set_depends_on++;
       }
     }
   }
   bool positive_changes = set_changes < (kLastFlag / 2);
   bool positive_depends_on = set_depends_on < (kLastFlag / 2);
   if (set_changes > 0) {
     if (positive_changes) {
-      strcat(buffer, "changes [");
+      offset += OS::SNPrintF(buffer + offset, "changes [");
     } else {
-      strcat(buffer, "changes all except [");
+      offset += OS::SNPrintF(buffer + offset, "changes all except [");
     }
     for (int bit = 0; bit < kLastFlag; ++bit) {
       if (((flags.ToIntegral() & (1 << bit)) != 0) == positive_changes) {
         switch (static_cast<GVNFlag>(bit)) {
-#define DECLARE_FLAG(type)                \
-          case kChanges##type:            \
-            strcat(buffer, separator);    \
-            strcat(buffer, #type);        \
-            separator = comma;            \
+#define DECLARE_FLAG(type)                                       \
+          case kChanges##type:                                   \
+            offset += OS::SNPrintF(buffer + offset, separator);  \
+            offset += OS::SNPrintF(buffer + offset, #type);      \
+            separator = comma;                                   \
             break;
 GVN_TRACKED_FLAG_LIST(DECLARE_FLAG)
 GVN_UNTRACKED_FLAG_LIST(DECLARE_FLAG)
 #undef DECLARE_FLAG
           default:
               break;
         }
       }
     }
-    strcat(buffer, "]");
+    offset += OS::SNPrintF(buffer + offset, "]");
   }
   if (set_depends_on > 0) {
     separator = "";
     if (set_changes > 0) {
-      strcat(buffer, ", ");
+      offset += OS::SNPrintF(buffer + offset, ", ");
     }
     if (positive_depends_on) {
-      strcat(buffer, "depends on [");
+      offset += OS::SNPrintF(buffer + offset, "depends on [");
     } else {
-      strcat(buffer, "depends on all except [");
+      offset += OS::SNPrintF(buffer + offset, "depends on all except [");
     }
     for (int bit = 0; bit < kLastFlag; ++bit) {
       if (((flags.ToIntegral() & (1 << bit)) != 0) == positive_depends_on) {
         switch (static_cast<GVNFlag>(bit)) {
-#define DECLARE_FLAG(type)                  \
-          case kDependsOn##type:            \
-            strcat(buffer, separator);      \
-            strcat(buffer, #type);          \
-            separator = comma;              \
+#define DECLARE_FLAG(type)                                       \
+          case kDependsOn##type:                                 \
+            offset += OS::SNPrintF(buffer + offset, separator);  \
+            offset += OS::SNPrintF(buffer + offset, #type);      \
+            separator = comma;                                   \
             break;
 GVN_TRACKED_FLAG_LIST(DECLARE_FLAG)
 GVN_UNTRACKED_FLAG_LIST(DECLARE_FLAG)
 #undef DECLARE_FLAG
           default:
             break;
         }
       }
     }
-    strcat(buffer, "]");
+    offset += OS::SNPrintF(buffer + offset, "]");
   }
 #else
-  char buffer[128];
-  snprintf(buffer, 128, "0x%08X", flags.ToIntegral());
+  OS::SNPrintF(buffer, "0x%08X", flags.ToIntegral());
 #endif
-  char* result = new char[strlen(buffer) + 1];
-  strcpy(result, buffer);
+  uint32_t string_len = strlen(underlying_buffer) + 1;
+  ASSERT(string_len <= sizeof(underlying_buffer));
+  char* result = new char[strlen(underlying_buffer) + 1];
+  memcpy(result, underlying_buffer, string_len);
   return SmartArrayPointer<char>(result);
 }
 
 
 void HGlobalValueNumberer::LoopInvariantCodeMotion() {
   for (int i = graph_->blocks()->length() - 1; i >= 0; --i) {
     HBasicBlock* block = graph_->blocks()->at(i);
     if (block->IsLoopHeader()) {
       GVNFlagSet side_effects = loop_side_effects_[block->block_id()];
       TraceGVN("Try loop invariant motion for block B%d %s\n",
@@ skipping 6814 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal