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

runtime/vm/disassembler_ia32.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_IA32)
 #include "platform/utils.h"
 #include "vm/allocation.h"
 #include "vm/heap.h"
 #include "vm/os.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
 // Tables used for decoding of x86 instructions.
 enum OperandOrder { UNSET_OP_ORDER = 0, REG_OPER_OP_ORDER, OPER_REG_OP_ORDER };
 
-
 struct ByteMnemonic {
   int b;  // -1 terminates, otherwise must be in range (0..255)
   const char* mnem;
   OperandOrder op_order_;
 };
 
-
 static ByteMnemonic two_operands_instr[] = {
     {0x01, "add", OPER_REG_OP_ORDER},   {0x03, "add", REG_OPER_OP_ORDER},
     {0x09, "or", OPER_REG_OP_ORDER},    {0x0B, "or", REG_OPER_OP_ORDER},
     {0x11, "adc", OPER_REG_OP_ORDER},   {0x13, "adc", REG_OPER_OP_ORDER},
     {0x19, "sbb", OPER_REG_OP_ORDER},   {0x1B, "sbb", REG_OPER_OP_ORDER},
     {0x21, "and", OPER_REG_OP_ORDER},   {0x23, "and", REG_OPER_OP_ORDER},
     {0x29, "sub", OPER_REG_OP_ORDER},   {0x2B, "sub", REG_OPER_OP_ORDER},
     {0x31, "xor", OPER_REG_OP_ORDER},   {0x33, "xor", REG_OPER_OP_ORDER},
     {0x39, "cmp", OPER_REG_OP_ORDER},   {0x3B, "cmp", REG_OPER_OP_ORDER},
     {0x85, "test", REG_OPER_OP_ORDER},  {0x87, "xchg", REG_OPER_OP_ORDER},
     {0x8A, "mov_b", REG_OPER_OP_ORDER}, {0x8B, "mov", REG_OPER_OP_ORDER},
     {0x8D, "lea", REG_OPER_OP_ORDER},   {-1, "", UNSET_OP_ORDER}};
 
-
 static ByteMnemonic zero_operands_instr[] = {
     {0xC3, "ret", UNSET_OP_ORDER},   {0xC9, "leave", UNSET_OP_ORDER},
     {0x90, "nop", UNSET_OP_ORDER},   {0xF4, "hlt", UNSET_OP_ORDER},
     {0xCC, "int3", UNSET_OP_ORDER},  {0x60, "pushad", UNSET_OP_ORDER},
     {0x61, "popad", UNSET_OP_ORDER}, {0x9C, "pushfd", UNSET_OP_ORDER},
     {0x9D, "popfd", UNSET_OP_ORDER}, {0x9E, "sahf", UNSET_OP_ORDER},
     {0x99, "cdq", UNSET_OP_ORDER},   {0x9B, "fwait", UNSET_OP_ORDER},
     {-1, "", UNSET_OP_ORDER}};
 
-
 static ByteMnemonic call_jump_instr[] = {{0xE8, "call", UNSET_OP_ORDER},
                                          {0xE9, "jmp", UNSET_OP_ORDER},
                                          {-1, "", UNSET_OP_ORDER}};
 
-
 static ByteMnemonic short_immediate_instr[] = {
     {0x05, "add", UNSET_OP_ORDER}, {0x0D, "or", UNSET_OP_ORDER},
     {0x15, "adc", UNSET_OP_ORDER}, {0x25, "and", UNSET_OP_ORDER},
     {0x2D, "sub", UNSET_OP_ORDER}, {0x35, "xor", UNSET_OP_ORDER},
     {0x3D, "cmp", UNSET_OP_ORDER}, {-1, "", UNSET_OP_ORDER}};
 
-
 static const char* jump_conditional_mnem[] = {
     /*0*/ "jo",  "jno", "jc",  "jnc",
     /*4*/ "jz",  "jnz", "jna", "ja",
     /*8*/ "js",  "jns", "jpe", "jpo",
     /*12*/ "jl", "jnl", "jng", "jg"};
 
-
 static const char* set_conditional_mnem[] = {
     /*0*/ "seto",  "setno", "setc",  "setnc",
     /*4*/ "setz",  "setnz", "setna", "seta",
     /*8*/ "sets",  "setns", "setpe", "setpo",
     /*12*/ "setl", "setnl", "setng", "setg"};
 
-
 static const char* conditional_move_mnem[] = {
     /*0*/ "cmovo",  "cmovno", "cmovc",  "cmovnc",
     /*4*/ "cmovz",  "cmovnz", "cmovna", "cmova",
     /*8*/ "cmovs",  "cmovns", "cmovpe", "cmovpo",
     /*12*/ "cmovl", "cmovnl", "cmovng", "cmovg"};
 
-
 enum InstructionType {
   NO_INSTR,
   ZERO_OPERANDS_INSTR,
   TWO_OPERANDS_INSTR,
   JUMP_CONDITIONAL_SHORT_INSTR,
   REGISTER_INSTR,
   MOVE_REG_INSTR,
   CALL_JUMP_INSTR,
   SHORT_IMMEDIATE_INSTR
 };
 
-
 struct InstructionDesc {
   const char* mnem;
   InstructionType type;
   OperandOrder op_order_;
 };
 
-
 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(ByteMnemonic bm[], InstructionType type);
   void SetTableRange(InstructionType type,
                      uint8_t start,
                      uint8_t end,
                      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 = "";
     instructions_[i].type = NO_INSTR;
     instructions_[i].op_order_ = UNSET_OP_ORDER;
   }
 }
 
-
 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(REGISTER_INSTR, 0x40, 0x47, "inc");
   SetTableRange(REGISTER_INSTR, 0x48, 0x4F, "dec");
   SetTableRange(REGISTER_INSTR, 0x50, 0x57, "push");
   SetTableRange(REGISTER_INSTR, 0x58, 0x5F, "pop");
   SetTableRange(REGISTER_INSTR, 0x91, 0x97, "xchg eax,");  // 0x90 is nop.
   SetTableRange(MOVE_REG_INSTR, 0xB8, 0xBF, "mov");
 }
 
-
 void InstructionTable::CopyTable(ByteMnemonic bm[], InstructionType type) {
   for (int i = 0; bm[i].b >= 0; i++) {
     InstructionDesc* id = &instructions_[bm[i].b];
     id->mnem = bm[i].mnem;
     id->op_order_ = bm[i].op_order_;
     ASSERT(id->type == NO_INSTR);  // Information already entered
     id->type = type;
   }
 }
 
-
 void InstructionTable::SetTableRange(InstructionType type,
                                      uint8_t start,
                                      uint8_t end,
                                      const char* mnem) {
   for (uint8_t b = start; b <= end; b++) {
     InstructionDesc* id = &instructions_[b];
     ASSERT(id->type == NO_INSTR);  // Information already entered
     id->mnem = mnem;
     id->type = type;
   }
 }
 
-
 void InstructionTable::AddJumpConditionalShort() {
   for (uint8_t b = 0x70; b <= 0x7F; b++) {
     InstructionDesc* id = &instructions_[b];
     ASSERT(id->type == NO_INSTR);  // Information already entered
     id->mnem = jump_conditional_mnem[b & 0x0F];
     id->type = JUMP_CONDITIONAL_SHORT_INSTR;
   }
 }
 
-
 static InstructionTable instruction_table;
 
