Remove support for 32-bit offsets in utility classes (5/5)

[dblaikie]

Great!

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

public:
     uint32_t getNameCount() const { return Hdr.NameCount; }
 
     const DenseSet<Abbrev, AbbrevMapInfo> &getAbbrevs() const {
       return Abbrevs;
     }
 
     Expected<Entry> getEntry(uint64_t *Offset) const;
 
-    // A temporarily method to preserve compatibility with existing code.
-    // Will be removed when the migration to 64-bit offsets is finished.
-    Expected<Entry> getEntry(uint32_t *Offset) const;
-
     /// Look up all entries in this Name Index matching \c Key.
     iterator_range<ValueIterator> equal_range(StringRef Key) const;
 
     NameIterator begin() const { return NameIterator(this, 1); }
     NameIterator end() const { return NameIterator(this, getNameCount() + 1); }
 
     Error extract();
     uint64_t getUnitOffset() const { return Base; }

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

public:
   /// \param DebugInfoData The data where we want to skip the value.
   /// \param OffsetPtr A reference to the offset that will be updated.
   /// \param FormParams DWARF parameters to help interpret forms.
   /// \returns true on success, false if the form was not skipped.
   static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
                         uint64_t *OffsetPtr,
                         const dwarf::FormParams FormParams);
 
-  // The following methods are temporarily kept in order to preserve
-  // compatibility with existing code and migrate to 64-bit offsets smoothly.
-  // They will be removed when the migration is finished.
-  // Please do not use them in new code.
-  static DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit,
-                                       uint32_t *OffsetPtr);
-  bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
-                    dwarf::FormParams FormParams,
-                    const DWARFContext *Context = nullptr,
-                    const DWARFUnit *Unit = nullptr);
-  bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
-                    dwarf::FormParams FormParams, const DWARFUnit *U) {
-    return extractValue(Data, OffsetPtr, FormParams, nullptr, U);
-  }
-  bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
-                 const dwarf::FormParams Params) const {
-    return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, Params);
-  }
-  static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                        uint32_t *OffsetPtr,
-                        const dwarf::FormParams FormParams);
-
 private:
   void dumpString(raw_ostream &OS) const;
 };
 
 namespace dwarf {
 
 /// Take an optional DWARFFormValue and try to extract a string value from it.
 ///

llvm/trunk/include/llvm/Support/DataExtractor.h

public:
   ///
   /// @return
   ///     \b true if \a offset is a valid offset and there are enough
   ///     bytes for a pointer available at that offset, \b false
   ///     otherwise.
   bool isValidOffsetForAddress(uint64_t offset) const {
     return isValidOffsetForDataOfSize(offset, AddressSize);
   }
-
-  // The following methods are temporarily kept in order to preserve
-  // compatibility with existing code and migrate to 64-bit offsets smoothly.
-  // They will be removed when the migration is finished.
-  // Please do not use them in new code.
-  const char *getCStr(uint32_t *offset_ptr) const;
-  StringRef getCStrRef(uint32_t *offset_ptr) const;
-  uint64_t getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const;
-  int64_t getSigned(uint32_t *offset_ptr, uint32_t size) const;
-  uint64_t getAddress(uint32_t *offset_ptr) const {
-    return getUnsigned(offset_ptr, AddressSize);
-  }
-  uint8_t getU8(uint32_t *offset_ptr) const;
-  uint8_t *getU8(uint32_t *offset_ptr, uint8_t *dst, uint32_t count) const;
-  uint16_t getU16(uint32_t *offset_ptr) const;
-  uint16_t *getU16(uint32_t *offset_ptr, uint16_t *dst, uint32_t count) const;
-  uint32_t getU24(uint32_t *offset_ptr) const;
-  uint32_t getU32(uint32_t *offset_ptr) const;
-  uint32_t *getU32(uint32_t *offset_ptr, uint32_t *dst, uint32_t count) const;
-  uint64_t getU64(uint32_t *offset_ptr) const;
-  uint64_t *getU64(uint32_t *offset_ptr, uint64_t *dst, uint32_t count) const;
-  int64_t getSLEB128(uint32_t *offset_ptr) const;
-  uint64_t getULEB128(uint32_t *offset_ptr) const;
 };
 
 } // namespace llvm
 
 #endif

llvm/trunk/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

DWARFDebugNames::NameIndex::getEntry(uint64_t *Offset) const {
   for (auto &Value : E.Values) {
     if (!Value.extractValue(AS, Offset, FormParams))
       return createStringError(errc::io_error,
                                "Error extracting index attribute values.");
   }
   return std::move(E);
 }
 
