[Support] Make DataExtractor error messages more clear

[labath]

Summary

This is a result of the discussion at D78113. Previously we would be
only giving the current offset at which the error was detected. However,
this was phrased somewhat ambiguously (as it could also mean that end of
data was at that offset). The new error message includes the current
offset as well as the extent of the data being read.

I've changed a couple of file-level static functions into private member
functions in order to avoid passing a bunch of new arguments everywhere.

[jhenderson]

llvm/lib/Support/DataExtractor.cpp

27

My instinct says that this needs to be Data.size() + Offset. I'm reading some of the changed messages in the tests and getting confused by how they line up with the range Example: "offset 0x48 while reading [0xbadbeef, 0xbadbef7)" - what is the offset 0x48 referring to? I think "offset 0xbadbef6 while reading..." (or whatever the value actually should be) might be clearer.

llvm/test/DebugInfo/X86/dwarfdump-debug-loc-error-cases2.s

16

Does this error message need updating?

llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s

16

Same as above.

[jhenderson]

llvm/include/llvm/Support/DataExtractor.h

696

Any particular reason this is protected, not private?

[labath]

llvm/lib/Support/DataExtractor.cpp

27

Yeah, that one is funny. What happens there is that the very first read starts at a completely bogus offset. In this case that happens because the value of DW_AT_location is (deliberately) corrupted, but it could happen when following other kinds of indirect references (e.g. DW_FORM_strp), depending on how exactly is that implemented.

What would you say to checking for Data.size() < Offset and emitting a different error message in that case ("reading offset 0xdeadbeef beyond the end of data at 0x48") ?

[labath]

llvm/include/llvm/Support/DataExtractor.h

696

There is, though it's fairly arbitrary -- it seemed like it could be useful to subclasses like DWARFDataExtractor.

[jhenderson]

llvm/include/llvm/Support/DataExtractor.h

696

Fair enough. I'll leave it up to you to decide what would be best.

llvm/lib/Support/DataExtractor.cpp

27

That seems like a reasonable improvement. It might mean I'm less likely to get completely thrown by the error message in the future!

[labath]

llvm/include/llvm/Support/DataExtractor.h

696

Actually, I'll just make it private. It's easy to make it protected if needed.

[labath]

• impove error message, update test expectations

Sorry about the delay.

[jhenderson]

llvm/lib/Support/DataExtractor.cpp

30

FWIW, I'm not convinced illegal_byte_sequence is really the right thing to use. I had a discussion with someone else recently about this, but in every example usage I found online outside LLVM, it is for unicode encoding issues. The standard is silent on the exact purpose of it so the argument is that it's perfectly reasonable to use it for other bad sequences. I personally would use invalid_argument here, since you're trying to read using an invalid Offset.

35–38

If I'm not mistaken, this case needs a unit test?

[labath]

llvm/lib/Support/DataExtractor.cpp

30

Yes, invalid_argument looks better here.

35–38

Test added.

[labath]

• change errc value
• add unit test

[jhenderson]

LGTM, with one suggestion.

llvm/lib/Support/DataExtractor.cpp

30

Looks like you only changed the second case here? Potentially, Size could be invalid causing the error. What do you think?

[labath]

llvm/lib/Support/DataExtractor.cpp

30

Yes, that was intentional. I don't think we should blame the Size variable here. Since that is a long lived member variable, I think we should be assuming that it is correct. The first thing to blame should be the Offset argument, but in this case that also looks plausible, so we blame the data contents. For that illegal_byte_sequence seems appropriate (with the unicode caveat).

I think this is similar to how e.g. passing a bogus pointer to a system call results in EFAULT, but passing a pointer to incorrect data results in a more specific error code.

[jhenderson]

llvm/lib/Support/DataExtractor.cpp

30

Okay, happy either way.

llvm/include/llvm/Support/DataExtractor.h

public:
   /// Return the number of bytes in the underlying buffer.
   size_t size() const { return Data.size(); }
 
 protected:
   // Make it possible for subclasses to access these fields without making them
   // public.
   static uint64_t &getOffset(Cursor &C) { return C.Offset; }
   static Error &getError(Cursor &C) { return C.Err; }
