llvm · Aug 6, 2019
diff --git a/‎llvm/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
+2-2 b/‎llvm/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
+2-2
diff --git a/‎llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
+37-33 b/‎llvm/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
+37-33
@@ -130,11 +130,11 @@ class DWARFAbbreviationDeclaration {
   /// \param Attr DWARF attribute to search for.
   /// \param U the DWARFUnit the contains the DIE.
   /// \returns Optional DWARF form value if the attribute was extracted.
-  Optional<DWARFFormValue> getAttributeValue(const uint32_t DIEOffset,
+  Optional<DWARFFormValue> getAttributeValue(const uint64_t DIEOffset,
                                              const dwarf::Attribute Attr,
                                              const DWARFUnit &U) const;
 
-  bool extract(DataExtractor Data, uint32_t* OffsetPtr);
+  bool extract(DataExtractor Data, uint64_t* OffsetPtr);
   void dump(raw_ostream &OS) const;
 
   // Return an optional byte size of all attribute data in this abbreviation
 
@@ -96,7 +96,7 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable {
     using AtomType = uint16_t;
     using Form = dwarf::Form;
 
-    uint32_t DIEOffsetBase;
+    uint64_t DIEOffsetBase;
     SmallVector<std::pair<AtomType, Form>, 3> Atoms;
 
     Optional<uint64_t> extractOffset(Optional<DWARFFormValue> Value) const;
@@ -109,7 +109,7 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable {
   /// Returns true if we should continue scanning for entries or false if we've
   /// reached the last (sentinel) entry of encountered a parsing error.
   bool dumpName(ScopedPrinter &W, SmallVectorImpl<DWARFFormValue> &AtomForms,
-                uint32_t *DataOffset) const;
+                uint64_t *DataOffset) const;
 
 public:
   /// Apple-specific implementation of an Accelerator Entry.
@@ -119,7 +119,7 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable {
     Entry(const HeaderData &Data);
     Entry() = default;
 
-    void extract(const AppleAcceleratorTable &AccelTable, uint32_t *Offset);
+    void extract(const AppleAcceleratorTable &AccelTable, uint64_t *Offset);
 
   public:
     Optional<uint64_t> getCUOffset() const override;
@@ -143,15 +143,15 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable {
   class ValueIterator : public std::iterator<std::input_iterator_tag, Entry> {
     const AppleAcceleratorTable *AccelTable = nullptr;
     Entry Current;           ///< The current entry.
-    unsigned DataOffset = 0; ///< Offset into the section.
+    uint64_t DataOffset = 0; ///< Offset into the section.
     unsigned Data = 0; ///< Current data entry.
     unsigned NumData = 0; ///< Number of data entries.
 
     /// Advance the iterator.
     void Next();
   public:
     /// Construct a new iterator for the entries at \p DataOffset.
-    ValueIterator(const AppleAcceleratorTable &AccelTable, unsigned DataOffset);
+    ValueIterator(const AppleAcceleratorTable &AccelTable, uint64_t DataOffset);
     /// End marker.
     ValueIterator() = default;
 
@@ -193,7 +193,7 @@ class AppleAcceleratorTable : public DWARFAcceleratorTable {
   /// DieOffset is the offset into the .debug_info section for the DIE
   /// related to the input hash data offset.
   /// DieTag is the tag of the DIE
-  std::pair<uint32_t, dwarf::Tag> readAtoms(uint32_t &HashDataOffset);
+  std::pair<uint64_t, dwarf::Tag> readAtoms(uint64_t *HashDataOffset);
   void dump(raw_ostream &OS) const override;
 
   /// Look up all entries in the accelerator table matching \c Key.
@@ -245,7 +245,7 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
   struct Header : public HeaderPOD {
     SmallString<8> AugmentationString;
 
-    Error extract(const DWARFDataExtractor &AS, uint32_t *Offset);
+    Error extract(const DWARFDataExtractor &AS, uint64_t *Offset);
     void dump(ScopedPrinter &W) const;
   };
 
@@ -354,30 +354,30 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
     DataExtractor StrData;
 
     uint32_t Index;
-    uint32_t StringOffset;
-    uint32_t EntryOffset;
+    uint64_t StringOffset;
+    uint64_t EntryOffset;
 
   public:
     NameTableEntry(const DataExtractor &StrData, uint32_t Index,
-                   uint32_t StringOffset, uint32_t EntryOffset)
+                   uint64_t StringOffset, uint64_t EntryOffset)
         : StrData(StrData), Index(Index), StringOffset(StringOffset),
           EntryOffset(EntryOffset) {}
 
     /// Return the index of this name in the parent Name Index.
     uint32_t getIndex() const { return Index; }
 
     /// Returns the offset of the name of the described entities.
-    uint32_t getStringOffset() const { return StringOffset; }
+    uint64_t getStringOffset() const { return StringOffset; }
 
     /// Return the string referenced by this name table entry or nullptr if the
     /// string offset is not valid.
     const char *getString() const {
-      uint32_t Off = StringOffset;
+      uint64_t Off = StringOffset;
       return StrData.getCStr(&Off);
     }
 
     /// Returns the offset of the first Entry in the list.
-    uint32_t getEntryOffset() const { return EntryOffset; }
+    uint64_t getEntryOffset() const { return EntryOffset; }
   };
 
   /// Represents a single accelerator table within the DWARF v5 .debug_names
@@ -389,40 +389,40 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
 
     // Base of the whole unit and of various important tables, as offsets from
     // the start of the section.
-    uint32_t Base;
-    uint32_t CUsBase;
-    uint32_t BucketsBase;
-    uint32_t HashesBase;
-    uint32_t StringOffsetsBase;
-    uint32_t EntryOffsetsBase;
-    uint32_t EntriesBase;
+    uint64_t Base;
+    uint64_t CUsBase;
+    uint64_t BucketsBase;
+    uint64_t HashesBase;
+    uint64_t StringOffsetsBase;
+    uint64_t EntryOffsetsBase;
+    uint64_t EntriesBase;
 
     void dumpCUs(ScopedPrinter &W) const;
     void dumpLocalTUs(ScopedPrinter &W) const;
     void dumpForeignTUs(ScopedPrinter &W) const;
     void dumpAbbreviations(ScopedPrinter &W) const;
-    bool dumpEntry(ScopedPrinter &W, uint32_t *Offset) const;
+    bool dumpEntry(ScopedPrinter &W, uint64_t *Offset) const;
     void dumpName(ScopedPrinter &W, const NameTableEntry &NTE,
                   Optional<uint32_t> Hash) const;
     void dumpBucket(ScopedPrinter &W, uint32_t Bucket) const;
 
-    Expected<AttributeEncoding> extractAttributeEncoding(uint32_t *Offset);
+    Expected<AttributeEncoding> extractAttributeEncoding(uint64_t *Offset);
 
     Expected<std::vector<AttributeEncoding>>
-    extractAttributeEncodings(uint32_t *Offset);
+    extractAttributeEncodings(uint64_t *Offset);
 
-    Expected<Abbrev> extractAbbrev(uint32_t *Offset);
+    Expected<Abbrev> extractAbbrev(uint64_t *Offset);
 
   public:
-    NameIndex(const DWARFDebugNames &Section, uint32_t Base)
+    NameIndex(const DWARFDebugNames &Section, uint64_t Base)
         : Section(Section), Base(Base) {}
 
     /// Reads offset of compilation unit CU. CU is 0-based.
-    uint32_t getCUOffset(uint32_t CU) const;
+    uint64_t getCUOffset(uint32_t CU) const;
     uint32_t getCUCount() const { return Hdr.CompUnitCount; }
 
     /// Reads offset of local type unit TU, TU is 0-based.
-    uint32_t getLocalTUOffset(uint32_t TU) const;
+    uint64_t getLocalTUOffset(uint32_t TU) const;
     uint32_t getLocalTUCount() const { return Hdr.LocalTypeUnitCount; }
 
     /// Reads signature of foreign type unit TU. TU is 0-based.
@@ -451,6 +451,10 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
       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.
@@ -460,8 +464,8 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
     NameIterator end() const { return NameIterator(this, getNameCount() + 1); }
 
     Error extract();
-    uint32_t getUnitOffset() const { return Base; }
-    uint32_t getNextUnitOffset() const { return Base + 4 + Hdr.UnitLength; }
+    uint64_t getUnitOffset() const { return Base; }
+    uint64_t getNextUnitOffset() const { return Base + 4 + Hdr.UnitLength; }
     void dump(ScopedPrinter &W) const;
 
     friend class DWARFDebugNames;
@@ -479,12 +483,12 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
     bool IsLocal;
 
     Optional<Entry> CurrentEntry;
-    unsigned DataOffset = 0; ///< Offset into the section.
+    uint64_t DataOffset = 0; ///< Offset into the section.
     std::string Key;         ///< The Key we are searching for.
     Optional<uint32_t> Hash; ///< Hash of Key, if it has been computed.
 
     bool getEntryAtCurrentOffset();
-    Optional<uint32_t> findEntryOffsetInCurrentIndex();
+    Optional<uint64_t> findEntryOffsetInCurrentIndex();
     bool findInCurrentIndex();
     void searchFromStartOfCurrentIndex();
     void next();
@@ -572,7 +576,7 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
 
 private:
   SmallVector<NameIndex, 0> NameIndices;
-  DenseMap<uint32_t, const NameIndex *> CUToNameIndex;
+  DenseMap<uint64_t, const NameIndex *> CUToNameIndex;
 
 public:
   DWARFDebugNames(const DWARFDataExtractor &AccelSection,
@@ -591,7 +595,7 @@ class DWARFDebugNames : public DWARFAcceleratorTable {
 
   /// Return the Name Index covering the compile unit at CUOffset, or nullptr if
   /// there is no Name Index covering that unit.
-  const NameIndex *getCUNameIndex(uint32_t CUOffset);
+  const NameIndex *getCUNameIndex(uint64_t CUOffset);
 };
 
 } // end namespace llvm