llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

   1 //===- llvm/unittest/DebugInfo/DWARFDebugArangeSetTest.cpp-----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
  10 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
  11 #include "llvm/Testing/Support/Error.h"
  12 #include "gtest/gtest.h"
  13
  14 using namespace llvm;
  15
  16 namespace {
  17
  18 struct WarningHandler {
  19   ~WarningHandler() { EXPECT_THAT_ERROR(std::move(Err), Succeeded()); }
  20
  21   void operator()(Error E) { Err = joinErrors(std::move(Err), std::move(E)); }
  22
  23   Error getWarning() { return std::move(Err); }
  24
  25   Error Err = Error::success();
  26 };
  27
  28 template <size_t SecSize>
  29 void ExpectExtractError(const char (&SecDataRaw)[SecSize],
  30                         const char *ErrorMessage) {
  31   DWARFDataExtractor Extractor(StringRef(SecDataRaw, SecSize - 1),
  32                                /* IsLittleEndian = */ true,
  33                                /* AddressSize = */ 4);
  34   DWARFDebugArangeSet Set;
  35   uint64_t Offset = 0;
  36   WarningHandler Warnings;
  37   Error E = Set.extract(Extractor, &Offset, Warnings);
  38   ASSERT_TRUE(E.operator bool());
  39   EXPECT_STREQ(ErrorMessage, toString(std::move(E)).c_str());
  40 }
  41
  42 TEST(DWARFDebugArangeSet, LengthExceedsSectionSize) {
  43   static const char DebugArangesSecRaw[] =
  44       "\x15\x00\x00\x00" // The length exceeds the section boundaries
  45       "\x02\x00"         // Version
  46       "\x00\x00\x00\x00" // Debug Info Offset
  47       "\x04"             // Address Size
  48       "\x00"             // Segment Selector Size
  49       "\x00\x00\x00\x00" // Padding
  50       "\x00\x00\x00\x00" // Termination tuple
  51       "\x00\x00\x00\x00";
  52   ExpectExtractError(
  53       DebugArangesSecRaw,
  54       "the length of address range table at offset 0x0 exceeds section size");
  55 }
  56
  57 TEST(DWARFDebugArangeSet, LengthExceedsSectionSizeDWARF64) {
  58   static const char DebugArangesSecRaw[] =
  59       "\xff\xff\xff\xff"                 // DWARF64 mark
  60       "\x15\x00\x00\x00\x00\x00\x00\x00" // The length exceeds the section
  61                                          // boundaries
  62       "\x02\x00"                         // Version
  63       "\x00\x00\x00\x00\x00\x00\x00\x00" // Debug Info Offset
  64       "\x04"                             // Address Size
  65       "\x00"                             // Segment Selector Size
  66                                          // No padding
  67       "\x00\x00\x00\x00"                 // Termination tuple
  68       "\x00\x00\x00\x00";
  69   ExpectExtractError(
  70       DebugArangesSecRaw,
  71       "the length of address range table at offset 0x0 exceeds section size");
  72 }
  73
  74 TEST(DWARFDebugArangeSet, UnsupportedAddressSize) {
  75   static const char DebugArangesSecRaw[] =
  76       "\x0c\x00\x00\x00"  // Length
  77       "\x02\x00"          // Version
  78       "\x00\x00\x00\x00"  // Debug Info Offset
  79       "\x03"              // Address Size (not supported)
  80       "\x00"              // Segment Selector Size
  81                           // No padding
  82       "\x00\x00\x00\x00"; // Termination tuple
  83   ExpectExtractError(
  84       DebugArangesSecRaw,
  85       "address range table at offset 0x0 has unsupported address size: 3 "
  86       "(supported are 2, 4, 8)");
  87 }
  88
  89 TEST(DWARFDebugArangeSet, UnsupportedSegmentSelectorSize) {
  90   static const char DebugArangesSecRaw[] =
  91       "\x14\x00\x00\x00" // Length
  92       "\x02\x00"         // Version
  93       "\x00\x00\x00\x00" // Debug Info Offset
  94       "\x04"             // Address Size
  95       "\x04"             // Segment Selector Size (not supported)
  96                          // No padding
  97       "\x00\x00\x00\x00" // Termination tuple
  98       "\x00\x00\x00\x00"
  99       "\x00\x00\x00\x00";
 100   ExpectExtractError(
 101       DebugArangesSecRaw,
 102       "non-zero segment selector size in address range table at offset 0x0 "
 103       "is not supported");
 104 }
 105
 106 TEST(DWARFDebugArangeSet, NoTerminationEntry) {
 107   static const char DebugArangesSecRaw[] =
 108       "\x14\x00\x00\x00" // Length
 109       "\x02\x00"         // Version
 110       "\x00\x00\x00\x00" // Debug Info Offset
 111       "\x04"             // Address Size
 112       "\x00"             // Segment Selector Size
 113       "\x00\x00\x00\x00" // Padding
 114       "\x00\x00\x00\x00" // Entry: Address
 115       "\x01\x00\x00\x00" //        Length
 116       ;                  // No termination tuple
 117   ExpectExtractError(
 118       DebugArangesSecRaw,
 119       "address range table at offset 0x0 is not terminated by null entry");
 120 }
 121
 122 TEST(DWARFDebugArangeSet, ReservedUnitLength) {
 123   // Note: 12 is the minimum length to pass the basic check for the size of
 124   // the section. 1 will be automatically subtracted in ExpectExtractError().
 125   static const char DebugArangesSecRaw[12 + 1] =
 126       "\xf0\xff\xff\xff"; // Reserved unit length value
 127   ExpectExtractError(DebugArangesSecRaw,
 128                      "parsing address ranges table at offset 0x0: unsupported "
 129                      "reserved unit length of value 0xfffffff0");
 130 }
 131
 132 TEST(DWARFDebugArangeSet, SectionTooShort) {
 133   // Note: 1 will be automatically subtracted in ExpectExtractError().
 134   static const char DebugArangesSecRaw[11 + 1] = {0};
 135   ExpectExtractError(DebugArangesSecRaw,
 136                      "parsing address ranges table at offset 0x0: unexpected "
 137                      "end of data at offset 0xb while reading [0xb, 0xc)");
 138 }
 139
 140 TEST(DWARFDebugArangeSet, SectionTooShortDWARF64) {
 141   // Note: 1 will be automatically subtracted in ExpectExtractError().
 142   static const char DebugArangesSecRaw[23 + 1] =
 143       "\xff\xff\xff\xff"; // DWARF64 mark
 144   ExpectExtractError(DebugArangesSecRaw,
 145                      "parsing address ranges table at offset 0x0: unexpected "
 146                      "end of data at offset 0x17 while reading [0x17, 0x18)");
 147 }
 148
 149 TEST(DWARFDebugArangeSet, NoSpaceForEntries) {
 150   static const char DebugArangesSecRaw[] =
 151       "\x0c\x00\x00\x00" // Length
 152       "\x02\x00"         // Version
 153       "\x00\x00\x00\x00" // Debug Info Offset
 154       "\x04"             // Address Size
 155       "\x00"             // Segment Selector Size
 156       "\x00\x00\x00\x00" // Padding
 157       ;                  // No entries
 158   ExpectExtractError(
 159       DebugArangesSecRaw,
 160       "address range table at offset 0x0 has an insufficient length "
 161       "to contain any entries");
 162 }
 163
 164 TEST(DWARFDebugArangeSet, UnevenLength) {
 165   static const char DebugArangesSecRaw[] =
 166       "\x1b\x00\x00\x00" // Length (not a multiple of tuple size)
 167       "\x02\x00"         // Version
 168       "\x00\x00\x00\x00" // Debug Info Offset
 169       "\x04"             // Address Size
 170       "\x00"             // Segment Selector Size
 171       "\x00\x00\x00\x00" // Padding
 172       "\x00\x00\x00\x00" // Entry: Address
 173       "\x01\x00\x00\x00" //        Length
 174       "\x00\x00\x00\x00" // Termination tuple
 175       "\x00\x00\x00\x00";
 176   ExpectExtractError(
 177       DebugArangesSecRaw,
 178       "address range table at offset 0x0 has length that is not a multiple "
 179       "of the tuple size");
 180 }
 181
 182 TEST(DWARFDebugArangeSet, ZeroAddressEntry) {
 183   static const char DebugArangesSecRaw[] =
 184       "\x1c\x00\x00\x00" // Length
 185       "\x02\x00"         // Version
 186       "\x00\x00\x00\x00" // Debug Info Offset
 187       "\x04"             // Address Size
 188       "\x00"             // Segment Selector Size
 189       "\x00\x00\x00\x00" // Padding
 190       "\x00\x00\x00\x00" // Entry1: Address
 191       "\x01\x00\x00\x00" //         Length
 192       "\x00\x00\x00\x00" // Termination tuple
 193       "\x00\x00\x00\x00";
 194   DWARFDataExtractor Extractor(
 195       StringRef(DebugArangesSecRaw, sizeof(DebugArangesSecRaw) - 1),
 196       /*IsLittleEndian=*/true,
 197       /*AddressSize=*/4);
 198   DWARFDebugArangeSet Set;
 199   uint64_t Offset = 0;
 200   ASSERT_THAT_ERROR(Set.extract(Extractor, &Offset, WarningHandler()),
 201                     Succeeded());
 202   auto Range = Set.descriptors();
 203   auto Iter = Range.begin();
 204   ASSERT_EQ(std::distance(Iter, Range.end()), 1);
 205   EXPECT_EQ(Iter->Address, 0u);
 206   EXPECT_EQ(Iter->Length, 1u);
 207 }
 208
 209 TEST(DWARFDebugArangeSet, ZeroLengthEntry) {
 210   static const char DebugArangesSecRaw[] =
 211       "\x1c\x00\x00\x00" // Length
 212       "\x02\x00"         // Version
 213       "\x00\x00\x00\x00" // Debug Info Offset
 214       "\x04"             // Address Size
 215       "\x00"             // Segment Selector Size
 216       "\x00\x00\x00\x00" // Padding
 217       "\x01\x00\x00\x00" // Entry1: Address
 218       "\x00\x00\x00\x00" //         Length
 219       "\x00\x00\x00\x00" // Termination tuple
 220       "\x00\x00\x00\x00";
 221   DWARFDataExtractor Extractor(
 222       StringRef(DebugArangesSecRaw, sizeof(DebugArangesSecRaw) - 1),
 223       /*IsLittleEndian=*/true,
 224       /*AddressSize=*/4);
 225   DWARFDebugArangeSet Set;
 226   uint64_t Offset = 0;
 227   ASSERT_THAT_ERROR(Set.extract(Extractor, &Offset, WarningHandler()),
 228                     Succeeded());
 229   auto Range = Set.descriptors();
 230   auto Iter = Range.begin();
 231   ASSERT_EQ(std::distance(Iter, Range.end()), 1);
 232   EXPECT_EQ(Iter->Address, 1u);
 233   EXPECT_EQ(Iter->Length, 0u);
 234 }
 235
 236 TEST(DWARFDebugArangesSet, PrematureTerminator) {
 237   static const char DebugArangesSecRaw[] =
 238       "\x24\x00\x00\x00" // Length
 239       "\x02\x00"         // Version
 240       "\x00\x00\x00\x00" // Debug Info Offset
 241       "\x04"             // Address Size
 242       "\x00"             // Segment Selector Size
 243       "\x00\x00\x00\x00" // Padding
 244       "\x00\x00\x00\x00" // Entry1: Premature
 245       "\x00\x00\x00\x00" //         terminator
 246       "\x01\x00\x00\x00" // Entry2: Address
 247       "\x01\x00\x00\x00" //         Length
 248       "\x00\x00\x00\x00" // Termination tuple
 249       "\x00\x00\x00\x00";
 250   DWARFDataExtractor Extractor(
 251       StringRef(DebugArangesSecRaw, sizeof(DebugArangesSecRaw) - 1),
 252       /*IsLittleEndian=*/true,
 253       /*AddressSize=*/4);
 254   DWARFDebugArangeSet Set;
 255   uint64_t Offset = 0;
 256   WarningHandler Warnings;
 257   ASSERT_THAT_ERROR(Set.extract(Extractor, &Offset, Warnings), Succeeded());
 258   auto Range = Set.descriptors();
 259   auto Iter = Range.begin();
 260   ASSERT_EQ(std::distance(Iter, Range.end()), 2);
 261   EXPECT_EQ(Iter->Address, 0u);
 262   EXPECT_EQ(Iter->Length, 0u);
 263   ++Iter;
 264   EXPECT_EQ(Iter->Address, 1u);
 265   EXPECT_EQ(Iter->Length, 1u);
 266   EXPECT_THAT_ERROR(
 267       Warnings.getWarning(),
 268       FailedWithMessage("address range table at offset 0x0 has a premature "
 269                         "terminator entry at offset 0x10"));
 270 }
 271
 272 } // end anonymous namespace