Colored syntax highlighting for llvm-dwarfdump.

[aprantl]

Summary

While waiting for clang to compile (http://xkcd.com/303/) I started hacking on the text output of llvm-dwarfdump, specifically I added colored syntax highlighting. The color scheme is the one that Greg's colorize script for dwarfdump on Darwin is using.

This patch starts by colorizing the .debug_info output. Adding more sections and syntax elements should be trivial.

Do we want this?

[echristo]

Definitely want it.

Two things:

a) Might want to make it an option?
b) Formatting for the SyntaxHighlighting.h file.

Is there any way we can piggy back more off the existing color support? (Not that this is complicated and I've not looked at it at all)

-eric

[aprantl]

In D6852#105642, @echristo wrote:

Definitely want it.

Two things:

a) Might want to make it an option?

With this implementation colorizing is depending on the terminal type: Invoking llvm-dwarfdump results in color output, whereas llvm-dwarfdump | less will be monochrome.
The frontend provides an -fdiagnostics-color option that is on by default. We could do something similar here; If we do this; it should override the terminal detection, such that llvm-dwarfdump --color | less produces color output no matter what.

b) Formatting for the SyntaxHighlighting.h file.

Is there any way we can piggy back more off the existing color support? (Not that this is complicated and I've not looked at it at all)

Is there more/better color support somewhere that we could re-use? I only looked at the AST dumper in clang so far, which just hardcodes the colors.

[friss]

lib/DebugInfo/DWARFDebugInfoEntry.cpp

44–47

I'm not too fond of all the extra scopes, dunno what others think.

If this could be implemented too look like:

WithColor(OS, syntax::Address) << format("\n0x%8.8x: ", Offset);

I think I'd prefer that (not sure if just adding a conversion operator from WithColor to raw_ostream would do the trick).

[aprantl]

• Ran everything through clang-format (with the exception of the switch statement, which becomes unreadable).
• A new --color option can be used to forcibly turn color on or off. Default is autodetect.

• adrian

[echristo]

I'm fine with this or with what Frederic is suggesting :)

[aprantl]

thanks, Eric!

@Fred: this is the closest I could get it so far. I think this is still better than the previous version.
Bonus points for the person who gets rid of the get() function!

[aprantl]

got rid of a (now) unnecessary lexical scope.

[friss]

Yes, I like it much better. You already have Eric's sign-off anyway, but here are a couple of additional suggestions if you like:

lib/DebugInfo/DWARFDebugInfoEntry.cpp

153–156

Could you write this:

WithColor(OS, Color).get << Name;

and have Color be a variable that you initialize to Enumerator and reset to String if we get Name from the linetable? This way you don't duplicate the {decl,call}_file condtiion with the if above.

lib/DebugInfo/DWARFFormValue.cpp

487–492

You don't need the extra scope here.

lib/DebugInfo/CMakeLists.txt

   DWARFFormValue.cpp
   DWARFTypeUnit.cpp
   DWARFUnit.cpp
+  SyntaxHighlighting.cpp
   )

lib/DebugInfo/DWARFDebugInfoEntry.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "SyntaxHighlighting.h"
 #include "llvm/DebugInfo/DWARFDebugInfoEntry.h"
 #include "llvm/DebugInfo/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARFContext.h"

 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace dwarf;
