VM: Re-format to use at most one newline between functions

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 20 matching lines @@
 
 //------------------------------------------------------------------
 // Tables
 //------------------------------------------------------------------
 struct ByteMnemonic {
   int b;  // -1 terminates, otherwise must be in range (0..255)
   OperandType op_order_;
   const char* mnem;
 };
 
-
 static const ByteMnemonic two_operands_instr[] = {
     {0x00, BYTE_OPER_REG_OP_ORDER, "add"},
     {0x01, OPER_REG_OP_ORDER, "add"},
     {0x02, BYTE_REG_OPER_OP_ORDER, "add"},
     {0x03, REG_OPER_OP_ORDER, "add"},
     {0x08, BYTE_OPER_REG_OP_ORDER, "or"},
     {0x09, OPER_REG_OP_ORDER, "or"},
     {0x0A, BYTE_REG_OPER_OP_ORDER, "or"},
     {0x0B, REG_OPER_OP_ORDER, "or"},
     {0x10, BYTE_OPER_REG_OP_ORDER, "adc"},
@@ skipping 25 matching lines @@
     {0x85, REG_OPER_OP_ORDER, "test"},
     {0x86, BYTE_REG_OPER_OP_ORDER, "xchg"},
     {0x87, REG_OPER_OP_ORDER, "xchg"},
     {0x88, BYTE_OPER_REG_OP_ORDER, "mov"},
     {0x89, OPER_REG_OP_ORDER, "mov"},
     {0x8A, BYTE_REG_OPER_OP_ORDER, "mov"},
     {0x8B, REG_OPER_OP_ORDER, "mov"},
     {0x8D, REG_OPER_OP_ORDER, "lea"},
     {-1, UNSET_OP_ORDER, ""}};
 
-
 static const ByteMnemonic zero_operands_instr[] = {
     {0xC3, UNSET_OP_ORDER, "ret"},   {0xC9, UNSET_OP_ORDER, "leave"},
     {0xF4, UNSET_OP_ORDER, "hlt"},   {0xFC, UNSET_OP_ORDER, "cld"},
     {0xCC, UNSET_OP_ORDER, "int3"},  {0x60, UNSET_OP_ORDER, "pushad"},
     {0x61, UNSET_OP_ORDER, "popad"}, {0x9C, UNSET_OP_ORDER, "pushfd"},
     {0x9D, UNSET_OP_ORDER, "popfd"}, {0x9E, UNSET_OP_ORDER, "sahf"},
     {0x99, UNSET_OP_ORDER, "cdq"},   {0x9B, UNSET_OP_ORDER, "fwait"},
     {0xA4, UNSET_OP_ORDER, "movs"},  {0xA5, UNSET_OP_ORDER, "movs"},
     {0xA6, UNSET_OP_ORDER, "cmps"},  {0xA7, UNSET_OP_ORDER, "cmps"},
     {-1, UNSET_OP_ORDER, ""}};
 
-
 static const ByteMnemonic call_jump_instr[] = {{0xE8, UNSET_OP_ORDER, "call"},
                                                {0xE9, UNSET_OP_ORDER, "jmp"},
                                                {-1, UNSET_OP_ORDER, ""}};
 
-
 static const ByteMnemonic short_immediate_instr[] = {
     {0x05, UNSET_OP_ORDER, "add"}, {0x0D, UNSET_OP_ORDER, "or"},
     {0x15, UNSET_OP_ORDER, "adc"}, {0x1D, UNSET_OP_ORDER, "sbb"},
     {0x25, UNSET_OP_ORDER, "and"}, {0x2D, UNSET_OP_ORDER, "sub"},
     {0x35, UNSET_OP_ORDER, "xor"}, {0x3D, UNSET_OP_ORDER, "cmp"},
     {-1, UNSET_OP_ORDER, ""}};
 
