[dwarfdump][NFC] Consistent errors and warnings with --verify

[JDevlieghere]

Summary

This patch introduces 3 helper functions: error(), warn() and note() to
make printing during verification more consistent. When supported, the
respective prefixes are printed in color using the same color scheme as
clang.

[JDevlieghere]

I opted for this approach rather than passing a Twine to an error/warn function because of format objects.

[aprantl]

Sweet.
And then we can add color (using the same color scheme as clang with -fcolor-diagnostics) when printing to a real TTY (there already is code in dwarfdump to detect this).

Are there errors/warnings outside of DWARFVerifier.cpp, too?

lib/DebugInfo/DWARF/DWARFVerifier.cpp

154 ↗

(On Diff #117011)

in the compiler we often prefix additional comments with note: . Should we do this here, too? (with a note() << function?

[JDevlieghere]

• Feedback Adrian
• Add color
• Add note()

[aprantl]

Thanks!

lib/DebugInfo/DWARF/DWARFVerifier.cpp

328 ↗

(On Diff #117017)

This doesn't belong in this review, but I just noticed that we also should define a similar helper for formatting a range. I think at some point we all agreed that half-open ranges should be formatted [start,end).

test/tools/llvm-dwarfdump/X86/verify_unit_header_chain.s

7 ↗

(On Diff #117017)

extra whitespace

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

private:
   DWARFContext &DCtx;
   DIDumpOptions DumpOpts;
   /// A map that tracks all references (converted absolute references) so we
   /// can verify each reference points to a valid DIE and not an offset that
   /// lies between to valid DIEs.
   std::map<uint64_t, std::set<uint32_t>> ReferenceToDIEOffsets;
   uint32_t NumDebugLineErrors = 0;
 
+  raw_ostream &error() const;
+  raw_ostream &warn() const;
+  raw_ostream &note() const;
+
   /// Verifies the abbreviations section.
   ///
   /// This function currently checks that:
   /// --No abbreviation declaration has more than one attributes with the same
   /// name.
   ///
   /// \param Abbrev Pointer to the abbreviations section we are verifying
   /// Abbrev can be a pointer to either .debug_abbrev or debug_abbrev.dwo.

llvm/trunk/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/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.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) {
if (!DCtx.getDebugAbbrev()->getAbbreviationDeclarationSet(AbbrOffset))
     ValidAbbrevOffset = false;
 
   ValidLength = DebugInfoData.isValidOffset(OffsetStart + Length + 3);
   ValidVersion = DWARFContext::isSupportedVersion(Version);
   ValidAddrSize = AddrSize == 4 || AddrSize == 8;
   if (!ValidLength || !ValidVersion || !ValidAddrSize || !ValidAbbrevOffset ||
       !ValidType) {
     Success = false;
-    OS << format("Units[%d] - start offset: 0x%08x \n", UnitIndex, OffsetStart);
+    error() << format("Units[%d] - start offset: 0x%08x \n", UnitIndex,
+                      OffsetStart);
     if (!ValidLength)
-      OS << "\tError: The length for this unit is too "
+      note() << "The length for this unit is too "
             "large for the .debug_info provided.\n";
     if (!ValidVersion)
-      OS << "\tError: The 16 bit unit header version is not valid.\n";
+      note() << "The 16 bit unit header version is not valid.\n";
     if (!ValidType)
-      OS << "\tError: The unit type encoding is not valid.\n";
+      note() << "The unit type encoding is not valid.\n";
     if (!ValidAbbrevOffset)
-      OS << "\tError: The offset into the .debug_abbrev section is "
+      note() << "The offset into the .debug_abbrev section is "
             "not valid.\n";
     if (!ValidAddrSize)
-      OS << "\tError: The address size is unsupported.\n";
+      note() << "The address size is unsupported.\n";
   }
   *Offset = OffsetStart + Length + 4;
   return Success;
 }
 
 bool DWARFVerifier::verifyUnitContents(DWARFUnit Unit) {
   uint32_t NumUnitErrors = 0;
   unsigned NumDies = Unit.getNumDIEs();
   for (unsigned I = 0; I < NumDies; ++I) {
     auto Die = Unit.getDIEAtIndex(I);
     if (Die.getTag() == DW_TAG_null)
       continue;
     for (auto AttrValue : Die.attributes()) {
       NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue);
       NumUnitErrors += verifyDebugInfoForm(Die, AttrValue);
     }
   }
 
   if (DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false)) {
     DieRangeInfo RI;
     NumUnitErrors += verifyDieRanges(Die, RI);
   } else {
-    OS << "error: Compilation unit without unit DIE.\n";
+    error() << "Compilation unit without unit DIE.\n";
     NumUnitErrors++;
   }
 
   return NumUnitErrors == 0;
 }
 
 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
   unsigned NumErrors = 0;
   if (Abbrev) {
     const DWARFAbbreviationDeclarationSet *AbbrDecls =
         Abbrev->getAbbreviationDeclarationSet(0);
     for (auto AbbrDecl : *AbbrDecls) {
       SmallDenseSet<uint16_t> AttributeSet;
       for (auto Attribute : AbbrDecl.attributes()) {
         auto Result = AttributeSet.insert(Attribute.Attr);
         if (!Result.second) {
-          OS << "Error: Abbreviation declaration contains multiple "
+          error() << "Abbreviation declaration contains multiple "
                   << AttributeString(Attribute.Attr) << " attributes.\n";
           AbbrDecl.dump(OS);
           ++NumErrors;
         }
       }
     }
   }
   return NumErrors;
 }