+
+  /// If it is possible to read \a Size bytes at offset \a Offset, returns \b
+  /// true. Otherwise, returns \b false. If \a E is not nullptr, also sets the
+  /// error object to indicate an error.
+  bool prepareRead(uint64_t Offset, uint64_t Size, Error *E) const;
+
+private:
+  template <typename T> T getU(uint64_t *OffsetPtr, Error *Err) const;
+  template <typename T>
+  T *getUs(uint64_t *OffsetPtr, T *Dst, uint32_t Count, Error *Err) const;
 };
 
 } // namespace llvm
 
 #endif

llvm/lib/Support/DataExtractor.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/SwapByteOrder.h"
 
 using namespace llvm;
 
-static void unexpectedEndReached(Error *E, uint64_t Offset) {
+bool DataExtractor::prepareRead(uint64_t Offset, uint64_t Size,
+                                Error *E) const {
+  if (isValidOffsetForDataOfSize(Offset, Size))
+    return true;
   if (E)
-    *E = createStringError(errc::illegal_byte_sequence,
-                           "unexpected end of data at offset 0x%" PRIx64,
-                           Offset);
+    *E = createStringError(
+        errc::illegal_byte_sequence,
+        "unexpected end of data at offset 0x%zx while reading [0x%" PRIx64
+        ", 0x%" PRIx64 ")",
+        Data.size(), Offset, Offset + Size);
+  return false;
 }
 
 static bool isError(Error *E) { return E && *E; }
 
 template <typename T>
-static T getU(uint64_t *offset_ptr, const DataExtractor *de,
-              bool isLittleEndian, const char *Data, llvm::Error *Err) {
+T DataExtractor::getU(uint64_t *offset_ptr, Error *Err) const {
   ErrorAsOutParameter ErrAsOut(Err);
   T val = 0;
   if (isError(Err))
     return val;
 
   uint64_t offset = *offset_ptr;
-  if (!de->isValidOffsetForDataOfSize(offset, sizeof(T))) {
-    unexpectedEndReached(Err, offset);
+  if (!prepareRead(offset, sizeof(T), Err))
     return val;
-  }
-  std::memcpy(&val, &Data[offset], sizeof(val));
-  if (sys::IsLittleEndianHost != isLittleEndian)
+  std::memcpy(&val, &Data.data()[offset], sizeof(val));
+  if (sys::IsLittleEndianHost != IsLittleEndian)
     sys::swapByteOrder(val);
 
   // Advance the offset
   *offset_ptr += sizeof(val);
   return val;
 }
 
 template <typename T>
-static T *getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
-                const DataExtractor *de, bool isLittleEndian, const char *Data,
-                llvm::Error *Err) {
+T *DataExtractor::getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
+                        Error *Err) const {
   ErrorAsOutParameter ErrAsOut(Err);
   if (isError(Err))
     return nullptr;
 
   uint64_t offset = *offset_ptr;
 
-  if (!de->isValidOffsetForDataOfSize(offset, sizeof(*dst) * count)) {
-    unexpectedEndReached(Err, offset);
+  if (!prepareRead(offset, sizeof(*dst) * count, Err))
     return nullptr;
-  }
   for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
        ++value_ptr, offset += sizeof(*dst))
-    *value_ptr = getU<T>(offset_ptr, de, isLittleEndian, Data, Err);
+    *value_ptr = getU<T>(offset_ptr, Err);
   // Advance the offset
   *offset_ptr = offset;
   // Return a non-NULL pointer to the converted data as an indicator of
   // success
   return dst;
 }
 
 uint8_t DataExtractor::getU8(uint64_t *offset_ptr, llvm::Error *Err) const {
-  return getU<uint8_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
+  return getU<uint8_t>(offset_ptr, Err);
 }
 
