[Support] Move syntax highlighting into support

[JDevlieghere]

Summary

Move the DWARF syntax highlighting into support. This has several
advantages, among which the facts that this makes the WithColor RAII
wrapper available outside libDebugInfo. Furthermore, several projects
all have their own code for handling colored output. This provides a
place to centralize it and guarantees a consistent experience.

[davide]

Makes sense to me, can you do the formatting separately?

llvm/include/llvm/Support/WithColor.h

30–32

unrelated formatting change?

llvm/lib/DebugInfo/DWARF/SyntaxHighlighting.cpp

0

these formatting changes are unrelated I assume? If so, can you split?

[davide]

Marking as requested changes to get off of my queue. You can commit the formatting changes without review, then update this patch (I'll take another look).

[zturner]

This would be a good chance to change the name of SyntaxHighlighting.h to WithColor.h and similarly for the cpp. Thoughts?

[JDevlieghere]

In D44215#1030164, @davide wrote:

Makes sense to me, can you do the formatting separately?

My motivation is that I'm touching the lines anyway, so I might as well do it now.

[dblaikie]

llvm/lib/DebugInfo/DWARF/SyntaxHighlighting.cpp

0

Any interest in fixing this enum (Address/String/Tag/Attribute) to either have a prefix (HC_) or use an enum class (HighlightColor::Address, etc) in a follow-up change?

I think I wrote some code the other day where I thought I was using a variable named "Address" (wihch I'd forgotten to actually declare/initialize) but was actually using this enum constant...

[JDevlieghere]

Updated the diff with feedback Zachary & Dave. Thanks for the swift reviews!

[davide]

As discussed, given you're moving the whole file anyway, this is fine. Thanks

llvm/include/llvm/Support/WithColor.h

-//===- SyntaxHighlighting.h -------------------------------------*- C++ -*-===//
+//===- WithColor.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
+#ifndef LLVM_SUPPORT_WITHCOLOR_H
+#define LLVM_SUPPORT_WITHCOLOR_H
 
 namespace llvm {
 
 class raw_ostream;
 
-namespace dwarf {
-namespace syntax {
-
 // Symbolic names for various syntax elements.
-enum HighlightColor {
+enum class HighlightColor {
   Address,
   String,
   Tag,
   Attribute,
   Enumerator,
   Macro,
   Error,
   Warning,
   Note
 };
 
-/// An RAII object that temporarily switches an output stream to a
-/// specific color.
+/// An RAII object that temporarily switches an output stream to a specific
+/// color.
 class WithColor {
   raw_ostream &OS;
   /// Determine whether colors should be displayed.
   bool colorsEnabled(raw_ostream &OS);
 
 public:
-  /// To be used like this: WithColor(OS, syntax::String) << "text";
-  WithColor(raw_ostream &OS, enum HighlightColor Type);
+  /// To be used like this: WithColor(OS, HighlightColor::String) << "text";
+  WithColor(raw_ostream &OS, HighlightColor S);
   ~WithColor();
 
   raw_ostream &get() { return OS; }
   operator raw_ostream &() { return OS; }
 };
 
-} // end namespace syntax
-} // end namespace dwarf
-
 } // end namespace llvm
 
-#endif // LLVM_LIB_DEBUGINFO_SYNTAXHIGHLIGHTING_H
+#endif // LLVM_LIB_DEBUGINFO_WITHCOLOR_H

llvm/lib/DebugInfo/DWARF/CMakeLists.txt

add_llvm_library(LLVMDebugInfoDWARF
   DWARFDie.cpp
   DWARFExpression.cpp
   DWARFFormValue.cpp
   DWARFGdbIndex.cpp
   DWARFTypeUnit.cpp
   DWARFUnitIndex.cpp
   DWARFUnit.cpp
   DWARFVerifier.cpp
-  SyntaxHighlighting.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/DWARF
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
   )

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

 //===- DWARFDebugMacro.cpp ------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
-#include "SyntaxHighlighting.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 using namespace llvm;
 using namespace dwarf;
-using namespace syntax;
 
 void DWARFDebugMacro::dump(raw_ostream &OS) const {
   unsigned IndLevel = 0;
   for (const Entry &E : Macros) {
     // There should not be DW_MACINFO_end_file when IndLevel is Zero. However,
     // this check handles the case of corrupted ".debug_macinfo" section.
     if (IndLevel > 0)
       IndLevel -= (E.Type == DW_MACINFO_end_file);
     // Print indentation.
     for (unsigned I = 0; I < IndLevel; I++)
       OS << "  ";
     IndLevel += (E.Type == DW_MACINFO_start_file);
 
-    WithColor(OS, syntax::Macro).get() << MacinfoString(E.Type);
+    WithColor(OS, HighlightColor::Macro).get() << MacinfoString(E.Type);
     switch (E.Type) {
     default:
       // Got a corrupted ".debug_macinfo" section (invalid macinfo type).
       break;
     case DW_MACINFO_define:
     case DW_MACINFO_undef:
       OS << " - lineno: " << E.Line;
       OS << " macro: " << E.MacroStr;

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

 //===- DWARFDie.cpp -------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
-#include "SyntaxHighlighting.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <string>
 #include <utility>
 
 using namespace llvm;
 using namespace dwarf;
 using namespace object;
-using namespace syntax;
 
 static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
   OS << " (";
   do {
     uint64_t Shift = countTrailingZeros(Val);
     assert(Shift < 64 && "undefined behavior");
     uint64_t Bit = 1ULL << Shift;
     auto PropName = ApplePropertyString(Bit);
static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
                           DIDumpOptions DumpOpts) {
   if (!Die.isValid())
     return;
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
   OS.indent(Indent + 2);
   auto attrString = AttributeString(Attr);
   if (!attrString.empty())
-    WithColor(OS, syntax::Attribute) << attrString;
+    WithColor(OS, HighlightColor::Attribute) << attrString;
   else
-    WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", Attr);
+    WithColor(OS, HighlightColor::Attribute).get()
+        << format("DW_AT_Unknown_%x", Attr);
 
   if (DumpOpts.Verbose || DumpOpts.ShowForm) {
     auto formString = FormEncodingString(Form);
     if (!formString.empty())
       OS << " [" << formString << ']';
     else
       OS << format(" [DW_FORM_Unknown_%x]", Form);
   }
 
   DWARFUnit *U = Die.getDwarfUnit();
   DWARFFormValue formValue(Form);
 
   if (!formValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr,
                               U->getFormParams(), U))
     return;
 
   OS << "\t(";
 
   StringRef Name;
   std::string File;
-  auto Color = syntax::Enumerator;
+  auto Color = HighlightColor::Enumerator;
   if (Attr == DW_AT_decl_file || Attr == DW_AT_call_file) {
-    Color = syntax::String;
+    Color = HighlightColor::String;
     if (const auto *LT = U->getContext().getLineTableForUnit(U))
       if (LT->getFileNameByIndex(
               formValue.getAsUnsignedConstant().getValue(),
               U->getCompilationDir(),
               DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) {
         File = '"' + File + '"';
         Name = File;
       }
void DWARFDie::dump(raw_ostream &OS, unsigned Indent,
   if (DumpOpts.ShowParents) {
     DumpOpts.ShowParents = false;
     Indent = dumpParentChain(getParent(), OS, Indent, DumpOpts);
   }
 
   if (debug_info_data.isValidOffset(offset)) {
     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
     if (DumpOpts.ShowAddresses)
-      WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
+      WithColor(OS, HighlightColor::Address).get()
+          << format("\n0x%8.8x: ", Offset);
 
     if (abbrCode) {
       auto AbbrevDecl = getAbbreviationDeclarationPtr();
       if (AbbrevDecl) {
         auto tagString = TagString(getTag());
         if (!tagString.empty())
-          WithColor(OS, syntax::Tag).get().indent(Indent) << tagString;
+          WithColor(OS, HighlightColor::Tag).get().indent(Indent) << tagString;
         else
-          WithColor(OS, syntax::Tag).get().indent(Indent)
+          WithColor(OS, HighlightColor::Tag).get().indent(Indent)
               << format("DW_TAG_Unknown_%x", getTag());
 
         if (DumpOpts.Verbose)
           OS << format(" [%u] %c", abbrCode,
                        AbbrevDecl->hasChildren() ? '*' : ' ');
         OS << '\n';
 
         // Dump all data in the DIE for the attributes.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

 //===- DWARFFormValue.cpp -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
-#include "SyntaxHighlighting.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
 #include <limits>
 
 using namespace llvm;
 using namespace dwarf;
-using namespace syntax;
 
 static const DWARFFormValue::FormClass DWARF5FormClasses[] = {
     DWARFFormValue::FC_Unknown,  // 0x0
     DWARFFormValue::FC_Address,  // 0x01 DW_FORM_addr
     DWARFFormValue::FC_Unknown,  // 0x02 unused
     DWARFFormValue::FC_Block,    // 0x03 DW_FORM_block2
     DWARFFormValue::FC_Block,    // 0x04 DW_FORM_block4
     DWARFFormValue::FC_Constant, // 0x05 DW_FORM_data2
bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
   }
 
   return true;
 }
 
 void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   uint64_t UValue = Value.uval;
   bool CURelativeOffset = false;
-  raw_ostream &AddrOS =
-      DumpOpts.ShowAddresses ? WithColor(OS, syntax::Address).get() : nulls();
+  raw_ostream &AddrOS = DumpOpts.ShowAddresses
+                            ? WithColor(OS, HighlightColor::Address).get()
+                            : nulls();
   switch (Form) {
   case DW_FORM_addr:
     AddrOS << format("0x%016" PRIx64, UValue);
     break;
   case DW_FORM_GNU_addr_index: {
     AddrOS << format(" indexed (%8.8x) address = ", (uint32_t)UValue);
     uint64_t Address;
     if (U == nullptr)
void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   default:
     OS << format("DW_FORM(0x%4.4x)", Form);
     break;
   }
 
   if (CURelativeOffset) {
     if (DumpOpts.Verbose)
       OS << " => {";
-    WithColor(OS, syntax::Address).get()
+    WithColor(OS, HighlightColor::Address).get()
         << format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
     if (DumpOpts.Verbose)
       OS << "}";
   }
 }
 
 void DWARFFormValue::dumpString(raw_ostream &OS) const {
   Optional<const char *> DbgStr = getAsCString();
   if (DbgStr.hasValue()) {
-    auto COS = WithColor(OS, syntax::String);
+    auto COS = WithColor(OS, HighlightColor::String);
     COS.get() << '"';
     COS.get().write_escaped(DbgStr.getValue());
     COS.get() << '"';
   }
 }
 
 Optional<const char *> DWARFFormValue::getAsCString() const {
   if (!isFormClass(FC_String))

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

 //===- DWARFVerifier.cpp --------------------------------------------------===//
 //
 //                     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/DebugInfo/DWARF/DWARFVerifier.h"
+#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
-#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 using namespace object;
-using namespace syntax;
 
 DWARFVerifier::DieRangeInfo::address_range_iterator
 DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) {
   auto Begin = Ranges.begin();
   auto End = Ranges.end();
   auto Pos = std::lower_bound(Begin, End, R);
 
   if (Pos != End) {
NumErrors += verifyAppleAccelTable(&D.getAppleNamespacesSection(), &StrData,
                                   ".apple_namespaces");
   if (!D.getAppleObjCSection().Data.empty())
     NumErrors +=
         verifyAppleAccelTable(&D.getAppleObjCSection(), &StrData, ".apple_objc");
   return NumErrors == 0;
 }
 
 raw_ostream &DWARFVerifier::error() const {
-  return WithColor(OS, syntax::Error).get() << "error: ";
+  return WithColor(OS, HighlightColor::Error).get() << "error: ";
 }
 
 raw_ostream &DWARFVerifier::warn() const {
-  return WithColor(OS, syntax::Warning).get() << "warning: ";
+  return WithColor(OS, HighlightColor::Warning).get() << "warning: ";
 }
 
 raw_ostream &DWARFVerifier::note() const {
-  return WithColor(OS, syntax::Note).get() << "note: ";
+  return WithColor(OS, HighlightColor::Note).get() << "note: ";
 }

llvm/lib/DebugInfo/DWARF/SyntaxHighlighting.cpp

-//===- SyntaxHighlighting.cpp ---------------------------------------------===//
-//
-//                     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"
-#include "llvm/Support/raw_ostream.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));
-
-bool WithColor::colorsEnabled(raw_ostream &OS) {
-  if (UseColor == cl::BOU_UNSET)
-    return OS.has_colors();
-  return UseColor == cl::BOU_TRUE;
-}
-
-WithColor::WithColor(raw_ostream &OS, enum HighlightColor Type) : OS(OS) {
-  // Detect color from terminal type unless the user passed the --color option.
-  if (colorsEnabled(OS)) {
-    switch (Type) {
-    case Address:    OS.changeColor(raw_ostream::YELLOW);         break;
-    case String:     OS.changeColor(raw_ostream::GREEN);          break;
-    case Tag:        OS.changeColor(raw_ostream::BLUE);           break;
-    case Attribute:  OS.changeColor(raw_ostream::CYAN);           break;
-    case Enumerator: OS.changeColor(raw_ostream::MAGENTA);        break;
-    case Macro:      OS.changeColor(raw_ostream::RED);            break;
-    case Error:      OS.changeColor(raw_ostream::RED, true);      break;
-    case Warning:    OS.changeColor(raw_ostream::MAGENTA, true);  break;
-    case Note:       OS.changeColor(raw_ostream::BLACK, true);    break;
-    }
-  }
-}
-
-WithColor::~WithColor() {
-  if (colorsEnabled(OS))
-    OS.resetColor();
-}

llvm/lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   ThreadPool.cpp
   Timer.cpp
   ToolOutputFile.cpp
   TrigramIndex.cpp
   Triple.cpp
   Twine.cpp
   Unicode.cpp
   UnicodeCaseFold.cpp
+  WithColor.cpp
   YAMLParser.cpp
   YAMLTraits.cpp
   raw_os_ostream.cpp
   raw_ostream.cpp
   regcomp.c
   regerror.c
   regexec.c
   regfree.c

llvm/lib/Support/WithColor.cpp

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