A64: Abstract colour definitions for the Simulator tracing.

src/a64/simulator-a64.cc

 // Copyright 2013 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 33 matching lines @@
 #if defined(USE_SIMULATOR)
 
 
 // This macro provides a platform independent use of sscanf. The reason for
 // SScanF not being implemented in a platform independent way through
 // ::v8::internal::OS in the same way as SNPrintF is that the
 // Windows C Run-Time Library does not provide vsscanf.
 #define SScanF sscanf  // NOLINT
 
 
+// Helpers for colors.
+// Depending on your terminal configuration, the colour names may not match the
+// observed colours.
+#define COLOUR(colour_code)  "\033[" colour_code "m"
+#define BOLD(colour_code)    "1;" colour_code
+#define NORMAL ""
+#define GREY   "30"
+#define GREEN  "32"
+#define ORANGE "33"
+#define BLUE   "34"
+#define PURPLE "35"
+#define INDIGO "36"
+#define WHITE  "37"
+typedef char const * const TEXT_COLOUR;
+TEXT_COLOUR clr_normal         = FLAG_log_colour ? COLOUR(NORMAL)       : "";
+TEXT_COLOUR clr_flag_name      = FLAG_log_colour ? COLOUR(BOLD(GREY))   : "";
+TEXT_COLOUR clr_flag_value     = FLAG_log_colour ? COLOUR(BOLD(WHITE))  : "";
+TEXT_COLOUR clr_reg_name       = FLAG_log_colour ? COLOUR(BOLD(BLUE))   : "";
+TEXT_COLOUR clr_reg_value      = FLAG_log_colour ? COLOUR(BOLD(INDIGO)) : "";
+TEXT_COLOUR clr_fpreg_name     = FLAG_log_colour ? COLOUR(BOLD(ORANGE)) : "";
+TEXT_COLOUR clr_fpreg_value    = FLAG_log_colour ? COLOUR(BOLD(PURPLE)) : "";
+TEXT_COLOUR clr_memory_value   = FLAG_log_colour ? COLOUR(BOLD(GREEN))  : "";
+TEXT_COLOUR clr_memory_address = FLAG_log_colour ? COLOUR(GREEN)        : "";
+TEXT_COLOUR clr_debug_number   = FLAG_log_colour ? COLOUR(BOLD(ORANGE)) : "";
+TEXT_COLOUR clr_debug_message  = FLAG_log_colour ? COLOUR(ORANGE)       : "";
+TEXT_COLOUR clr_printf         = FLAG_log_colour ? COLOUR(GREEN)        : "";
+
+
 // This is basically the same as PrintF, with a guard for FLAG_trace_sim.
 void PRINTF_CHECKING TraceSim(const char* format, ...) {
   if (FLAG_trace_sim) {
     va_list arguments;
     va_start(arguments, format);
     OS::VPrint(format, arguments);
     va_end(arguments);
   }
 }
 
@@ skipping 749 matching lines @@
   Instruction* end = start->InstructionAtOffset(count * kInstructionSize);
   for (Instruction* pc = start; pc < end; pc = pc->following()) {
     disassembler_decoder_->Decode(pc);
   }
 }
 
 
 void Simulator::PrintSystemRegisters(bool print_all) {
   static bool first_run = true;
 
-  // Define some colour codes to use for the register dump.
-  // TODO(jbramley): Find a more elegant way of defining these.
-  char const * const clr_normal     = (FLAG_log_colour) ? ("\033[m") : ("");
-  char const * const clr_flag_name  = (FLAG_log_colour) ? ("\033[1;30m") : ("");
-  char const * const clr_flag_value = (FLAG_log_colour) ? ("\033[1;37m") : ("");
-
   static SimSystemRegister last_nzcv;
   if (print_all || first_run || (last_nzcv.RawValue() != nzcv().RawValue())) {
     fprintf(stream_, "# %sFLAGS: %sN:%d Z:%d C:%d V:%d%s\n",
             clr_flag_name,
             clr_flag_value,
             N(), Z(), C(), V(),
             clr_normal);
   }
   last_nzcv = nzcv();
 
@@ skipping 15 matching lines @@
   last_fpcr = fpcr();
 
   first_run = false;
 }
 
 
 void Simulator::PrintRegisters(bool print_all_regs) {
   static bool first_run = true;
   static int64_t last_regs[kNumberOfRegisters];
 
-  // Define some colour codes to use for the register dump.
-  // TODO(jbramley): Find a more elegant way of defining these.
-  char const * const clr_normal    = (FLAG_log_colour) ? ("\033[m") : ("");
-  char const * const clr_reg_name  = (FLAG_log_colour) ? ("\033[1;34m") : ("");
-  char const * const clr_reg_value = (FLAG_log_colour) ? ("\033[1;36m") : ("");
-
   for (unsigned i = 0; i < kNumberOfRegisters; i++) {
     if (print_all_regs || first_run ||
         (last_regs[i] != xreg(i, Reg31IsStackPointer))) {
       fprintf(stream_,
               "# %s%4s:%s 0x%016" PRIx64 "%s\n",
               clr_reg_name,
               XRegNameForCode(i, Reg31IsStackPointer),
               clr_reg_value,
               xreg(i, Reg31IsStackPointer),
               clr_normal);
     }
     // Cache the new register value so the next run can detect any changes.
     last_regs[i] = xreg(i, Reg31IsStackPointer);
   }
   first_run = false;
 }
 
 
 void Simulator::PrintFPRegisters(bool print_all_regs) {
   static bool first_run = true;
   static uint64_t last_regs[kNumberOfFPRegisters];
 
-  // Define some colour codes to use for the register dump.
-  // TODO(jbramley): Find a more elegant way of defining these.
-  char const * const clr_normal    = (FLAG_log_colour) ? ("\033[m") : ("");
-  char const * const clr_reg_name  = (FLAG_log_colour) ? ("\033[1;33m") : ("");
-  char const * const clr_reg_value = (FLAG_log_colour) ? ("\033[1;35m") : ("");
-
   // Print as many rows of registers as necessary, keeping each individual
   // register in the same column each time (to make it easy to visually scan
   // for changes).
   for (unsigned i = 0; i < kNumberOfFPRegisters; i++) {
     if (print_all_regs || first_run || (last_regs[i] != dreg_bits(i))) {
       fprintf(stream_,
               "# %s %4s:%s 0x%016" PRIx64 "%s (%s%s:%s %g%s %s:%s %g%s)\n",
-              clr_reg_name,
+              clr_fpreg_name,
               VRegNameForCode(i),
-              clr_reg_value,
+              clr_fpreg_value,
               dreg_bits(i),
               clr_normal,
-              clr_reg_name,
+              clr_fpreg_name,
               DRegNameForCode(i),
-              clr_reg_value,
+              clr_fpreg_value,
               dreg(i),
-              clr_reg_name,
+              clr_fpreg_name,
               SRegNameForCode(i),
-              clr_reg_value,
+              clr_fpreg_value,
               sreg(i),
               clr_normal);
     }
     // Cache the new register value so the next run can detect any changes.
     last_regs[i] = dreg_bits(i);
   }
   first_run = false;
 }
 
 