-
 static const char* const conditional_code_suffix[] = {
     "o", "no", "c",  "nc", "z", "nz", "na", "a",
     "s", "ns", "pe", "po", "l", "ge", "le", "g"};
 
-
 enum InstructionType {
   NO_INSTR,
   ZERO_OPERANDS_INSTR,
   TWO_OPERANDS_INSTR,
   JUMP_CONDITIONAL_SHORT_INSTR,
   REGISTER_INSTR,
   PUSHPOP_INSTR,  // Has implicit 64-bit operand size.
   MOVE_REG_INSTR,
   CALL_JUMP_INSTR,
   SHORT_IMMEDIATE_INSTR
 };
 
-
 enum Prefixes {
   ESCAPE_PREFIX = 0x0F,
   OPERAND_SIZE_OVERRIDE_PREFIX = 0x66,
   ADDRESS_SIZE_OVERRIDE_PREFIX = 0x67,
   REPNE_PREFIX = 0xF2,
   REP_PREFIX = 0xF3,
   REPEQ_PREFIX = REP_PREFIX
 };
 
-
 struct InstructionDesc {
   const char* mnem;
   InstructionType type;
   OperandType op_order_;
   bool byte_size_operation;  // Fixed 8-bit operation.
 };
 
-
 class InstructionTable : public ValueObject {
  public:
   InstructionTable();
   const InstructionDesc& Get(uint8_t x) const { return instructions_[x]; }
 
  private:
   InstructionDesc instructions_[256];
   void Clear();
   void Init();
   void CopyTable(const ByteMnemonic bm[], InstructionType type);
   void SetTableRange(InstructionType type,
                      uint8_t start,
                      uint8_t end,
                      bool byte_size,
                      const char* mnem);
   void AddJumpConditionalShort();
 
   DISALLOW_COPY_AND_ASSIGN(InstructionTable);
 };
 
-
 InstructionTable::InstructionTable() {
   Clear();
   Init();
 }
 
-
 void InstructionTable::Clear() {
   for (int i = 0; i < 256; i++) {
     instructions_[i].mnem = "(bad)";
     instructions_[i].type = NO_INSTR;
     instructions_[i].op_order_ = UNSET_OP_ORDER;
     instructions_[i].byte_size_operation = false;
   }
 }
 
-
 void InstructionTable::Init() {
   CopyTable(two_operands_instr, TWO_OPERANDS_INSTR);
   CopyTable(zero_operands_instr, ZERO_OPERANDS_INSTR);
   CopyTable(call_jump_instr, CALL_JUMP_INSTR);
   CopyTable(short_immediate_instr, SHORT_IMMEDIATE_INSTR);
   AddJumpConditionalShort();
   SetTableRange(PUSHPOP_INSTR, 0x50, 0x57, false, "push");
   SetTableRange(PUSHPOP_INSTR, 0x58, 0x5F, false, "pop");
   SetTableRange(MOVE_REG_INSTR, 0xB8, 0xBF, false, "mov");
 }
 
-
 void InstructionTable::CopyTable(const ByteMnemonic bm[],
                                  InstructionType type) {
   for (int i = 0; bm[i].b >= 0; i++) {
     InstructionDesc* id = &instructions_[bm[i].b];
     id->mnem = bm[i].mnem;
     OperandType op_order = bm[i].op_order_;
     id->op_order_ =
         static_cast<OperandType>(op_order & ~BYTE_SIZE_OPERAND_FLAG);
     ASSERT(NO_INSTR == id->type);  // Information not already entered
     id->type = type;
     id->byte_size_operation = ((op_order & BYTE_SIZE_OPERAND_FLAG) != 0);
   }
 }
 
-
 void InstructionTable::SetTableRange(InstructionType type,
                                      uint8_t start,
                                      uint8_t end,
                                      bool byte_size,
                                      const char* mnem) {
   for (uint8_t b = start; b <= end; b++) {
     InstructionDesc* id = &instructions_[b];
     ASSERT(NO_INSTR == id->type);  // Information not already entered
     id->mnem = mnem;
     id->type = type;
     id->byte_size_operation = byte_size;
   }
 }
 
