Revert of Fix printf formats

src/wasm/decoder.h

 // Copyright 2015 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.
 
 #ifndef V8_WASM_DECODER_H_
 #define V8_WASM_DECODER_H_
 
-#include "src/base/compiler-specific.h"
 #include "src/base/smart-pointers.h"
 #include "src/flags.h"
 #include "src/signature.h"
-#include "src/utils.h"
 #include "src/wasm/wasm-result.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 #if DEBUG
 #define TRACE(...)                                    \
   do {                                                \
@@ skipping 19 matching lines @@
         limit_(end),
         end_(end),
         error_pc_(nullptr),
         error_pt_(nullptr) {}
 
   virtual ~Decoder() {}
 
   inline bool check(const byte* base, int offset, int length, const char* msg) {
     DCHECK_GE(base, start_);
     if ((base + offset + length) > limit_) {
-      error(base, base + offset, "%s", msg);
+      error(base, base + offset, msg);
       return false;
     }
     return true;
   }
 
   // Reads a single 8-bit byte, reporting an error if out of bounds.
   inline uint8_t checked_read_u8(const byte* base, int offset,
                                  const char* msg = "expected 1 byte") {
     return check(base, offset, 1, msg) ? base[offset] : 0;
   }
@@ skipping 190 matching lines @@
       error(pc_, nullptr, "reading %d bytes would underflow/overflow", size);
       return false;
     } else if (pc_ < start_ || limit_ < (pc_ + size)) {
       error(pc_, nullptr, "expected %d bytes, fell off end", size);
       return false;
     } else {
       return true;
     }
   }
 
-  void error(const char* msg) { error(pc_, nullptr, "%s", msg); }
+  void error(const char* msg) { error(pc_, nullptr, msg); }
 
-  void error(const byte* pc, const char* msg) { error(pc, nullptr, "%s", msg); }
+  void error(const byte* pc, const char* msg) { error(pc, nullptr, msg); }
 
   // Sets internal error state.
-  void PRINTF_FORMAT(4, 5)
-      error(const byte* pc, const byte* pt, const char* format, ...) {
+  void error(const byte* pc, const byte* pt, const char* format, ...) {
     if (ok()) {
 #if DEBUG
       if (FLAG_wasm_break_on_decoder_error) {
         base::OS::DebugBreak();
       }
 #endif
       const int kMaxErrorMsg = 256;
       char* buffer = new char[kMaxErrorMsg];
       va_list arguments;
       va_start(arguments, format);
@@ skipping 108 matching lines @@
         extra_bits_value = (static_cast<int8_t>(b << kExtraBits) >> 8) &
                            kExtraBitsMask & ~0x80;
       } else {
         extra_bits_value = 0;
       }
       if (*length == kMaxLength && (b & kExtraBitsMask) != extra_bits_value) {
         error(base, ptr, "extra bits in varint");
         return 0;
       }
       if ((b & 0x80) != 0) {
-        error(base, ptr, "%s", msg);
+        error(base, ptr, msg);
         return 0;
       }
     }
     return result;
   }
 };
 
 #undef TRACE
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_DECODER_H_