-
 // Mnemonics for instructions 0xF0 byte.
 // Returns NULL if the instruction is not handled here.
 static const char* F0Mnem(uint8_t f0byte) {
   switch (f0byte) {
     case 0x12:
       return "movhlps";
     case 0x14:
       return "unpcklps";
     case 0x15:
       return "unpckhps";
@@ skipping 76 matching lines @@
   if (data == 0x59) mnemonic = "mulpd ";
   if (data == 0x5E) mnemonic = "divpd ";
   if (data == 0x5D) mnemonic = "minpd ";
   if (data == 0x5F) mnemonic = "maxpd ";
   if (data == 0x51) mnemonic = "sqrtpd ";
   if (data == 0x5A) mnemonic = "cvtpd2ps ";
   ASSERT(mnemonic != NULL);
   return mnemonic;
 }
 
-
 static bool IsTwoXmmRegInstruction(uint8_t f0byte) {
   return f0byte == 0x28 || f0byte == 0x11 || f0byte == 0x12 || f0byte == 0x14 ||
          f0byte == 0x15 || f0byte == 0x16 || f0byte == 0x51 || f0byte == 0x52 ||
          f0byte == 0x53 || f0byte == 0x54 || f0byte == 0x56 || f0byte == 0x58 ||
          f0byte == 0x59 || f0byte == 0x5C || f0byte == 0x5D || f0byte == 0x5E ||
          f0byte == 0x5F || f0byte == 0x5A;
 }
 
-
 // The implementation of x86 decoding based on the above tables.
 class X86Decoder : public ValueObject {
  public:
   X86Decoder(char* buffer, intptr_t buffer_size)
       : buffer_(buffer), buffer_size_(buffer_size), buffer_pos_(0) {
     buffer_[buffer_pos_] = '\0';
   }
 
   ~X86Decoder() {}
 
@@ skipping 62 matching lines @@
     *regop = (data & 0x38) >> 3;
     *rm = data & 7;
   }
 
   static void GetSib(uint8_t data, int* scale, int* index, int* base) {
     *scale = (data >> 6) & 3;
     *index = (data >> 3) & 7;
     *base = data & 7;
   }
 
-
   // Convenience functions.
   char* get_buffer() const { return buffer_; }
   char* current_position_in_buffer() { return buffer_ + buffer_pos_; }
   intptr_t remaining_size_in_buffer() { return buffer_size_ - buffer_pos_; }
 
   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_.
 
   DISALLOW_COPY_AND_ASSIGN(X86Decoder);
 };
 
-
 void X86Decoder::PrintInt(int value) {
   char int_buffer[16];
   OS::SNPrint(int_buffer, sizeof(int_buffer), "%#x", value);
   Print(int_buffer);
 }
 
-
 // Append the int value (printed in hex) to the output buffer.
 void X86Decoder::PrintHex(int value, bool signed_value) {
   char hex_buffer[16];
   if (signed_value && value < 0) {
     OS::SNPrint(hex_buffer, sizeof(hex_buffer), "-%#x", -value);
   } else {
     OS::SNPrint(hex_buffer, sizeof(hex_buffer), "%#x", value);
   }
   Print(hex_buffer);
 }
 
-
 // Append the str to the output buffer.
 void X86Decoder::Print(const char* str) {
   char cur = *str++;
   while (cur != '\0' && (buffer_pos_ < (buffer_size_ - 1))) {
     buffer_[buffer_pos_++] = cur;
     cur = *str++;
   }
   buffer_[buffer_pos_] = '\0';
 }
 
-
 static const int kMaxCPURegisters = 8;
 static const char* cpu_regs[kMaxCPURegisters] = {"eax", "ecx", "edx", "ebx",
                                                  "esp", "ebp", "esi", "edi"};
 
 static const int kMaxByteCPURegisters = 8;
 static const char* byte_cpu_regs[kMaxByteCPURegisters] = {
     "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"};
 
 static const int kMaxXmmRegisters = 8;
 static const char* xmm_regs[kMaxXmmRegisters] = {
     "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"};
 
 void X86Decoder::PrintCPURegister(int reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kMaxCPURegisters);
   Print(cpu_regs[reg]);
 }
 
-
 void X86Decoder::PrintCPUByteRegister(int reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kMaxByteCPURegisters);
   Print(byte_cpu_regs[reg]);
 }
 
