vm: x64 disassembler fix

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 356 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, ...) PRINTF_ATTRIBUTE(2, 3);
-  void AppendAddressToBuffer(uint8_t* addr);
+  void Print(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
+  void PrintAddress(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);
   int PrintRightOperand(uint8_t* modrmp);
   int PrintRightByteOperand(uint8_t* modrmp);
   int PrintRightXMMOperand(uint8_t* modrmp);
+  void PrintDisp(int disp, const char* after);
   int PrintImmediate(uint8_t* data, OperandSize size);
+  void PrintImmediateValue(int64_t value);
   int PrintImmediateOp(uint8_t* data);
   const char* TwoByteMnemonic(uint8_t opcode);
   int TwoByteOpcodeInstruction(uint8_t* data);
 
   int F6F7Instruction(uint8_t* data);
   int ShiftInstruction(uint8_t* data);
   int JumpShort(uint8_t* data);
   int JumpConditional(uint8_t* data);
   int JumpConditionalShort(uint8_t* data);
   int SetCC(uint8_t* data);
   int FPUInstruction(uint8_t* data);
   int MemoryFPUInstruction(int escape_opcode, int regop, uint8_t* modrm_start);
   int RegisterFPUInstruction(int escape_opcode, uint8_t modrm_byte);
 
   bool DecodeInstructionType(uint8_t** data);
 
   void UnimplementedInstruction() {
-    AppendToBuffer("'Unimplemented Instruction'");
+    Print("'Unimplemented Instruction'");
   }
 
   char* buffer_;  // Decode instructions into this buffer.
   intptr_t buffer_size_;  // The size of the buffer_.
   intptr_t buffer_pos_;  // Current character position in the buffer_.
 
   // Prefixes parsed
   uint8_t rex_;
   uint8_t operand_size_;  // 0x66 or (if no group 3 prefix is present) 0x0.
   // 0xF2, 0xF3, or (if no group 1 prefix is present) 0.
   uint8_t group_1_prefix_;
   // Byte size operand override.
   bool byte_size_operand_;
 
   DISALLOW_COPY_AND_ASSIGN(DisassemblerX64);
 };
 
 
 // Append the str to the output buffer.
-void DisassemblerX64::AppendToBuffer(const char* format, ...) {
+void DisassemblerX64::Print(const char* format, ...) {
   intptr_t available = buffer_size_ - buffer_pos_;
   if (available <= 1) {
     ASSERT(buffer_[buffer_pos_] == '\0');
     return;
   }
   char* buf = buffer_ + buffer_pos_;
   va_list args;
   va_start(args, format);
   int length = OS::VSNPrint(buf, available, format, args);
   va_end(args);
   buffer_pos_ =
       (length >= available) ? (buffer_size_ - 1) : (buffer_pos_ + length);
   ASSERT(buffer_pos_ < buffer_size_);
 }
 
 
 int DisassemblerX64::PrintRightOperandHelper(
     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("[rip%s%#x]", disp < 0 ? "-" : "+", Utils::Abs(disp));
+        Print("[rip");
+        PrintDisp(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));
+          Print("[%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+%#x]",
-                         NameOfCPURegister(index),
-                         1 << scale, disp);
+          Print("[%s*%d", NameOfCPURegister(index), 1 << scale);
+          PrintDisp(disp, "]");
           return 6;
         } else if (index != 4 && base != 5) {
           // [base+index*scale]
-          AppendToBuffer("[%s+%s*%d]",
-                         NameOfCPURegister(base),
-                         NameOfCPURegister(index),
-                         1 << scale);
+          Print("[%s+%s*%d]",
+                NameOfCPURegister(base),
+                NameOfCPURegister(index),
+                1 << scale);
           return 2;
         } else {
           UnimplementedInstruction();
           return 1;
         }
       } else {
-        AppendToBuffer("[%s]", NameOfCPURegister(rm));
+        Print("[%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-%#x]", NameOfCPURegister(base), -disp);
-          } else {
-            AppendToBuffer("[%s+%#x]", NameOfCPURegister(base), disp);
-          }
+          Print("[%s", NameOfCPURegister(base));
+          PrintDisp(disp, "]");
         } else {
-          if (-disp > 0) {
-            AppendToBuffer("[%s+%s*%d-%#x]",
-                           NameOfCPURegister(base),
-                           NameOfCPURegister(index),
-                           1 << scale,
-                           -disp);
-          } else {
-            AppendToBuffer("[%s+%s*%d+%#x]",
-                           NameOfCPURegister(base),
-                           NameOfCPURegister(index),
-                           1 << scale,
-                           disp);
-          }
+          Print("[%s+%s*%d",
+                NameOfCPURegister(base),
+                NameOfCPURegister(index),
+                1 << scale);
+          PrintDisp(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-%#x]", NameOfCPURegister(rm), -disp);
-        } else {
-        AppendToBuffer("[%s+%#x]", NameOfCPURegister(rm), disp);
-        }
+        Print("[%s", NameOfCPURegister(rm));
+        PrintDisp(disp, "]");
         return (mod == 2) ? 5 : 2;
       }
       break;
     case 3:
-      AppendToBuffer("%s", (this->*register_name)(rm));
+      Print("%s", (this->*register_name)(rm));
       return 1;
     default:
       UnimplementedInstruction();
       return 1;
   }
   UNREACHABLE();
 }
 
 
 int DisassemblerX64::PrintImmediate(uint8_t* data, OperandSize size) {
@@ skipping 14 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("%#" Px64 "", value);
+  PrintImmediateValue(value);
   return count;
 }
 
+void DisassemblerX64::PrintImmediateValue(int64_t value) {
+  if ((value >= 0) && (value <= 9)) {
+    Print("%" Pd64 "", value);
+  } else {
+    Print("%#" Px64 "", value);
+  }
+}
+
+void DisassemblerX64::PrintDisp(int disp, const char* after) {
+  if (-disp > 0) {
+    Print("-%#x", -disp);
+  } else {
+    Print("+%#x", disp);
+  }
+  if (after != NULL) Print("%s", after);
+}
+
+
+
 
 // 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;
   get_modrm(modrm, &mod, &regop, &rm);
   const char* mnem = "Imm???";
   switch (regop) {
@@ skipping 17 matching lines @@
       break;
     case 6:
       mnem = "xor";
       break;
     case 7:
       mnem = "cmp";
       break;
     default:
       UnimplementedInstruction();
   }
-  AppendToBuffer("%s%c ", mnem, operand_size_code());
+  Print("%s%c ", mnem, operand_size_code());
   int count = PrintRightOperand(data + 1);
-  AppendToBuffer(",");
+  Print(",");
   OperandSize immediate_size = byte_size_immediate ? BYTE_SIZE : operand_size();
   count += PrintImmediate(data + 1 + count, immediate_size);
   return 1 + count;
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::F6F7Instruction(uint8_t* data) {
   ASSERT(*data == 0xF7 || *data == 0xF6);
   uint8_t modrm = *(data + 1);
@@ skipping 13 matching lines @@
         break;
       case 6:
         mnem = "div";
         break;
       case 7:
         mnem = "idiv";
         break;
       default:
         UnimplementedInstruction();
     }
-    AppendToBuffer("%s%c %s",
-                   mnem,
-                   operand_size_code(),
-                   NameOfCPURegister(rm));
+    Print("%s%c %s",
+          mnem,
+          operand_size_code(),
+          NameOfCPURegister(rm));
     return 2;
   } else if (regop == 0) {
-    AppendToBuffer("test%c ", operand_size_code());
+    Print("test%c ", operand_size_code());
     int count = PrintRightOperand(data + 1);  // Use name of 64-bit register.
-    AppendToBuffer(",0x");
+    Print(",");
     count += PrintImmediate(data + 1 + count, operand_size());
     return 1 + count;
   } else {
     UnimplementedInstruction();
     return 2;
   }
 }
 
 
 int DisassemblerX64::ShiftInstruction(uint8_t* data) {
@@ skipping 39 matching lines @@
       UnimplementedInstruction();
       return num_bytes;
   }
   ASSERT(NULL != mnem);
   if (op == 0xD0) {
     imm8 = 1;
   } else if (op == 0xC0) {
     imm8 = *(data + 2);
     num_bytes = 3;
   }
-  AppendToBuffer("%s%c %s,",
-                 mnem,
-                 operand_size_code(),
-                 byte_size_operand_ ? NameOfByteCPURegister(rm)
-                                    : NameOfCPURegister(rm));
+  Print("%s%c %s,",
+        mnem,
+        operand_size_code(),
+        byte_size_operand_ ? NameOfByteCPURegister(rm)
+                           : NameOfCPURegister(rm));
   if (op == 0xD2) {
-    AppendToBuffer("cl");
+    Print("cl");
   } else {
-    AppendToBuffer("%d", imm8);
+    Print("%d", imm8);
   }
   return num_bytes;
 }
 
 
 int DisassemblerX64::PrintRightOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp,
                                  &DisassemblerX64::NameOfCPURegister);
 }
 
@@ skipping 17 matching lines @@
                                    uint8_t* data) {
   uint8_t modrm = *data;
   int mod, regop, rm;
   get_modrm(modrm, &mod, &regop, &rm);
   int advance = 0;
   const char* register_name =
       byte_size_operand_ ? NameOfByteCPURegister(regop)
                          : NameOfCPURegister(regop);
   switch (op_order) {
     case REG_OPER_OP_ORDER: {
-      AppendToBuffer("%s%c %s,",
-                     mnem,
-                     operand_size_code(),
-                     register_name);
+      Print("%s%c %s,", mnem, operand_size_code(), register_name);
       advance = byte_size_operand_ ? PrintRightByteOperand(data)
                                    : PrintRightOperand(data);
       break;
     }
     case OPER_REG_OP_ORDER: {
-      AppendToBuffer("%s%c ", mnem, operand_size_code());
+      Print("%s%c ", mnem, operand_size_code());
       advance = byte_size_operand_ ? PrintRightByteOperand(data)
                                    : PrintRightOperand(data);
-      AppendToBuffer(",%s", register_name);
+      Print(",%s", register_name);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   return advance;
 }
 
 
@@ skipping 12 matching lines @@
     return obj.ToCString();
   }
 
   const Class& clazz = Class::Handle(obj.clazz());
   const char* full_class_name = clazz.ToCString();
   return OS::SCreate(Thread::Current()->zone(),
       "instance of %s", full_class_name);
 }
 
 
