clang-format runtime/vm

runtime/vm/disassembler_mips.cc

 // Copyright (c) 2013, 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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 #include "platform/assert.h"
 #include "vm/instructions.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
 class MIPSDecoder : public ValueObject {
  public:
   MIPSDecoder(char* buffer, size_t buffer_size)
-      : buffer_(buffer),
-        buffer_size_(buffer_size),
-        buffer_pos_(0) {
+      : buffer_(buffer), buffer_size_(buffer_size), buffer_pos_(0) {
     buffer_[buffer_pos_] = '\0';
   }
 
   ~MIPSDecoder() {}
 
   // Writes one disassembled instruction into 'buffer' (0-terminated).
   // Returns true if the instruction was successfully decoded, false otherwise.
   void InstructionDecode(Instr* instr);
 
  private:
@@ skipping 14 matching lines @@
   void DecodeSpecial(Instr* instr);
   void DecodeSpecial2(Instr* instr);
   void DecodeRegImm(Instr* instr);
   void DecodeCop1(Instr* instr);
 
   // Convenience functions.
   char* get_buffer() const { return buffer_; }
   char* current_position_in_buffer() { return buffer_ + buffer_pos_; }
   size_t remaining_size_in_buffer() { return buffer_size_ - buffer_pos_; }
 
-  char* buffer_;  // Decode instructions into this buffer.
+  char* buffer_;        // Decode instructions into this buffer.
   size_t buffer_size_;  // The size of the character buffer.
-  size_t buffer_pos_;  // Current character position in buffer.
+  size_t buffer_pos_;   // Current character position in buffer.
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(MIPSDecoder);
 };
 
 
 // Support for assertions in the MIPSDecoder formatting functions.
-#define STRING_STARTS_WITH(string, compare_string) \
+#define STRING_STARTS_WITH(string, compare_string)                             \
   (strncmp(string, compare_string, strlen(compare_string)) == 0)
 
 
 // Append the str to the output buffer.
 void MIPSDecoder::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 char* reg_names[kNumberOfCpuRegisters] = {
-  "zr", "at", "v0", "v1" , "a0", "a1", "a2", "a3",
-  "t0", "t1", "t2", "t3" , "t4", "t5", "t6", "t7",
-  "s0", "s1", "s2", "thr", "s4", "s5", "s6", "pp",
-  "t8", "t9", "k0", "k1" , "gp", "sp", "fp", "ra",
+    "zr", "at", "v0", "v1", "a0", "a1", "a2", "a3", "t0",  "t1", "t2",
+    "t3", "t4", "t5", "t6", "t7", "s0", "s1", "s2", "thr", "s4", "s5",
+    "s6", "pp", "t8", "t9", "k0", "k1", "gp", "sp", "fp",  "ra",
 };
 
 
 static const char* freg_names[kNumberOfFRegisters] = {
-  "f0" , "f1" , "f2" , "f3" , "f4" , "f5" , "f6" , "f7" ,
-  "f8" , "f9" , "f10", "f11", "f12", "f13", "f14", "f15",
-  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
-  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
+    "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",  "f8",  "f9",  "f10",
+    "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21",
+    "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 };
 
 
 void MIPSDecoder::PrintRegister(Register reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kNumberOfCpuRegisters);
   Print(reg_names[reg]);
 }
 
 
@@ skipping 41 matching lines @@
     case 'd': {  // 'fd: Fd register
       PrintFRegister(instr->FdField());
       return 2;
     }
   }
   UNREACHABLE();
   return -1;
 }
 
 
-void MIPSDecoder::PrintFormat(Instr *instr) {
+void MIPSDecoder::PrintFormat(Instr* instr) {
   switch (instr->FormatField()) {
     case FMT_S: {
       Print("s");
       break;
     }
     case FMT_D: {
       Print("d");
       break;
     }
     case FMT_W: {
@@ skipping 18 matching lines @@
 
 // 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 MIPSDecoder::FormatOption(Instr* instr, const char* format) {
   switch (format[0]) {
     case 'c': {
       ASSERT(STRING_STARTS_WITH(format, "code"));
-      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                remaining_size_in_buffer(),
-                                "0x%x",
-                                 instr->BreakCodeField());
+      buffer_pos_ +=
+          OS::SNPrint(current_position_in_buffer(), remaining_size_in_buffer(),
+                      "0x%x", instr->BreakCodeField());
       return 4;
     }
     case 'h': {
       ASSERT(STRING_STARTS_WITH(format, "hint"));
       if (instr->SaField() == 0x10) {
         // The high bit of the SA field is the only one that means something for
         // JALR and JR. TODO(zra): Fill in the other cases for PREF if needed.
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                   remaining_size_in_buffer(),
-                                   ".hb");
+                                   remaining_size_in_buffer(), ".hb");
       } else if (instr->SaField() != 0) {
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                           remaining_size_in_buffer(),
-                           ".unknown");
+                                   remaining_size_in_buffer(), ".unknown");
       }
       return 4;
     }
     case 'd': {
       ASSERT(STRING_STARTS_WITH(format, "dest"));
       int off = instr->SImmField() << 2;
       uword destination =
           reinterpret_cast<uword>(instr) + off + Instr::kInstrSize;
-      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                 remaining_size_in_buffer(),
-                                 "%#" Px "",
-                                 destination);
+      buffer_pos_ +=
+          OS::SNPrint(current_position_in_buffer(), remaining_size_in_buffer(),
+                      "%#" Px "", destination);
       return 4;
     }
     case 'i': {
       ASSERT(STRING_STARTS_WITH(format, "imm"));
       if (format[3] == 'u') {
         int32_t imm = instr->UImmField();
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                   remaining_size_in_buffer(),
-                                   "0x%x",
-                                   imm);
+                                   remaining_size_in_buffer(), "0x%x", imm);
       } else {
         ASSERT(STRING_STARTS_WITH(format, "imms"));
         int32_t imm = instr->SImmField();
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                   remaining_size_in_buffer(),
-                                   "%d",
-                                   imm);
+                                   remaining_size_in_buffer(), "%d", imm);
       }
       return 4;
     }
     case 'r': {
       return FormatRegister(instr, format);
     }
     case 'f': {
       if (format[1] == 'm') {
         ASSERT(STRING_STARTS_WITH(format, "fmt"));
         PrintFormat(instr);
         return 3;
       } else {
         return FormatFRegister(instr, format);
       }
     }
     case 's': {
       ASSERT(STRING_STARTS_WITH(format, "sa"));
-      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                 remaining_size_in_buffer(),
-                                 "%d",
-                                 instr->SaField());
+      buffer_pos_ +=
+          OS::SNPrint(current_position_in_buffer(), remaining_size_in_buffer(),
+                      "%d", instr->SaField());
       return 2;
     }