+using namespace syntax;
 
 // Small helper to extract a DIE pointed by a reference
 // attribute. It looks up the Unit containing the DIE and calls

 
   if (debug_info_data.isValidOffset(offset)) {
     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
+    WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
 
-    OS << format("\n0x%8.8x: ", Offset);
     if (abbrCode) {
       if (AbbrevDecl) {
           const char *tagString = TagString(getTag());
           if (tagString)
-          OS.indent(indent) << tagString;
+            WithColor(OS, syntax::Tag).get().indent(indent) << tagString;
           else
-          OS.indent(indent) << format("DW_TAG_Unknown_%x", getTag());
+            WithColor(OS, syntax::Tag).get().indent(indent) <<
+              format("DW_TAG_Unknown_%x", getTag());
+
         OS << format(" [%u] %c\n", abbrCode,
                      AbbrevDecl->hasChildren() ? '*' : ' ');
 

   OS.indent(indent+2);
   const char *attrString = AttributeString(attr);
   if (attrString)
-    OS << attrString;
+    WithColor(OS, syntax::Attribute).get() << attrString;
   else
-    OS << format("DW_AT_Unknown_%x", attr);
+    WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", attr);
+
   const char *formString = FormEncodingString(form);
   if (formString)
     OS << " [" << formString << ']';

     Name = AttributeValueString(attr, *Val);
 
   if (Name) {
-    OS << Name;
+    if (attr == DW_AT_decl_file || attr == DW_AT_call_file)
+      WithColor(OS, syntax::String).get() << Name;
+    else
+      WithColor(OS, syntax::Enumerator).get() << Name;
   } else if (attr == DW_AT_decl_line || attr == DW_AT_call_line) {
     OS << *formValue.getAsUnsignedConstant();
   } else {

lib/DebugInfo/DWARFFormValue.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "SyntaxHighlighting.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"

 #include <cassert>
 using namespace llvm;
 using namespace dwarf;
+using namespace syntax;
 
 namespace {
 uint8_t getRefAddrSize(uint8_t AddrSize, uint16_t Version) {

     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
     Optional<const char *> DbgStr = getAsCString(cu);
     if (DbgStr.hasValue()) {
-      OS << '"';
-      OS.write_escaped(DbgStr.getValue());
-      OS << '"';
+      auto &COS = WithColor(OS, syntax::String).get();
+      COS << '"';
+      COS.write_escaped(DbgStr.getValue());
+      COS << '"';
     }
     break;
   }

     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
     Optional<const char *> DbgStr = getAsCString(cu);
     if (DbgStr.hasValue()) {
-      OS << '"';
-      OS.write_escaped(DbgStr.getValue());
-      OS << '"';
+      auto &COS = WithColor(OS, syntax::String).get();
+      COS << '"';
+      COS.write_escaped(DbgStr.getValue());
+      COS << '"';
     }
     break;
   }

     break;
   }
 
-  if (cu_relative_offset)
-    OS << format(" => {0x%8.8" PRIx64 "}", uvalue + (cu ? cu->getOffset() : 0));
+  if (cu_relative_offset) {
+    OS << " => {";
+    {
+      WithColor(OS, syntax::Address).get()
+        << format("0x%8.8" PRIx64, uvalue + (cu ? cu->getOffset() : 0));
+    }
+    OS << "}";
+  }
 }
 
 Optional<const char *> DWARFFormValue::getAsCString(const DWARFUnit *U) const {

lib/DebugInfo/SyntaxHighlighting.h

+//===-- SyntaxHighlighting.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_DEBUGINFO_SYNTAXHIGHLIGHTING_H
+#define LLVM_LIB_DEBUGINFO_SYNTAXHIGHLIGHTING_H
+
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace dwarf {
+namespace syntax {
+
+// Symbolic names for various syntax elements.
+enum HighlightColor { Address, String, Tag, Attribute, Enumerator };
+
+/// An RAII object that temporarily switches an output stream to a
+/// specific color.
+class WithColor {
+  llvm::raw_ostream &OS;
+
+public:
+  WithColor(llvm::raw_ostream &OS, enum HighlightColor Type);
+  ~WithColor();
+
+  llvm::raw_ostream& get() { return OS; }
+  operator llvm::raw_ostream& () { return OS; }
+};
+}
+}
+}
+
+#endif

lib/DebugInfo/SyntaxHighlighting.cpp

+//===-- SyntaxHighlighting.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SyntaxHighlighting.h"
+#include "llvm/Support/CommandLine.h"
+using namespace llvm;
+using namespace dwarf;
+using namespace syntax;
+
+static cl::opt<cl::boolOrDefault>
+    UseColor("color",
+             cl::desc("use colored syntax highlighting (default=autodetect)"),
+             cl::init(cl::BOU_UNSET));
+
+WithColor::WithColor(llvm::raw_ostream &OS, enum HighlightColor Type) : OS(OS) {
+  // Detect color from terminal type unless the user passed the --color option.
+  if (UseColor == cl::BOU_UNSET ? OS.has_colors() : UseColor == cl::BOU_TRUE) {
+    switch (Type) {
+    case Address:    OS.changeColor(llvm::raw_ostream::YELLOW);  break;
+    case String:     OS.changeColor(llvm::raw_ostream::GREEN);   break;
+    case Tag:        OS.changeColor(llvm::raw_ostream::BLUE);    break;
+    case Attribute:  OS.changeColor(llvm::raw_ostream::CYAN);    break;
+    case Enumerator: OS.changeColor(llvm::raw_ostream::MAGENTA); break;
+    }
+  }
+}
+
+WithColor::~WithColor() {
+  if (UseColor == cl::BOU_UNSET ? OS.has_colors() : UseColor == cl::BOU_TRUE)
+    OS.resetColor();
+}