@@ skipping 2015 matching lines @@
     return SScanF(desc + 2, "%" SCNx64,
                   reinterpret_cast<uint64_t*>(value)) == 1;
   } else {
     return SScanF(desc, "%" SCNu64,
                   reinterpret_cast<uint64_t*>(value)) == 1;
   }
 }
 
 
 bool Simulator::PrintValue(const char* desc) {
-  // Define some colour codes to use for the register dump.
-  // TODO(jbramley): Find a more elegant way of defining these.
-  char const * const clr_normal    = FLAG_log_colour ? "\033[m" : "";
-  char const * const clr_reg_name  = FLAG_log_colour ? "\033[1;34m" : "";
-  char const * const clr_reg_value = FLAG_log_colour ? "\033[1;36m" : "";
-  char const * const clr_fpreg_name  = FLAG_log_colour ? "\033[1;33m" : "";
-  char const * const clr_fpreg_value = FLAG_log_colour ? "\033[1;35m" : "";
-
   if (strcmp(desc, "csp") == 0) {
     ASSERT(CodeFromName(desc) == static_cast<int>(kSPRegInternalCode));
     PrintF("%s csp:%s 0x%016" PRIx64 "%s\n",
         clr_reg_name, clr_reg_value, xreg(31, Reg31IsStackPointer), clr_normal);
     return true;
   } else if (strcmp(desc, "wcsp") == 0) {
     ASSERT(CodeFromName(desc) == static_cast<int>(kSPRegInternalCode));
     PrintF("%s wcsp:%s 0x%08" PRIx32 "%s\n",
         clr_reg_name, clr_reg_value, wreg(31, Reg31IsStackPointer), clr_normal);
     return true;
@@ skipping 358 matching lines @@
 // (refer to InvocationCallback in v8.h).
 typedef void (*SimulatorRuntimeDirectApiCall)(int64_t arg0);
 typedef void (*SimulatorRuntimeProfilingApiCall)(int64_t arg0, void* arg1);
 
 // This signature supports direct call to accessor getter callback.
 typedef void (*SimulatorRuntimeDirectGetterCall)(int64_t arg0, int64_t arg1);
 typedef void (*SimulatorRuntimeProfilingGetterCall)(int64_t arg0, int64_t arg1,
                                                     void* arg2);
 
 void Simulator::VisitException(Instruction* instr) {
-  // Define some colour codes to use for log messages.
-  // TODO(jbramley): Find a more elegant way of defining these.
-  char const* const clr_normal        = (FLAG_log_colour) ? ("\033[m")
-                                                          : ("");
-  char const* const clr_debug_number  = (FLAG_log_colour) ? ("\033[1;33m")
-                                                          : ("");
-  char const* const clr_debug_message = (FLAG_log_colour) ? ("\033[0;33m")
-                                                          : ("");
-  char const* const clr_printf        = (FLAG_log_colour) ? ("\033[0;32m")
-                                                          : ("");
-
   switch (instr->Mask(ExceptionMask)) {
     case HLT: {
       if (instr->ImmException() == kImmExceptionIsDebug) {
         // Read the arguments encoded inline in the instruction stream.
         uint32_t code;
         uint32_t parameters;
 
         memcpy(&code,
                pc_->InstructionAtOffset(kDebugCodeOffset),
                sizeof(code));
@@ skipping 296 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64