-    default: {
-      UNREACHABLE();
-    }
+    default: { UNREACHABLE(); }
   }
   UNREACHABLE();
   return -1;
 }
 
 
 // Format takes a formatting string for a whole instruction and prints it into
 // the output buffer. All escaped options are handed to FormatOption to be
 // parsed further.
 void MIPSDecoder::Format(Instr* instr, const char* format) {
   char cur = *format++;
   while ((cur != 0) && (buffer_pos_ < (buffer_size_ - 1))) {
     if (cur == '\'') {  // Single quote is used as the formatting escape.
       format += FormatOption(instr, format);
     } else {
       buffer_[buffer_pos_++] = cur;
     }
     cur = *format++;
   }
-  buffer_[buffer_pos_]  = '\0';
+  buffer_[buffer_pos_] = '\0';
 }
 
 
 // For currently unimplemented decodings the disassembler calls Unknown(instr)
 // which will just print "unknown" of the instruction bits.
 void MIPSDecoder::Unknown(Instr* instr) {
   Format(instr, "unknown");
 }
 
 
 void MIPSDecoder::DecodeSpecial(Instr* instr) {
   ASSERT(instr->OpcodeField() == SPECIAL);
   switch (instr->FunctionField()) {
     case ADDU: {
       Format(instr, "addu 'rd, 'rs, 'rt");
       break;
     }
     case AND: {
       Format(instr, "and 'rd, 'rs, 'rt");
       break;
     }
     case BREAK: {
       Format(instr, "break 'code");
       if (instr->BreakCodeField() == Instr::kStopMessageCode) {
         const char* message = *reinterpret_cast<const char**>(
             reinterpret_cast<intptr_t>(instr) - Instr::kInstrSize);
-        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                   remaining_size_in_buffer(),
-                                   " ; \"%s\"",
-                                   message);
+        buffer_pos_ +=
+            OS::SNPrint(current_position_in_buffer(),
+                        remaining_size_in_buffer(), " ; \"%s\"", message);
       }
       break;
     }
     case DIV: {
       Format(instr, "div 'rs, 'rt");
       break;
     }
     case DIVU: {
       Format(instr, "divu 'rs, 'rt");
       break;
@@ skipping 56 matching lines @@
       } else if (instr->RsField() == R0) {
         Format(instr, "mov 'rd, 'rt");
       } else if (instr->RtField() == R0) {
         Format(instr, "mov 'rd, 'rs");
       } else {
         Format(instr, "or 'rd, 'rs, 'rt");
       }
       break;
     }
     case SLL: {
-      if ((instr->RdField() == R0) &&
-          (instr->RtField() == R0) &&
+      if ((instr->RdField() == R0) && (instr->RtField() == R0) &&
           (instr->SaField() == 0)) {
         Format(instr, "nop");
       } else {
         Format(instr, "sll 'rd, 'rt, 'sa");
       }
       break;
     }
     case SLLV: {
       Format(instr, "sllv 'rd, 'rt, 'rs");
       break;
@@ skipping 365 matching lines @@
       break;
     }
     default: {
       Unknown(instr);
       break;
     }
   }
 }
 
 
-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) {
+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) {
   MIPSDecoder decoder(human_buffer, human_size);
   Instr* instr = Instr::At(pc);
   decoder.InstructionDecode(instr);
   OS::SNPrint(hex_buffer, hex_size, "%08x", instr->InstructionBits());
   if (out_instr_len) {
     *out_instr_len = Instr::kInstrSize;
   }
 
   *object = NULL;
   if (!code.IsNull()) {
     *object = &Object::Handle();
     if (!DecodeLoadObjectFromPoolOrThread(pc, code, *object)) {
       *object = NULL;
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS