[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

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

326–330

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

extra whitespace

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 { return OS << "error: "; }
+  raw_ostream &warning() const { return OS << "warning: "; }
+
   /// 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.

lib/DebugInfo/DWARF/DWARFVerifier.cpp

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 "
+      OS << "\tThe 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";
+      OS << "\tThe 16 bit unit header version is not valid.\n";
     if (!ValidType)
-      OS << "\tError: The unit type encoding is not valid.\n";
+      OS << "\tThe unit type encoding is not valid.\n";
     if (!ValidAbbrevOffset)
-      OS << "\tError: The offset into the .debug_abbrev section is "
+      OS << "\tThe offset into the .debug_abbrev section is "
             "not valid.\n";
     if (!ValidAddrSize)
-      OS << "\tError: The address size is unsupported.\n";
+      OS << "\t: 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";
+    warning() << ".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["
+        warning() << ".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;
 }

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

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

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

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: The length for this unit is too large for the .debug_info provided.
+# CHECK-NEXT: 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"

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:   The unit type encoding is not valid.
+# CHECK-NEXT:   The address size is unsupported.
+# CHECK-NEXT: error: Units[2] - start offset: 0x00000026
+# CHECK-NEXT:   The 16 bit unit header version is not valid.
+# CHECK-NEXT:   The offset into the .debug_abbrev section is not valid.
+# CHECK-NEXT: error: Units[4] - start offset: 0x00000041
+# CHECK-NEXT:   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: