Revert of Fix printf formats

src/x64/disasm-x64.cc

 // Copyright 2011 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.
 
 #include <assert.h>
 #include <stdarg.h>
 #include <stdio.h>
 
 #if V8_TARGET_ARCH_X64
 
-#include "src/base/compiler-specific.h"
 #include "src/base/lazy-instance.h"
 #include "src/disasm.h"
 
 namespace disasm {
 
 enum OperandType {
   UNSET_OP_ORDER = 0,
   // Operand size decides between 16, 32 and 64 bit operands.
   REG_OPER_OP_ORDER = 1,  // Register destination, operand source.
   OPER_REG_OP_ORDER = 2,  // Operand destination, register source.
@@ skipping 451 matching lines @@
   int F6F7Instruction(byte* data);
   int ShiftInstruction(byte* data);
   int JumpShort(byte* data);
   int JumpConditional(byte* data);
   int JumpConditionalShort(byte* data);
   int SetCC(byte* data);
   int FPUInstruction(byte* data);
   int MemoryFPUInstruction(int escape_opcode, int regop, byte* modrm_start);
   int RegisterFPUInstruction(int escape_opcode, byte modrm_byte);
   int AVXInstruction(byte* data);
-  PRINTF_FORMAT(2, 3) void AppendToBuffer(const char* format, ...);
+  void AppendToBuffer(const char* format, ...);
 
   void UnimplementedInstruction() {
     if (abort_on_unimplemented_) {
       CHECK(false);
     } else {
       AppendToBuffer("'Unimplemented Instruction'");
     }
   }
 };
 
@@ skipping 118 matching lines @@
       break;
     case OPERAND_QUADWORD_SIZE:
       value = *reinterpret_cast<int32_t*>(data);
       count = 4;
       break;
     default:
       UNREACHABLE();
       value = 0;  // Initialize variables on all paths to satisfy the compiler.
       count = 0;
   }
-  AppendToBuffer("%" PRIx64, value);
+  AppendToBuffer("%" V8_PTR_PREFIX "x", value);
   return count;
 }
 
 
 int DisassemblerX64::PrintRightOperand(byte* modrmp) {
   return PrintRightOperandHelper(modrmp,
                                  &DisassemblerX64::NameOfCPURegister);
 }
 
 
@@ skipping 1360 matching lines @@
       case ZERO_OPERANDS_INSTR:
         if (current >= 0xA4 && current <= 0xA7) {
           // String move or compare operations.
           if (group_1_prefix_ == REP_PREFIX) {
             // REP.
             AppendToBuffer("rep ");
           }
           if (rex_w()) AppendToBuffer("REX.W ");
           AppendToBuffer("%s%c", idesc.mnem, operand_size_code());
         } else {
-          AppendToBuffer("%s%c", idesc.mnem, operand_size_code());
+          AppendToBuffer("%s", idesc.mnem, operand_size_code());
         }
         data++;
         break;
 
       case TWO_OPERANDS_INSTR:
         data++;
         data += PrintOperands(idesc.mnem, idesc.op_order_, data);
         break;
 
       case JUMP_CONDITIONAL_SHORT_INSTR:
@@ skipping 314 matching lines @@
             value = *reinterpret_cast<uint32_t*>(data + 1);
             data += 5;
             break;
           case OPERAND_QUADWORD_SIZE:
             value = *reinterpret_cast<int32_t*>(data + 1);
             data += 5;
             break;
           default:
             UNREACHABLE();
         }
-        AppendToBuffer("test%c rax,0x%" PRIx64, operand_size_code(), value);
+        AppendToBuffer("test%c rax,0x%" V8_PTR_PREFIX "x",
+                       operand_size_code(),
+                       value);
         break;
       }
       case 0xD1:  // fall through
       case 0xD3:  // fall through
       case 0xC1:
         data += ShiftInstruction(data);
         break;
       case 0xD0:  // fall through
       case 0xD2:  // fall through
       case 0xC0:
@@ skipping 152 matching lines @@
     for (int i = 6 - static_cast<int>(pc - prev_pc); i >= 0; i--) {
       fprintf(f, "  ");
     }
     fprintf(f, "  %s\n", buffer.start());
   }
 }
 
 }  // namespace disasm
 
 #endif  // V8_TARGET_ARCH_X64