-
 void X86Decoder::PrintXmmRegister(int reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kMaxXmmRegisters);
   Print(xmm_regs[reg]);
 }
 
 void X86Decoder::PrintXmmComparison(int comparison) {
   ASSERT(0 <= comparison);
   ASSERT(comparison < 8);
   static const char* comparisons[8] = {
       "eq", "lt", "le", "unordered", "not eq", "not lt", "not le", "ordered"};
   Print(comparisons[comparison]);
 }
 
-
 void X86Decoder::PrintAddress(uword addr) {
   char addr_buffer[32];
   OS::SNPrint(addr_buffer, sizeof(addr_buffer), "%#" Px "", addr);
   Print(addr_buffer);
 
   // Try to print as  stub name.
   const char* name_of_stub = StubCode::NameOfStub(addr);
   if (name_of_stub != NULL) {
     Print("  [stub: ");
     Print(name_of_stub);
     Print("]");
   }
 }
 
-
 int X86Decoder::PrintRightOperandHelper(uint8_t* modrmp,
                                         RegisterNamePrinter register_printer) {
   int mod, regop, rm;
   GetModRm(*modrmp, &mod, &regop, &rm);
   switch (mod) {
     case 0:
       if (rm == ebp) {
         int32_t disp = *reinterpret_cast<int32_t*>(modrmp + 1);
         Print("[");
         PrintHex(disp);
@@ skipping 100 matching lines @@
     case 3:
       (this->*register_printer)(rm);
       return 1;
     default:
       UNIMPLEMENTED();
       return 1;
   }
   UNREACHABLE();
 }
 
-
 int X86Decoder::PrintRightOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp, &X86Decoder::PrintCPURegister);
 }
 
-
 int X86Decoder::PrintRightXmmOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp, &X86Decoder::PrintXmmRegister);
 }
 
-
 int X86Decoder::PrintRightByteOperand(uint8_t* modrmp) {
   return PrintRightOperandHelper(modrmp, &X86Decoder::PrintCPUByteRegister);
 }
 
