Fix some style issues in the ARM code....

src/arm/disasm-arm.cc

 // Copyright 2007-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 318 matching lines @@
       reg++;
       rlist >>= 1;
     }
     Print("}");
     return 5;
   }
   UNREACHABLE();
   return -1;
 }
 
+
 // Handle all VFP register based formatting in this function to reduce the
 // complexity of FormatOption.
 int Decoder::FormatVFPRegister(Instr* instr, const char* format) {
   ASSERT((format[0] == 'S') || (format[0] == 'D'));
 
   if (format[1] == 'n') {
     int reg = instr->VnField();
     if (format[0] == 'S') PrintSRegister(((reg << 1) | instr->NField()));
     if (format[0] == 'D') PrintDRegister(reg);
     return 2;
   } else if (format[1] == 'm') {
     int reg = instr->VmField();
     if (format[0] == 'S') PrintSRegister(((reg << 1) | instr->MField()));
     if (format[0] == 'D') PrintDRegister(reg);
     return 2;
   } else if (format[1] == 'd') {
     int reg = instr->VdField();
     if (format[0] == 'S') PrintSRegister(((reg << 1) | instr->DField()));
     if (format[0] == 'D') PrintDRegister(reg);
     return 2;
   }
 
   UNREACHABLE();
   return -1;
 }
 
+
 int Decoder::FormatVFPinstruction(Instr* instr, const char* format) {
     Print(format);
     return 0;
 }
 
 
-
-
 // FormatOption takes a formatting string and interprets it based on
 // the current instructions. The format string points to the first
 // character of the option string (the option escape has already been
 // consumed by the caller.)  FormatOption returns the number of
 // characters that were consumed from the formatting string.
 int Decoder::FormatOption(Instr* instr, const char* format) {
   switch (format[0]) {
     case 'a': {  // 'a: accumulate multiplies
       if (instr->Bit(21) == 0) {
         Print("ul");
@@ skipping 507 matching lines @@
         break;
       }
     }
     return;
   }
   Format(instr, "break 'msg");
 }
 
 
 // void Decoder::DecodeTypeVFP(Instr* instr)
-// Implements the following
-// VFP instructions
-// fmsr :Sn = Rt
-// fmrs :Rt = Sn
+// Implements the following VFP instructions:
+// fmsr: Sn = Rt
+// fmrs: Rt = Sn
 // fsitod: Dd = Sm
 // ftosid: Sd = Dm
 // Dd = faddd(Dn, Dm)
 // Dd = fsubd(Dn, Dm)
 // Dd = fmuld(Dn, Dm)
 // Dd = fdivd(Dn, Dm)
 // vcmp(Dd, Dm)
 // VMRS
 void Decoder::DecodeTypeVFP(Instr* instr) {
   ASSERT((instr->TypeField() == 7) && (instr->Bit(24) == 0x0) );
@@ skipping 30 matching lines @@
       Format(instr, "vcmp.f64'cond 'Dd, 'Dm");
     } else if ((instr->Bits(23, 20) == 0xF) &&
                (instr->Bits(19, 16) == 0x1) &&
                (instr->Bits(11, 8) == 0xA) &&
                (instr->Bits(7, 5) == 0x0) &&
                (instr->Bit(4) == 0x1)    &&
                (instr->Bits(3, 0) == 0x0)) {
         if (instr->Bits(15, 12) == 0xF)
           Format(instr, "vmrs'cond APSR, FPSCR");
         else
-          Unknown(instr);  // not used by V8
+          Unknown(instr);  // Not used by V8.
     } else {
-      Unknown(instr);  // not used by V8
+      Unknown(instr);  // Not used by V8.
     }
   } else if (instr->Bit(21) == 1) {
     if ((instr->Bit(20) == 0x1) &&
         (instr->Bits(11, 9) == 0x5) &&
         (instr->Bit(8) == 0x1) &&
         (instr->Bit(6) == 0) &&
         (instr->Bit(4) == 0)) {
       Format(instr, "vadd.f64'cond 'Dd, 'Dn, 'Dm");
     } else if ((instr->Bit(20) == 0x1) &&
                (instr->Bits(11, 9) == 0x5) &&
                (instr->Bit(8) == 0x1) &&
                (instr->Bit(6) == 1) &&
                (instr->Bit(4) == 0)) {
       Format(instr, "vsub.f64'cond 'Dd, 'Dn, 'Dm");
     } else if ((instr->Bit(20) == 0x0) &&
                (instr->Bits(11, 9) == 0x5) &&
                (instr->Bit(8) == 0x1) &&
                (instr->Bit(6) == 0) &&
                (instr->Bit(4) == 0)) {
       Format(instr, "vmul.f64'cond 'Dd, 'Dn, 'Dm");
     } else {
-      Unknown(instr);  // not used by V8
+      Unknown(instr);  // Not used by V8.
     }
   } else {
     if ((instr->Bit(20) == 0x0) &&
         (instr->Bits(11, 8) == 0xA) &&
         (instr->Bits(6, 5) == 0x0) &&
         (instr->Bit(4) == 1) &&
         (instr->Bits(3, 0) == 0x0)) {
       Format(instr, "vmov'cond 'Sn, 'rt");
     } else if ((instr->Bit(20) == 0x1) &&
                (instr->Bits(11, 8) == 0xA) &&
                (instr->Bits(6, 5) == 0x0) &&
                (instr->Bit(4) == 1) &&
                (instr->Bits(3, 0) == 0x0)) {
       Format(instr, "vmov'cond 'rt, 'Sn");
     } else {
-      Unknown(instr);  // not used by V8
+      Unknown(instr);  // Not used by V8.
     }
   }
 }
 
 
-
-// Decode Type 6 coprocessor instructions
+// Decode Type 6 coprocessor instructions.
 // Dm = fmdrr(Rt, Rt2)
 // <Rt, Rt2> = fmrrd(Dm)
 void Decoder::DecodeType6CoprocessorIns(Instr* instr) {
   ASSERT((instr->TypeField() == 6));
 
   if (instr->Bit(23) == 1) {
-     Unknown(instr);  // not used by V8
+     Unknown(instr);  // Not used by V8.
   } else if (instr->Bit(22) == 1) {
     if ((instr->Bits(27, 24) == 0xC) &&
         (instr->Bit(22) == 1) &&
         (instr->Bits(11, 8) == 0xB) &&
         (instr->Bits(7, 6) == 0x0) &&
         (instr->Bit(4) == 1)) {
       if (instr->Bit(20) == 0) {
         Format(instr, "vmov'cond 'Dm, 'rt, 'rn");
       } else if (instr->Bit(20) == 1) {
         Format(instr, "vmov'cond 'rt, 'rn, 'Dm");
       }
     } else {
-      Unknown(instr);  // not used by V8
+      Unknown(instr);  // Not used by V8.
     }
   } else if (instr->Bit(21) == 1) {
-    Unknown(instr);  // not used by V8
+    Unknown(instr);  // Not used by V8.
   } else {
-    Unknown(instr);  // not used by V8
+    Unknown(instr);  // Not used by V8.
   }
 }
 
 
 // Disassemble the instruction at *instr_ptr into the output buffer.
 int Decoder::InstructionDecode(byte* instr_ptr) {
   Instr* instr = Instr::At(instr_ptr);
   // Print raw instruction bytes.
   out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
                                        "%08x       ",
@@ skipping 123 matching lines @@
     buffer[0] = '\0';
     byte* prev_pc = pc;
     pc += d.InstructionDecode(buffer, pc);
     fprintf(f, "%p    %08x      %s\n",
             prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
   }
 }
 
 
 }  // namespace disasm