-uint8_t *
-DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const {
-  return getUs<uint8_t>(offset_ptr, dst, count, this, IsLittleEndian,
-                        Data.data(), nullptr);
+uint8_t *DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst,
+                              uint32_t count) const {
+  return getUs<uint8_t>(offset_ptr, dst, count, nullptr);
 }
 
 uint8_t *DataExtractor::getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const {
-  return getUs<uint8_t>(&C.Offset, Dst, Count, this, IsLittleEndian,
-                        Data.data(), &C.Err);
+  return getUs<uint8_t>(&C.Offset, Dst, Count, &C.Err);
 }
 
 uint16_t DataExtractor::getU16(uint64_t *offset_ptr, llvm::Error *Err) const {
-  return getU<uint16_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
+  return getU<uint16_t>(offset_ptr, Err);
 }
 
 uint16_t *DataExtractor::getU16(uint64_t *offset_ptr, uint16_t *dst,
                                 uint32_t count) const {
-  return getUs<uint16_t>(offset_ptr, dst, count, this, IsLittleEndian,
-                         Data.data(), nullptr);
+  return getUs<uint16_t>(offset_ptr, dst, count, nullptr);
 }
 
 uint32_t DataExtractor::getU24(uint64_t *OffsetPtr, Error *Err) const {
-  uint24_t ExtractedVal =
-      getU<uint24_t>(OffsetPtr, this, IsLittleEndian, Data.data(), Err);
+  uint24_t ExtractedVal = getU<uint24_t>(OffsetPtr, Err);
   // The 3 bytes are in the correct byte order for the host.
   return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
 }
 
 uint32_t DataExtractor::getU32(uint64_t *offset_ptr, llvm::Error *Err) const {
-  return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
+  return getU<uint32_t>(offset_ptr, Err);
 }
 
 uint32_t *DataExtractor::getU32(uint64_t *offset_ptr, uint32_t *dst,
                                 uint32_t count) const {
-  return getUs<uint32_t>(offset_ptr, dst, count, this, IsLittleEndian,
-                         Data.data(), nullptr);
+  return getUs<uint32_t>(offset_ptr, dst, count, nullptr);
 }
 
 uint64_t DataExtractor::getU64(uint64_t *offset_ptr, llvm::Error *Err) const {
-  return getU<uint64_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
+  return getU<uint64_t>(offset_ptr, Err);
 }
 
 uint64_t *DataExtractor::getU64(uint64_t *offset_ptr, uint64_t *dst,
                                 uint32_t count) const {
-  return getUs<uint64_t>(offset_ptr, dst, count, this, IsLittleEndian,
-                         Data.data(), nullptr);
+  return getUs<uint64_t>(offset_ptr, dst, count, nullptr);
 }
 
 uint64_t DataExtractor::getUnsigned(uint64_t *offset_ptr, uint32_t byte_size,
                                     llvm::Error *Err) const {
   switch (byte_size) {
   case 1:
     return getU8(offset_ptr, Err);
   case 2:
if (isError(Err))
     return StringRef();
 
   uint64_t Start = *OffsetPtr;
   StringRef::size_type Pos = Data.find('\0', Start);
   if (Pos != StringRef::npos) {
     *OffsetPtr = Pos + 1;
     return StringRef(Data.data() + Start, Pos - Start);
   }
-  unexpectedEndReached(Err, Start);
+  if (Err)
+    *Err = createStringError(errc::illegal_byte_sequence,
+                             "no null terminated string at offset 0x%" PRIx64,
+                             Start);
   return StringRef();
 }
 
 StringRef DataExtractor::getFixedLengthString(uint64_t *OffsetPtr,
                                               uint64_t Length,
                                               StringRef TrimChars) const {
   StringRef Bytes(getBytes(OffsetPtr, Length));
   return Bytes.trim(TrimChars);
 }
 
 StringRef DataExtractor::getBytes(uint64_t *OffsetPtr, uint64_t Length,
                                   Error *Err) const {
   ErrorAsOutParameter ErrAsOut(Err);
   if (isError(Err))
     return StringRef();
 
-  if (!isValidOffsetForDataOfSize(*OffsetPtr, Length)) {
-    unexpectedEndReached(Err, *OffsetPtr);
+  if (!prepareRead(*OffsetPtr, Length, Err))
     return StringRef();
-  }
 
   StringRef Result = Data.substr(*OffsetPtr, Length);
   *OffsetPtr += Length;
   return Result;
 }
 
 template <typename T>
 static T getLEB128(StringRef Data, uint64_t *OffsetPtr, Error *Err,
int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr, Error *Err) const {
   return getLEB128(Data, offset_ptr, Err, decodeSLEB128);
 }
 
 void DataExtractor::skip(Cursor &C, uint64_t Length) const {
   ErrorAsOutParameter ErrAsOut(&C.Err);
   if (isError(&C.Err))
     return;
 
-  if (isValidOffsetForDataOfSize(C.Offset, Length))
+  if (prepareRead(C.Offset, Length, &C.Err))
     C.Offset += Length;
-  else
-    unexpectedEndReached(&C.Err, C.Offset);
 }

llvm/test/DebugInfo/X86/dwarfdump-debug-loc-error-cases2.s

 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: not llvm-dwarfdump %t 2>%t.err | FileCheck %s
 # RUN: FileCheck %s < %t.err -check-prefix=ERR
 
 # CHECK:      DW_AT_name        ("x0")
 # CHECK-NEXT: DW_AT_location    (0x00000000
 # CHECK-NEXT:    [0x0000000000000000,  0x0000000000000002): DW_OP_reg5 RDI
 # CHECK-NEXT:    [0x0000000000000002,  0x0000000000000003): DW_OP_reg0 RAX)
 
 # CHECK:      DW_AT_name        ("x1")
 # CHECK-NEXT: DW_AT_location    (0xdeadbeef: )
-# ERR:    error: unexpected end of data at offset 0xdeadbeef
+# ERR:    error: unexpected end of data at offset 0x48 while reading [0xdeadbeef, 0xdeadbef7)
 
 # CHECK:      DW_AT_name        ("x2")
 # CHECK-NEXT: DW_AT_location    (0x00000036: )
 # ERR:    error: unexpected end of data at offset 0x48
 
 
         .type   f,@function
 f:                                      # @f
 .Lfunc_begin0:
         movl    %edi, %eax
 .Ltmp0:
         retq

llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-error-cases2.s

 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: not llvm-dwarfdump %t 2> %t.err | FileCheck %s
 # RUN: FileCheck %s < %t.err -check-prefix=ERR
 
 # CHECK:      DW_AT_name        ("x0")
 # CHECK-NEXT: DW_AT_location    (0x0000000c
 # CHECK-NEXT:    [0x0000000000000000,  0x0000000000000002): DW_OP_reg5 RDI
 # CHECK-NEXT:    [0x0000000000000002,  0x0000000000000003): DW_OP_reg0 RAX)
 
 # CHECK:      DW_AT_name        ("x1")
 # CHECK-NEXT: DW_AT_location    (0xdeadbeef: )
-# ERR:    error: unexpected end of data at offset 0xdeadbeef
+# ERR:    error: unexpected end of data at offset 0x34 while reading [0xdeadbeef, 0xdeadbef0)
 
 # CHECK:      DW_AT_name        ("x2")
 # CHECK-NEXT: DW_AT_location    (0x00000025
 # ERR:    error: unexpected end of data at offset 0x34
 
 
         .type   f,@function
 f:                                      # @f
 .Lfunc_begin0:
         movl    %edi, %eax
 .Ltmp0:
         retq

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: not 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: parsing address table at offset 0x0: unexpected end of data at offset 0x4
+# ERR: parsing address table at offset 0x0: unexpected end of data at offset 0xb while reading [0x4, 0xc)
 # ERR-NOT: {{.}}
 
 # too small section to contain an extended length field of a DWARF64 address table.
   .section  .debug_addr,"",@progbits
   .long 0xffffffff      # DWARF64 mark
   .space 7              # a DWARF64 unit length field takes 8 bytes.

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: not 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: parsing address table at offset 0x0: unexpected end of data at offset 0x0
+# ERR: parsing address table at offset 0x0: unexpected end of data at offset 0x2 while reading [0x0, 0x4)
 # 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_rnglists_invalid.s

 # RUN: llvm-mc %S/Inputs/debug_rnglists_short_section.s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN: not llvm-dwarfdump --debug-rnglists - 2>&1 | FileCheck %s --check-prefix=SHORT
 # SHORT-NOT: error:
 # SHORT-NOT: range list header
-# SHORT: error: parsing .debug_rnglists table at offset 0x0: unexpected end of data at offset 0x0
+# SHORT: error: parsing .debug_rnglists table at offset 0x0: unexpected end of data at offset 0x3
 # SHORT-NOT: range list header
 # SHORT-NOT: error:
 
 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN: not llvm-dwarfdump --debug-rnglists - 2> %t.err | FileCheck %s --check-prefix=GOOD
 # RUN: FileCheck %s --input-file %t.err
 
 # GOOD: .debug_rnglists contents:

llvm/unittests/DebugInfo/DWARF/DWARFAcceleratorTableTest.cpp

 
 TEST(DWARFDebugNames, TooSmallForDWARF64) {
   // DWARF64 header takes at least 44 bytes.
   static const char NamesSecData[43] = "\xff\xff\xff\xff"; // DWARF64 mark
   EXPECT_THAT_ERROR(
       ExtractDebugNames(StringRef(NamesSecData, sizeof(NamesSecData)),
                         StringRef()),
       FailedWithMessage("parsing .debug_names header at 0x0: unexpected end of "
-                        "data at offset 0x28"));
+                        "data at offset 0x2b while reading [0x28, 0x2c)"));
 }
 
 } // end anonymous namespace

llvm/unittests/DebugInfo/DWARF/DWARFDataExtractorTest.cpp

)";
   const DWARFObject &DObj = Ctx->getDWARFObj();
   ASSERT_EQ(6u, DObj.getLineSection().Data.size());
 
   DWARFDataExtractor Data(DObj, DObj.getLineSection(), Obj->isLittleEndian(),
                           Obj->getBytesInAddress());
   DataExtractor::Cursor C(0);
   EXPECT_EQ(0x42u, Data.getRelocatedAddress(C));
   EXPECT_EQ(0u, Data.getRelocatedAddress(C));
-  EXPECT_THAT_ERROR(C.takeError(),
-                    FailedWithMessage("unexpected end of data at offset 0x4"));
+  EXPECT_THAT_ERROR(
+      C.takeError(),
+      FailedWithMessage(
+          "unexpected end of data at offset 0x6 while reading [0x4, 0x8)"));
 }
 
 TEST(DWARFDataExtractorTest, getInitialLength) {
   auto GetWithError = [](ArrayRef<uint8_t> Bytes)
       -> Expected<std::tuple<uint64_t, dwarf::DwarfFormat, uint64_t>> {
     DWARFDataExtractor Data(Bytes, /*IsLittleEndian=*/false, /*AddressSize=*/8);
     DWARFDataExtractor::Cursor C(0);
     uint64_t Length;
auto GetWithoutError = [](ArrayRef<uint8_t> Bytes) {
     std::tie(Length, Format) = Data.getInitialLength(&Offset);
     return std::make_tuple(Length, Format, Offset);
   };
   auto ErrorResult = std::make_tuple(0, dwarf::DWARF32, 0);
 
   // Empty data.
   EXPECT_THAT_EXPECTED(
       GetWithError({}),
-      FailedWithMessage("unexpected end of data at offset 0x0"));
+      FailedWithMessage(
+          "unexpected end of data at offset 0x0 while reading [0x0, 0x4)"));
   EXPECT_EQ(GetWithoutError({}), ErrorResult);
 
   // Not long enough for the U32 field.
   EXPECT_THAT_EXPECTED(
       GetWithError({0x00, 0x01, 0x02}),
-      FailedWithMessage("unexpected end of data at offset 0x0"));
+      FailedWithMessage(
+          "unexpected end of data at offset 0x3 while reading [0x0, 0x4)"));
   EXPECT_EQ(GetWithoutError({0x00, 0x01, 0x02}), ErrorResult);
 
   EXPECT_THAT_EXPECTED(
       GetWithError({0x00, 0x01, 0x02, 0x03}),
       HasValue(std::make_tuple(0x00010203, dwarf::DWARF32, 4)));
   EXPECT_EQ(GetWithoutError({0x00, 0x01, 0x02, 0x03}),
             std::make_tuple(0x00010203, dwarf::DWARF32, 4));
 
