Fix printf formats

src/base/platform/platform.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This module contains the platform-specific code. This make the rest of the
 // code less dependent on operating system, compilers and runtime libraries.
 // This module does specifically not deal with differences between different
 // processor architecture.
 // The platform classes have the same definition for all platforms. The
 // implementation for a particular platform is put in platform_<os>.cc.
 // The build system then uses the implementation for the target platform.
 //
 // This design has been chosen because it is simple and fast. Alternatively,
 // the platform dependent classes could have been implemented using abstract
 // superclasses with virtual methods and having specializations for each
 // platform. This design was rejected because it was more complicated and
 // slower. It would require factory methods for selecting the right
 // implementation and the overhead of virtual methods for performance
 // sensitive like mutex locking/unlocking.
 
 #ifndef V8_BASE_PLATFORM_PLATFORM_H_
 #define V8_BASE_PLATFORM_PLATFORM_H_
 
 #include <cstdarg>
 #include <string>
 #include <vector>
 
 #include "src/base/build_config.h"
+#include "src/base/compiler-specific.h"
 #include "src/base/platform/mutex.h"
 #include "src/base/platform/semaphore.h"
 
 #if V8_OS_QNX
 #include "src/base/qnx-math.h"
 #endif
 
 namespace v8 {
 namespace base {
 
@@ skipping 108 matching lines @@
 
   // Opens a temporary file, the file is auto removed on close.
   static FILE* OpenTemporaryFile();
 
   // Log file open mode is platform-dependent due to line ends issues.
   static const char* const LogFileOpenMode;
 
   // Print output to console. This is mostly used for debugging output.
   // On platforms that has standard terminal output, the output
   // should go to stdout.
-  static void Print(const char* format, ...);
-  static void VPrint(const char* format, va_list args);
+  static PRINTF_FORMAT(1, 2) void Print(const char* format, ...);
+  static PRINTF_FORMAT(1, 0) void VPrint(const char* format, va_list args);
 
   // Print output to a file. This is mostly used for debugging output.
-  static void FPrint(FILE* out, const char* format, ...);
-  static void VFPrint(FILE* out, const char* format, va_list args);
+  static PRINTF_FORMAT(2, 3) void FPrint(FILE* out, const char* format, ...);
+  static PRINTF_FORMAT(2, 0) void VFPrint(FILE* out, const char* format,
+                                          va_list args);
 
   // Print error output to console. This is mostly used for error message
   // output. On platforms that has standard terminal output, the output
   // should go to stderr.
-  static void PrintError(const char* format, ...);
-  static void VPrintError(const char* format, va_list args);
+  static PRINTF_FORMAT(1, 2) void PrintError(const char* format, ...);
+  static PRINTF_FORMAT(1, 0) void VPrintError(const char* format, va_list args);
 
   // Allocate/Free memory used by JS heap. Pages are readable/writable, but
   // they are not guaranteed to be executable unless 'executable' is true.
   // Returns the address of allocated memory, or NULL if failed.
   static void* Allocate(const size_t requested,
                         size_t* allocated,
                         bool is_executable);
   static void Free(void* address, const size_t size);
 
   // This is the granularity at which the ProtectCode(...) call can set page
@@ skipping 36 matching lines @@
     virtual void* memory() const = 0;
     virtual size_t size() const = 0;
 
     static MemoryMappedFile* open(const char* name);
     static MemoryMappedFile* create(const char* name, size_t size,
                                     void* initial);
   };
 
   // Safe formatting print. Ensures that str is always null-terminated.
   // Returns the number of chars written, or -1 if output was truncated.
-  static int SNPrintF(char* str, int length, const char* format, ...);
-  static int VSNPrintF(char* str,
-                       int length,
-                       const char* format,
-                       va_list args);
+  static PRINTF_FORMAT(3, 4) int SNPrintF(char* str, int length,
+                                          const char* format, ...);
+  static PRINTF_FORMAT(3, 0) int VSNPrintF(char* str, int length,
+                                           const char* format, va_list args);
 
   static char* StrChr(char* str, int c);
   static void StrNCpy(char* dest, int length, const char* src, size_t n);
 
   // Support for the profiler.  Can do nothing, in which case ticks
   // occuring in shared libraries will not be properly accounted for.
   struct SharedLibraryAddress {
     SharedLibraryAddress(
         const std::string& library_path, uintptr_t start, uintptr_t end)
         : library_path(library_path), start(start), end(end) {}
@@ skipping 241 matching lines @@
   int stack_size_;
   Semaphore* start_semaphore_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_PLATFORM_PLATFORM_H_