[dwarfdump][NFC] Consistent printing of address ranges

[JDevlieghere]

Summary

This implement the insertion operator for DWARF address ranges so they
are consistently printed as [LowPC, HighPC).

While a dump method might have felt more consistent, it is used
exclusively for printing error messages in the verifier and never used
for actual dumping. Hence this approach is more intuitive and creates
less clutter at the call sites.

[aprantl]

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

21

I think we should use ", " instead of "- ". IMHO either it's start - end or [start, end)

[aprantl]

Otherwise this is great, thanks!

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

struct DWARFAddressRange {
   }
 };
 
 static inline bool operator<(const DWARFAddressRange &LHS,
                              const DWARFAddressRange &RHS) {
   return std::tie(LHS.LowPC, LHS.HighPC) < std::tie(RHS.LowPC, RHS.HighPC);
 }
 
+raw_ostream &operator<<(raw_ostream &OS, const DWARFAddressRange &R);
+
 /// DWARFAddressRangesVector - represents a set of absolute address ranges.
 using DWARFAddressRangesVector = std::vector<DWARFAddressRange>;
 
 class DWARFDebugRangeList {
 public:
   struct RangeListEntry {
     /// A beginning address offset. This address offset has the size of an
     /// address and is relative to the applicable base address of the

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
 #include <utility>
 
 using namespace llvm;
 
+raw_ostream &llvm::operator<<(raw_ostream &OS, const DWARFAddressRange &R) {
+  return OS << format("[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")", R.LowPC,
+                      R.HighPC);
+}
+
 void DWARFDebugRangeList::clear() {
   Offset = -1U;
   AddressSize = 0;
   Entries.clear();
 }
 
 bool DWARFDebugRangeList::extract(const DWARFDataExtractor &data,
                                   uint32_t *offset_ptr) {

lib/DebugInfo/DWARF/DWARFVerifier.cpp

unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
   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;
-      error() << format("Invalid address range [0x%08" PRIx64 " - 0x%08" PRIx64
-                        "].\n",
-                        Range.LowPC, Range.HighPC);
+      error() << "Invalid address range " << Range << "\n";
       continue;
     }
 
     // Verify that ranges don't intersect.
     const auto IntersectingRange = RI.insert(Range);
     if (IntersectingRange != RI.Ranges.end()) {
       ++NumErrors;
-      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);
+      error() << "DIE has overlapping address ranges: " << Range << " and "
+              << *IntersectingRange << "\n";
       break;
     }
   }
 
   // Verify that children don't intersect.
   const auto IntersectingChild = ParentRI.insert(RI);
   if (IntersectingChild != ParentRI.Children.end()) {
     ++NumErrors;