EXPECT_THAT_EXPECTED(
       GetWithError({0xff, 0xff, 0xff, 0xf0}),
       FailedWithMessage(
           "unsupported reserved unit length of value 0xfffffff0"));
   EXPECT_EQ(GetWithoutError({0xff, 0xff, 0xff, 0xf0}), ErrorResult);
 
   // DWARF64 marker without the subsequent length field.
   EXPECT_THAT_EXPECTED(
       GetWithError({0xff, 0xff, 0xff, 0xff}),
-      FailedWithMessage("unexpected end of data at offset 0x4"));
+      FailedWithMessage(
+          "unexpected end of data at offset 0x4 while reading [0x4, 0xc)"));
   EXPECT_EQ(GetWithoutError({0xff, 0xff, 0xff, 0xff}), ErrorResult);
 
   // Not enough data for the U64 length.
   EXPECT_THAT_EXPECTED(
       GetWithError({0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03}),
-      FailedWithMessage("unexpected end of data at offset 0x4"));
+      FailedWithMessage(
+          "unexpected end of data at offset 0x8 while reading [0x4, 0xc)"));
   EXPECT_EQ(GetWithoutError({0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03}),
             ErrorResult);
 
   EXPECT_THAT_EXPECTED(
       GetWithError({0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
                     0x06, 0x07}),
       HasValue(std::make_tuple(0x0001020304050607, dwarf::DWARF64, 12)));
   EXPECT_EQ(GetWithoutError({0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03,
                              0x04, 0x05, 0x06, 0x07}),
             std::make_tuple(0x0001020304050607, dwarf::DWARF64, 12));
 }
 
 } // namespace

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

