[llvm-gsymutil][NFC] refactor AddressRange&AddresRanges structures.

[avl]

Summary

llvm-gsymutil has an implementation of AddressRange and AddressRanges
classes. That implementation might be reused in other parts of llvm.
This patch moves AddressRange and AddressRanges classes into llvm/ADT.

[clayborg]

Very nice! Thanks for taking the time.

[avl]

Thank you for the review!

[RKSimon]

llvm/lib/Support/AddressRanges.cpp

24

@avl I'm seeing static analyzer warnings about using signed (negative) values into It2[] - maybe add a static cast?

[avl]

llvm/lib/Support/AddressRanges.cpp

24

Thanks! Will add cast.

llvm/include/llvm/ADT/AddressRanges.h

+//===- AddressRanges.h ------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_ADDRESSRANGES_H
+#define LLVM_ADT_ADDRESSRANGES_H
+
+#include "llvm/ADT/Optional.h"
+#include <cassert>
+#include <stdint.h>
+#include <vector>
+
+namespace llvm {
+
+/// A class that represents an address range. The range is specified using
+/// a start and an end address: [Start, End).
+class AddressRange {
+public:
+  AddressRange() {}
+  AddressRange(uint64_t S, uint64_t E) : Start(S), End(E) {
+    assert(Start <= End);
+  }
+  uint64_t start() const { return Start; }
+  uint64_t end() const { return End; }
+  uint64_t size() const { return End - Start; }
+  bool contains(uint64_t Addr) const { return Start <= Addr && Addr < End; }
+  bool intersects(const AddressRange &R) const {
+    return Start < R.End && R.Start < End;
+  }
+  bool operator==(const AddressRange &R) const {
+    return Start == R.Start && End == R.End;
+  }
+  bool operator!=(const AddressRange &R) const { return !(*this == R); }
+  bool operator<(const AddressRange &R) const {
+    return std::make_pair(Start, End) < std::make_pair(R.Start, R.End);
+  }
+
+private:
+  uint64_t Start = 0;
+  uint64_t End = 0;
+};
+
+/// The AddressRanges class helps normalize address range collections.
+/// This class keeps a sorted vector of AddressRange objects and can perform
+/// insertions and searches efficiently. The address ranges are always sorted
+/// and never contain any invalid or empty address ranges. Intersecting
+/// address ranges are combined during insertion.
+class AddressRanges {
+protected:
+  using Collection = std::vector<AddressRange>;
+  Collection Ranges;
+
+public:
+  void clear() { Ranges.clear(); }
+  bool empty() const { return Ranges.empty(); }
+  bool contains(uint64_t Addr) const;
+  bool contains(AddressRange Range) const;
+  Optional<AddressRange> getRangeThatContains(uint64_t Addr) const;
+  void insert(AddressRange Range);
+  void reserve(size_t Capacity) { Ranges.reserve(Capacity); }
+  size_t size() const { return Ranges.size(); }
+  bool operator==(const AddressRanges &RHS) const {
+    return Ranges == RHS.Ranges;
+  }
+  const AddressRange &operator[](size_t i) const {
+    assert(i < Ranges.size());
+    return Ranges[i];
+  }
+  Collection::const_iterator begin() const { return Ranges.begin(); }
+  Collection::const_iterator end() const { return Ranges.end(); }
+};
+
+} // namespace llvm
+
+#endif // LLVM_ADT_ADDRESSRANGES_H

llvm/include/llvm/DebugInfo/GSYM/DwarfTransformer.h

 //===- DwarfTransformer.h ---------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_DWARFTRANSFORMER_H
 #define LLVM_DEBUGINFO_GSYM_DWARFTRANSFORMER_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class raw_ostream;
 
 namespace gsym {
 

llvm/include/llvm/DebugInfo/GSYM/ExtractRanges.h

+//===- ExtractRanges.h ------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_EXTRACTRANGES_H
+#define LLVM_DEBUGINFO_GSYM_EXTRACTRANGES_H
+
+#include "llvm/ADT/AddressRanges.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+#include <stdint.h>
+#include <vector>
+
+#define HEX8(v) llvm::format_hex(v, 4)
+#define HEX16(v) llvm::format_hex(v, 6)
+#define HEX32(v) llvm::format_hex(v, 10)
+#define HEX64(v) llvm::format_hex(v, 18)
+
+namespace llvm {
+class DataExtractor;
+class raw_ostream;
+
+namespace gsym {
+
+class FileWriter;
+
+/// AddressRange objects are encoded and decoded to be relative to a base
+/// address. This will be the FunctionInfo's start address if the AddressRange
+/// is directly contained in a FunctionInfo, or a base address of the
+/// containing parent AddressRange or AddressRanges. This allows address
+/// ranges to be efficiently encoded using ULEB128 encodings as we encode the
+/// offset and size of each range instead of full addresses. This also makes
+/// encoded addresses easy to relocate as we just need to relocate one base
+/// address.
+/// @{
+AddressRange decodeRange(DataExtractor &Data, uint64_t BaseAddr,
+                         uint64_t &Offset);
+void encodeRange(const AddressRange &Range, FileWriter &O, uint64_t BaseAddr);
+/// @}
+
+/// Skip an address range object in the specified data a the specified
+/// offset.
+///
+/// \param Data The binary stream to read the data from.
+///
+/// \param Offset The byte offset within \a Data.
+void skipRange(DataExtractor &Data, uint64_t &Offset);
+
+/// Address ranges are decoded and encoded to be relative to a base address.
+/// See the AddressRange comment for the encode and decode methods for full
+/// details.
+/// @{
+void decodeRanges(AddressRanges &Ranges, DataExtractor &Data, uint64_t BaseAddr,
+                  uint64_t &Offset);
+void encodeRanges(const AddressRanges &Ranges, FileWriter &O,
+                  uint64_t BaseAddr);
+/// @}
+
+/// Skip an address range object in the specified data a the specified
+/// offset.
+///
+/// \param Data The binary stream to read the data from.
+///
+/// \param Offset The byte offset within \a Data.
+///
+/// \returns The number of address ranges that were skipped.
+uint64_t skipRanges(DataExtractor &Data, uint64_t &Offset);
+
+} // namespace gsym
+
+raw_ostream &operator<<(raw_ostream &OS, const AddressRange &R);
+
+raw_ostream &operator<<(raw_ostream &OS, const AddressRanges &AR);
+
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_GSYM_EXTRACTRANGES_H

llvm/include/llvm/DebugInfo/GSYM/FunctionInfo.h

 //===- FunctionInfo.h -------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
 #define LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include "llvm/DebugInfo/GSYM/InlineInfo.h"
 #include "llvm/DebugInfo/GSYM/LineTable.h"
 #include "llvm/DebugInfo/GSYM/LookupResult.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
 #include "llvm/DebugInfo/GSYM/StringTable.h"
 #include <cstdint>
 #include <tuple>
 
 namespace llvm {
 class raw_ostream;
 
 namespace gsym {
struct FunctionInfo {
   /// \returns An LookupResult or an error describing the issue that was
   /// encountered during decoding. An error should only be returned if the
   /// address is not contained in the FunctionInfo or if the data is corrupted.
   static llvm::Expected<LookupResult> lookup(DataExtractor &Data,
                                              const GsymReader &GR,
                                              uint64_t FuncAddr,
                                              uint64_t Addr);
 
-  uint64_t startAddress() const { return Range.Start; }
-  uint64_t endAddress() const { return Range.End; }
+  uint64_t startAddress() const { return Range.start(); }
+  uint64_t endAddress() const { return Range.end(); }
   uint64_t size() const { return Range.size(); }
-  void setStartAddress(uint64_t Addr) { Range.Start = Addr; }
-  void setEndAddress(uint64_t Addr) { Range.End = Addr; }
-  void setSize(uint64_t Size) { Range.End = Range.Start + Size; }
 
   void clear() {
     Range = {0, 0};
     Name = 0;
     OptLineTable = None;
     Inline = None;
   }
 };

llvm/include/llvm/DebugInfo/GSYM/GsymCreator.h

 
 #include <functional>
 #include <memory>
 #include <mutex>
 #include <thread>
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include "llvm/DebugInfo/GSYM/FileEntry.h"
 #include "llvm/DebugInfo/GSYM/FunctionInfo.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
 
 namespace llvm {
 
 namespace gsym {

llvm/include/llvm/DebugInfo/GSYM/InlineInfo.h

 //===- InlineInfo.h ---------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_INLINEINFO_H
 #define LLVM_DEBUGINFO_GSYM_INLINEINFO_H
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include "llvm/DebugInfo/GSYM/LineEntry.h"
 #include "llvm/DebugInfo/GSYM/LookupResult.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
 #include "llvm/Support/Error.h"
 #include <stdint.h>
 #include <vector>
 
-
 namespace llvm {
 class raw_ostream;
 
 namespace gsym {
 
 class GsymReader;
 /// Inline information stores the name of the inline function along with
 /// an array of address ranges. It also stores the call file and call line

llvm/include/llvm/DebugInfo/GSYM/LineEntry.h

 //===- LineEntry.h ----------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_LINEENTRY_H
 #define LLVM_DEBUGINFO_GSYM_LINEENTRY_H
 
-#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 
 namespace llvm {
 namespace gsym {
 
 /// Line entries are used to encode the line tables in FunctionInfo objects.
 /// They are stored as a sorted vector of these objects and store the
 /// address, file and line of the line table row for a given address. The
 /// size of a line table entry is calculated by looking at the next entry

llvm/include/llvm/DebugInfo/GSYM/LookupResult.h

 //===- LookupResult.h -------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
 #define LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include <inttypes.h>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 namespace gsym {
 
 struct SourceLocation {

llvm/include/llvm/DebugInfo/GSYM/Range.h

-//===- Range.h --------------------------------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEBUGINFO_GSYM_RANGE_H
-#define LLVM_DEBUGINFO_GSYM_RANGE_H
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/raw_ostream.h"
-#include <stdint.h>
-#include <vector>
-
-#define HEX8(v) llvm::format_hex(v, 4)
-#define HEX16(v) llvm::format_hex(v, 6)
-#define HEX32(v) llvm::format_hex(v, 10)
-#define HEX64(v) llvm::format_hex(v, 18)
-
-namespace llvm {
-class DataExtractor;
-class raw_ostream;
-
-namespace gsym {
-
-class FileWriter;
-
-/// A class that represents an address range. The range is specified using
-/// a start and an end address.
-struct AddressRange {
-  uint64_t Start;
-  uint64_t End;
-  AddressRange() : Start(0), End(0) {}
-  AddressRange(uint64_t S, uint64_t E) : Start(S), End(E) {}
-  uint64_t size() const { return End - Start; }
-  bool contains(uint64_t Addr) const { return Start <= Addr && Addr < End; }
-  bool intersects(const AddressRange &R) const {
-    return Start < R.End && R.Start < End;
-  }
-
-  bool operator==(const AddressRange &R) const {
-    return Start == R.Start && End == R.End;
-  }
-  bool operator!=(const AddressRange &R) const {
-    return !(*this == R);
-  }
-  bool operator<(const AddressRange &R) const {
-    return std::make_pair(Start, End) < std::make_pair(R.Start, R.End);
-  }
-  /// AddressRange objects are encoded and decoded to be relative to a base
-  /// address. This will be the FunctionInfo's start address if the AddressRange
-  /// is directly contained in a FunctionInfo, or a base address of the
-  /// containing parent AddressRange or AddressRanges. This allows address
-  /// ranges to be efficiently encoded using ULEB128 encodings as we encode the
-  /// offset and size of each range instead of full addresses. This also makes
-  /// encoded addresses easy to relocate as we just need to relocate one base
-  /// address.
-  /// @{
-  void decode(DataExtractor &Data, uint64_t BaseAddr, uint64_t &Offset);
-  void encode(FileWriter &O, uint64_t BaseAddr) const;
-  /// @}
-
-  /// Skip an address range object in the specified data a the specified
-  /// offset.
-  ///
-  /// \param Data The binary stream to read the data from.
-  ///
-  /// \param Offset The byte offset within \a Data.
-  static void skip(DataExtractor &Data, uint64_t &Offset);
-};
-
-raw_ostream &operator<<(raw_ostream &OS, const AddressRange &R);
-
-/// The AddressRanges class helps normalize address range collections.
-/// This class keeps a sorted vector of AddressRange objects and can perform
-/// insertions and searches efficiently. The address ranges are always sorted
-/// and never contain any invalid or empty address ranges. This allows us to
-/// emit address ranges into the GSYM file efficiently. Intersecting address
-/// ranges are combined during insertion so that we can emit the most compact
-/// representation for address ranges when writing to disk.
-class AddressRanges {
-protected:
-  using Collection = std::vector<AddressRange>;
-  Collection Ranges;
-public:
-  void clear() { Ranges.clear(); }
-  bool empty() const { return Ranges.empty(); }
-  bool contains(uint64_t Addr) const;
-  bool contains(AddressRange Range) const;
-  Optional<AddressRange> getRangeThatContains(uint64_t Addr) const;
-  void insert(AddressRange Range);
-  size_t size() const { return Ranges.size(); }
-  bool operator==(const AddressRanges &RHS) const {
-    return Ranges == RHS.Ranges;
-  }
-  const AddressRange &operator[](size_t i) const {
-    assert(i < Ranges.size());
-    return Ranges[i];
-  }
-  Collection::const_iterator begin() const { return Ranges.begin(); }
-  Collection::const_iterator end() const { return Ranges.end(); }
-
-  /// Address ranges are decoded and encoded to be relative to a base address.
-  /// See the AddressRange comment for the encode and decode methods for full
-  /// details.
-  /// @{
-  void decode(DataExtractor &Data, uint64_t BaseAddr, uint64_t &Offset);
-  void encode(FileWriter &O, uint64_t BaseAddr) const;
-  /// @}
-
-  /// Skip an address range object in the specified data a the specified
-  /// offset.
-  ///
-  /// \param Data The binary stream to read the data from.
-  ///
-  /// \param Offset The byte offset within \a Data.
-  ///
-  /// \returns The number of address ranges that were skipped.
-  static uint64_t skip(DataExtractor &Data, uint64_t &Offset);
-};
-
-raw_ostream &operator<<(raw_ostream &OS, const AddressRanges &AR);
-
-} // namespace gsym
-} // namespace llvm
-
-#endif // LLVM_DEBUGINFO_GSYM_RANGE_H

llvm/include/llvm/DebugInfo/GSYM/StringTable.h

 //===- StringTable.h --------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_STRINGTABLE_H
 #define LLVM_DEBUGINFO_GSYM_STRINGTABLE_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include <stdint.h>
 
 namespace llvm {
 namespace gsym {
 
 /// String tables in GSYM files are required to start with an empty
 /// string at offset zero. Strings must be UTF8 NULL terminated strings.
 struct StringTable {

llvm/lib/DebugInfo/GSYM/CMakeLists.txt

 add_llvm_component_library(LLVMDebugInfoGSYM
   DwarfTransformer.cpp
   Header.cpp
   FileWriter.cpp
   FunctionInfo.cpp
   GsymCreator.cpp
   GsymReader.cpp
   InlineInfo.cpp
   LineTable.cpp
   LookupResult.cpp
   ObjectFileTransformer.cpp
-  Range.cpp
+  ExtractRanges.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/GSYM
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
 
   DEPENDS
   LLVMMC
 
   LINK_COMPONENTS
   MC
   Object
   Support
   DebugInfoDWARF
   )

llvm/lib/DebugInfo/GSYM/DwarfTransformer.cpp

for (uint32_t RowIndex : RowVector) {
     uint64_t RowAddress = Row.Address.Address;
     // Watch out for a RowAddress that is in the middle of a line table entry
     // in the DWARF. If we pass an address in between two line table entries
     // we will get a RowIndex for the previous valid line table row which won't
     // be contained in our function. This is usually a bug in the DWARF due to
     // linker problems or LTO or other DWARF re-linking so it is worth emitting
     // an error, but not worth stopping the creation of the GSYM.
     if (!FI.Range.contains(RowAddress)) {
-      if (RowAddress < FI.Range.Start) {
+      if (RowAddress < FI.Range.start()) {
         Log << "error: DIE has a start address whose LowPC is between the "
           "line table Row[" << RowIndex << "] with address "
           << HEX64(RowAddress) << " and the next one.\n";
         Die.dump(Log, 0, DIDumpOptions::getForSingleDIE());
-        RowAddress = FI.Range.Start;
+        RowAddress = FI.Range.start();
       } else {
         continue;
       }
     }
 
     LineEntry LE(RowAddress, FileIdx, Row.Line);
     if (RowIndex != RowVector[0] && Row.Address < PrevRow.Address) {
       // We have seen full duplicate line tables for functions in some
for (const DWARFAddressRange &Range : Ranges) {
                << ") and will not be processed:\n";
             Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
           }
         }
         break;
       }
 
       FunctionInfo FI;
-      FI.setStartAddress(Range.LowPC);
-      FI.setEndAddress(Range.HighPC);
+      FI.Range = {Range.LowPC, Range.HighPC};
       FI.Name = *NameIndex;
       if (CUI.LineTable) {
         convertFunctionLineTable(OS, CUI, Die, Gsym, FI);
       }
       if (hasInlineInfo(Die, 0)) {
         FI.Inline = InlineInfo();
         FI.Inline->Name = *NameIndex;
         FI.Inline->Ranges.insert(FI.Range);

llvm/lib/DebugInfo/GSYM/ExtractRanges.cpp

+//===- ExtractRanges.cpp ----------------------------------------*- C++ -*-===//
+//
+// 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/DebugInfo/GSYM/ExtractRanges.h"
+#include "llvm/DebugInfo/GSYM/FileWriter.h"
+#include "llvm/Support/DataExtractor.h"
+#include <algorithm>
+#include <inttypes.h>
+
+namespace llvm {
+namespace gsym {
+
+void encodeRange(const AddressRange &Range, FileWriter &O, uint64_t BaseAddr) {
+  assert(Range.start() >= BaseAddr);
+  O.writeULEB(Range.start() - BaseAddr);
+  O.writeULEB(Range.size());
+}
+
+AddressRange decodeRange(DataExtractor &Data, uint64_t BaseAddr,
+                         uint64_t &Offset) {
+  const uint64_t AddrOffset = Data.getULEB128(&Offset);
+  const uint64_t Size = Data.getULEB128(&Offset);
+  const uint64_t StartAddr = BaseAddr + AddrOffset;
+
+  return {StartAddr, StartAddr + Size};
+}
+
+void encodeRanges(const AddressRanges &Ranges, FileWriter &O,
+                  uint64_t BaseAddr) {
+  O.writeULEB(Ranges.size());
+  if (Ranges.empty())
+    return;
+  for (auto Range : Ranges)
+    encodeRange(Range, O, BaseAddr);
+}
+
+void decodeRanges(AddressRanges &Ranges, DataExtractor &Data, uint64_t BaseAddr,
+                  uint64_t &Offset) {
+  Ranges.clear();
+  uint64_t NumRanges = Data.getULEB128(&Offset);
+  Ranges.reserve(NumRanges);
+  for (uint64_t RangeIdx = 0; RangeIdx < NumRanges; RangeIdx++)
+    Ranges.insert(decodeRange(Data, BaseAddr, Offset));
+}
+
+void skipRange(DataExtractor &Data, uint64_t &Offset) {
+  Data.getULEB128(&Offset);
+  Data.getULEB128(&Offset);
+}
+
+uint64_t skipRanges(DataExtractor &Data, uint64_t &Offset) {
+  uint64_t NumRanges = Data.getULEB128(&Offset);
+  for (uint64_t I = 0; I < NumRanges; ++I)
+    skipRange(Data, Offset);
+  return NumRanges;
+}
+
+} // namespace gsym
+
+raw_ostream &operator<<(raw_ostream &OS, const AddressRange &R) {
+  return OS << '[' << HEX64(R.start()) << " - " << HEX64(R.end()) << ")";
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const AddressRanges &AR) {
+  size_t Size = AR.size();
+  for (size_t I = 0; I < Size; ++I) {
+    if (I)
+      OS << ' ';
+    OS << AR[I];
+  }
+  return OS;
+}
+
+} // namespace llvm

llvm/lib/DebugInfo/GSYM/FunctionInfo.cpp

raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const FunctionInfo &FI) {
   if (FI.Inline)
     OS << FI.Inline << '\n';
   return OS;
 }
 
 llvm::Expected<FunctionInfo> FunctionInfo::decode(DataExtractor &Data,
                                                   uint64_t BaseAddr) {
   FunctionInfo FI;
-  FI.Range.Start = BaseAddr;
   uint64_t Offset = 0;
   if (!Data.isValidOffsetForDataOfSize(Offset, 4))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing FunctionInfo Size", Offset);
-  FI.Range.End = FI.Range.Start + Data.getU32(&Offset);
+  FI.Range = {BaseAddr, BaseAddr + Data.getU32(&Offset)};
   if (!Data.isValidOffsetForDataOfSize(Offset, 4))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing FunctionInfo Name", Offset);
   FI.Name = Data.getU32(&Offset);
   if (FI.Name == 0)
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": invalid FunctionInfo Name value 0x%8.8x",
         Offset - 4, FI.Name);
llvm::Expected<uint64_t> FunctionInfo::encode(FileWriter &O) const {
   O.writeU32(Name);
 
   if (OptLineTable.hasValue()) {
     O.writeU32(InfoType::LineTableInfo);
     // Write a uint32_t length as zero for now, we will fix this up after
     // writing the LineTable out with the number of bytes that were written.
     O.writeU32(0);
     const auto StartOffset = O.tell();
-    llvm::Error err = OptLineTable->encode(O, Range.Start);
+    llvm::Error err = OptLineTable->encode(O, Range.start());
     if (err)
       return std::move(err);
     const auto Length = O.tell() - StartOffset;
     if (Length > UINT32_MAX)
         return createStringError(std::errc::invalid_argument,
             "LineTable length is greater than UINT32_MAX");
     // Fixup the size of the LineTable data with the correct size.
     O.fixup32(static_cast<uint32_t>(Length), StartOffset - 4);
   }
 
   // Write out the inline function info if we have any and if it is valid.
   if (Inline.hasValue()) {
     O.writeU32(InfoType::InlineInfo);
     // Write a uint32_t length as zero for now, we will fix this up after
     // writing the LineTable out with the number of bytes that were written.
     O.writeU32(0);
     const auto StartOffset = O.tell();
-    llvm::Error err = Inline->encode(O, Range.Start);
+    llvm::Error err = Inline->encode(O, Range.start());
     if (err)
       return std::move(err);
     const auto Length = O.tell() - StartOffset;
     if (Length > UINT32_MAX)
         return createStringError(std::errc::invalid_argument,
             "InlineInfo length is greater than UINT32_MAX");
     // Fixup the size of the InlineInfo data with the correct size.
     O.fixup32(static_cast<uint32_t>(Length), StartOffset - 4);
   }
 
   // Terminate the data chunks with and end of list with zero size
   O.writeU32(InfoType::EndOfList);
   O.writeU32(0);
   return FuncInfoOffset;
 }
 
 
 llvm::Expected<LookupResult> FunctionInfo::lookup(DataExtractor &Data,
                                                   const GsymReader &GR,
                                                   uint64_t FuncAddr,
                                                   uint64_t Addr) {
   LookupResult LR;
   LR.LookupAddr = Addr;
-  LR.FuncRange.Start = FuncAddr;
   uint64_t Offset = 0;
-  LR.FuncRange.End = FuncAddr + Data.getU32(&Offset);
+  LR.FuncRange = {FuncAddr, FuncAddr + Data.getU32(&Offset)};
   uint32_t NameOffset = Data.getU32(&Offset);
   // The "lookup" functions doesn't report errors as accurately as the "decode"
   // function as it is meant to be fast. For more accurage errors we could call
   // "decode".
   if (!Data.isValidOffset(Offset))
     return createStringError(std::errc::io_error,
                               "FunctionInfo data is truncated");
   // This function will be called with the result of a binary search of the

llvm/lib/DebugInfo/GSYM/GsymCreator.cpp

Funcs.erase(
                          } else {
                            if (!Quiet) { // print warnings about overlaps
                              OS << "warning: function ranges overlap:\n"
                                 << Prev << "\n"
                                 << Curr << "\n";
                            }
                          }
                        } else if (Prev.Range.size() == 0 &&
-                                  Curr.Range.contains(Prev.Range.Start)) {
+                                  Curr.Range.contains(Prev.Range.start())) {
                          if (!Quiet) {
                            OS << "warning: removing symbol:\n"
                               << Prev << "\nKeeping:\n"
                               << Curr << "\n";
                          }
                          return true;
                        }
 
                        return false;
                      }),
       Funcs.end());
 
   // If our last function info entry doesn't have a size and if we have valid
   // text ranges, we should set the size of the last entry since any search for
   // a high address might match our last entry. By fixing up this size, we can
   // help ensure we don't cause lookups to always return the last symbol that
   // has no size when doing lookups.
   if (!Funcs.empty() && Funcs.back().Range.size() == 0 && ValidTextRanges) {
     if (auto Range =
-            ValidTextRanges->getRangeThatContains(Funcs.back().Range.Start)) {
-      Funcs.back().Range.End = Range->End;
+            ValidTextRanges->getRangeThatContains(Funcs.back().Range.start())) {
+      Funcs.back().Range = *Range;
     }
   }
   OS << "Pruned " << NumBefore - Funcs.size() << " functions, ended with "
      << Funcs.size() << " total\n";
   return Error::success();
 }
 
 uint32_t GsymCreator::insertString(StringRef S, bool Copy) {

llvm/lib/DebugInfo/GSYM/InlineInfo.cpp

 /// \param Data The binary stream to read the data from.
 ///
 /// \param Offset The byte offset within \a Data.
 ///
 /// \param SkippedRanges If true, address ranges have already been skipped.
 
 static bool skip(DataExtractor &Data, uint64_t &Offset, bool SkippedRanges) {
   if (!SkippedRanges) {
-    if (AddressRanges::skip(Data, Offset) == 0)
+    if (skipRanges(Data, Offset) == 0)
       return false;
   }
   bool HasChildren = Data.getU8(&Offset) != 0;
   Data.getU32(&Offset); // Skip Inline.Name.
   Data.getULEB128(&Offset); // Skip Inline.CallFile.
   Data.getULEB128(&Offset); // Skip Inline.CallLine.
   if (HasChildren) {
     while (skip(Data, Offset, false /* SkippedRanges */))

 ///
 /// \param BaseAddr The address that the relative address range offsets are
 ///                 relative to.
 
 static bool lookup(const GsymReader &GR, DataExtractor &Data, uint64_t &Offset,
                    uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs,
                    llvm::Error &Err) {
   InlineInfo Inline;
-  Inline.Ranges.decode(Data, BaseAddr, Offset);
+  decodeRanges(Inline.Ranges, Data, BaseAddr, Offset);
   if (Inline.Ranges.empty())
     return true;
   // Check if the address is contained within the inline information, and if
   // not, quickly skip this InlineInfo object and all its children.
   if (!Inline.Ranges.contains(Addr)) {
     skip(Data, Offset, true /* SkippedRanges */);
     return false;
   }
 
   // The address range is contained within this InlineInfo, add the source
   // location for this InlineInfo and any children that contain the address.
   bool HasChildren = Data.getU8(&Offset) != 0;
   Inline.Name = Data.getU32(&Offset);
   Inline.CallFile = (uint32_t)Data.getULEB128(&Offset);
   Inline.CallLine = (uint32_t)Data.getULEB128(&Offset);
   if (HasChildren) {
     // Child address ranges are encoded relative to the first address in the
     // parent InlineInfo object.
-    const auto ChildBaseAddr = Inline.Ranges[0].Start;
+    const auto ChildBaseAddr = Inline.Ranges[0].start();
     bool Done = false;
     while (!Done)
       Done = lookup(GR, Data, Offset, ChildBaseAddr, Addr, SrcLocs, Err);
   }
 
   Optional<FileEntry> CallFile = GR.getFile(Inline.CallFile);
   if (!CallFile) {
     Err = createStringError(std::errc::invalid_argument,
                             "failed to extract file[%" PRIu32 "]",
                             Inline.CallFile);
     return false;
   }
 
   if (CallFile->Dir || CallFile->Base) {
     SourceLocation SrcLoc;
     SrcLoc.Name = SrcLocs.back().Name;
     SrcLoc.Offset = SrcLocs.back().Offset;
     SrcLoc.Dir = GR.getString(CallFile->Dir);
     SrcLoc.Base = GR.getString(CallFile->Base);
     SrcLoc.Line = Inline.CallLine;
     SrcLocs.back().Name = GR.getString(Inline.Name);
-    SrcLocs.back().Offset = Addr - Inline.Ranges[0].Start;
+    SrcLocs.back().Offset = Addr - Inline.Ranges[0].start();
     SrcLocs.push_back(SrcLoc);
   }
   return true;
 }
 
 llvm::Error InlineInfo::lookup(const GsymReader &GR, DataExtractor &Data,
                                uint64_t BaseAddr, uint64_t Addr,
                                SourceLocations &SrcLocs) {

 /// \returns An InlineInfo or an error describing the issue that was
 /// encountered during decoding.
 static llvm::Expected<InlineInfo> decode(DataExtractor &Data, uint64_t &Offset,
                                          uint64_t BaseAddr) {
   InlineInfo Inline;
   if (!Data.isValidOffset(Offset))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing InlineInfo address ranges data", Offset);
-  Inline.Ranges.decode(Data, BaseAddr, Offset);
+  decodeRanges(Inline.Ranges, Data, BaseAddr, Offset);
   if (Inline.Ranges.empty())
     return Inline;
   if (!Data.isValidOffsetForDataOfSize(Offset, 1))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing InlineInfo uint8_t indicating children",
         Offset);
   bool HasChildren = Data.getU8(&Offset) != 0;
   if (!Data.isValidOffsetForDataOfSize(Offset, 4))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing InlineInfo uint32_t for name", Offset);
   Inline.Name = Data.getU32(&Offset);
   if (!Data.isValidOffset(Offset))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing ULEB128 for InlineInfo call file", Offset);
   Inline.CallFile = (uint32_t)Data.getULEB128(&Offset);
   if (!Data.isValidOffset(Offset))
     return createStringError(std::errc::io_error,
         "0x%8.8" PRIx64 ": missing ULEB128 for InlineInfo call line", Offset);
   Inline.CallLine = (uint32_t)Data.getULEB128(&Offset);
   if (HasChildren) {
     // Child address ranges are encoded relative to the first address in the
     // parent InlineInfo object.
-    const auto ChildBaseAddr = Inline.Ranges[0].Start;
+    const auto ChildBaseAddr = Inline.Ranges[0].start();
     while (true) {
       llvm::Expected<InlineInfo> Child = decode(Data, Offset, ChildBaseAddr);
       if (!Child)
         return Child.takeError();
       // InlineInfo with empty Ranges termintes a child sibling chain.
       if (Child.get().Ranges.empty())
         break;
       Inline.Children.emplace_back(std::move(*Child));

 
 llvm::Error InlineInfo::encode(FileWriter &O, uint64_t BaseAddr) const {
   // Users must verify the InlineInfo is valid prior to calling this funtion.
   // We don't want to emit any InlineInfo objects if they are not valid since
   // it will waste space in the GSYM file.
   if (!isValid())
     return createStringError(std::errc::invalid_argument,
                              "attempted to encode invalid InlineInfo object");
-  Ranges.encode(O, BaseAddr);
+  encodeRanges(Ranges, O, BaseAddr);
   bool HasChildren = !Children.empty();
   O.writeU8(HasChildren);
   O.writeU32(Name);
   O.writeULEB(CallFile);
   O.writeULEB(CallLine);
   if (HasChildren) {
     // Child address ranges are encoded as relative to the first
     // address in the Ranges for this object. This keeps the offsets
     // small and allows for efficient encoding using ULEB offsets.
-    const uint64_t ChildBaseAddr = Ranges[0].Start;
+    const uint64_t ChildBaseAddr = Ranges[0].start();
     for (const auto &Child : Children) {
       // Make sure all child address ranges are contained in the parent address
       // ranges.
       for (const auto &ChildRange: Child.Ranges) {
         if (!Ranges.contains(ChildRange))
           return createStringError(std::errc::invalid_argument,
                                    "child range not contained in parent");
       }

llvm/lib/DebugInfo/GSYM/Range.cpp

-//===- Range.cpp ------------------------------------------------*- C++ -*-===//
-//
-// 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/DebugInfo/GSYM/Range.h"
-#include "llvm/DebugInfo/GSYM/FileWriter.h"
-#include "llvm/Support/DataExtractor.h"
-#include <algorithm>
-#include <inttypes.h>
-
-using namespace llvm;
-using namespace gsym;
-
-
-void AddressRanges::insert(AddressRange Range) {
-  if (Range.size() == 0)
-    return;
-
-  auto It = llvm::upper_bound(Ranges, Range);
-  auto It2 = It;
-  while (It2 != Ranges.end() && It2->Start < Range.End)
-    ++It2;
-  if (It != It2) {
-    Range.End = std::max(Range.End, It2[-1].End);
-    It = Ranges.erase(It, It2);
-  }
-  if (It != Ranges.begin() && Range.Start < It[-1].End)
-    It[-1].End = std::max(It[-1].End, Range.End);
-  else
-    Ranges.insert(It, Range);
-}
-
-bool AddressRanges::contains(uint64_t Addr) const {
-  auto It = std::partition_point(
-      Ranges.begin(), Ranges.end(),
-      [=](const AddressRange &R) { return R.Start <= Addr; });
-  return It != Ranges.begin() && Addr < It[-1].End;
-}
-
-bool AddressRanges::contains(AddressRange Range) const {
-  if (Range.size() == 0)
-    return false;
-  auto It = std::partition_point(
-      Ranges.begin(), Ranges.end(),
-      [=](const AddressRange &R) { return R.Start <= Range.Start; });
-  if (It == Ranges.begin())
-    return false;
-  return Range.End <= It[-1].End;
-}
-
-Optional<AddressRange>
-AddressRanges::getRangeThatContains(uint64_t Addr) const {
-  auto It = std::partition_point(
-      Ranges.begin(), Ranges.end(),
-      [=](const AddressRange &R) { return R.Start <= Addr; });
-  if (It != Ranges.begin() && Addr < It[-1].End)
-    return It[-1];
-  return llvm::None;
-}
-
-raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const AddressRange &R) {
-  return OS << '[' << HEX64(R.Start) << " - " << HEX64(R.End) << ")";
-}
-
-raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const AddressRanges &AR) {
-  size_t Size = AR.size();
-  for (size_t I = 0; I < Size; ++I) {
-    if (I)
-      OS << ' ';
-    OS << AR[I];
-  }
-  return OS;
-}
-
-void AddressRange::encode(FileWriter &O, uint64_t BaseAddr) const {
-  assert(Start >= BaseAddr);
-  O.writeULEB(Start - BaseAddr);
-  O.writeULEB(size());
-}
-
-void AddressRange::decode(DataExtractor &Data, uint64_t BaseAddr,
-                          uint64_t &Offset) {
-  const uint64_t AddrOffset = Data.getULEB128(&Offset);
-  const uint64_t Size = Data.getULEB128(&Offset);
-  const uint64_t StartAddr = BaseAddr + AddrOffset;
-  Start = StartAddr;
-  End = StartAddr + Size;
-}
-
-void AddressRanges::encode(FileWriter &O, uint64_t BaseAddr) const {
-  O.writeULEB(Ranges.size());
-  if (Ranges.empty())
-    return;
-  for (auto Range : Ranges)
-    Range.encode(O, BaseAddr);
-}
-
-void AddressRanges::decode(DataExtractor &Data, uint64_t BaseAddr,
-                           uint64_t &Offset) {
-  clear();
-  uint64_t NumRanges = Data.getULEB128(&Offset);
-  if (NumRanges == 0)
-    return;
-  Ranges.resize(NumRanges);
-  for (auto &Range : Ranges)
-    Range.decode(Data, BaseAddr, Offset);
-}
-
-void AddressRange::skip(DataExtractor &Data, uint64_t &Offset) {
-  Data.getULEB128(&Offset);
-  Data.getULEB128(&Offset);
-}
-
-uint64_t AddressRanges::skip(DataExtractor &Data, uint64_t &Offset) {
-  uint64_t NumRanges = Data.getULEB128(&Offset);
-  for (uint64_t I=0; I<NumRanges; ++I)
-    AddressRange::skip(Data, Offset);
-  return NumRanges;
-}

llvm/lib/Support/AddressRanges.cpp

+//===- AddressRanges.cpp ----------------------------------------*- C++ -*-===//
+//
+// 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/ADT/AddressRanges.h"
+#include "llvm/ADT/STLExtras.h"
+#include <inttypes.h>
+
+using namespace llvm;
+
+void AddressRanges::insert(AddressRange Range) {
+  if (Range.size() == 0)
+    return;
+
+  auto It = llvm::upper_bound(Ranges, Range);
+  auto It2 = It;
+  while (It2 != Ranges.end() && It2->start() < Range.end())
+    ++It2;
+  if (It != It2) {
+    Range = {Range.start(), std::max(Range.end(), It2[-1].end())};
+    It = Ranges.erase(It, It2);
+  }
+  if (It != Ranges.begin() && Range.start() < It[-1].end())
+    It[-1] = {It[-1].start(), std::max(It[-1].end(), Range.end())};
+  else
+    Ranges.insert(It, Range);
+}
+
+bool AddressRanges::contains(uint64_t Addr) const {
+  auto It = std::partition_point(
+      Ranges.begin(), Ranges.end(),
+      [=](const AddressRange &R) { return R.start() <= Addr; });
+  return It != Ranges.begin() && Addr < It[-1].end();
+}
+
+bool AddressRanges::contains(AddressRange Range) const {
+  if (Range.size() == 0)
+    return false;
+  auto It = std::partition_point(
+      Ranges.begin(), Ranges.end(),
+      [=](const AddressRange &R) { return R.start() <= Range.start(); });
+  if (It == Ranges.begin())
+    return false;
+  return Range.end() <= It[-1].end();
+}
+
+Optional<AddressRange>
+AddressRanges::getRangeThatContains(uint64_t Addr) const {
+  auto It = std::partition_point(
+      Ranges.begin(), Ranges.end(),
+      [=](const AddressRange &R) { return R.start() <= Addr; });
+  if (It != Ranges.begin() && Addr < It[-1].end())
+    return It[-1];
+  return llvm::None;
+}

llvm/lib/Support/CMakeLists.txt

elseif(LLVM_INTEGRATED_CRT_ALLOC MATCHES "mimalloc$")
     endif()
     set(system_libs ${system_libs} "${MIMALLOC_LIB}" "-INCLUDE:malloc")
   endif()
 endif()
 
 add_subdirectory(BLAKE3)
 
 add_llvm_component_library(LLVMSupport
+  AddressRanges.cpp
   AArch64TargetParser.cpp
   ABIBreak.cpp
   ARMTargetParser.cpp
   AMDGPUMetadata.cpp
   APFixedPoint.cpp
   APFloat.cpp
   APInt.cpp
   APSInt.cpp

llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp

 //===- llvm/unittest/DebugInfo/GSYMTest.cpp -------------------------------===//
 //
 // 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/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/GSYM/DwarfTransformer.h"
-#include "llvm/DebugInfo/GSYM/Header.h"
+#include "llvm/DebugInfo/GSYM/ExtractRanges.h"
 #include "llvm/DebugInfo/GSYM/FileEntry.h"
 #include "llvm/DebugInfo/GSYM/FileWriter.h"
 #include "llvm/DebugInfo/GSYM/FunctionInfo.h"
 #include "llvm/DebugInfo/GSYM/GsymCreator.h"
 #include "llvm/DebugInfo/GSYM/GsymReader.h"
+#include "llvm/DebugInfo/GSYM/Header.h"
 #include "llvm/DebugInfo/GSYM/InlineInfo.h"
-#include "llvm/DebugInfo/GSYM/Range.h"
 #include "llvm/DebugInfo/GSYM/StringTable.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Testing/Support/Error.h"
 
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
TEST(GSYMTest, TestFunctionInfo) {
 
   FunctionInfo A1(0x1000, 0x100, NameOffset);
   FunctionInfo A2(0x1000, 0x100, NameOffset);
   FunctionInfo B;
   // Check == operator
   EXPECT_EQ(A1, A2);
   // Make sure things are not equal if they only differ by start address.
   B = A2;
-  B.setStartAddress(0x2000);
+  B.Range = {0x1001, B.endAddress()};
   EXPECT_NE(B, A2);
   // Make sure things are not equal if they only differ by size.
   B = A2;
-  B.setSize(0x101);
+  B.Range = {B.startAddress(), B.startAddress() + 0x101};
   EXPECT_NE(B, A2);
   // Make sure things are not equal if they only differ by name.
   B = A2;
   B.Name = 60;
   EXPECT_NE(B, A2);
   // Check < operator.
   // Check less than where address differs.
   B = A2;
-  B.setStartAddress(A2.startAddress() + 0x1000);
+  B.Range = {A2.startAddress() + 0x1000, A2.endAddress() + 0x1000};
   EXPECT_LT(A1, B);
 
   // We use the < operator to take a variety of different FunctionInfo
   // structs from a variety of sources: symtab, debug info, runtime info
   // and we sort them and want the sorting to allow us to quickly get the
   // best version of a function info.
   FunctionInfo FISymtab(StartAddr, Size, NameOffset);
   FunctionInfo FIWithLines(StartAddr, Size, NameOffset);
static void TestFunctionInfoEncodeDecode(llvm::support::endianness ByteOrder,
   FileWriter FW(OutStrm, ByteOrder);
   llvm::Expected<uint64_t> ExpectedOffset = FI.encode(FW);
   ASSERT_TRUE(bool(ExpectedOffset));
   // Verify we got the encoded offset back from the encode function.
   ASSERT_EQ(ExpectedOffset.get(), 0ULL);
   std::string Bytes(OutStrm.str());
   uint8_t AddressSize = 4;
   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
-  llvm::Expected<FunctionInfo> Decoded = FunctionInfo::decode(Data,
-                                                              FI.Range.Start);
+  llvm::Expected<FunctionInfo> Decoded =
+      FunctionInfo::decode(Data, FI.Range.start());
   // Make sure decoding succeeded.
   ASSERT_TRUE((bool)Decoded);
   // Make sure decoded object is the same as the one we encoded.
   EXPECT_EQ(FI, Decoded.get());
 }
 
 static void AddLines(uint64_t FuncAddr, uint32_t FileIdx, FunctionInfo &FI) {
     FI.OptLineTable = LineTable();

 }
 
 static void TestInlineInfoEncodeDecode(llvm::support::endianness ByteOrder,
                                        const InlineInfo &Inline) {
   // Test encoding and decoding InlineInfo objects
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   FileWriter FW(OutStrm, ByteOrder);
-  const uint64_t BaseAddr = Inline.Ranges[0].Start;
+  const uint64_t BaseAddr = Inline.Ranges[0].start();
   llvm::Error Err = Inline.encode(FW, BaseAddr);
   ASSERT_FALSE(Err);
   std::string Bytes(OutStrm.str());
   uint8_t AddressSize = 4;
   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
   llvm::Expected<InlineInfo> Decoded = InlineInfo::decode(Data, BaseAddr);
   // Make sure decoding succeeded.
   ASSERT_TRUE((bool)Decoded);

 }
 
 static void TestInlineInfoEncodeError(llvm::support::endianness ByteOrder,
                                       const InlineInfo &Inline,
                                       std::string ExpectedErrorMsg) {
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   FileWriter FW(OutStrm, ByteOrder);
-  const uint64_t BaseAddr = Inline.Ranges.empty() ? 0 : Inline.Ranges[0].Start;
+  const uint64_t BaseAddr =
+      Inline.Ranges.empty() ? 0 : Inline.Ranges[0].start();
   llvm::Error Err = Inline.encode(FW, BaseAddr);
   checkError(ExpectedErrorMsg, std::move(Err));
 }
 
 TEST(GSYMTest, TestInlineInfo) {
   // Test InlineInfo structs.
   InlineInfo II;
   EXPECT_FALSE(II.isValid());
TEST(GSYMTest, TestInlineInfo) {
   Inline1.Children.push_back(Inline1Sub1);
   Inline1.Children.push_back(Inline1Sub2);
   Root.Children.push_back(Inline1);
 
   // Make sure an address that is out of range won't match
   EXPECT_FALSE(Root.getInlineStack(0x50));
 
   // Verify that we get no inline stacks for addresses out of [0x100-0x200)
-  EXPECT_FALSE(Root.getInlineStack(Root.Ranges[0].Start - 1));
-  EXPECT_FALSE(Root.getInlineStack(Root.Ranges[0].End));
+  EXPECT_FALSE(Root.getInlineStack(Root.Ranges[0].start() - 1));
+  EXPECT_FALSE(Root.getInlineStack(Root.Ranges[0].end()));
 
   // Verify we get no inline stack entries for addresses that are in
   // [0x100-0x200) but not in [0x150-0x160)
-  EXPECT_FALSE(Root.getInlineStack(Inline1.Ranges[0].Start - 1));
-  EXPECT_FALSE(Root.getInlineStack(Inline1.Ranges[0].End));
+  EXPECT_FALSE(Root.getInlineStack(Inline1.Ranges[0].start() - 1));
+  EXPECT_FALSE(Root.getInlineStack(Inline1.Ranges[0].end()));
 
   // Verify we get one inline stack entry for addresses that are in
   // [[0x150-0x160)) but not in [0x152-0x155) or [0x157-0x158)
-  auto InlineInfos = Root.getInlineStack(Inline1.Ranges[0].Start);
+  auto InlineInfos = Root.getInlineStack(Inline1.Ranges[0].start());
   ASSERT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 1u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1);
-  InlineInfos = Root.getInlineStack(Inline1.Ranges[0].End - 1);
+  InlineInfos = Root.getInlineStack(Inline1.Ranges[0].end() - 1);
   EXPECT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 1u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1);
 
   // Verify we get two inline stack entries for addresses that are in
   // [0x152-0x155)
-  InlineInfos = Root.getInlineStack(Inline1Sub1.Ranges[0].Start);
+  InlineInfos = Root.getInlineStack(Inline1Sub1.Ranges[0].start());
   EXPECT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 2u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub1);
   ASSERT_EQ(*InlineInfos->at(1), Inline1);
-  InlineInfos = Root.getInlineStack(Inline1Sub1.Ranges[0].End - 1);
+  InlineInfos = Root.getInlineStack(Inline1Sub1.Ranges[0].end() - 1);
   EXPECT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 2u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub1);
   ASSERT_EQ(*InlineInfos->at(1), Inline1);
 
   // Verify we get two inline stack entries for addresses that are in
   // [0x157-0x158)
-  InlineInfos = Root.getInlineStack(Inline1Sub2.Ranges[0].Start);
+  InlineInfos = Root.getInlineStack(Inline1Sub2.Ranges[0].start());
   EXPECT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 2u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
   ASSERT_EQ(*InlineInfos->at(1), Inline1);
-  InlineInfos = Root.getInlineStack(Inline1Sub2.Ranges[0].End - 1);
+  InlineInfos = Root.getInlineStack(Inline1Sub2.Ranges[0].end() - 1);
   EXPECT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 2u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
   ASSERT_EQ(*InlineInfos->at(1), Inline1);
 
   // Test encoding and decoding InlineInfo objects
   TestInlineInfoEncodeDecode(llvm::support::little, Root);
   TestInlineInfoEncodeDecode(llvm::support::big, Root);
 }
 
 TEST(GSYMTest, TestInlineInfoEncodeErrors) {
   // Test InlineInfo encoding errors.
 
   // Test that we get an error when trying to encode an InlineInfo object
   // that has no ranges.
   InlineInfo Empty;
   std::string EmptyErr("attempted to encode invalid InlineInfo object");
   TestInlineInfoEncodeError(llvm::support::little, Empty, EmptyErr);
   TestInlineInfoEncodeError(llvm::support::big, Empty, EmptyErr);
 
   // Verify that we get an error trying to encode an InlineInfo object that has
   // a child InlineInfo that has no ranges.
   InlineInfo ContainsEmpty;
-  ContainsEmpty.Ranges.insert({0x100,200});
+  ContainsEmpty.Ranges.insert({0x100, 0x200});
   ContainsEmpty.Children.push_back(Empty);
   TestInlineInfoEncodeError(llvm::support::little, ContainsEmpty, EmptyErr);
   TestInlineInfoEncodeError(llvm::support::big, ContainsEmpty, EmptyErr);
 
   // Verify that we get an error trying to encode an InlineInfo object that has
   // a child whose address range is not contained in the parent address range.
   InlineInfo ChildNotContained;
   std::string ChildNotContainedErr("child range not contained in parent");
-  ChildNotContained.Ranges.insert({0x100,200});
+  ChildNotContained.Ranges.insert({0x100, 0x200});
   InlineInfo ChildNotContainedChild;
-  ChildNotContainedChild.Ranges.insert({0x200,300});
+  ChildNotContainedChild.Ranges.insert({0x200, 0x300});
   ChildNotContained.Children.push_back(ChildNotContainedChild);
   TestInlineInfoEncodeError(llvm::support::little, ChildNotContained,
                             ChildNotContainedErr);
   TestInlineInfoEncodeError(llvm::support::big, ChildNotContained,
                             ChildNotContainedErr);
 
 }
 
 TEST(GSYMTest, TestInlineInfoDecodeErrors) {
   // Test decoding InlineInfo objects that ensure we report an appropriate
   // error message.
   const llvm::support::endianness ByteOrder = llvm::support::little;
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   FileWriter FW(OutStrm, ByteOrder);
   const uint64_t BaseAddr = 0x100;
   TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
       "0x00000000: missing InlineInfo address ranges data");
   AddressRanges Ranges;
   Ranges.insert({BaseAddr, BaseAddr+0x100});
-  Ranges.encode(FW, BaseAddr);
+  encodeRanges(Ranges, FW, BaseAddr);
   TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
       "0x00000004: missing InlineInfo uint8_t indicating children");
   FW.writeU8(0);
   TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
       "0x00000005: missing InlineInfo uint32_t for name");
   FW.writeU32(0);
   TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
       "0x00000009: missing ULEB128 for InlineInfo call file");
TEST(GSYMTest, TestLineEntry) {
   EXPECT_TRUE(E1.isValid());
   EXPECT_EQ(E1, E2);
   EXPECT_NE(E1, DifferentAddr);
   EXPECT_NE(E1, DifferentFile);
   EXPECT_NE(E1, DifferentLine);
   EXPECT_LT(E1, DifferentAddr);
 }
 
-TEST(GSYMTest, TestRanges) {
-  // test llvm::gsym::AddressRange.
-  const uint64_t StartAddr = 0x1000;
-  const uint64_t EndAddr = 0x2000;
-  // Verify constructor and API to ensure it takes start and end address.
-  const AddressRange Range(StartAddr, EndAddr);
-  EXPECT_EQ(Range.size(), EndAddr - StartAddr);
-
-  // Verify llvm::gsym::AddressRange::contains().
-  EXPECT_FALSE(Range.contains(0));
-  EXPECT_FALSE(Range.contains(StartAddr - 1));
-  EXPECT_TRUE(Range.contains(StartAddr));
-  EXPECT_TRUE(Range.contains(EndAddr - 1));
-  EXPECT_FALSE(Range.contains(EndAddr));
-  EXPECT_FALSE(Range.contains(UINT64_MAX));
-
-  const AddressRange RangeSame(StartAddr, EndAddr);
-  const AddressRange RangeDifferentStart(StartAddr + 1, EndAddr);
-  const AddressRange RangeDifferentEnd(StartAddr, EndAddr + 1);
-  const AddressRange RangeDifferentStartEnd(StartAddr + 1, EndAddr + 1);
-  // Test == and != with values that are the same
-  EXPECT_EQ(Range, RangeSame);
-  EXPECT_FALSE(Range != RangeSame);
-  // Test == and != with values that are the different
-  EXPECT_NE(Range, RangeDifferentStart);
-  EXPECT_NE(Range, RangeDifferentEnd);
-  EXPECT_NE(Range, RangeDifferentStartEnd);
-  EXPECT_FALSE(Range == RangeDifferentStart);
-  EXPECT_FALSE(Range == RangeDifferentEnd);
-  EXPECT_FALSE(Range == RangeDifferentStartEnd);
-
-  // Test "bool operator<(const AddressRange &, const AddressRange &)".
-  EXPECT_FALSE(Range < RangeSame);
-  EXPECT_FALSE(RangeSame < Range);
-  EXPECT_LT(Range, RangeDifferentStart);
-  EXPECT_LT(Range, RangeDifferentEnd);
-  EXPECT_LT(Range, RangeDifferentStartEnd);
-  // Test "bool operator<(const AddressRange &, uint64_t)"
-  EXPECT_LT(Range.Start, StartAddr + 1);
-  // Test "bool operator<(uint64_t, const AddressRange &)"
-  EXPECT_LT(StartAddr - 1, Range.Start);
-
-  // Verify llvm::gsym::AddressRange::isContiguousWith() and
-  // llvm::gsym::AddressRange::intersects().
-  const AddressRange EndsBeforeRangeStart(0, StartAddr - 1);
-  const AddressRange EndsAtRangeStart(0, StartAddr);
-  const AddressRange OverlapsRangeStart(StartAddr - 1, StartAddr + 1);
-  const AddressRange InsideRange(StartAddr + 1, EndAddr - 1);
-  const AddressRange OverlapsRangeEnd(EndAddr - 1, EndAddr + 1);
-  const AddressRange StartsAtRangeEnd(EndAddr, EndAddr + 0x100);
-  const AddressRange StartsAfterRangeEnd(EndAddr + 1, EndAddr + 0x100);
-
-  EXPECT_FALSE(Range.intersects(EndsBeforeRangeStart));
-  EXPECT_FALSE(Range.intersects(EndsAtRangeStart));
-  EXPECT_TRUE(Range.intersects(OverlapsRangeStart));
-  EXPECT_TRUE(Range.intersects(InsideRange));
-  EXPECT_TRUE(Range.intersects(OverlapsRangeEnd));
-  EXPECT_FALSE(Range.intersects(StartsAtRangeEnd));
-  EXPECT_FALSE(Range.intersects(StartsAfterRangeEnd));
-
-  // Test the functions that maintain GSYM address ranges:
-  //  "bool AddressRange::contains(uint64_t Addr) const;"
-  //  "void AddressRanges::insert(const AddressRange &R);"
-  AddressRanges Ranges;
-  Ranges.insert(AddressRange(0x1000, 0x2000));
-  Ranges.insert(AddressRange(0x2000, 0x3000));
-  Ranges.insert(AddressRange(0x4000, 0x5000));
-
-  EXPECT_FALSE(Ranges.contains(0));
-  EXPECT_FALSE(Ranges.contains(0x1000 - 1));
-  EXPECT_TRUE(Ranges.contains(0x1000));
-  EXPECT_TRUE(Ranges.contains(0x2000));
-  EXPECT_TRUE(Ranges.contains(0x4000));
-  EXPECT_TRUE(Ranges.contains(0x2000 - 1));
-  EXPECT_TRUE(Ranges.contains(0x3000 - 1));
-  EXPECT_FALSE(Ranges.contains(0x3000 + 1));
-  EXPECT_TRUE(Ranges.contains(0x5000 - 1));
-  EXPECT_FALSE(Ranges.contains(0x5000 + 1));
-  EXPECT_FALSE(Ranges.contains(UINT64_MAX));
-
-  EXPECT_FALSE(Ranges.contains(AddressRange()));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000-1, 0x1000)));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x1000)));
-  EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x1000+1)));
-  EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2000)));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x2001)));
-  EXPECT_TRUE(Ranges.contains(AddressRange(0x2000, 0x3000)));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x2000, 0x3001)));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x3000, 0x3001)));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x1500, 0x4500)));
-  EXPECT_FALSE(Ranges.contains(AddressRange(0x5000, 0x5001)));
-
-  // Verify that intersecting ranges get combined
-  Ranges.clear();
-  Ranges.insert(AddressRange(0x1100, 0x1F00));
-  // Verify a wholy contained range that is added doesn't do anything.
-  Ranges.insert(AddressRange(0x1500, 0x1F00));
-  EXPECT_EQ(Ranges.size(), 1u);
-  EXPECT_EQ(Ranges[0], AddressRange(0x1100, 0x1F00));
-
-  // Verify a range that starts before and intersects gets combined.
-  Ranges.insert(AddressRange(0x1000, Ranges[0].Start + 1));
-  EXPECT_EQ(Ranges.size(), 1u);
-  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x1F00));
-
-  // Verify a range that starts inside and extends ranges gets combined.
-  Ranges.insert(AddressRange(Ranges[0].End - 1, 0x2000));
-  EXPECT_EQ(Ranges.size(), 1u);
-  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
-
-  // Verify that adjacent ranges don't get combined
-  Ranges.insert(AddressRange(0x2000, 0x3000));
-  EXPECT_EQ(Ranges.size(), 2u);
-  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
-  EXPECT_EQ(Ranges[1], AddressRange(0x2000, 0x3000));
-  // Verify if we add an address range that intersects two ranges
-  // that they get combined
-  Ranges.insert(AddressRange(Ranges[0].End - 1, Ranges[1].Start + 1));
-  EXPECT_EQ(Ranges.size(), 1u);
-  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x3000));
-
-  Ranges.insert(AddressRange(0x3000, 0x4000));
-  Ranges.insert(AddressRange(0x4000, 0x5000));
-  Ranges.insert(AddressRange(0x2000, 0x4500));
-  EXPECT_EQ(Ranges.size(), 1u);
-  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x5000));
-}
-
 TEST(GSYMTest, TestStringTable) {
   StringTable StrTab(StringRef("\0Hello\0World\0", 13));
   // Test extracting strings from a string table.
   EXPECT_EQ(StrTab.getString(0), "");
   EXPECT_EQ(StrTab.getString(1), "Hello");
   EXPECT_EQ(StrTab.getString(7), "World");
   EXPECT_EQ(StrTab.getString(8), "orld");
   // Test pointing to last NULL terminator gets empty string.
TEST(GSYMTest, TestAddressRangeEncodeDecode) {
   // the base address of the parent range for subranges.
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = llvm::support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   const uint64_t BaseAddr = 0x1000;
   const AddressRange Range1(0x1000, 0x1010);
   const AddressRange Range2(0x1020, 0x1030);
-  Range1.encode(FW, BaseAddr);
-  Range2.encode(FW, BaseAddr);
+  encodeRange(Range1, FW, BaseAddr);
+  encodeRange(Range2, FW, BaseAddr);
   std::string Bytes(OutStrm.str());
   uint8_t AddressSize = 4;
   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
 
   AddressRange DecodedRange1, DecodedRange2;
   uint64_t Offset = 0;
-  DecodedRange1.decode(Data, BaseAddr, Offset);
-  DecodedRange2.decode(Data, BaseAddr, Offset);
+  DecodedRange1 = decodeRange(Data, BaseAddr, Offset);
+  DecodedRange2 = decodeRange(Data, BaseAddr, Offset);
   EXPECT_EQ(Range1, DecodedRange1);
   EXPECT_EQ(Range2, DecodedRange2);
 }
 
 static void TestAddressRangeEncodeDecodeHelper(const AddressRanges &Ranges,
                                                const uint64_t BaseAddr) {
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = llvm::support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
-  Ranges.encode(FW, BaseAddr);
+  encodeRanges(Ranges, FW, BaseAddr);
 
   std::string Bytes(OutStrm.str());
   uint8_t AddressSize = 4;
   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
 
   AddressRanges DecodedRanges;
   uint64_t Offset = 0;
-  DecodedRanges.decode(Data, BaseAddr, Offset);
+  decodeRanges(DecodedRanges, Data, BaseAddr, Offset);
   EXPECT_EQ(Ranges, DecodedRanges);
 }
 
 TEST(GSYMTest, TestAddressRangesEncodeDecode) {
   // Test encoding and decoding AddressRanges. AddressRanges objects contain
   // ranges that are stored as offsets from the a base address. The base address
   // is the FunctionInfo's base address for function level ranges, and is the
   // base address of the parent range for subranges.
TEST(GSYMTest, TestGsymCreatorEncodeErrors) {
   TestGsymCreatorEncodeError(llvm::support::little, GC,
                              "attempted to encode invalid InlineInfo object");
 }
 
 static void Compare(const GsymCreator &GC, const GsymReader &GR) {
   // Verify that all of the data in a GsymCreator is correctly decoded from
   // a GsymReader. To do this, we iterator over
   GC.forEachFunctionInfo([&](const FunctionInfo &FI) -> bool {
-    auto DecodedFI = GR.getFunctionInfo(FI.Range.Start);
+    auto DecodedFI = GR.getFunctionInfo(FI.Range.start());
     EXPECT_TRUE(bool(DecodedFI));
     EXPECT_EQ(FI, *DecodedFI);
     return true; // Keep iterating over all FunctionInfo objects.
   });
 }
 
 static void TestEncodeDecode(const GsymCreator &GC,
                              support::endianness ByteOrder, uint16_t Version,

llvm/unittests/Support/AddressRangeTest.cpp

+//===- llvm/unittest/Support/AddresRangeTest.cpp --------------------------===//
+//
+// 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/ADT/AddressRanges.h"
+#include "llvm/Testing/Support/Error.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <string>
+
+using namespace llvm;
+
+TEST(AddressRangeTest, TestRanges) {
+  // test llvm::AddressRange.
+  const uint64_t StartAddr = 0x1000;
+  const uint64_t EndAddr = 0x2000;
+  // Verify constructor and API to ensure it takes start and end address.
+  const AddressRange Range(StartAddr, EndAddr);
+  EXPECT_EQ(Range.size(), EndAddr - StartAddr);
+
+  // Verify llvm::AddressRange::contains().
+  EXPECT_FALSE(Range.contains(0));
+  EXPECT_FALSE(Range.contains(StartAddr - 1));
+  EXPECT_TRUE(Range.contains(StartAddr));
+  EXPECT_TRUE(Range.contains(EndAddr - 1));
+  EXPECT_FALSE(Range.contains(EndAddr));
+  EXPECT_FALSE(Range.contains(UINT64_MAX));
+
+  const AddressRange RangeSame(StartAddr, EndAddr);
+  const AddressRange RangeDifferentStart(StartAddr + 1, EndAddr);
+  const AddressRange RangeDifferentEnd(StartAddr, EndAddr + 1);
+  const AddressRange RangeDifferentStartEnd(StartAddr + 1, EndAddr + 1);
+  // Test == and != with values that are the same
+  EXPECT_EQ(Range, RangeSame);
+  EXPECT_FALSE(Range != RangeSame);
+  // Test == and != with values that are the different
+  EXPECT_NE(Range, RangeDifferentStart);
+  EXPECT_NE(Range, RangeDifferentEnd);
+  EXPECT_NE(Range, RangeDifferentStartEnd);
+  EXPECT_FALSE(Range == RangeDifferentStart);
+  EXPECT_FALSE(Range == RangeDifferentEnd);
+  EXPECT_FALSE(Range == RangeDifferentStartEnd);
+
+  // Test "bool operator<(const AddressRange &, const AddressRange &)".
+  EXPECT_FALSE(Range < RangeSame);
+  EXPECT_FALSE(RangeSame < Range);
+  EXPECT_LT(Range, RangeDifferentStart);
+  EXPECT_LT(Range, RangeDifferentEnd);
+  EXPECT_LT(Range, RangeDifferentStartEnd);
+  // Test "bool operator<(const AddressRange &, uint64_t)"
+  EXPECT_LT(Range.start(), StartAddr + 1);
+  // Test "bool operator<(uint64_t, const AddressRange &)"
+  EXPECT_LT(StartAddr - 1, Range.start());
+
+  // Verify llvm::AddressRange::isContiguousWith() and
+  // llvm::AddressRange::intersects().
+  const AddressRange EndsBeforeRangeStart(0, StartAddr - 1);
+  const AddressRange EndsAtRangeStart(0, StartAddr);
+  const AddressRange OverlapsRangeStart(StartAddr - 1, StartAddr + 1);
+  const AddressRange InsideRange(StartAddr + 1, EndAddr - 1);
+  const AddressRange OverlapsRangeEnd(EndAddr - 1, EndAddr + 1);
+  const AddressRange StartsAtRangeEnd(EndAddr, EndAddr + 0x100);
+  const AddressRange StartsAfterRangeEnd(EndAddr + 1, EndAddr + 0x100);
+
+  EXPECT_FALSE(Range.intersects(EndsBeforeRangeStart));
+  EXPECT_FALSE(Range.intersects(EndsAtRangeStart));
+  EXPECT_TRUE(Range.intersects(OverlapsRangeStart));
+  EXPECT_TRUE(Range.intersects(InsideRange));
+  EXPECT_TRUE(Range.intersects(OverlapsRangeEnd));
+  EXPECT_FALSE(Range.intersects(StartsAtRangeEnd));
+  EXPECT_FALSE(Range.intersects(StartsAfterRangeEnd));
+
+  // Test the functions that maintain address ranges:
+  //  "bool AddressRange::contains(uint64_t Addr) const;"
+  //  "void AddressRanges::insert(const AddressRange &R);"
+  AddressRanges Ranges;
+  Ranges.insert(AddressRange(0x1000, 0x2000));
+  Ranges.insert(AddressRange(0x2000, 0x3000));
+  Ranges.insert(AddressRange(0x4000, 0x5000));
+
+  EXPECT_FALSE(Ranges.contains(0));
+  EXPECT_FALSE(Ranges.contains(0x1000 - 1));
+  EXPECT_TRUE(Ranges.contains(0x1000));
+  EXPECT_TRUE(Ranges.contains(0x2000));
+  EXPECT_TRUE(Ranges.contains(0x4000));
+  EXPECT_TRUE(Ranges.contains(0x2000 - 1));
+  EXPECT_TRUE(Ranges.contains(0x3000 - 1));
+  EXPECT_FALSE(Ranges.contains(0x3000 + 1));
+  EXPECT_TRUE(Ranges.contains(0x5000 - 1));
+  EXPECT_FALSE(Ranges.contains(0x5000 + 1));
+  EXPECT_FALSE(Ranges.contains(UINT64_MAX));
+
+  EXPECT_FALSE(Ranges.contains(AddressRange()));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000 - 1, 0x1000)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x1000)));
+  EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x1000 + 1)));
+  EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2000)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x2001)));
+  EXPECT_TRUE(Ranges.contains(AddressRange(0x2000, 0x3000)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x2000, 0x3001)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x3000, 0x3001)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1500, 0x4500)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x5000, 0x5001)));
+
+  // Verify that intersecting ranges get combined
+  Ranges.clear();
+  Ranges.insert(AddressRange(0x1100, 0x1F00));
+  // Verify a wholy contained range that is added doesn't do anything.
+  Ranges.insert(AddressRange(0x1500, 0x1F00));
+  EXPECT_EQ(Ranges.size(), 1u);
+  EXPECT_EQ(Ranges[0], AddressRange(0x1100, 0x1F00));
+
+  // Verify a range that starts before and intersects gets combined.
+  Ranges.insert(AddressRange(0x1000, Ranges[0].start() + 1));
+  EXPECT_EQ(Ranges.size(), 1u);
+  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x1F00));
+
+  // Verify a range that starts inside and extends ranges gets combined.
+  Ranges.insert(AddressRange(Ranges[0].end() - 1, 0x2000));
+  EXPECT_EQ(Ranges.size(), 1u);
+  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
+
+  // Verify that adjacent ranges don't get combined
+  Ranges.insert(AddressRange(0x2000, 0x3000));
+  EXPECT_EQ(Ranges.size(), 2u);
+  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
+  EXPECT_EQ(Ranges[1], AddressRange(0x2000, 0x3000));
+  // Verify if we add an address range that intersects two ranges
+  // that they get combined
+  Ranges.insert(AddressRange(Ranges[0].end() - 1, Ranges[1].start() + 1));
+  EXPECT_EQ(Ranges.size(), 1u);
+  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x3000));
+
+  Ranges.insert(AddressRange(0x3000, 0x4000));
+  Ranges.insert(AddressRange(0x4000, 0x5000));
+  Ranges.insert(AddressRange(0x2000, 0x4500));
+  EXPECT_EQ(Ranges.size(), 1u);
+  EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x5000));
+}

llvm/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_llvm_unittest(SupportTests
+  AddressRangeTest.cpp
   AlignmentTest.cpp
   AlignOfTest.cpp
   AllocatorTest.cpp
   AnnotationsTest.cpp
   ARMAttributeParser.cpp
   ArrayRecyclerTest.cpp
   Base64Test.cpp
   BinaryStreamTest.cpp