[DataExtractor] Improve error message when we run off the end of the buffer

[labath]

Summary

Include the offset at which this happened.

[jhenderson]

LGTM, thanks!

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) {
+static void unexpectedEndReached(Error *E, uint64_t Offset) {
   if (E)
     *E = createStringError(errc::illegal_byte_sequence,
-                           "unexpected end of data");
+                           "unexpected end of data at offset 0x%" PRIx64,
+                           Offset);
 }
 
 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) {
   ErrorAsOutParameter ErrAsOut(Err);
   T val = 0;
   if (isError(Err))
     return val;
 
   uint64_t offset = *offset_ptr;
   if (!de->isValidOffsetForDataOfSize(offset, sizeof(T))) {
-    unexpectedEndReached(Err);
+    unexpectedEndReached(Err, offset);
     return val;
   }
   std::memcpy(&val, &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) {
   ErrorAsOutParameter ErrAsOut(Err);
   if (isError(Err))
     return nullptr;
 
   uint64_t offset = *offset_ptr;
 
   if (!de->isValidOffsetForDataOfSize(offset, sizeof(*dst) * count)) {
-    unexpectedEndReached(Err);
+    unexpectedEndReached(Err, offset);
     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);
   // Advance the offset
   *offset_ptr = offset;
   // Return a non-NULL pointer to the converted data as an indicator of

 void DataExtractor::skip(Cursor &C, uint64_t Length) const {
   ErrorAsOutParameter ErrAsOut(&C.Err);
   if (isError(&C.Err))
     return;
 
   if (isValidOffsetForDataOfSize(C.Offset, Length))
     C.Offset += Length;
   else
-    unexpectedEndReached(&C.Err);
+    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: llvm-dwarfdump %t | FileCheck %s
 
 # 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
-# CHECK-NEXT:    error: unexpected end of data)
+# CHECK-NEXT:    error: unexpected end of data at offset 0xdeadbeef)
 
 # CHECK:      DW_AT_name        ("x2")
 # CHECK-NEXT: DW_AT_location    (0x00000036
-# CHECK-NEXT:    error: unexpected end of data)
+# CHECK-NEXT:    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: llvm-dwarfdump %t | FileCheck %s
 
 # 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
-# CHECK-NEXT:    error: unexpected end of data)
+# CHECK-NEXT:    error: unexpected end of data at offset 0xdeadbeef)
 
 # CHECK:      DW_AT_name        ("x2")
 # CHECK-NEXT: DW_AT_location    (0x00000025
-# CHECK-NEXT:    error: unexpected end of data)
+# CHECK-NEXT:    error: unexpected end of data at offset 0x34)
 
 
         .type   f,@function
 f:                                      # @f
 .Lfunc_begin0:
         movl    %edi, %eax
 .Ltmp0:
         retq

llvm/unittests/DebugInfo/DWARF/DWARFDataExtractorTest.cpp

auto GetWithoutError = [](ArrayRef<uint8_t> Bytes) {
     uint64_t Length;
     dwarf::DwarfFormat Format;
     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"));
+  EXPECT_THAT_EXPECTED(
+      GetWithError({}),
+      FailedWithMessage("unexpected end of data at offset 0x0"));
   EXPECT_EQ(GetWithoutError({}), ErrorResult);
 
   // Not long enough for the U32 field.
-  EXPECT_THAT_EXPECTED(GetWithError({0x00, 0x01, 0x02}),
-                       FailedWithMessage("unexpected end of data"));
+  EXPECT_THAT_EXPECTED(
+      GetWithError({0x00, 0x01, 0x02}),
+      FailedWithMessage("unexpected end of data at offset 0x0"));
   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));
 
   // Zeroes are not an error, but without the Error object it is hard to tell
   // them apart from a failed read.
   EXPECT_THAT_EXPECTED(
       GetWithError({0x00, 0x00, 0x00, 0x00}),
       HasValue(std::make_tuple(0x00000000, dwarf::DWARF32, 4)));
   EXPECT_EQ(GetWithoutError({0x00, 0x00, 0x00, 0x00}),
             std::make_tuple(0x00000000, dwarf::DWARF32, 4));
 
   // Smallest invalid value.
   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"));
+  EXPECT_THAT_EXPECTED(
+      GetWithError({0xff, 0xff, 0xff, 0xff}),
+      FailedWithMessage("unexpected end of data at offset 0x4"));
   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"));
+      FailedWithMessage("unexpected end of data at offset 0x4"));
   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/DWARFDieTest.cpp

EXPECT_THAT_EXPECTED(
       HasValue(testing::ElementsAre(DWARFLocationExpression{None, {0x47}})));
 
   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),
-                       Failed<ErrorInfoBase>(testing::Property(
-                           &ErrorInfoBase::message, "unexpected end of data")));
+  EXPECT_THAT_EXPECTED(
+      Die.getLocations(DW_AT_call_data_location),
+      FailedWithMessage("unexpected end of data at offset 0x20"));
 
   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