-
 void InstructionTable::AddJumpConditionalShort() {
   for (uint8_t b = 0x70; b <= 0x7F; b++) {
     InstructionDesc* id = &instructions_[b];
     ASSERT(NO_INSTR == id->type);  // Information not already entered
     id->mnem = NULL;               // Computed depending on condition code.
     id->type = JUMP_CONDITIONAL_SHORT_INSTR;
   }
 }
 
-
 static InstructionTable instruction_table;
 
-
 static InstructionDesc cmov_instructions[16] = {
     {"cmovo", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovno", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovc", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovnc", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovz", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovnz", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovna", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmova", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovs", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovns", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovpe", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovpo", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovl", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovge", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovle", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
     {"cmovg", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false}};
 
-
 //-------------------------------------------------
 // DisassemblerX64 implementation.
 
-
 static const int kMaxXmmRegisters = 16;
 static const char* xmm_regs[kMaxXmmRegisters] = {
     "xmm0", "xmm1", "xmm2",  "xmm3",  "xmm4",  "xmm5",  "xmm6",  "xmm7",
     "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"};
 
 class DisassemblerX64 : public ValueObject {
  public:
   DisassemblerX64(char* buffer, intptr_t buffer_size)
       : buffer_(buffer),
         buffer_size_(buffer_size),
@@ skipping 111 matching lines @@
   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::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) {
@@ skipping 60 matching lines @@
     case 3:
       Print("%s", (this->*register_name)(rm));
       return 1;
     default:
       UnimplementedInstruction();
       return 1;
   }
   UNREACHABLE();
 }
 
-
 int DisassemblerX64::PrintImmediate(uint8_t* data,
                                     OperandSize size,
                                     bool sign_extend) {
   int64_t value;
   int count;
   switch (size) {
     case BYTE_SIZE:
       if (sign_extend) {
         value = *reinterpret_cast<int8_t*>(data);
       } else {
@@ skipping 41 matching lines @@
 
 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) {
     case 0:
@@ skipping 25 matching lines @@
   }
   Print("%s%c ", mnem, operand_size_code());
   int count = PrintRightOperand(data + 1);
   Print(",");
   OperandSize immediate_size = byte_size_immediate ? BYTE_SIZE : operand_size();
   count +=
       PrintImmediate(data + 1 + count, immediate_size, byte_size_immediate);
   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);
   int mod, regop, rm;
   get_modrm(modrm, &mod, &regop, &rm);
   if (mod == 3 && regop != 0) {
     const char* mnem = NULL;
     switch (regop) {
       case 2:
@@ skipping 21 matching lines @@
     int count = PrintRightOperand(data + 1);  // Use name of 64-bit register.
     Print(",");
     count += PrintImmediate(data + 1 + count, operand_size());
     return 1 + count;
   } else {
     UnimplementedInstruction();
     return 2;
   }
 }
 
-
 int DisassemblerX64::ShiftInstruction(uint8_t* data) {
   uint8_t op = *data & (~1);
   if (op != 0xD0 && op != 0xD2 && op != 0xC0) {
     UnimplementedInstruction();
     return 1;
   }
   uint8_t modrm = *(data + 1);
   int mod, regop, rm;
   get_modrm(modrm, &mod, &regop, &rm);
   regop &= 0x7;  // The REX.R bit does not affect the operation.
@@ skipping 40 matching lines @@
   Print("%s%c %s,", mnem, operand_size_code(),
         byte_size_operand_ ? NameOfByteCPURegister(rm) : NameOfCPURegister(rm));
   if (op == 0xD2) {
     Print("cl");
   } else {
     Print("%d", imm8);
   }
   return num_bytes;
 }
 
-
 int DisassemblerX64::PrintRightOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp, &DisassemblerX64::NameOfCPURegister);
 }
 
-
 int DisassemblerX64::PrintRightByteOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp,
                                  &DisassemblerX64::NameOfByteCPURegister);
 }
 
-
 int DisassemblerX64::PrintRightXMMOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp, &DisassemblerX64::NameOfXMMRegister);
 }
 
-
 // Returns number of bytes used including the current *data.
 // Writes instruction's mnemonic, left and right operands to 'tmp_buffer_'.
 int DisassemblerX64::PrintOperands(const char* mnem,
                                    OperandType op_order,
                                    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)
@@ skipping 12 matching lines @@
       Print(",%s", register_name);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   return advance;
 }
 
-
 void DisassemblerX64::PrintAddress(uint8_t* addr_byte_ptr) {
   uword addr = reinterpret_cast<uword>(addr_byte_ptr);
   Print("%#" Px "", addr);
 }
 
-
 // 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;
   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];
   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];
   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];
   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);
 
   if (modrm_byte >= 0xC0) {
     return RegisterFPUInstruction(escape_opcode, modrm_byte);
   } else {
     return MemoryFPUInstruction(escape_opcode, modrm_byte, data + 1);
   }
 }
 
-
 int DisassemblerX64::MemoryFPUInstruction(int escape_opcode,
                                           int modrm_byte,
                                           uint8_t* modrm_start) {
   const char* mnem = "?";
   int regop = (modrm_byte >> 3) & 0x7;  // reg/op field of modrm byte.
   switch (escape_opcode) {
     case 0xD9:
       switch (regop) {
         case 0:
           mnem = "fld_s";
@@ skipping 232 matching lines @@
   }
 
   if (has_register) {
     Print("%s st%d", mnem, modrm_byte & 0x7);
   } else {
     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.
@@ skipping 94 matching lines @@
 
     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.
@@ skipping 362 matching lines @@
     } else {
       Print(",");
       current += PrintImmediate(current, BYTE_SIZE);
     }
   } else {
     UnimplementedInstruction();
   }
   return static_cast<int>(current - data);
 }
 
-
 // Mnemonics for two-byte opcode instructions starting with 0x0F.
 // The argument is the second byte of the two-byte opcode.
 // Returns NULL if the instruction is not handled here.
 const char* DisassemblerX64::TwoByteMnemonic(uint8_t opcode) {
   switch (opcode) {
     case 0x1F:
       return "nop";
     case 0x2A:  // F2/F3 prefix.
       return "cvtsi2s";
     case 0x31:
@@ skipping 37 matching lines @@
       return "movsxw";
     case 0x12:
       return "movhlps";
     case 0x16:
       return "movlhps";
     default:
       return NULL;
   }
 }
 
-
 int DisassemblerX64::InstructionDecode(uword pc) {
   uint8_t* data = reinterpret_cast<uint8_t*>(pc);
 
   const bool processed = DecodeInstructionType(&data);
 
   if (!processed) {
     switch (*data) {
       case 0xC2:
         Print("ret ");
         PrintImmediateValue(*reinterpret_cast<uint16_t*>(data + 1));
@@ skipping 296 matching lines @@
   }  // !processed
 
   ASSERT(buffer_[buffer_pos_] == '\0');
 
   int instr_len = data - reinterpret_cast<uint8_t*>(pc);
   ASSERT(instr_len > 0);  // Ensure progress.
 
   return instr_len;
 }
 
-
 void Disassembler::DecodeInstruction(char* hex_buffer,
                                      intptr_t hex_size,
                                      char* human_buffer,
                                      intptr_t human_size,
                                      int* out_instr_len,
                                      const Code& code,
                                      Object** object,
                                      uword pc) {
   ASSERT(hex_size > 0);
   ASSERT(human_size > 0);
@@ skipping 19 matching lines @@
       *object = NULL;
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64