-void DisassemblerX64::AppendAddressToBuffer(uint8_t* addr_byte_ptr) {
+void DisassemblerX64::PrintAddress(uint8_t* addr_byte_ptr) {
   uword addr = reinterpret_cast<uword>(addr_byte_ptr);
-  AppendToBuffer("%#" Px "", addr);
+  Print("%#" Px "", addr);
   // Try to print as heap object or stub name
   if (((addr & kSmiTagMask) == kHeapObjectTag) &&
       reinterpret_cast<RawObject*>(addr)->IsWellFormed() &&
       reinterpret_cast<RawObject*>(addr)->IsOldObject() &&
       !Dart::vm_isolate()->heap()->CodeContains(addr) &&
       !Isolate::Current()->heap()->CodeContains(addr) &&
       Disassembler::CanFindOldObject(addr)) {
     NoSafepointScope no_safepoint;
     const Object& obj = Object::Handle(reinterpret_cast<RawObject*>(addr));
     if (obj.IsArray()) {
       const Array& arr = Array::Cast(obj);
       intptr_t len = arr.Length();
       if (len > 5) len = 5;  // Print a max of 5 elements.
-      AppendToBuffer("  Array[");
+      Print("  Array[");
       int i = 0;
       Object& element = Object::Handle();
       while (i < len) {
         element = arr.At(i);
-        if (i > 0) AppendToBuffer(", ");
-        AppendToBuffer("%s", ObjectToCStringNoGC(element));
+        if (i > 0) Print(", ");
+        Print("%s", ObjectToCStringNoGC(element));
         i++;
       }
-      if (i < arr.Length()) AppendToBuffer(", ...");
-      AppendToBuffer("]");
+      if (i < arr.Length()) Print(", ...");
+      Print("]");
       return;
     }
-    AppendToBuffer("  '%s'", ObjectToCStringNoGC(obj));
+    Print("  '%s'", ObjectToCStringNoGC(obj));
   } else {
     // 'addr' is not an object, but probably a code address.
     const char* name_of_stub = StubCode::NameOfStub(addr);
     if (name_of_stub != NULL) {
-      AppendToBuffer("  [stub: %s]", name_of_stub);
+      Print("  [stub: %s]", name_of_stub);
     }
   }
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::JumpShort(uint8_t* data) {
   ASSERT(0xEB == *data);
   uint8_t b = *(data + 1);
   uint8_t* dest = data + static_cast<int8_t>(b) + 2;
-  AppendToBuffer("jmp ");
-  AppendAddressToBuffer(dest);
+  Print("jmp ");
+  PrintAddress(dest);
   return 2;
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::JumpConditional(uint8_t* data) {
   ASSERT(0x0F == *data);
   uint8_t cond = *(data + 1) & 0x0F;
   uint8_t* dest = data + *reinterpret_cast<int32_t*>(data + 2) + 6;
   const char* mnem = conditional_code_suffix[cond];
-  AppendToBuffer("j%s ", mnem);
-  AppendAddressToBuffer(dest);
+  Print("j%s ", mnem);
+  PrintAddress(dest);
   return 6;  // includes 0x0F
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::JumpConditionalShort(uint8_t* data) {
   uint8_t cond = *data & 0x0F;
   uint8_t b = *(data + 1);
   uint8_t* dest = data + static_cast<int8_t>(b) + 2;
   const char* mnem = conditional_code_suffix[cond];
-  AppendToBuffer("j%s ", mnem);
-  AppendAddressToBuffer(dest);
+  Print("j%s ", mnem);
+  PrintAddress(dest);
   return 2;
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::SetCC(uint8_t* data) {
   ASSERT(0x0F == *data);
   uint8_t cond = *(data + 1) & 0x0F;
   const char* mnem = conditional_code_suffix[cond];
-  AppendToBuffer("set%s%c ", mnem, operand_size_code());
+  Print("set%s%c ", mnem, operand_size_code());
   PrintRightByteOperand(data + 2);
   return 3;  // includes 0x0F
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::FPUInstruction(uint8_t* data) {
   uint8_t escape_opcode = *data;
   ASSERT(0xD8 == (escape_opcode & 0xF8));
   uint8_t modrm_byte = *(data+1);
@@ skipping 38 matching lines @@
 
     case 0xDF: switch (regop) {
         case 5: mnem = "fild_d"; break;
         case 7: mnem = "fistp_d"; break;
         default: UnimplementedInstruction();
       }
       break;
 
     default: UnimplementedInstruction();
   }
-  AppendToBuffer("%s ", mnem);
+  Print("%s ", mnem);
   int count = PrintRightOperand(modrm_start);
   return count + 1;
 }
 
 int DisassemblerX64::RegisterFPUInstruction(int escape_opcode,
                                             uint8_t modrm_byte) {
   bool has_register = false;  // Is the FPU register encoded in modrm_byte?
   const char* mnem = "?";
 
   switch (escape_opcode) {
@@ skipping 95 matching lines @@
       } else if ((modrm_byte & 0xF8) == 0xE8) {
         mnem = "fucomip";
         has_register = true;
       }
       break;
 
     default: UnimplementedInstruction();
   }
 
   if (has_register) {
-    AppendToBuffer("%s st%d", mnem, modrm_byte & 0x7);
+    Print("%s st%d", mnem, modrm_byte & 0x7);
   } else {
-    AppendToBuffer("%s", mnem);
+    Print("%s", mnem);
   }
   return 2;
 }
 
 
 // TODO(srdjan): Should we add a branch hint argument?
 bool DisassemblerX64::DecodeInstructionType(uint8_t** data) {
   uint8_t current;
 
   // Scan for prefixes.
   while (true) {
     current = **data;
     if (current == OPERAND_SIZE_OVERRIDE_PREFIX) {  // Group 3 prefix.
       operand_size_ = current;
     } else if ((current & 0xF0) == 0x40) {  // REX prefix.
       setRex(current);
       // TODO(srdjan): Should we enable printing of REX.W?
-      // if (rex_w()) AppendToBuffer("REX.W ");
+      // if (rex_w()) Print("REX.W ");
     } else if ((current & 0xFE) == 0xF2) {  // Group 1 prefix (0xF2 or 0xF3).
       group_1_prefix_ = current;
     } else if (current == 0xF0) {
-      AppendToBuffer("lock ");
+      Print("lock ");
     } else {  // Not a prefix - an opcode.
       break;
     }
     (*data)++;
   }
 
   const InstructionDesc& idesc = instruction_table.Get(current);
   byte_size_operand_ = idesc.byte_size_operation;
 
   switch (idesc.type) {
     case ZERO_OPERANDS_INSTR:
       if (current >= 0xA4 && current <= 0xA7) {
         // String move or compare operations.
         if (group_1_prefix_ == REP_PREFIX) {
           // REP.
-          AppendToBuffer("rep ");
+          Print("rep ");
         }
         // TODO(srdjan): Should we enable printing of REX.W?
-        // if (rex_w()) AppendToBuffer("REX.W ");
-        AppendToBuffer("%s%c", idesc.mnem, operand_size_code());
+        // if (rex_w()) Print("REX.W ");
+        Print("%s%c", idesc.mnem, operand_size_code());
       } else {
-        AppendToBuffer("%s%c", idesc.mnem, operand_size_code());
+        Print("%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:
       (*data) += JumpConditionalShort(*data);
       break;
 
     case REGISTER_INSTR:
-      AppendToBuffer("%s%c %s",
-                     idesc.mnem,
-                     operand_size_code(),
-                     NameOfCPURegister(base_reg(current & 0x07)));
+      Print("%s%c %s",
+            idesc.mnem,
+            operand_size_code(),
+            NameOfCPURegister(base_reg(current & 0x07)));
       (*data)++;
       break;
     case PUSHPOP_INSTR:
-      AppendToBuffer("%s %s",
-                     idesc.mnem,
-                     NameOfCPURegister(base_reg(current & 0x07)));
+      Print("%s %s",
+            idesc.mnem,
+            NameOfCPURegister(base_reg(current & 0x07)));
       (*data)++;
       break;
     case MOVE_REG_INSTR: {
       uint8_t* addr = NULL;
       switch (operand_size()) {
         case WORD_SIZE:
           addr = reinterpret_cast<uint8_t*>(
               *reinterpret_cast<int16_t*>(*data + 1));
           (*data) += 3;
           break;
         case DOUBLEWORD_SIZE:
           addr = reinterpret_cast<uint8_t*>(
               *reinterpret_cast<int32_t*>(*data + 1));
           (*data) += 5;
           break;
         case QUADWORD_SIZE:
           addr = reinterpret_cast<uint8_t*>(
               *reinterpret_cast<int64_t*>(*data + 1));
           (*data) += 9;
           break;
         default:
           UNREACHABLE();
       }
-      AppendToBuffer("mov%c %s,",
-                     operand_size_code(),
-                     NameOfCPURegister(base_reg(current & 0x07)));
-      AppendAddressToBuffer(addr);
+      Print("mov%c %s,",
+            operand_size_code(),
+            NameOfCPURegister(base_reg(current & 0x07)));
+      PrintAddress(addr);
       break;
     }
 
     case CALL_JUMP_INSTR: {
       uint8_t* addr = *data + *reinterpret_cast<int32_t*>(*data + 1) + 5;
-      AppendToBuffer("%s ", idesc.mnem);
-      AppendAddressToBuffer(addr);
+      Print("%s ", idesc.mnem);
+      PrintAddress(addr);
       (*data) += 5;
       break;
     }
 
     case SHORT_IMMEDIATE_INSTR: {
       uint8_t* addr =
           reinterpret_cast<uint8_t*>(*reinterpret_cast<int32_t*>(*data + 1));
-      AppendToBuffer("%s rax, ", idesc.mnem);
-      AppendAddressToBuffer(addr);
+      Print("%s rax, ", idesc.mnem);
+      PrintAddress(addr);
       (*data) += 5;
       break;
     }
 
     case NO_INSTR:
       return false;
 
     default:
       UNIMPLEMENTED();  // This type is not implemented.
   }
   return true;
 }
 
 
 // Handle all two-byte opcodes, which start with 0x0F.
 // These instructions may be affected by an 0x66, 0xF2, or 0xF3 prefix.
 // We do not use any three-byte opcodes, which start with 0x0F38 or 0x0F3A.
 int DisassemblerX64::TwoByteOpcodeInstruction(uint8_t* data) {
   uint8_t opcode = *(data + 1);
   uint8_t* current = data + 2;
   // At return, "current" points to the start of the next instruction.
   const char* mnemonic = TwoByteMnemonic(opcode);
   if (operand_size_ == 0x66) {
     // 0x66 0x0F prefix.
     int mod, regop, rm;
     if (opcode == 0xC6) {
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("shufpd %s, ", NameOfXMMRegister(regop));
+      Print("shufpd %s, ", NameOfXMMRegister(regop));
       current += PrintRightXMMOperand(current);
-      AppendToBuffer(" [%x]", *current);
+      Print(" [%x]", *current);
       current++;
     } else if (opcode == 0x3A) {
       uint8_t third_byte = *current;
       current = data + 3;
       if (third_byte == 0x17) {
         get_modrm(*current, &mod, &regop, &rm);
-        AppendToBuffer("extractps ");  // reg/m32, xmm, imm8
+        Print("extractps ");  // reg/m32, xmm, imm8
         current += PrintRightOperand(current);
-        AppendToBuffer(", %s, %d", NameOfCPURegister(regop), (*current) & 3);
+        Print(", %s, %d", NameOfCPURegister(regop), (*current) & 3);
         current += 1;
       } else if (third_byte == 0x0b) {
         get_modrm(*current, &mod, &regop, &rm);
          // roundsd xmm, xmm/m64, imm8
-        AppendToBuffer("roundsd %s, ", NameOfCPURegister(regop));
+        Print("roundsd %s, ", NameOfCPURegister(regop));
         current += PrintRightOperand(current);
-        AppendToBuffer(", %d", (*current) & 3);
+        Print(", %d", (*current) & 3);
         current += 1;
       } else {
         UnimplementedInstruction();
       }
     } else {
       get_modrm(*current, &mod, &regop, &rm);
       if (opcode == 0x1f) {
         current++;
         if (rm == 4) {  // SIB byte present.
           current++;
         }
         if (mod == 1) {  // Byte displacement.
           current += 1;
         } else if (mod == 2) {  // 32-bit displacement.
           current += 4;
         }  // else no immediate displacement.
-        AppendToBuffer("nop");
+        Print("nop");
       } else if (opcode == 0x28) {
-        AppendToBuffer("movapd %s, ", NameOfXMMRegister(regop));
+        Print("movapd %s, ", NameOfXMMRegister(regop));
         current += PrintRightXMMOperand(current);
       } else if (opcode == 0x29) {
-        AppendToBuffer("movapd ");
+        Print("movapd ");
         current += PrintRightXMMOperand(current);
-        AppendToBuffer(", %s", NameOfXMMRegister(regop));
+        Print(", %s", NameOfXMMRegister(regop));
       } else if (opcode == 0x6E) {
-        AppendToBuffer("mov%c %s,",
-                       rex_w() ? 'q' : 'd',
-                       NameOfXMMRegister(regop));
+        Print("mov%c %s,",
+              rex_w() ? 'q' : 'd',
+              NameOfXMMRegister(regop));
         current += PrintRightOperand(current);
       } else if (opcode == 0x6F) {
-        AppendToBuffer("movdqa %s,",
-                       NameOfXMMRegister(regop));
+        Print("movdqa %s,",
+              NameOfXMMRegister(regop));
         current += PrintRightXMMOperand(current);
       } else if (opcode == 0x7E) {
-        AppendToBuffer("mov%c ",
-                       rex_w() ? 'q' : 'd');
+        Print("mov%c ",
+              rex_w() ? 'q' : 'd');
         current += PrintRightOperand(current);
-        AppendToBuffer(", %s", NameOfXMMRegister(regop));
+        Print(", %s", NameOfXMMRegister(regop));
       } else if (opcode == 0x7F) {
-        AppendToBuffer("movdqa ");
+        Print("movdqa ");
         current += PrintRightXMMOperand(current);
-        AppendToBuffer(", %s", NameOfXMMRegister(regop));
+        Print(", %s", NameOfXMMRegister(regop));
       } else if (opcode == 0xD6) {
-        AppendToBuffer("movq ");
+        Print("movq ");
         current += PrintRightXMMOperand(current);
-        AppendToBuffer(", %s", NameOfXMMRegister(regop));
+        Print(", %s", NameOfXMMRegister(regop));
       } else if (opcode == 0x50) {
-        AppendToBuffer("movmskpd %s,", NameOfCPURegister(regop));
+        Print("movmskpd %s,", NameOfCPURegister(regop));
         current += PrintRightXMMOperand(current);
       } else {
         const char* mnemonic = "?";
         if (opcode == 0x14) {
           mnemonic = "unpcklpd";
         } else if (opcode == 0x15) {
           mnemonic = "unpckhpd";
         } else if (opcode == 0x54) {
           mnemonic = "andpd";
         } else  if (opcode == 0x56) {
@@ skipping 20 matching lines @@
           mnemonic = "minpd";
         } else if (opcode == 0x5F) {
           mnemonic = "maxpd";
         } else if (opcode == 0x51) {
           mnemonic = "sqrtpd";
         } else if (opcode == 0x5A) {
           mnemonic = "cvtpd2ps";
         } else {
           UnimplementedInstruction();
         }
-        AppendToBuffer("%s %s,", mnemonic, NameOfXMMRegister(regop));
+        Print("%s %s,", mnemonic, NameOfXMMRegister(regop));
         current += PrintRightXMMOperand(current);
       }
     }
   } else if (group_1_prefix_ == 0xF2) {
     // Beginning of instructions with prefix 0xF2.
 
     if (opcode == 0x11 || opcode == 0x10) {
       // MOVSD: Move scalar double-precision fp to/from/between XMM registers.
-      AppendToBuffer("movsd ");
+      Print("movsd ");
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
       if (opcode == 0x11) {
         current += PrintRightXMMOperand(current);
-        AppendToBuffer(",%s", NameOfXMMRegister(regop));
+        Print(",%s", NameOfXMMRegister(regop));
       } else {
-        AppendToBuffer("%s,", NameOfXMMRegister(regop));
+        Print("%s,", NameOfXMMRegister(regop));
         current += PrintRightXMMOperand(current);
       }
     } else if (opcode == 0x2A) {
       // CVTSI2SD: integer to XMM double conversion.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("%sd %s,", mnemonic, NameOfXMMRegister(regop));
+      Print("%sd %s,", mnemonic, NameOfXMMRegister(regop));
       current += PrintRightOperand(current);
     } else if (opcode == 0x2C) {
       // CVTTSD2SI:
       // Convert with truncation scalar double-precision FP to integer.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("cvttsd2si%c %s,",
+      Print("cvttsd2si%c %s,",
           operand_size_code(), NameOfCPURegister(regop));
       current += PrintRightXMMOperand(current);
     } else if (opcode == 0x2D) {
       // CVTSD2SI: Convert scalar double-precision FP to integer.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("cvtsd2si%c %s,",
+      Print("cvtsd2si%c %s,",
           operand_size_code(), NameOfCPURegister(regop));
       current += PrintRightXMMOperand(current);
     } else if ((opcode & 0xF8) == 0x58 || opcode == 0x51) {
       // XMM arithmetic. Mnemonic was retrieved at the start of this function.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("%s %s,", mnemonic, NameOfXMMRegister(regop));
+      Print("%s %s,", mnemonic, NameOfXMMRegister(regop));
       current += PrintRightXMMOperand(current);
     } else {
       UnimplementedInstruction();
     }
   } else if (group_1_prefix_ == 0xF3) {
     // Instructions with prefix 0xF3.
     if (opcode == 0x11 || opcode == 0x10) {
       // MOVSS: Move scalar double-precision fp to/from/between XMM registers.
-      AppendToBuffer("movss ");
+      Print("movss ");
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
       if (opcode == 0x11) {
         current += PrintRightOperand(current);
-        AppendToBuffer(",%s", NameOfXMMRegister(regop));
+        Print(",%s", NameOfXMMRegister(regop));
       } else {
-        AppendToBuffer("%s,", NameOfXMMRegister(regop));
+        Print("%s,", NameOfXMMRegister(regop));
         current += PrintRightOperand(current);
       }
     } else if (opcode == 0x2A) {
       // CVTSI2SS: integer to XMM single conversion.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("%ss %s,", mnemonic, NameOfXMMRegister(regop));
+      Print("%ss %s,", mnemonic, NameOfXMMRegister(regop));
       current += PrintRightOperand(current);
     } else if (opcode == 0x2C) {
       // CVTTSS2SI:
       // Convert with truncation scalar single-precision FP to dword integer.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("cvttss2si%c %s,",
-          operand_size_code(), NameOfCPURegister(regop));
+      Print("cvttss2si%c %s,",
+            operand_size_code(), NameOfCPURegister(regop));
       current += PrintRightXMMOperand(current);
     } else if (opcode == 0x5A) {
       // CVTSS2SD:
       // Convert scalar single-precision FP to scalar double-precision FP.
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("cvtss2sd %s,", NameOfXMMRegister(regop));
+      Print("cvtss2sd %s,", NameOfXMMRegister(regop));
       current += PrintRightXMMOperand(current);
     } else if (opcode == 0x7E) {
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("movq %s, ", NameOfXMMRegister(regop));
+      Print("movq %s, ", NameOfXMMRegister(regop));
       current += PrintRightXMMOperand(current);
     } else if (opcode == 0x58) {
       int mod, regop, rm;
       get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("addss %s,", NameOfXMMRegister(regop));
+      Print("addss %s,", NameOfXMMRegister(regop));
       current += PrintRightXMMOperand(current);
     } else {
       UnimplementedInstruction();
     }
   } else if (opcode == 0x1F) {
     // NOP
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
     current++;
     if (rm == 4) {  // SIB byte present.
       current++;
     }
     if (mod == 1) {  // Byte displacement.
       current += 1;
     } else if (mod == 2) {  // 32-bit displacement.
       current += 4;
     }  // else no immediate displacement.
-    AppendToBuffer("nop");
+    Print("nop");
 
   } else if (opcode == 0x28) {
     // movaps xmm, xmm/m128
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movaps %s, ", NameOfXMMRegister(regop));
+    Print("movaps %s, ", NameOfXMMRegister(regop));
     current += PrintRightXMMOperand(current);
   } else if (opcode == 0x29) {
     // movaps xmm/m128, xmm
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movaps ");
+    Print("movaps ");
     current += PrintRightXMMOperand(current);
-    AppendToBuffer(", %s", NameOfXMMRegister(regop));
+    Print(", %s", NameOfXMMRegister(regop));
   } else if (opcode == 0x11) {
     // movups xmm/m128, xmm
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movups ");
+    Print("movups ");
     current += PrintRightXMMOperand(current);
-    AppendToBuffer(", %s", NameOfXMMRegister(regop));
+    Print(", %s", NameOfXMMRegister(regop));
   } else if (opcode == 0x10) {
     // movups xmm, xmm/m128
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movups %s, ", NameOfXMMRegister(regop));
+    Print("movups %s, ", NameOfXMMRegister(regop));
     current += PrintRightXMMOperand(current);
   } else if (opcode == 0x50) {
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movmskps %s,", NameOfCPURegister(regop));
+    Print("movmskps %s,", NameOfCPURegister(regop));
     current += PrintRightXMMOperand(current);
   } else if (opcode == 0xA2 || opcode == 0x31) {
     // RDTSC or CPUID
-    AppendToBuffer("%s", mnemonic);
+    Print("%s", mnemonic);
 
   } else if ((opcode & 0xF0) == 0x40) {
     // CMOVcc: conditional move.
     int condition = opcode & 0x0F;
     const InstructionDesc& idesc = cmov_instructions[condition];
     byte_size_operand_ = idesc.byte_size_operation;
     current += PrintOperands(idesc.mnem, idesc.op_order_, current);
 
   } else if (opcode == 0x12 || opcode == 0x14 || opcode == 0x15 ||
              opcode == 0x16 || opcode == 0x51 || opcode == 0x52 ||
@@ skipping 17 matching lines @@
       case 0x59: mnemonic = "mulps"; break;
       case 0x5A: mnemonic = "cvtsd2ss"; break;
       case 0x5C: mnemonic = "subps"; break;
       case 0x5D: mnemonic = "minps"; break;
       case 0x5E: mnemonic = "divps"; break;
       case 0x5F: mnemonic = "maxps"; break;
       default: UNREACHABLE();
     }
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("%s %s, ", mnemonic, NameOfXMMRegister(regop));
+    Print("%s %s, ", mnemonic, NameOfXMMRegister(regop));
     current += PrintRightXMMOperand(current);
   } else if (opcode == 0xC2 || opcode == 0xC6) {
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
     if (opcode == 0xC2) {
-      AppendToBuffer("cmpps %s, ", NameOfXMMRegister(regop));
+      Print("cmpps %s, ", NameOfXMMRegister(regop));
     } else {
       ASSERT(opcode == 0xC6);
-      AppendToBuffer("shufps %s, ", NameOfXMMRegister(regop));
+      Print("shufps %s, ", NameOfXMMRegister(regop));
     }
     current += PrintRightXMMOperand(current);
-    AppendToBuffer(" [%x]", *current);
+    Print(" [%x]", *current);
     current++;
   } else if ((opcode & 0xF0) == 0x80) {
     // Jcc: Conditional jump (branch).
     current = data + JumpConditional(data);
 
   } else if (opcode == 0xBE || opcode == 0xBF || opcode == 0xB6 ||
              opcode == 0xB7 || opcode == 0xAF || opcode == 0xB0 ||
              opcode == 0xB1) {
     // Size-extending moves, IMUL, cmpxchg.
     current += PrintOperands(mnemonic, REG_OPER_OP_ORDER, current);
 
   } else if ((opcode & 0xF0) == 0x90) {
     // SETcc: Set byte on condition. Needs pointer to beginning of instruction.
     current = data + SetCC(data);
 
   } else if (((opcode & 0xFE) == 0xA4) || ((opcode & 0xFE) == 0xAC) ||
              (opcode == 0xAB) || (opcode == 0xA3) || (opcode == 0xBD)) {
     // SHLD, SHRD (double-prec. shift), BTS (bit test and set), BT (bit test).
-    AppendToBuffer("%s%c ", mnemonic, operand_size_code());
+    Print("%s%c ", mnemonic, operand_size_code());
     int mod, regop, rm;
     get_modrm(*current, &mod, &regop, &rm);
     current += PrintRightOperand(current);
-    AppendToBuffer(",%s", NameOfCPURegister(regop));
+    Print(",%s", NameOfCPURegister(regop));
     if ((opcode == 0xAB) || (opcode == 0xA3) || (opcode == 0xBD)) {
       // Done.
     } else if ((opcode == 0xA5) || (opcode == 0xAD)) {
-      AppendToBuffer(",cl");
+      Print(",cl");
     } else {
-      AppendToBuffer(",");
+      Print(",");
       current += PrintImmediate(current, BYTE_SIZE);
     }
   } else {
     UnimplementedInstruction();
   }
   return static_cast<int>(current - data);
 }
 
 
 // Mnemonics for two-byte opcode instructions starting with 0x0F.
@@ skipping 55 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 %#x", *reinterpret_cast<uint16_t*>(data + 1));
+        Print("ret ");
+        PrintImmediateValue(*reinterpret_cast<uint16_t*>(data + 1));
         data += 3;
         break;
 
       case 0xC8:
-        AppendToBuffer("enter %d, %d",
-                       *reinterpret_cast<uint16_t*>(data + 1),
-                       data[3]);
+        Print("enter %d, %d",
+              *reinterpret_cast<uint16_t*>(data + 1),
+              data[3]);
         data += 4;
         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,%#x",
-                       operand_size_code(),
-                       NameOfCPURegister(regop),
-                       NameOfCPURegister(rm), imm);
+        Print("imul%c %s,%s,",
+              operand_size_code(),
+              NameOfCPURegister(regop),
+              NameOfCPURegister(rm));
+        PrintImmediateValue(imm);
         data += 2 + (*data == 0x6B ? 1 : 4);
         break;
       }
 
       case 0x81:  // fall through
       case 0x83:  // 0x81 with sign extension bit set
         data += PrintImmediateOp(data);
         break;
 
       case 0x0F:
         data += TwoByteOpcodeInstruction(data);
         break;
 
       case 0x8F: {
         data++;
         int mod, regop, rm;
         get_modrm(*data, &mod, &regop, &rm);
         if (regop == 0) {
-          AppendToBuffer("pop ");
+          Print("pop ");
           data += PrintRightOperand(data);
         }
       }
         break;
 
       case 0xFF: {
         data++;
         int mod, regop, rm;
         get_modrm(*data, &mod, &regop, &rm);
         const char* mnem = NULL;
@@ skipping 10 matching lines @@
           case 4:
             mnem = "jmp";
             break;
           case 6:
             mnem = "push";
             break;
           default:
             mnem = "???";
         }
         if (regop <= 1) {
-          AppendToBuffer("%s%c ", mnem, operand_size_code());
+          Print("%s%c ", mnem, operand_size_code());
         } else {
-          AppendToBuffer("%s ", mnem);
+          Print("%s ", mnem);
         }
         data += PrintRightOperand(data);
       }
         break;
 
       case 0xC7:  // imm32, fall through
       case 0xC6:  // imm8
       {
         bool is_byte = *data == 0xC6;
         data++;
         if (is_byte) {
-          AppendToBuffer("movb ");
+          Print("movb ");
           data += PrintRightByteOperand(data);
           int32_t imm = *data;
-          AppendToBuffer(",%#x", imm);
+          Print(",");
+          PrintImmediateValue(imm);
           data++;
         } else {
-          AppendToBuffer("mov%c ", operand_size_code());
+          Print("mov%c ", operand_size_code());
           data += PrintRightOperand(data);
           int32_t imm = *reinterpret_cast<int32_t*>(data);
-          AppendToBuffer(",%#x", imm);
+          Print(",");
+          PrintImmediateValue(imm);
           data += 4;
         }
       }
         break;
 
       case 0x80: {
         data++;
-        AppendToBuffer("cmpb ");
+        Print("cmpb ");
         data += PrintRightByteOperand(data);
         int32_t imm = *data;
-        AppendToBuffer(",%#x", imm);
+        Print(",");
+        PrintImmediateValue(imm);
         data++;
       }
         break;
 
       case 0x88:  // 8bit, fall through
       case 0x89:  // 32bit
       {
         bool is_byte = *data == 0x88;
         int mod, regop, rm;
         data++;
         get_modrm(*data, &mod, &regop, &rm);
         if (is_byte) {
-          AppendToBuffer("movb ");
+          Print("movb ");
           data += PrintRightByteOperand(data);
-          AppendToBuffer(",%s", NameOfByteCPURegister(regop));
+          Print(",%s", NameOfByteCPURegister(regop));
         } else {
-          AppendToBuffer("mov%c ", operand_size_code());
+          Print("mov%c ", operand_size_code());
           data += PrintRightOperand(data);
-          AppendToBuffer(",%s", NameOfCPURegister(regop));
+          Print(",%s", NameOfCPURegister(regop));
         }
       }
         break;
 
       case 0x90:
       case 0x91:
       case 0x92:
       case 0x93:
       case 0x94:
       case 0x95:
       case 0x96:
       case 0x97: {
         int reg = (*data & 0x7) | (rex_b() ? 8 : 0);
         if (reg == 0) {
-          AppendToBuffer("nop");  // Common name for xchg rax,rax.
+          Print("nop");  // Common name for xchg rax,rax.
         } else {
-          AppendToBuffer("xchg%c rax, %s",
-                         operand_size_code(),
-                         NameOfCPURegister(reg));
+          Print("xchg%c rax, %s", operand_size_code(), NameOfCPURegister(reg));
         }
         data++;
       }
         break;
       case 0xB0:
       case 0xB1:
       case 0xB2:
       case 0xB3:
       case 0xB4:
       case 0xB5:
       case 0xB6:
       case 0xB7:
       case 0xB8:
       case 0xB9:
       case 0xBA:
       case 0xBB:
       case 0xBC:
       case 0xBD:
       case 0xBE:
       case 0xBF: {
         // mov reg8,imm8 or mov reg32,imm32
         uint8_t opcode = *data;
         data++;
         uint8_t is_32bit = (opcode >= 0xB8);
         int reg = (opcode & 0x7) | (rex_b() ? 8 : 0);
         if (is_32bit) {
-          AppendToBuffer("mov%c %s, ",
-                         operand_size_code(),
-                         NameOfCPURegister(reg));
+          Print("mov%c %s,", operand_size_code(), NameOfCPURegister(reg));
           data += PrintImmediate(data, DOUBLEWORD_SIZE);
         } else {
-          AppendToBuffer("movb %s, ",
-                         NameOfByteCPURegister(reg));
+          Print("movb %s,", NameOfByteCPURegister(reg));
           data += PrintImmediate(data, BYTE_SIZE);
         }
         break;
       }
       case 0xFE: {
         data++;
         int mod, regop, rm;
         get_modrm(*data, &mod, &regop, &rm);
         if (regop == 1) {
-          AppendToBuffer("decb ");
+          Print("decb ");
           data += PrintRightByteOperand(data);
         } else {
           UnimplementedInstruction();
         }
         break;
       }
       case 0x68:
-        AppendToBuffer("push %#x", *reinterpret_cast<int32_t*>(data + 1));
+        Print("push ");
+        PrintImmediateValue(*reinterpret_cast<int32_t*>(data + 1));
         data += 5;
         break;
 
       case 0x6A:
-        AppendToBuffer("push %#x", *reinterpret_cast<int8_t*>(data + 1));
+        Print("push ");
+        PrintImmediateValue(*reinterpret_cast<int8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA1:  // Fall through.
       case 0xA3:
         switch (operand_size()) {
           case DOUBLEWORD_SIZE: {
-            AppendAddressToBuffer(
+            PrintAddress(
                 reinterpret_cast<uint8_t*>(
                     *reinterpret_cast<int32_t*>(data + 1)));
             if (*data == 0xA1) {  // Opcode 0xA1
-              AppendToBuffer("movzxlq rax,(");
-              AppendAddressToBuffer(
+              Print("movzxlq rax,(");
+              PrintAddress(
                   reinterpret_cast<uint8_t*>(
                       *reinterpret_cast<int32_t*>(data + 1)));
-              AppendToBuffer(")");
+              Print(")");
             } else {  // Opcode 0xA3
-              AppendToBuffer("movzxlq (");
-              AppendAddressToBuffer(
+              Print("movzxlq (");
+              PrintAddress(
                   reinterpret_cast<uint8_t*>(
                       *reinterpret_cast<int32_t*>(data + 1)));
-              AppendToBuffer("),rax");
+              Print("),rax");
            }
             data += 5;
             break;
           }
           case QUADWORD_SIZE: {
             // New x64 instruction mov rax,(imm_64).
             if (*data == 0xA1) {  // Opcode 0xA1
-              AppendToBuffer("movq rax,(");
-              AppendAddressToBuffer(*reinterpret_cast<uint8_t**>(data + 1));
-              AppendToBuffer(")");
+              Print("movq rax,(");
+              PrintAddress(*reinterpret_cast<uint8_t**>(data + 1));
+              Print(")");
             } else {  // Opcode 0xA3
-              AppendToBuffer("movq (");
-              AppendAddressToBuffer(*reinterpret_cast<uint8_t**>(data + 1));
-              AppendToBuffer("),rax");
+              Print("movq (");
+              PrintAddress(*reinterpret_cast<uint8_t**>(data + 1));
+              Print("),rax");
             }
             data += 9;
             break;
           }
           default:
             UnimplementedInstruction();
             data += 2;
         }
         break;
 
       case 0xA8:
-        AppendToBuffer("test al,%#x", *reinterpret_cast<uint8_t*>(data + 1));
+        Print("test al,");
+        PrintImmediateValue(*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,%#" Px64 "",
-                       operand_size_code(),
-                       value);
+        Print("test%c rax,", operand_size_code());
+        PrintImmediateValue(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 55 matching lines @@
   if (out_instr_len) {
     *out_instr_len = instruction_length;
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64