Add attributions so printf like functions can have their arguments checked.

runtime/vm/disassembler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/disassembler.h"
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_X64)
 #include "platform/utils.h"
 #include "vm/allocation.h"
@@ skipping 355 matching lines @@
 
   const char* NameOfByteCPURegister(int reg) const {
     return NameOfCPURegister(reg);
   }
 
   const char* NameOfXMMRegister(int reg) const {
     ASSERT((0 <= reg) && (reg < kMaxXmmRegisters));
     return xmm_regs[reg];
   }
 
-  void AppendToBuffer(const char* format, ...);
+  void AppendToBuffer(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
   void AppendAddressToBuffer(uint8_t* addr);
 
   int PrintOperands(const char* mnem,
                     OperandType op_order,
                     uint8_t* data);
 
   typedef const char* (DisassemblerX64::*RegisterNameMapping)(int reg) const;
 
   int PrintRightOperandHelper(uint8_t* modrmp,
                               RegisterNameMapping register_name);
@@ skipping 52 matching lines @@
     uint8_t* modrmp,
     RegisterNameMapping direct_register_name) {
   int mod, regop, rm;
   get_modrm(*modrmp, &mod, &regop, &rm);
   RegisterNameMapping register_name = (mod == 3) ? direct_register_name :
       &DisassemblerX64::NameOfCPURegister;
   switch (mod) {
     case 0:
       if ((rm & 7) == 5) {
         int32_t disp = *reinterpret_cast<int32_t*>(modrmp + 1);
-        AppendToBuffer("[0x%x]", disp);
+        AppendToBuffer("[%#x]", disp);
         return 5;
       } else if ((rm & 7) == 4) {
         // Codes for SIB byte.
         uint8_t sib = *(modrmp + 1);
         int scale, index, base;
         get_sib(sib, &scale, &index, &base);
         if (index == 4 && (base & 7) == 4 && scale == 0 /*times_1*/) {
           // index == rsp means no index. Only use sib byte with no index for
           // rsp and r12 base.
           AppendToBuffer("[%s]", NameOfCPURegister(base));
           return 2;
         } else if (base == 5) {
           // base == rbp means no base register (when mod == 0).
           int32_t disp = *reinterpret_cast<int32_t*>(modrmp + 2);
-          AppendToBuffer("[%s*%d+0x%x]",
+          AppendToBuffer("[%s*%d+%#x]",
                          NameOfCPURegister(index),
                          1 << scale, disp);
           return 6;
         } else if (index != 4 && base != 5) {
           // [base+index*scale]
           AppendToBuffer("[%s+%s*%d]",
                          NameOfCPURegister(base),
                          NameOfCPURegister(index),
                          1 << scale);
           return 2;
         } else {
           UnimplementedInstruction();
           return 1;
         }
       } else {
         AppendToBuffer("[%s]", NameOfCPURegister(rm));
         return 1;
       }
       break;
     case 1:  // fall through
     case 2:
       if ((rm & 7) == 4) {
         uint8_t sib = *(modrmp + 1);
         int scale, index, base;
         get_sib(sib, &scale, &index, &base);
         int disp = (mod == 2) ? *reinterpret_cast<int32_t*>(modrmp + 2)
                               : *reinterpret_cast<char*>(modrmp + 2);
         if (index == 4 && (base & 7) == 4 && scale == 0 /*times_1*/) {
           if (-disp > 0) {
-            AppendToBuffer("[%s-0x%x]", NameOfCPURegister(base), -disp);
+            AppendToBuffer("[%s-%#x]", NameOfCPURegister(base), -disp);
           } else {
-            AppendToBuffer("[%s+0x%x]", NameOfCPURegister(base), disp);
+            AppendToBuffer("[%s+%#x]", NameOfCPURegister(base), disp);
           }
         } else {
           if (-disp > 0) {
-            AppendToBuffer("[%s+%s*%d-0x%x]",
+            AppendToBuffer("[%s+%s*%d-%#x]",
                            NameOfCPURegister(base),
                            NameOfCPURegister(index),
                            1 << scale,
                            -disp);
           } else {
-            AppendToBuffer("[%s+%s*%d+0x%x]",
+            AppendToBuffer("[%s+%s*%d+%#x]",
                            NameOfCPURegister(base),
                            NameOfCPURegister(index),
                            1 << scale,
                            disp);
           }
         }
         return mod == 2 ? 6 : 3;
       } else {
         // No sib.
         int disp = (mod == 2) ? *reinterpret_cast<int32_t*>(modrmp + 1)
                               : *reinterpret_cast<char*>(modrmp + 1);
         if (-disp > 0) {
-        AppendToBuffer("[%s-0x%x]", NameOfCPURegister(rm), -disp);
+        AppendToBuffer("[%s-%#x]", NameOfCPURegister(rm), -disp);
         } else {
-        AppendToBuffer("[%s+0x%x]", NameOfCPURegister(rm), disp);
+        AppendToBuffer("[%s+%#x]", NameOfCPURegister(rm), disp);
         }
         return (mod == 2) ? 5 : 2;
       }
       break;
     case 3:
       AppendToBuffer("%s", (this->*register_name)(rm));
       return 1;
     default:
       UnimplementedInstruction();
       return 1;
@@ skipping 20 matching lines @@
       break;
     case 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("%"PRIxPTR, value);
+  AppendToBuffer("%#"Px"", value);
   return count;
 }
 
 
 // Returns number of bytes used by machine instruction, including *data byte.
 // Writes immediate instructions to 'tmp_buffer_'.
 int DisassemblerX64::PrintImmediateOp(uint8_t* data) {
   bool byte_size_immediate = (*data & 0x02) != 0;
   uint8_t modrm = *(data + 1);
   int mod, regop, rm;
@@ skipping 217 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, format, full_class_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, full_class_name);
   return chars;
 }
 
 
 void DisassemblerX64::AppendAddressToBuffer(uint8_t* addr_byte_ptr) {
   NoGCScope no_gc;
   uword addr = reinterpret_cast<uword>(addr_byte_ptr);
-  AppendToBuffer("0x%0"PRIxPTR, addr);
+  AppendToBuffer("%#"Px"", addr);
   // Try to print as heap object or stub name
   if (!Isolate::Current()->heap()->CodeContains(addr) &&
       Isolate::Current()->heap()->Contains(addr - kHeapObjectTag)) {
     Object& obj = Object::Handle(reinterpret_cast<RawObject*>(addr));
     if (obj.IsArray()) {
       const Array& arr = Array::CheckedHandle(obj.raw());
       intptr_t len = arr.Length();
       if (len > 5) len = 5;  // Print a max of 5 elements.
       AppendToBuffer("  Array[");
       int i = 0;
       while (i < len) {
         obj = arr.At(i);
         if (i > 0) AppendToBuffer(", ");
-        AppendToBuffer(ObjectToCStringNoGC(obj));
+        AppendToBuffer("%s", ObjectToCStringNoGC(obj));
         i++;
       }
       if (i < arr.Length()) AppendToBuffer(", ...");
       AppendToBuffer("]");
       return;
     }
     AppendToBuffer("  '%s'", ObjectToCStringNoGC(obj));
   } else {
     // 'addr' is not an object, but probably a code address.
     const char* name_of_stub = StubCode::NameOfStub(addr);
@@ skipping 268 matching lines @@
       if (current >= 0xA4 && current <= 0xA7) {
         // String move or compare operations.
         if (group_1_prefix_ == REP_PREFIX) {
           // REP.
           AppendToBuffer("rep ");
         }
         // TODO(srdjan): Should we enable printing of REX.W?
         // if (rex_w()) AppendToBuffer("REX.W ");
         AppendToBuffer("%s%c", idesc.mnem, operand_size_code());
       } else {
-        AppendToBuffer("%s", idesc.mnem, operand_size_code());
+        AppendToBuffer("%s%c", 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 375 matching lines @@
 
 
 int DisassemblerX64::InstructionDecode(uword pc) {
   uint8_t* data = reinterpret_cast<uint8_t*>(pc);
 
   const bool processed = DecodeInstructionType(&data);
 
   if (!processed) {
     switch (*data) {
       case 0xC2:
-        AppendToBuffer("ret 0x%x", *reinterpret_cast<uint16_t*>(data + 1));
+        AppendToBuffer("ret %#x", *reinterpret_cast<uint16_t*>(data + 1));
         data += 3;
         break;
 
       case 0x69:  // fall through
       case 0x6B: {
         int mod, regop, rm;
         get_modrm(*(data + 1), &mod, &regop, &rm);
         int32_t imm = *data == 0x6B ? *(data + 2)
             : *reinterpret_cast<int32_t*>(data + 2);
-        AppendToBuffer("imul%c %s,%s,0x%x",
+        AppendToBuffer("imul%c %s,%s,%#x",
                        operand_size_code(),
                        NameOfCPURegister(regop),
                        NameOfCPURegister(rm), imm);
         data += 2 + (*data == 0x6B ? 1 : 4);
         break;
       }
 
       case 0x81:  // fall through
       case 0x83:  // 0x81 with sign extension bit set
         data += PrintImmediateOp(data);
@@ skipping 47 matching lines @@
 
       case 0xC7:  // imm32, fall through
       case 0xC6:  // imm8
       {
         bool is_byte = *data == 0xC6;
         data++;
         if (is_byte) {
           AppendToBuffer("movb ");
           data += PrintRightByteOperand(data);
           int32_t imm = *data;
-          AppendToBuffer(",0x%x", imm);
+          AppendToBuffer(",%#x", imm);
           data++;
         } else {
           AppendToBuffer("mov%c ", operand_size_code());
           data += PrintRightOperand(data);
           int32_t imm = *reinterpret_cast<int32_t*>(data);
-          AppendToBuffer(",0x%x", imm);
+          AppendToBuffer(",%#x", imm);
           data += 4;
         }
       }
         break;
 
       case 0x80: {
         data++;
         AppendToBuffer("cmpb ");
         data += PrintRightByteOperand(data);
         int32_t imm = *data;
-        AppendToBuffer(",0x%x", imm);
+        AppendToBuffer(",%#x", imm);
         data++;
       }
         break;
 
       case 0x88:  // 8bit, fall through
       case 0x89:  // 32bit
       {
         bool is_byte = *data == 0x88;
         int mod, regop, rm;
         data++;
@@ skipping 68 matching lines @@
         get_modrm(*data, &mod, &regop, &rm);
         if (regop == 1) {
           AppendToBuffer("decb ");
           data += PrintRightByteOperand(data);
         } else {
           UnimplementedInstruction();
         }
         break;
       }
       case 0x68:
-        AppendToBuffer("push 0x%x", *reinterpret_cast<int32_t*>(data + 1));
+        AppendToBuffer("push %#x", *reinterpret_cast<int32_t*>(data + 1));
         data += 5;
         break;
 
       case 0x6A:
-        AppendToBuffer("push 0x%x", *reinterpret_cast<int8_t*>(data + 1));
+        AppendToBuffer("push %#x", *reinterpret_cast<int8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA1:  // Fall through.
       case 0xA3:
         switch (operand_size()) {
           case DOUBLEWORD_SIZE: {
             AppendAddressToBuffer(
                 reinterpret_cast<uint8_t*>(
                     *reinterpret_cast<int32_t*>(data + 1)));
@@ skipping 27 matching lines @@
             data += 9;
             break;
           }
           default:
             UnimplementedInstruction();
             data += 2;
         }
         break;
 
       case 0xA8:
-        AppendToBuffer("test al,0x%x", *reinterpret_cast<uint8_t*>(data + 1));
+        AppendToBuffer("test al,%#x", *reinterpret_cast<uint8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA9: {
         int64_t value = 0;
         switch (operand_size()) {
           case WORD_SIZE:
             value = *reinterpret_cast<uint16_t*>(data + 1);
             data += 3;
             break;
           case DOUBLEWORD_SIZE:
             value = *reinterpret_cast<uint32_t*>(data + 1);
             data += 5;
             break;
           case QUADWORD_SIZE:
             value = *reinterpret_cast<int32_t*>(data + 1);
             data += 5;
             break;
           default:
             UNREACHABLE();
         }
-        AppendToBuffer("test%c rax,0x%0"PRIxPTR,
+        AppendToBuffer("test%c rax,%#"Px"",
                        operand_size_code(),
                        value);
         break;
       }
       case 0xD1:  // fall through
       case 0xD3:  // fall through
       case 0xC1:
         data += ShiftInstruction(data);
         break;
       case 0xD0:  // fall through
@@ skipping 87 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64