-// A temporarily method to preserve compatibility with existing code.
-// Will be removed when the migration to 64-bit offsets is finished.
-Expected<DWARFDebugNames::Entry>
-DWARFDebugNames::NameIndex::getEntry(uint32_t *Offset) const {
-  uint64_t Offset64 = *Offset;
-  auto Result = getEntry(&Offset64);
-  *Offset = Offset64;
-  return Result;
-}
-
 DWARFDebugNames::NameTableEntry
 DWARFDebugNames::NameIndex::getNameTableEntry(uint32_t Index) const {
   assert(0 < Index && Index <= Hdr.NameCount);
   uint64_t StringOffsetOffset = StringOffsetsBase + 4 * (Index - 1);
   uint64_t EntryOffsetOffset = EntryOffsetsBase + 4 * (Index - 1);
   const DWARFDataExtractor &AS = Section.AccelSection;
 
   uint64_t StringOffset = AS.getRelocatedValue(4, &StringOffsetOffset);

llvm/trunk/lib/DebugInfo/DWARF/DWARFFormValue.cpp

Optional<uint64_t> DWARFFormValue::getAsCStringOffset() const {
   return Value.uval;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsReferenceUVal() const {
   if (!isFormClass(FC_Reference))
     return None;
   return Value.uval;
 }
-
-// The following is temporary code aimed to preserve compatibility with
-// existing code which uses 32-bit offsets.
-// It will be removed when migration to 64-bit offsets is finished.
-
-namespace {
-
-class WrapOffset {
-  uint64_t Offset64;
-  uint32_t *Offset32;
-
-public:
-  WrapOffset(uint32_t *Offset)
-      : Offset64(*Offset), Offset32(Offset) {}
-  ~WrapOffset() { *Offset32 = Offset64; }
-  operator uint64_t *() { return &Offset64; }
-};
-
-}
-
-DWARFFormValue DWARFFormValue::createFromUnit(dwarf::Form F, const DWARFUnit *U,
-                                              uint32_t *OffsetPtr) {
-  return createFromUnit(F, U, WrapOffset(OffsetPtr));
-}
-
-bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                               uint32_t *OffsetPtr,
-                               const dwarf::FormParams Params) {
-  return skipValue(Form, DebugInfoData, WrapOffset(OffsetPtr), Params);
-}
-
-bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
-                                  uint32_t *OffsetPtr, dwarf::FormParams FP,
-                                  const DWARFContext *Ctx,
-                                  const DWARFUnit *CU) {
-  return extractValue(Data, WrapOffset(OffsetPtr), FP, Ctx, CU);
-}

llvm/trunk/lib/Support/DataExtractor.cpp

int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr) const {
   int64_t result = decodeSLEB128(
       reinterpret_cast<const uint8_t *>(Data.data() + *offset_ptr), &bytes_read,
       reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);
   if (error)
     return 0;
   *offset_ptr += bytes_read;
   return result;
 }
-
-// The following is temporary code aimed to preserve compatibility with
-// existing code which uses 32-bit offsets.
-// It will be removed when migration to 64-bit offsets is finished.
-
-namespace {
-
-class WrapOffset {
-  uint64_t offset64;
-  uint32_t *offset32_ptr;
-
-public:
-  WrapOffset(uint32_t *offset_ptr)
-      : offset64(*offset_ptr), offset32_ptr(offset_ptr) {}
-  ~WrapOffset() { *offset32_ptr = offset64; }
-  operator uint64_t *() { return &offset64; }
-};
-
-}
-
-uint8_t DataExtractor::getU8(uint32_t *offset_ptr) const {
-  return getU8(WrapOffset(offset_ptr));
-}
-
-uint8_t *
-DataExtractor::getU8(uint32_t *offset_ptr, uint8_t *dst, uint32_t count) const {
-  return getU8(WrapOffset(offset_ptr), dst, count);
-}
-
-uint16_t DataExtractor::getU16(uint32_t *offset_ptr) const {
-  return getU16(WrapOffset(offset_ptr));
-}
-
-uint16_t *DataExtractor::getU16(uint32_t *offset_ptr, uint16_t *dst,
-                                uint32_t count) const {
-  return getU16(WrapOffset(offset_ptr), dst, count);
-}
-
-uint32_t DataExtractor::getU24(uint32_t *offset_ptr) const {
-  return getU24(WrapOffset(offset_ptr));
-}
-
-uint32_t DataExtractor::getU32(uint32_t *offset_ptr) const {
-  return getU32(WrapOffset(offset_ptr));
-}
-
-uint32_t *DataExtractor::getU32(uint32_t *offset_ptr, uint32_t *dst,
-                                uint32_t count) const {
-  return getU32(WrapOffset(offset_ptr), dst, count);
-}
-
-uint64_t DataExtractor::getU64(uint32_t *offset_ptr) const {
-  return getU64(WrapOffset(offset_ptr));
-}
-
-uint64_t *DataExtractor::getU64(uint32_t *offset_ptr, uint64_t *dst,
-                                uint32_t count) const {
-  return getU64(WrapOffset(offset_ptr), dst, count);
-}
-
-uint64_t
-DataExtractor::getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const {
-  return getUnsigned(WrapOffset(offset_ptr), byte_size);
-}
-
-int64_t
-DataExtractor::getSigned(uint32_t *offset_ptr, uint32_t byte_size) const {
-  return getSigned(WrapOffset(offset_ptr), byte_size);
-}
-
-const char *DataExtractor::getCStr(uint32_t *offset_ptr) const {
-  return getCStr(WrapOffset(offset_ptr));
-}
-
-StringRef DataExtractor::getCStrRef(uint32_t *offset_ptr) const {
-  return getCStrRef(WrapOffset(offset_ptr));
-}
-
-uint64_t DataExtractor::getULEB128(uint32_t *offset_ptr) const {
-  return getULEB128(WrapOffset(offset_ptr));
-}
-
-int64_t DataExtractor::getSLEB128(uint32_t *offset_ptr) const {
-  return getSLEB128(WrapOffset(offset_ptr));
-}

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   OS << "printELFLinkerOptions not implemented!\n";
 }
 
-// FIXME: As soon as the DataExtractor interface handles uint64_t *, this 
-// should be eliminated. See upstream review https://reviews.llvm.org/D64006.
-inline uint32_t *AdjustPtr(uint64_t *Offset) {
-  uint32_t *Ptr = reinterpret_cast<uint32_t *>(Offset);
-  if (sys::IsBigEndianHost)
-    Ptr++;
-  return Ptr;
-}
-
 template <class ELFT>
 void DumpStyle<ELFT>::printFunctionStackSize(
     const ELFObjectFile<ELFT> *Obj, uint64_t SymValue, SectionRef FunctionSec,
     const StringRef SectionName, DataExtractor Data, uint64_t *Offset) {
   // This function ignores potentially erroneous input, unless it is directly
   // related to stack size reporting.
   SymbolRef FuncSym;
   for (const ELFSymbolRef &Symbol : Obj->symbols()) {
else
       consumeError(FuncNameOrErr.takeError());
   } else
     reportWarning(" '" + FileStr +
                   "': could not identify function symbol for stack size entry");
 
   // Extract the size. The expectation is that Offset is pointing to the right
   // place, i.e. past the function address.
   uint64_t PrevOffset = *Offset;
-  uint64_t StackSize = Data.getULEB128(AdjustPtr(Offset));
+  uint64_t StackSize = Data.getULEB128(Offset);
   // getULEB128() does not advance Offset if it is not able to extract a valid
   // integer.
   if (*Offset == PrevOffset)
     reportError(
         FileStr,
         createStringError(object_error::parse_failed,
                           "could not extract a valid stack size in section %s",
                           SectionName.data()));
void DumpStyle<ELFT>::printStackSize(const ELFObjectFile<ELFT> *Obj,
   uint64_t Offset = Reloc.getOffset();
   if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1))
     reportError(FileStr, createStringError(
                              object_error::parse_failed,
                              "found invalid relocation offset into section %s "
                              "while trying to extract a stack size entry",
                              StackSizeSectionName.data()));
 
-  uint64_t Addend = Data.getAddress(AdjustPtr(&Offset));
+  uint64_t Addend = Data.getAddress(&Offset);
   uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend);
   this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName,
                                Data, &Offset);
 }
 
 template <class ELFT>
 SectionRef toSectionRef(const ObjectFile *Obj, const typename ELFT::Shdr *Sec) {
   DataRefImpl DRI;
while (Offset < Contents.size()) {
       if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) {
         reportError(
             FileStr,
             createStringError(
                 object_error::parse_failed,
                 "section %s ended while trying to extract a stack size entry",
                 SectionName.data()));
       }
-      uint64_t SymValue = Data.getAddress(AdjustPtr(&Offset));
+      uint64_t SymValue = Data.getAddress(&Offset);
       printFunctionStackSize(Obj, SymValue,
                              toSectionRef<ELFT>(Obj, FunctionELFSec),
                              SectionName, Data, &Offset);
     }
   }
 }
 
 template <class ELFT>

llvm/trunk/unittests/Support/DataExtractorTest.cpp

 //===- llvm/unittest/Support/DataExtractorTest.cpp - DataExtractor tests --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/DataExtractor.h"
 #include "gtest/gtest.h"
 using namespace llvm;
 
 namespace {
 
-// Test fixture
-template <typename T>
-class DataExtractorTest : public ::testing::Test { };
-
-// Test DataExtractor with both types which can be used for offsets.
-typedef ::testing::Types</*uint32_t, */uint64_t> TestTypes;
-TYPED_TEST_CASE(DataExtractorTest, TestTypes);
-
 const char numberData[] = "\x80\x90\xFF\xFF\x80\x00\x00\x00";
 const char stringData[] = "hellohello\0hello";
 const char leb128data[] = "\xA6\x49";
 const char bigleb128data[] = "\xAA\xA9\xFF\xAA\xFF\xAA\xFF\x4A";
 
-TYPED_TEST(DataExtractorTest, OffsetOverflow) {
+TEST(DataExtractorTest, OffsetOverflow) {
   DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
   EXPECT_FALSE(DE.isValidOffsetForDataOfSize(-2U, 5));
 }
 
-TYPED_TEST(DataExtractorTest, UnsignedNumbers) {
+TEST(DataExtractorTest, UnsignedNumbers) {
   DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
-  TypeParam offset = 0;
+  uint64_t offset = 0;
 
   EXPECT_EQ(0x80U, DE.getU8(&offset));
   EXPECT_EQ(1U, offset);
   offset = 0;
   EXPECT_EQ(0x8090U, DE.getU16(&offset));
   EXPECT_EQ(2U, offset);
   offset = 0;
   EXPECT_EQ(0x8090FFFFU, DE.getU32(&offset));
TEST(DataExtractorTest, UnsignedNumbers) {
   offset = 0;
 
   EXPECT_EQ(data, DE.getU32(&offset, data, 2));
   EXPECT_EQ(0xFFFF9080U, data[0]);
   EXPECT_EQ(0x80U, data[1]);
   EXPECT_EQ(8U, offset);
 }
 
-TYPED_TEST(DataExtractorTest, SignedNumbers) {
+TEST(DataExtractorTest, SignedNumbers) {
   DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
-  TypeParam offset = 0;
+  uint64_t offset = 0;
 
   EXPECT_EQ(-128, DE.getSigned(&offset, 1));
   EXPECT_EQ(1U, offset);
   offset = 0;
   EXPECT_EQ(-32624, DE.getSigned(&offset, 2));
   EXPECT_EQ(2U, offset);
   offset = 0;
   EXPECT_EQ(-2137980929, DE.getSigned(&offset, 4));
   EXPECT_EQ(4U, offset);
   offset = 0;
   EXPECT_EQ(-9182558167379214336LL, DE.getSigned(&offset, 8));
   EXPECT_EQ(8U, offset);
 }
 
-TYPED_TEST(DataExtractorTest, Strings) {
+TEST(DataExtractorTest, Strings) {
   DataExtractor DE(StringRef(stringData, sizeof(stringData)-1), false, 8);
-  TypeParam offset = 0;
+  uint64_t offset = 0;
 
   EXPECT_EQ(stringData, DE.getCStr(&offset));
   EXPECT_EQ(11U, offset);
   EXPECT_EQ(nullptr, DE.getCStr(&offset));
   EXPECT_EQ(11U, offset);
 }
 
-TYPED_TEST(DataExtractorTest, LEB128) {
+TEST(DataExtractorTest, LEB128) {
   DataExtractor DE(StringRef(leb128data, sizeof(leb128data)-1), false, 8);
-  TypeParam offset = 0;
+  uint64_t offset = 0;
 
   EXPECT_EQ(9382ULL, DE.getULEB128(&offset));
   EXPECT_EQ(2U, offset);
   offset = 0;
   EXPECT_EQ(-7002LL, DE.getSLEB128(&offset));
   EXPECT_EQ(2U, offset);
 
   DataExtractor BDE(StringRef(bigleb128data, sizeof(bigleb128data)-1), false,8);
   offset = 0;
   EXPECT_EQ(42218325750568106ULL, BDE.getULEB128(&offset));
   EXPECT_EQ(8U, offset);
   offset = 0;
   EXPECT_EQ(-29839268287359830LL, BDE.getSLEB128(&offset));
   EXPECT_EQ(8U, offset);
 }
 
-TYPED_TEST(DataExtractorTest, LEB128_error) {
+TEST(DataExtractorTest, LEB128_error) {
   DataExtractor DE(StringRef("\x81"), false, 8);
-  TypeParam Offset = 0;
+  uint64_t Offset = 0;
   EXPECT_EQ(0U, DE.getULEB128(&Offset));
   EXPECT_EQ(0U, Offset);
 
   Offset = 0;
   EXPECT_EQ(0U, DE.getSLEB128(&Offset));
   EXPECT_EQ(0U, Offset);
 }
 }