ExpectExtractError(DebugArangesSecRaw,
                      "reserved unit length of value 0xfffffff0");
 }
 
 TEST(DWARFDebugArangeSet, SectionTooShort) {
   // Note: 1 will be automatically subtracted in ExpectExtractError().
   static const char DebugArangesSecRaw[11 + 1] = {0};
   ExpectExtractError(DebugArangesSecRaw,
                      "parsing address ranges table at offset 0x0: unexpected "
-                     "end of data at offset 0xb");
+                     "end of data at offset 0xb while reading [0xb, 0xc)");
 }
 
 TEST(DWARFDebugArangeSet, SectionTooShortDWARF64) {
   // Note: 1 will be automatically subtracted in ExpectExtractError().
   static const char DebugArangesSecRaw[23 + 1] =
       "\xff\xff\xff\xff"; // DWARF64 mark
   ExpectExtractError(DebugArangesSecRaw,
                      "parsing address ranges table at offset 0x0: unexpected "
-                     "end of data at offset 0x17");
+                     "end of data at offset 0x17 while reading [0x17, 0x18)");
 }
 
 TEST(DWARFDebugArangeSet, NoSpaceForEntries) {
   static const char DebugArangesSecRaw[] =
       "\x0c\x00\x00\x00" // Length
       "\x02\x00"         // Version
       "\x00\x00\x00\x00" // Debug Info Offset
       "\x04"             // Address Size

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) {
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0, LineTable::Byte}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(0),
-      FailedWithMessage("parsing line table prologue at offset 0x00000000: "
-                        "unexpected end of data at offset 0x0"));
+      FailedWithMessage(
+          "parsing line table prologue at offset 0x00000000: "
+          "unexpected end of data at offset 0x1 while reading [0x0, 0x4)"));
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(1),
       FailedWithMessage(
           "offset 0x00000001 is not a valid debug line section offset"));
 }
 
 TEST_P(DebugLineParameterisedFixture, PrologueGetLength) {

llvm/unittests/DebugInfo/DWARF/DWARFDieTest.cpp

TEST(DWARFDie, getLocations) {
   EXPECT_THAT_EXPECTED(
       Die.getLocations(DW_AT_vtable_elem_location),
       Failed<ErrorInfoBase>(testing::Property(
           &ErrorInfoBase::message,
           "Unable to resolve indirect address 1 for: DW_LLE_startx_length")));
 
   EXPECT_THAT_EXPECTED(
       Die.getLocations(DW_AT_call_data_location),
-      FailedWithMessage("unexpected end of data at offset 0x20"));
+      FailedWithMessage(
+          "unexpected end of data at offset 0x20 while reading [0x20, 0x21)"));
 
   EXPECT_THAT_EXPECTED(
       Die.getLocations(DW_AT_call_data_value),
       Failed<ErrorInfoBase>(testing::Property(&ErrorInfoBase::message,
                                               "No DW_AT_call_data_value")));
 }
 
 } // end anonymous namespace

llvm/unittests/Support/DataExtractorTest.cpp

TEST(DataExtractorTest, Strings) {
   EXPECT_EQ(nullptr, DE.getCStr(&offset));
   EXPECT_EQ(11U, offset);
 
   DataExtractor::Cursor C(0);
   EXPECT_EQ(stringData, DE.getCStr(C));
   EXPECT_EQ(11U, C.tell());
   EXPECT_EQ(nullptr, DE.getCStr(C));
   EXPECT_EQ(11U, C.tell());
-  EXPECT_THAT_ERROR(C.takeError(),
-                    FailedWithMessage("unexpected end of data at offset 0xb"));
+  EXPECT_THAT_ERROR(
+      C.takeError(),
+      FailedWithMessage("no null terminated string at offset 0xb"));
 }
 
 TEST(DataExtractorTest, LEB128) {
   DataExtractor DE(StringRef(leb128data, sizeof(leb128data)-1), false, 8);
   uint64_t offset = 0;
 
   EXPECT_EQ(9382ULL, DE.getULEB128(&offset));
   EXPECT_EQ(2U, offset);