-
 int X86Decoder::PrintOperands(const char* mnem,
                               OperandOrder op_order,
                               uint8_t* data) {
   uint8_t modrm = *data;
   int mod, regop, rm;
   GetModRm(modrm, &mod, &regop, &rm);
   int advance = 0;
   switch (op_order) {
     case REG_OPER_OP_ORDER: {
       Print(mnem);
@@ skipping 11 matching lines @@
       PrintCPURegister(regop);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   return advance;
 }
 
-
 int X86Decoder::PrintImmediateOp(uint8_t* data, bool size_override) {
   bool sign_extension_bit = (*data & 0x02) != 0;
   uint8_t modrm = *(data + 1);
   int mod, regop, rm;
   GetModRm(modrm, &mod, &regop, &rm);
   const char* mnem = "Imm???";
   switch (regop) {
     case 0:
       mnem = "add";
       break;
@@ skipping 30 matching lines @@
     return 1 + count + 2 /*int16_t*/;
   } else if (sign_extension_bit) {
     PrintHex(*reinterpret_cast<int8_t*>(data + 1 + count), sign_extension_bit);
     return 1 + count + 1 /*int8_t*/;
   } else {
     PrintHex(*reinterpret_cast<int32_t*>(data + 1 + count));
     return 1 + count + 4 /*int32_t*/;
   }
 }
 
-
 int X86Decoder::DecodeEnter(uint8_t* data) {
   uint16_t size = *reinterpret_cast<uint16_t*>(data + 1);
   uint8_t level = *reinterpret_cast<uint8_t*>(data + 3);
   Print("enter ");
   PrintInt(size);
   Print(", ");
   PrintInt(level);
   return 4;
 }
 
-
 // Returns number of bytes used, including *data.
 int X86Decoder::JumpShort(uint8_t* data) {
   ASSERT(*data == 0xEB);
   uint8_t b = *(data + 1);
   uword dest = reinterpret_cast<uword>(data) + static_cast<int8_t>(b) + 2;
   Print("jmp ");
   PrintAddress(dest);
   return 2;
 }
 
-
 // Returns number of bytes used, including *data.
 int X86Decoder::JumpConditional(uint8_t* data, const char* comment) {
   ASSERT(*data == 0x0F);
   uint8_t cond = *(data + 1) & 0x0F;
   uword dest =
       reinterpret_cast<uword>(data) + *reinterpret_cast<int32_t*>(data + 2) + 6;
   const char* mnem = jump_conditional_mnem[cond];
   Print(mnem);
   Print(" ");
   PrintAddress(dest);
   if (comment != NULL) {
     Print(", ");
     Print(comment);
   }
   return 6;  // includes 0x0F
 }
 
-
 // Returns number of bytes used, including *data.
 int X86Decoder::JumpConditionalShort(uint8_t* data, const char* comment) {
   uint8_t cond = *data & 0x0F;
   uint8_t b = *(data + 1);
   uword dest = reinterpret_cast<uword>(data) + static_cast<int8_t>(b) + 2;
   const char* mnem = jump_conditional_mnem[cond];
   Print(mnem);
   Print(" ");
   PrintAddress(dest);
   if (comment != NULL) {
     Print(", ");
     Print(comment);
   }
   return 2;
 }
 
-
 // Returns number of bytes used, including *data.
 int X86Decoder::SetCC(uint8_t* data) {
   ASSERT(*data == 0x0F);
   uint8_t cond = *(data + 1) & 0x0F;
   const char* mnem = set_conditional_mnem[cond];
   Print(mnem);
   Print(" ");
   PrintRightByteOperand(data + 2);
   return 3;  // includes 0x0F
 }
 
-
 // Returns number of bytes used, including *data.
 int X86Decoder::CMov(uint8_t* data) {
   ASSERT(*data == 0x0F);
   uint8_t cond = *(data + 1) & 0x0F;
   const char* mnem = conditional_move_mnem[cond];
   int op_size = PrintOperands(mnem, REG_OPER_OP_ORDER, data + 2);
   return 2 + op_size;  // includes 0x0F
 }
 
-
 int X86Decoder::D1D3C1Instruction(uint8_t* data) {
   uint8_t op = *data;
   ASSERT(op == 0xD1 || op == 0xD3 || op == 0xC1);
   int mod, regop, rm;
   GetModRm(*(data + 1), &mod, &regop, &rm);
   int num_bytes = 1;
   const char* mnem = NULL;
   switch (regop) {
     case 2:
       mnem = "rcl";
@@ skipping 23 matching lines @@
     PrintInt(*(data + 2));
     num_bytes++;
   } else {
     ASSERT(op == 0xD3);
     num_bytes += PrintRightOperand(data + 1);
     Print(", cl");
   }
   return num_bytes;
 }
 
-
 uint8_t* X86Decoder::F3Instruction(uint8_t* data) {
   if (*(data + 1) == 0x0F) {
     uint8_t b2 = *(data + 2);
     switch (b2) {
       case 0x2C: {
         data += 3;
         data += PrintOperands("cvttss2si", REG_OPER_OP_ORDER, data);
         break;
       }
       case 0x2A: {
@@ skipping 96 matching lines @@
     }
   } else if (*(data + 1) == 0xA4) {
     Print("rep_movsb");
     data += 2;
   } else {
     UNIMPLEMENTED();
   }
   return data;
 }
 
-
 // Returns number of bytes used, including *data.
 int X86Decoder::F7Instruction(uint8_t* data) {
   ASSERT(*data == 0xF7);
   uint8_t modrm = *(data + 1);
   int mod, regop, rm;
   GetModRm(modrm, &mod, &regop, &rm);
   if (mod == 3 && regop != 0) {
     const char* mnem = NULL;
     switch (regop) {
       case 2:
@@ skipping 223 matching lines @@
     return 2;
   } else if (b1 == 0xDA && b2 == 0xE9) {
     const char* mnem = "fucompp";
     Print(mnem);
     return 2;
   }
   Print("Unknown FP instruction");
   return 2;
 }
 
-
 uint8_t* X86Decoder::SSEInstruction(uint8_t prefix,
                                     uint8_t primary,
                                     uint8_t* data) {
   ASSERT(prefix == 0x0F);
   int mod, regop, rm;
   if (primary == 0x10) {
     GetModRm(*data, &mod, &regop, &rm);
     Print("movups ");
     PrintXmmRegister(regop);
     Print(",");
@@ skipping 11 matching lines @@
     GetModRm(*data, &mod, &regop, &rm);
     Print(f0mnem);
     Print(" ");
     PrintXmmRegister(regop);
     Print(",");
     data += PrintRightXmmOperand(data);
   }
   return data;
 }
 
-
 int X86Decoder::BitwisePDInstruction(uint8_t* data) {
   const char* mnem =
       (*data == 0x57) ? "xorpd" : (*data == 0x56) ? "orpd" : "andpd";
   int mod, regop, rm;
   GetModRm(*(data + 1), &mod, &regop, &rm);
   Print(mnem);
   Print(" ");
   PrintXmmRegister(regop);
   Print(",");
   return 1 + PrintRightXmmOperand(data + 1);
 }
 
-
 int X86Decoder::Packed660F38Instruction(uint8_t* data) {
   if (*(data + 1) == 0x25) {
     Print("pmovsxdq ");
     int mod, regop, rm;
     GetModRm(*(data + 2), &mod, &regop, &rm);
     PrintXmmRegister(regop);
     Print(",");
     return 2 + PrintRightXmmOperand(data + 2);
   } else if (*(data + 1) == 0x29) {
     Print("pcmpeqq ");
     int mod, regop, rm;
     GetModRm(*(data + 2), &mod, &regop, &rm);
     PrintXmmRegister(regop);
     Print(",");
     return 2 + PrintRightXmmOperand(data + 2);
   }
   UNREACHABLE();
   return 1;
 }
 
-
 // Called when disassembling test eax, 0xXXXXX.
 void X86Decoder::CheckPrintStop(uint8_t* data) {
   // Recognize stop pattern.
   if (*reinterpret_cast<uint8_t*>(data + 5) == 0xCC) {
     Print("  STOP:'");
     const char* text = *reinterpret_cast<const char**>(data + 1);
     Print(text);
     Print("'");
   }
 }
 
 const char* X86Decoder::GetBranchPrefix(uint8_t** data) {
   // We use these two prefixes only with branch prediction
   switch (**data) {
     case 0x3E:  // ds
       (*data)++;
       return "predicted taken";
     case 0x2E:  // cs
       (*data)++;
       return "predicted not taken";
     case 0xF0:  // lock
       Print("lock ");
       (*data)++;
       return NULL;
     default:  // Ignore all other instructions.
       return NULL;
   }
 }
 
-
 bool X86Decoder::DecodeInstructionType(const InstructionDesc& idesc,
                                        const char* branch_hint,
                                        uint8_t** data) {
   switch (idesc.type) {
     case ZERO_OPERANDS_INSTR:
       Print(idesc.mnem);
       (*data)++;
       return true;
 
     case TWO_OPERANDS_INSTR:
@@ skipping 42 matching lines @@
 
     case NO_INSTR:
       return false;
 
     default:
       UNIMPLEMENTED();  // This type is not implemented.
       return false;
   }
 }
 
-
 int X86Decoder::InstructionDecode(uword pc) {
   uint8_t* data = reinterpret_cast<uint8_t*>(pc);
   // Check for hints.
   const char* branch_hint = GetBranchPrefix(&data);
   const InstructionDesc& idesc = instruction_table.Get(*data);
   // Will be set to false if the current instruction
   // is not in 'instructions' table.
   bool processed = DecodeInstructionType(idesc, branch_hint, &data);
   //----------------------------
   if (!processed) {
@@ skipping 551 matching lines @@
         UNIMPLEMENTED();
     }
   }
 
   int instr_len = data - reinterpret_cast<uint8_t*>(pc);
   ASSERT(instr_len > 0);  // Ensure progress.
 
   return instr_len;
 }  // NOLINT
 
-
 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 23 matching lines @@
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32