if (!verifyUnitHeader(DebugInfoData, &Offset, UnitIdx, UnitType,
       Unit->extract(DebugInfoData, &OffsetStart);
       if (!verifyUnitContents(*Unit))
         ++NumDebugInfoErrors;
     }
     hasDIE = DebugInfoData.isValidOffset(Offset);
     ++UnitIdx;
   }
   if (UnitIdx == 0 && !hasDIE) {
-    OS << "Warning: .debug_info is empty.\n";
+    warn() << ".debug_info is empty.\n";
     isHeaderChainValid = true;
   }
   NumDebugInfoErrors += verifyDebugInfoReferences();
   return (isHeaderChainValid && NumDebugInfoErrors == 0);
 }
 
 unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
                                         DieRangeInfo &ParentRI) {
   unsigned NumErrors = 0;
 
   if (!Die.isValid())
     return NumErrors;
 
   DWARFAddressRangesVector Ranges = Die.getAddressRanges();
 
   // Build RI for this DIE and check that ranges within this DIE do not
   // overlap.
   DieRangeInfo RI(Die);
   for (auto Range : Ranges) {
     if (!Range.valid()) {
       ++NumErrors;
-      OS << format("error: Invalid address range [0x%08" PRIx64
-                   " - 0x%08" PRIx64 "].\n",
+      error() << format("Invalid address range [0x%08" PRIx64 " - 0x%08" PRIx64
+                        "].\n",
                         Range.LowPC, Range.HighPC);
       continue;
     }
 
     // Verify that ranges don't intersect.
     const auto IntersectingRange = RI.insert(Range);
     if (IntersectingRange != RI.Ranges.end()) {
       ++NumErrors;
-      OS << format("error: DIE has overlapping address ranges: [0x%08" PRIx64
-                   " - 0x%08" PRIx64 "] and [0x%08" PRIx64 " - 0x%08" PRIx64
-                   "].\n",
+      error() << format("DIE has overlapping address ranges: [0x%08" PRIx64
+                        " - 0x%08" PRIx64 "] and [0x%08" PRIx64
+                        " - 0x%08" PRIx64 "].\n",
                         Range.LowPC, Range.HighPC, IntersectingRange->LowPC,
                         IntersectingRange->HighPC);
       break;
     }
   }
 
   // Verify that children don't intersect.
   const auto IntersectingChild = ParentRI.insert(RI);
   if (IntersectingChild != ParentRI.Children.end()) {
     ++NumErrors;
-    OS << "error: DIEs have overlapping address ranges:";
+    error() << "DIEs have overlapping address ranges:";
     Die.dump(OS, 0);
     IntersectingChild->Die.dump(OS, 0);
     OS << "\n";
   }
 
   // Verify that ranges are contained within their parent.
   bool ShouldBeContained = !Ranges.empty() && !ParentRI.Ranges.empty() &&
                            !(Die.getTag() == DW_TAG_subprogram &&
                              ParentRI.Die.getTag() == DW_TAG_subprogram);
   if (ShouldBeContained && !ParentRI.contains(RI)) {
     ++NumErrors;
-    OS << "error: DIE address ranges are not "
+    error() << "DIE address ranges are not "
                "contained in its parent's ranges:";
     Die.dump(OS, 0);
     ParentRI.Die.dump(OS, 0);
     OS << "\n";
   }
 
   // Recursively check children.
   for (DWARFDie Child : Die)
     NumErrors += verifyDieRanges(Child, RI);
 
   return NumErrors;
 }
 
 unsigned DWARFVerifier::verifyDebugInfoAttribute(const DWARFDie &Die,
                                                  DWARFAttribute &AttrValue) {
   const DWARFObject &DObj = DCtx.getDWARFObj();
   unsigned NumErrors = 0;
   const auto Attr = AttrValue.Attr;
   switch (Attr) {
   case DW_AT_ranges:
     // Make sure the offset in the DW_AT_ranges attribute is valid.
     if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
       if (*SectionOffset >= DObj.getRangeSection().Data.size()) {
         ++NumErrors;
-        OS << "error: DW_AT_ranges offset is beyond .debug_ranges "
+        error() << "DW_AT_ranges offset is beyond .debug_ranges "
                    "bounds:\n";
         Die.dump(OS, 0, DumpOpts);
         OS << "\n";
       }
     } else {
       ++NumErrors;
-      OS << "error: DIE has invalid DW_AT_ranges encoding:\n";
+      error() << "DIE has invalid DW_AT_ranges encoding:\n";
       Die.dump(OS, 0, DumpOpts);
       OS << "\n";
     }
     break;
   case DW_AT_stmt_list:
     // Make sure the offset in the DW_AT_stmt_list attribute is valid.
     if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
       if (*SectionOffset >= DObj.getLineSection().Data.size()) {
         ++NumErrors;
-        OS << "error: DW_AT_stmt_list offset is beyond .debug_line "
+        error() << "DW_AT_stmt_list offset is beyond .debug_line "
                    "bounds: "
                 << format("0x%08" PRIx64, *SectionOffset) << "\n";
         Die.dump(OS, 0, DumpOpts);
         OS << "\n";
       }
     } else {
       ++NumErrors;
-      OS << "error: DIE has invalid DW_AT_stmt_list encoding:\n";
+      error() << "DIE has invalid DW_AT_stmt_list encoding:\n";
       Die.dump(OS, 0, DumpOpts);
       OS << "\n";
     }
     break;
 
   default:
     break;
   }
case DW_FORM_ref_udata: {
     Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
     assert(RefVal);
     if (RefVal) {
       auto DieCU = Die.getDwarfUnit();
       auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset();
       auto CUOffset = AttrValue.Value.getRawUValue();
       if (CUOffset >= CUSize) {
         ++NumErrors;
-        OS << "error: " << FormEncodingString(Form) << " CU offset "
+        error() << FormEncodingString(Form) << " CU offset "
                 << format("0x%08" PRIx64, CUOffset)
                 << " is invalid (must be less than CU size of "
                 << format("0x%08" PRIx32, CUSize) << "):\n";
         Die.dump(OS, 0, DumpOpts);
         OS << "\n";
       } else {
         // Valid reference, but we will verify it points to an actual
         // DIE later.
         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
       }
     }
     break;
   }
   case DW_FORM_ref_addr: {
     // Verify all absolute DIE references have valid offsets in the
     // .debug_info section.
     Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
     assert(RefVal);
     if (RefVal) {
       if (*RefVal >= DObj.getInfoSection().Data.size()) {
         ++NumErrors;
-        OS << "error: DW_FORM_ref_addr offset beyond .debug_info "
+        error() << "DW_FORM_ref_addr offset beyond .debug_info "
                    "bounds:\n";
         Die.dump(OS, 0, DumpOpts);
         OS << "\n";
       } else {
         // Valid reference, but we will verify it points to an actual
         // DIE later.
         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
       }
     }
     break;
   }
   case DW_FORM_strp: {
     auto SecOffset = AttrValue.Value.getAsSectionOffset();
     assert(SecOffset); // DW_FORM_strp is a section offset.
     if (SecOffset && *SecOffset >= DObj.getStringSection().size()) {
       ++NumErrors;
-      OS << "error: DW_FORM_strp offset beyond .debug_str bounds:\n";
+      error() << "DW_FORM_strp offset beyond .debug_str bounds:\n";
       Die.dump(OS, 0, DumpOpts);
       OS << "\n";
     }
     break;
   }
   default:
     break;
   }
   return NumErrors;
 }
 
 unsigned DWARFVerifier::verifyDebugInfoReferences() {
   // Take all references and make sure they point to an actual DIE by
   // getting the DIE by offset and emitting an error
   OS << "Verifying .debug_info references...\n";
   unsigned NumErrors = 0;
   for (auto Pair : ReferenceToDIEOffsets) {
     auto Die = DCtx.getDIEForOffset(Pair.first);
     if (Die)
       continue;
     ++NumErrors;
-    OS << "error: invalid DIE reference " << format("0x%08" PRIx64, Pair.first)
+    error() << "invalid DIE reference " << format("0x%08" PRIx64, Pair.first)
             << ". Offset is in between DIEs:\n";
     for (auto Offset : Pair.second) {
       auto ReferencingDie = DCtx.getDIEForOffset(Offset);
       ReferencingDie.dump(OS, 0, DumpOpts);
       OS << "\n";
     }
     OS << "\n";
   }
   return NumErrors;
for (const auto &CU : DCtx.compile_units()) {
     auto StmtSectionOffset = toSectionOffset(Die.find(DW_AT_stmt_list));
     if (!StmtSectionOffset)
       continue;
     const uint32_t LineTableOffset = *StmtSectionOffset;
     auto LineTable = DCtx.getLineTableForUnit(CU.get());
     if (LineTableOffset < DCtx.getDWARFObj().getLineSection().Data.size()) {
       if (!LineTable) {
         ++NumDebugLineErrors;
-        OS << "error: .debug_line[" << format("0x%08" PRIx32, LineTableOffset)
+        error() << ".debug_line[" << format("0x%08" PRIx32, LineTableOffset)
                 << "] was not able to be parsed for CU:\n";
         Die.dump(OS, 0, DumpOpts);
         OS << '\n';
         continue;
       }
     } else {
       // Make sure we don't get a valid line table back if the offset is wrong.
       assert(LineTable == nullptr);
       // Skip this line table as it isn't valid. No need to create an error
       // here because we validate this in the .debug_info verifier.
       continue;
     }
     auto Iter = StmtListToDie.find(LineTableOffset);
     if (Iter != StmtListToDie.end()) {
       ++NumDebugLineErrors;
-      OS << "error: two compile unit DIEs, "
+      error() << "two compile unit DIEs, "
               << format("0x%08" PRIx32, Iter->second.getOffset()) << " and "
               << format("0x%08" PRIx32, Die.getOffset())
               << ", have the same DW_AT_stmt_list section offset:\n";
       Iter->second.dump(OS, 0, DumpOpts);
       Die.dump(OS, 0, DumpOpts);
       OS << '\n';
       // Already verified this line table before, no need to do it again.
       continue;
     }
     StmtListToDie[LineTableOffset] = Die;
   }
for (const auto &CU : DCtx.compile_units()) {
     uint32_t MaxFileIndex = LineTable->Prologue.FileNames.size();
     uint32_t MaxDirIndex = LineTable->Prologue.IncludeDirectories.size();
     uint32_t FileIndex = 1;
     StringMap<uint16_t> FullPathMap;
     for (const auto &FileName : LineTable->Prologue.FileNames) {
       // Verify directory index.
       if (FileName.DirIdx > MaxDirIndex) {
         ++NumDebugLineErrors;
-        OS << "error: .debug_line["
+        error() << ".debug_line["
                 << format("0x%08" PRIx64,
                           *toSectionOffset(Die.find(DW_AT_stmt_list)))
                 << "].prologue.file_names[" << FileIndex
                 << "].dir_idx contains an invalid index: " << FileName.DirIdx
                 << "\n";
       }
 
       // Check file paths for duplicates.
       std::string FullPath;
       const bool HasFullPath = LineTable->getFileNameByIndex(
           FileIndex, CU->getCompilationDir(),
           DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FullPath);
       assert(HasFullPath && "Invalid index?");
       (void)HasFullPath;
       auto It = FullPathMap.find(FullPath);
       if (It == FullPathMap.end())
         FullPathMap[FullPath] = FileIndex;
       else if (It->second != FileIndex) {
-        OS << "warning: .debug_line["
+        warn() << ".debug_line["
                << format("0x%08" PRIx64,
                          *toSectionOffset(Die.find(DW_AT_stmt_list)))
                << "].prologue.file_names[" << FileIndex
                << "] is a duplicate of file_names[" << It->second << "]\n";
       }
 
       FileIndex++;
     }
 
     // Verify rows.
     uint64_t PrevAddress = 0;
     uint32_t RowIndex = 0;
     for (const auto &Row : LineTable->Rows) {
       // Verify row address.
       if (Row.Address < PrevAddress) {
         ++NumDebugLineErrors;
-        OS << "error: .debug_line["
+        error() << ".debug_line["
                 << format("0x%08" PRIx64,
                           *toSectionOffset(Die.find(DW_AT_stmt_list)))
                 << "] row[" << RowIndex
                 << "] decreases in address from previous row:\n";
 
         DWARFDebugLine::Row::dumpTableHeader(OS);
         if (RowIndex > 0)
           LineTable->Rows[RowIndex - 1].dump(OS);
         Row.dump(OS);
         OS << '\n';
       }
 
       // Verify file index.
       if (Row.File > MaxFileIndex) {
         ++NumDebugLineErrors;
-        OS << "error: .debug_line["
+        error() << ".debug_line["
                 << format("0x%08" PRIx64,
                           *toSectionOffset(Die.find(DW_AT_stmt_list)))
                 << "][" << RowIndex << "] has invalid file index " << Row.File
                 << " (valid values are [1," << MaxFileIndex << "]):\n";
         DWARFDebugLine::Row::dumpTableHeader(OS);
         Row.dump(OS);
         OS << '\n';
       }
       if (Row.EndSequence)
         PrevAddress = 0;
       else
         PrevAddress = Row.Address;
unsigned DWARFVerifier::verifyAccelTable(const DWARFSection *AccelSection,
                                          DataExtractor *StrData,
                                          const char *SectionName) {
   unsigned NumErrors = 0;
   DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), *AccelSection,
                                       DCtx.isLittleEndian(), 0);
   DWARFAcceleratorTable AccelTable(AccelSectionData, *StrData);
 
   OS << "Verifying " << SectionName << "...\n";
-  // Verify that the fixed part of the header is not too short.
 
+  // Verify that the fixed part of the header is not too short.
   if (!AccelSectionData.isValidOffset(AccelTable.getSizeHdr())) {
-    OS << "\terror: Section is too small to fit a section header.\n";
+    error() << "Section is too small to fit a section header.\n";
     return 1;
   }
+
   // Verify that the section is not too short.
   if (!AccelTable.extract()) {
-    OS << "\terror: Section is smaller than size described in section header.\n";
+    error() << "Section is smaller than size described in section header.\n";
     return 1;
   }
+
   // Verify that all buckets have a valid hash index or are empty.
   uint32_t NumBuckets = AccelTable.getNumBuckets();
   uint32_t NumHashes = AccelTable.getNumHashes();
 
   uint32_t BucketsOffset =
       AccelTable.getSizeHdr() + AccelTable.getHeaderDataLength();
   uint32_t HashesBase = BucketsOffset + NumBuckets * 4;
   uint32_t OffsetsBase = HashesBase + NumHashes * 4;
   for (uint32_t BucketIdx = 0; BucketIdx < NumBuckets; ++BucketIdx) {
     uint32_t HashIdx = AccelSectionData.getU32(&BucketsOffset);
     if (HashIdx >= NumHashes && HashIdx != UINT32_MAX) {
-      OS << format("\terror: Bucket[%d] has invalid hash index: %u.\n", BucketIdx,
+      error() << format("Bucket[%d] has invalid hash index: %u.\n", BucketIdx,
                         HashIdx);
       ++NumErrors;
     }
   }
   uint32_t NumAtoms = AccelTable.getAtomsDesc().size();
   if (NumAtoms == 0) {
-    OS << "\terror: no atoms; failed to read HashData.\n";
+    error() << "No atoms: failed to read HashData.\n";
     return 1;
   }
   if (!AccelTable.validateForms()) {
-    OS << "\terror: unsupported form; failed to read HashData.\n";
+    error() << "Unsupported form: failed to read HashData.\n";
     return 1;
   }
 
   for (uint32_t HashIdx = 0; HashIdx < NumHashes; ++HashIdx) {
     uint32_t HashOffset = HashesBase + 4 * HashIdx;
     uint32_t DataOffset = OffsetsBase + 4 * HashIdx;
     uint32_t Hash = AccelSectionData.getU32(&HashOffset);
     uint32_t HashDataOffset = AccelSectionData.getU32(&DataOffset);
     if (!AccelSectionData.isValidOffsetForDataOfSize(HashDataOffset,
                                                      sizeof(uint64_t))) {
-      OS << format("\terror: Hash[%d] has invalid HashData offset: 0x%08x.\n",
+      error() << format("Hash[%d] has invalid HashData offset: 0x%08x.\n",
                         HashIdx, HashDataOffset);
       ++NumErrors;
     }
 
     uint32_t StrpOffset;
     uint32_t StringOffset;
     uint32_t StringCount = 0;
     unsigned Offset;
     unsigned Tag;
     while ((StrpOffset = AccelSectionData.getU32(&HashDataOffset)) != 0) {
       const uint32_t NumHashDataObjects =
           AccelSectionData.getU32(&HashDataOffset);
       for (uint32_t HashDataIdx = 0; HashDataIdx < NumHashDataObjects;
            ++HashDataIdx) {
         std::tie(Offset, Tag) = AccelTable.readAtoms(HashDataOffset);
         auto Die = DCtx.getDIEForOffset(Offset);
         if (!Die) {
           const uint32_t BucketIdx =
               NumBuckets ? (Hash % NumBuckets) : UINT32_MAX;
           StringOffset = StrpOffset;
           const char *Name = StrData->getCStr(&StringOffset);
           if (!Name)
             Name = "<NULL>";
 
-          OS << format(
-              "\terror: %s Bucket[%d] Hash[%d] = 0x%08x "
+          error() << format(
+              "%s Bucket[%d] Hash[%d] = 0x%08x "
               "Str[%u] = 0x%08x "
               "DIE[%d] = 0x%08x is not a valid DIE offset for \"%s\".\n",
               SectionName, BucketIdx, HashIdx, Hash, StringCount, StrpOffset,
               HashDataIdx, Offset, Name);
 
           ++NumErrors;
           continue;
         }
         if ((Tag != dwarf::DW_TAG_null) && (Die.getTag() != Tag)) {
-          OS << "\terror: Tag " << dwarf::TagString(Tag)
+          error() << "Tag " << dwarf::TagString(Tag)
                   << " in accelerator table does not match Tag "
                   << dwarf::TagString(Die.getTag()) << " of DIE[" << HashDataIdx
                   << "].\n";
           ++NumErrors;
         }
       }
       ++StringCount;
     }
   }
   return NumErrors;
 }
bool DWARFVerifier::handleAccelTables() {
   if (!D.getAppleNamespacesSection().Data.empty())
     NumErrors += verifyAccelTable(&D.getAppleNamespacesSection(), &StrData,
                                   ".apple_namespaces");
   if (!D.getAppleObjCSection().Data.empty())
     NumErrors +=
         verifyAccelTable(&D.getAppleObjCSection(), &StrData, ".apple_objc");
   return NumErrors == 0;
 }
+
+raw_ostream &DWARFVerifier::error() const {
+  return WithColor(OS, syntax::Error).get() << "error: ";
+}
+
+raw_ostream &DWARFVerifier::warn() const {
+  return WithColor(OS, syntax::Warning).get() << "warning: ";
+}
+
+raw_ostream &DWARFVerifier::note() const {
+  return WithColor(OS, syntax::Note).get() << "note: ";
+}

llvm/trunk/lib/DebugInfo/DWARF/SyntaxHighlighting.h

 namespace llvm {
 
 class raw_ostream;
 
 namespace dwarf {
 namespace syntax {
 
 // Symbolic names for various syntax elements.
-enum HighlightColor { Address, String, Tag, Attribute, Enumerator, Macro };
+enum HighlightColor {
+  Address,
+  String,
+  Tag,
+  Attribute,
+  Enumerator,
+  Macro,
+  Error,
+  Warning,
+  Note
+};
 
 /// An RAII object that temporarily switches an output stream to a
 /// specific color.
 class WithColor {
   raw_ostream &OS;
 
 public:
   /// To be used like this: WithColor(OS, syntax::String) << "text";
   WithColor(raw_ostream &OS, enum HighlightColor Type);
   ~WithColor();
 
-  raw_ostream& get() { return OS; }
-  operator raw_ostream& () { return OS; }
+  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

llvm/trunk/lib/DebugInfo/DWARF/SyntaxHighlighting.cpp

static cl::opt<cl::boolOrDefault>
     UseColor("color",
              cl::desc("use colored syntax highlighting (default=autodetect)"),
              cl::init(cl::BOU_UNSET));
 
 WithColor::WithColor(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(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 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 (UseColor == cl::BOU_UNSET ? OS.has_colors() : UseColor == cl::BOU_TRUE)
     OS.resetColor();
 }

llvm/trunk/test/tools/llvm-dwarfdump/X86/apple_names_verify_form.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN: | not llvm-dwarfdump -verify - \
 # RUN: | FileCheck %s
 
 # CHECK: Verifying .apple_names...
-# CHECK-NEXT: error: unsupported form; failed to read HashData.
+# CHECK-NEXT: error: Unsupported form: failed to read HashData.
 
-# This test is meant to verify that the -verify option 
+# This test is meant to verify that the -verify option
 # in llvm-dwarfdump, correctly identifies that Atom[0].form is unsupported.
 # As a result, the hashdata cannot be read.
 
   .section  __TEXT,__text,regular,pure_instructions
   .file 1 "basic.c"
   .comm _i,4,2                  ## @i
   .comm _j,4,2                  ## @j
   .section  __DWARF,__debug_str,regular,debug

llvm/trunk/test/tools/llvm-dwarfdump/X86/apple_names_verify_num_atoms.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN: | not llvm-dwarfdump -verify - \
 # RUN: | FileCheck %s
 
 # CHECK: Verifying .apple_names...
-# CHECK-NEXT: error: no atoms; failed to read HashData.
+# CHECK-NEXT: error: No atoms: failed to read HashData.
 
-# This test is meant to verify that the -verify option 
+# This test is meant to verify that the -verify option
 # in llvm-dwarfdump, correctly identifies that there is not Atom.
 # As a result, the hashdata cannot be read.
 
   .section  __TEXT,__text,regular,pure_instructions
   .file 1 "basic.c"
   .comm _i,4,2                  ## @i
   .comm _j,4,2                  ## @j
   .section  __DWARF,__debug_str,regular,debug
 Linfo_string:
   .asciz  "Apple LLVM version 8.1.0 (clang-802.0.35)" ## string offset=0
   .asciz  "basic.c"               ## string offset=42
   .asciz  "/Users/sgravani/Development/tests" ## string offset=50
   .asciz  "i"                     ## string offset=84
   .asciz  "int"                   ## string offset=86
   .asciz  "j"                     ## string offset=90
-  
   .section  __DWARF,__debug_info,regular,debug
 Lsection_info:
   .section  __DWARF,__apple_names,regular,debug
 Lnames_begin:
   .long 1212240712              ## Header Magic
   .short  1                       ## Header Version
   .short  0                       ## Header Hash Function
   .long 2                       ## Header Bucket Count

llvm/trunk/test/tools/llvm-dwarfdump/X86/verify_debug_abbrev.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-unknown-linux-gnu -o - \
 # RUN: | not llvm-dwarfdump -verify - \
 # RUN: | FileCheck %s
 
 # CHECK: Verifying .debug_abbrev...
-# CHECK-NEXT: Error: Abbreviation declaration contains multiple DW_AT_stmt_list attributes.
+# CHECK-NEXT: error: Abbreviation declaration contains multiple DW_AT_stmt_list attributes.
 # CHECK-NEXT:[1] DW_TAG_compile_unit  DW_CHILDREN_no
 # CHECK-NEXT: DW_AT_stmt_list DW_FORM_sec_offset
 # CHECK-NEXT: DW_AT_GNU_dwo_name  DW_FORM_strp
 # CHECK-NEXT: DW_AT_stmt_list DW_FORM_strp{{[[:space:]]}}
-# CHECK-NEXT: Error: Abbreviation declaration contains multiple DW_AT_producer attributes.
+# CHECK-NEXT: error: Abbreviation declaration contains multiple DW_AT_producer attributes.
 # CHECK-NEXT:[1] DW_TAG_compile_unit  DW_CHILDREN_yes
 # CHECK-NEXT: DW_AT_GNU_dwo_name  DW_FORM_GNU_str_index
 # CHECK-NEXT: DW_AT_producer  DW_FORM_GNU_str_index
 # CHECK-NEXT: DW_AT_producer  DW_FORM_data2
 
 
   .section  .debug_abbrev,"",@progbits
   .byte  1                       # Abbreviation Code

llvm/trunk/test/tools/llvm-dwarfdump/X86/verify_debug_info.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN: | not llvm-dwarfdump -v -verify - \
 # RUN: | FileCheck %s
 
 # CHECK: error: DIE has invalid DW_AT_stmt_list encoding:{{[[:space:]]}}
 # CHECK-NEXT: 0x0000000c: DW_TAG_compile_unit [1] *
 # CHECK-NEXT: DW_AT_producer [DW_FORM_strp] ( .debug_str[0x00000000] = "clang version 5.0.0 (trunk 308185) (llvm/trunk 308186)")
 # CHECK-NEXT: DW_AT_language [DW_FORM_data2]  (DW_LANG_C99)
 # CHECK-NEXT: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000037] = "basic.c")
 # CHECK-NEXT: DW_AT_stmt_list [DW_FORM_strx4] ( indexed (00000000) string = )
 # CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strp] ( .debug_str[0x0000003f] = "/Users/sgravani/Development/tests")
 # CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # CHECK-NEXT: DW_AT_high_pc [DW_FORM_data4] (0x00000016){{[[:space:]]}}
-# CHECK-NEXT: Units[2] - start offset: 0x00000068
-# CHECK-NEXT: Error: The length for this unit is too large for the .debug_info provided.
-# CHECK-NEXT: Error: The unit type encoding is not valid.
+# CHECK-NEXT: error: Units[2] - start offset: 0x00000068
+# CHECK-NEXT: note: The length for this unit is too large for the .debug_info provided.
+# CHECK-NEXT: note: The unit type encoding is not valid.
 
 
   .section  __TEXT,__text,regular,pure_instructions
   .globl  _main                   ## -- Begin function main
   .p2align  4, 0x90
 _main:                                  ## @main
 Lfunc_begin0:
   .file 1 "basic.c"

llvm/trunk/test/tools/llvm-dwarfdump/X86/verify_unit_header_chain.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN: | not llvm-dwarfdump -verify - \
 # RUN: | FileCheck %s
 
 # CHECK: Verifying .debug_info Unit Header Chain...
-# CHECK-NEXT: Units[1] - start offset: 0x0000000d 
-# CHECK-NEXT:   Error: The unit type encoding is not valid.
-# CHECK-NEXT:   Error: The address size is unsupported.
-# CHECK-NEXT: Units[2] - start offset: 0x00000026 
-# CHECK-NEXT:   Error: The 16 bit unit header version is not valid.
-# CHECK-NEXT:   Error: The offset into the .debug_abbrev section is not valid.
-# CHECK-NEXT: Units[4] - start offset: 0x00000041 
-# CHECK-NEXT:   Error: The length for this unit is too large for the .debug_info provided.
+# CHECK-NEXT: error: Units[1] - start offset: 0x0000000d
+# CHECK-NEXT: note: The unit type encoding is not valid.
+# CHECK-NEXT: note: The address size is unsupported.
+# CHECK-NEXT: error: Units[2] - start offset: 0x00000026
+# CHECK-NEXT: note: The 16 bit unit header version is not valid.
+# CHECK-NEXT: note: The offset into the .debug_abbrev section is not valid.
+# CHECK-NEXT: error: Units[4] - start offset: 0x00000041
+# CHECK-NEXT: note: The length for this unit is too large for the .debug_info provided.
 
   .section  __TEXT,__text,regular,pure_instructions
   .file 1 "basic.c"
   .comm _i,4,2                  ## @i
   .comm _j,4,2                  ## @j
   .section  __DWARF,__debug_str,regular,debug
 Linfo_string:
   .asciz  "clang version 5.0.0 (trunk 307232) (llvm/trunk 307042)" ## string offset=0

 Ltu_begin1:
   .long 26                      ## Length of Unit -- Error: The length for this unit is too large for the .debug_info provided.
   .short  5                       ## DWARF version number
   .byte 2                       ## DWARF Unit Type
   .byte 4                       ## Address Size (in bytes)
   .long 0
   .quad 0
   .long   0
-  .byte   0   
+  .byte   0
 
 .subsections_via_symbols
   .section  __DWARF,__debug_line,regular,debug
 Lsection_line:
 Lline_table_start0: