[DebugInfo] Use "an address table" in diagnostic messages of DWARFDebugAddr.

[ikudrin]

Summary

This is an extract from D74196, according to @dblaikie's suggestion.

This replaces a collocation "a .debug_addr table" with "an address table" because the latter sounds more accurate.

[jhenderson]

LGTM.

llvm/lib/DebugInfo/DWARF/DWARFDebugAddr.cpp

Error DWARFDebugAddrTable::extract(DWARFDataExtractor Data,
                                    uint16_t Version,
                                    uint8_t AddrSize,
                                    std::function<void(Error)> WarnCallback) {
   clear();
   HeaderOffset = *OffsetPtr;
   // Read and verify the length field.
   if (!Data.isValidOffsetForDataOfSize(*OffsetPtr, sizeof(uint32_t)))
     return createStringError(errc::invalid_argument,
-                       "section is not large enough to contain a "
-                       ".debug_addr table length at offset 0x%"
+                       "section is not large enough to contain an "
+                       "address table length at offset 0x%"
                        PRIx64, *OffsetPtr);
   uint16_t UnitVersion;
   if (Version == 0) {
     WarnCallback(createStringError(errc::invalid_argument,
                        "DWARF version is not defined in CU,"
                        " assuming version 5"));
     UnitVersion = 5;
   } else {
     UnitVersion = Version;
   }
   // TODO: Add support for DWARF64.
   Format = dwarf::DwarfFormat::DWARF32;
   if (UnitVersion >= 5) {
     HeaderData.Length = Data.getU32(OffsetPtr);
     if (HeaderData.Length == dwarf::DW_LENGTH_DWARF64) {
       invalidateLength();
       return createStringError(errc::not_supported,
           "DWARF64 is not supported in .debug_addr at offset 0x%" PRIx64,
           HeaderOffset);
     }
     if (HeaderData.Length + sizeof(uint32_t) < sizeof(Header)) {
       uint32_t TmpLength = getLength();
       invalidateLength();
       return createStringError(errc::invalid_argument,
-                         ".debug_addr table at offset 0x%" PRIx64
+                         "address table at offset 0x%" PRIx64
                          " has too small length (0x%" PRIx32
                          ") to contain a complete header",
                          HeaderOffset, TmpLength);
     }
     uint64_t End = HeaderOffset + getLength();
     if (!Data.isValidOffsetForDataOfSize(HeaderOffset, End - HeaderOffset)) {
       uint32_t TmpLength = getLength();
       invalidateLength();
       return createStringError(errc::invalid_argument,
-          "section is not large enough to contain a .debug_addr table "
+          "section is not large enough to contain an address table "
           "of length 0x%" PRIx32 " at offset 0x%" PRIx64,
           TmpLength, HeaderOffset);
     }
 
     HeaderData.Version = Data.getU16(OffsetPtr);
     HeaderData.AddrSize = Data.getU8(OffsetPtr);
     HeaderData.SegSize = Data.getU8(OffsetPtr);
     DataSize = getDataSize();
return createStringError(errc::not_supported, "version %" PRIu16
         HeaderData.Version, HeaderOffset);
   }
   // FIXME: For now we just treat version mismatch as an error,
   // however the correct way to associate a .debug_addr table
   // with a .debug_info table is to look at the DW_AT_addr_base
   // attribute in the info table.
   if (HeaderData.Version != UnitVersion)
     return createStringError(errc::invalid_argument,
-                       ".debug_addr table at offset 0x%" PRIx64
+                       "address table at offset 0x%" PRIx64
                        " has version %" PRIu16
                        " which is different from the version suggested"
                        " by the DWARF unit header: %" PRIu16,
                        HeaderOffset, HeaderData.Version, UnitVersion);
   if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
     return createStringError(errc::not_supported,
-                       ".debug_addr table at offset 0x%" PRIx64
+                       "address table at offset 0x%" PRIx64
                        " has unsupported address size %" PRIu8,
                        HeaderOffset, HeaderData.AddrSize);
   if (HeaderData.AddrSize != AddrSize && AddrSize != 0)
     WarnCallback(createStringError(
         errc::invalid_argument,
-        ".debug_addr table at offset 0x%" PRIx64 " has address size %" PRIu8
+        "address table at offset 0x%" PRIx64 " has address size %" PRIu8
         " which is different from CU address size %" PRIu8,
         HeaderOffset, HeaderData.AddrSize, AddrSize));
 
   // TODO: add support for non-zero segment selector size.
   if (HeaderData.SegSize != 0)
     return createStringError(errc::not_supported,
-                       ".debug_addr table at offset 0x%" PRIx64
+                       "address table at offset 0x%" PRIx64
                        " has unsupported segment selector size %" PRIu8,
                        HeaderOffset, HeaderData.SegSize);
   if (DataSize % HeaderData.AddrSize != 0) {
     invalidateLength();
     return createStringError(errc::invalid_argument,
-                       ".debug_addr table at offset 0x%" PRIx64
+                       "address table at offset 0x%" PRIx64
                        " contains data of size %" PRIu32
                        " which is not a multiple of addr size %" PRIu8,
                        HeaderOffset, DataSize, HeaderData.AddrSize);
   }
   Data.setAddressSize(HeaderData.AddrSize);
   uint32_t AddrCount = DataSize / HeaderData.AddrSize;
   for (uint32_t I = 0; I < AddrCount; ++I)
     Addrs.push_back(Data.getRelocatedAddress(OffsetPtr));
if (Addrs.size() > 0) {
     OS << "]\n";
   }
 }
 
 Expected<uint64_t> DWARFDebugAddrTable::getAddrEntry(uint32_t Index) const {
   if (Index < Addrs.size())
     return Addrs[Index];
   return createStringError(errc::invalid_argument,
-                           "Index %" PRIu32 " is out of range of the "
-                           ".debug_addr table at offset 0x%" PRIx64,
+                           "Index %" PRIu32 " is out of range in the "
+                           "address table at offset 0x%" PRIx64,
                            Index, HeaderOffset);
 }
 
 uint32_t DWARFDebugAddrTable::getLength() const {
   if (HeaderData.Length == 0)
     return 0;
   // TODO: DWARF64 support.
   return HeaderData.Length + sizeof(uint32_t);

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.warn | FileCheck %s
 # RUN: FileCheck %s -input-file %t.warn -check-prefix=WARN
 
-# WARN: .debug_addr table at offset 0x0 has address size 8 which is different from CU address size 4
+# WARN: address table at offset 0x0 has address size 8 which is different from CU address size 4
 # WARN-NOT: {{.}}
 
 # CHECK: .debug_addr contents
 # CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x0000000100000000
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x04, seg_size = 0x00

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
 # CHECK: .debug_addr contents:
 # CHECK-NOT: {{.}}
-# ERR: .debug_addr table at offset 0x0 contains data of size 7 which is not a multiple of addr size 4
+# ERR: address table at offset 0x0 contains data of size 7 which is not a multiple of addr size 4
 # ERR-NOT: {{.}}
 
 # data size is not multiple of address_size
   .section  .debug_addr,"",@progbits
 .Ldebug_addr0:
   .long 11 # unit_length = .short + .byte + .byte + .long + .long - 1
   .short 5 # version
   .byte 4  # address_size
   .byte 0  # segment_selector_size
   .long 0x00000000
   .long 0x00000001

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
 # CHECK: .debug_addr contents:
 # CHECK-NOT: {{.}}
-# ERR: .debug_addr table at offset 0x0 has unsupported segment selector size 1
+# ERR: address table at offset 0x0 has unsupported segment selector size 1
 # ERR-NOT: {{.}}
 
 # non-zero segment_selector_size
 # TODO: make this valid
   .section  .debug_addr,"",@progbits
 .Ldebug_addr0:
   .long 4  # unit_length = .short + .byte + .byte
   .short 5 # version
   .byte 4  # address_size
   .byte 1  # segment_selector_size

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
 # CHECK: .debug_addr contents:
 # CHECK-NOT: {{.}}
-# ERR: .debug_addr table at offset 0x0 has too small length (0x5) to contain a complete header
+# ERR: address table at offset 0x0 has too small length (0x5) to contain a complete header
 # ERR-NOT: {{.}}
 
 # too small length value
   .section  .debug_addr,"",@progbits
 .Ldebug_addr0:
   .long 1  # unit_length
   .short 5 # version
   .byte 4  # address_size
   .byte 0  # segment_selector_size
   .long 0x00000000
   .long 0x00000001

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
 # CHECK: .debug_addr contents:
 # CHECK-NOT: {{.}}
-# ERR: section is not large enough to contain a .debug_addr table length at offset 0x0
+# ERR: section is not large enough to contain an address table length at offset 0x0
 # ERR-NOT: {{.}}
 
 # too small section to contain length field
   .section  .debug_addr,"",@progbits
 .Ldebug_addr0:
   .short 1 # unit_length

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
 # CHECK: .debug_addr contents:
 # CHECK-NOT: {{.}}
-# ERR: section is not large enough to contain a .debug_addr table of length 0x10 at offset 0x0
+# ERR: section is not large enough to contain an address table of length 0x10 at offset 0x0
 # ERR-NOT: {{.}}
 
 # too small section to contain section of given length
   .section  .debug_addr,"",@progbits
 .Ldebug_addr0:
   .long 12 # unit_length
   .short 5 # version
   .byte 4  # address_size
   .byte 0  # segment_selector_size

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
-# ERR: .debug_addr table at offset 0x0 has version 4 which is different from the version suggested by the DWARF unit header: 5
+# ERR: address table at offset 0x0 has version 4 which is different from the version suggested by the DWARF unit header: 5
 # ERR-NOT: {{.}}
 
 # CHECK: .debug_addr contents
 # CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x00000000
 # CHECK-NEXT:     0x00000001
 # CHECK-NEXT:     ]