Increase performance of llvm-gsymutil by up to 200%.

llvm-gsymutil was maintaining an address ranges collection behind a mutex and having the multi-threaded code access this and hold the mutex was causing slowdown when converting DWARF to GSYM. This patch does the following:
- removes the "Ranges" variable from the GsymCreator and any functions and places that used it
- clients don't try to detect if a function has been added for an address range, we now remove any inferior copies of information in the GsymCreator::finalize() routine as was done before, we just have more items to remove, though performance is greator due to less mutex thread locking
- after I started adding all of the inferior funtion info objects the previous patch that tried to remove infrior debug info had bugs in it, so I replace the removeIfBinary() function in GsymCreator with a more efficient and easier to debug way to do things which copies items from the GsymCreator::Funcs into a new vector of FunctionInfo objects and then replaces GsymCreator::Funcs at the end.
- Sorting of FunctionInfo objects has been modified to also compare InlineInfo objects. We found cases where LTO was ruining inline function address ranges and we ended up with a variety of FunctionInfo objects for the same range that had varying amounts of valid debug info. This patch now ensure that two function info objects with different inline info for the same function address range, the best one will be picked to ensure the greatest fidelity.
- If we detect that a DW_TAG_subprogram has inline functions and after parsing it, we don't end up with any valid inline information, we set the optional to std::nullopt to avoid emitting empty inline information and wasting space.

My tests show a 200% perf increase on M1 macs and a 100% performance increase on linux machines for the same complex large DWARF input binary.

Differential Revision: https://reviews.llvm.org/D156773

Author: clayborg

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

@@ -202,21 +202,27 @@ inline bool operator==(const FunctionInfo &LHS, const FunctionInfo &RHS) {
 inline bool operator!=(const FunctionInfo &LHS, const FunctionInfo &RHS) {
   return !(LHS == RHS);
 }
-/// This sorting will order things consistently by address range first, but then
-/// followed by inlining being valid and line tables. We might end up with a
-/// FunctionInfo from debug info that will have the same range as one from the
-/// symbol table, but we want to quickly be able to sort and use the best version
-/// when creating the final GSYM file.
+/// This sorting will order things consistently by address range first, but
+/// then followed by increasing levels of debug info like inline information
+/// and line tables. We might end up with a FunctionInfo from debug info that
+/// will have the same range as one from the symbol table, but we want to
+/// quickly be able to sort and use the best version when creating the final
+/// GSYM file. This function compares the inline information as we have seen
+/// cases where LTO can generate a wide array of differing inline information,
+/// mostly due to messing up the address ranges for inlined functions, so the
+/// inline information with the most entries will appeear last. If the inline
+/// information match, either by both function infos not having any or both
+/// being exactly the same, we will then compare line tables. Comparing line
+/// tables allows the entry with the most line entries to appear last. This
+/// ensures we are able to save the FunctionInfo with the most debug info into
+/// the GSYM file.
 inline bool operator<(const FunctionInfo &LHS, const FunctionInfo &RHS) {
   // First sort by address range
   if (LHS.Range != RHS.Range)
     return LHS.Range < RHS.Range;
-
-  // Then sort by inline
-  if (LHS.Inline.has_value() != RHS.Inline.has_value())
-    return RHS.Inline.has_value();
-
-  return LHS.OptLineTable < RHS.OptLineTable;
+  if (LHS.Inline == RHS.Inline)
+    return LHS.OptLineTable < RHS.OptLineTable;
+  return LHS.Inline < RHS.Inline;
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const FunctionInfo &R);

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

@@ -142,8 +142,8 @@ class GsymCreator {
   std::vector<llvm::gsym::FileEntry> Files;
   std::vector<uint8_t> UUID;
   std::optional<AddressRanges> ValidTextRanges;
-  AddressRanges Ranges;
   std::optional<uint64_t> BaseAddress;
+  bool IsSegment = false;
   bool Finalized = false;
   bool Quiet;
 
@@ -282,6 +282,15 @@ class GsymCreator {
                            llvm::support::endianness ByteOrder,
                            uint64_t SegmentSize) const;
 
+  /// Let this creator know that this is a segment of another GsymCreator.
+  ///
+  /// When we have a segment, we know that function infos will be added in
+  /// ascending address range order without having to be finalized. We also
+  /// don't need to sort and unique entries during the finalize function call.
+  void setIsSegment() {
+    IsSegment = true;
+  }
+
 public:
   GsymCreator(bool Quiet = false);
 
@@ -379,17 +388,6 @@ class GsymCreator {
   /// object.
   size_t getNumFunctionInfos() const;
 
-  /// Check if an address has already been added as a function info.
-  ///
-  /// FunctionInfo data can come from many sources: debug info, symbol tables,
-  /// exception information, and more. Symbol tables should be added after
-  /// debug info and can use this function to see if a symbol's start address
-  /// has already been added to the GsymReader. Calling this before adding
-  /// a function info from a source other than debug info avoids clients adding
-  /// many redundant FunctionInfo objects from many sources only for them to be
-  /// removed during the finalize() call.
-  bool hasFunctionInfoForAddress(uint64_t Addr) const;
-
   /// Set valid .text address ranges that all functions must be contained in.
   void SetValidTextRanges(AddressRanges &TextRanges) {
     ValidTextRanges = TextRanges;

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

@@ -164,6 +164,17 @@ struct InlineInfo {
   /// \returns An error object that indicates success or failure or the
   /// encoding process.
   llvm::Error encode(FileWriter &O, uint64_t BaseAddr) const;
+
+  /// Compare InlineInfo objects.
+  ///
+  /// When comparing InlineInfo objects the item with the most inline functions
+  /// wins. If we have two FunctionInfo objects that both have the same address
+  /// range and both have valid InlineInfo objects, we want the one with the
+  /// most inline functions to win so we save the most information possible
+  /// to the GSYM file. We have seen cases where LTO messes up the inline
+  /// function information for the same address range, so this helps ensure we
+  /// get the most descriptive information we can for an address range.
+  bool operator<(const InlineInfo &RHS) const;
 };
 
 inline bool operator==(const InlineInfo &LHS, const InlineInfo &RHS) {

llvm/lib/DebugInfo/GSYM/DwarfTransformer.cpp

@@ -215,8 +215,6 @@ static void parseInlineInfo(GsymCreator &Gsym, raw_ostream &Log, CUInfo &CUI,
   if (Tag == dwarf::DW_TAG_inlined_subroutine) {
     // create new InlineInfo and append to parent.children
     InlineInfo II;
-    DWARFAddressRange FuncRange =
-        DWARFAddressRange(FI.startAddress(), FI.endAddress());
     Expected<DWARFAddressRangesVector> RangesOrError = Die.getAddressRanges();
     if (RangesOrError) {
       for (const DWARFAddressRange &Range : RangesOrError.get()) {
@@ -421,6 +419,23 @@ void DwarfTransformer::handleDie(raw_ostream &OS, CUInfo &CUI, DWARFDie Die) {
         FI.Inline->Name = *NameIndex;
         FI.Inline->Ranges.insert(FI.Range);
         parseInlineInfo(Gsym, OS, CUI, Die, 0, FI, *FI.Inline);
+        // Make sure we at least got some valid inline info other than just
+        // the top level function. If we didn't then remove the inline info
+        // from the function info. We have seen cases where LTO tries to modify
+        // the DWARF for functions and it messes up the address ranges for
+        // the inline functions so it is no longer valid.
+        //
+        // By checking if there are any valid children on the top level inline
+        // information object, we will know if we got anything valid from the
+        // debug info.
+        if (FI.Inline->Children.empty()) {
+          if (!Gsym.isQuiet()) {
+            OS << "warning: DIE contains inline function information that has "
+                  "no valid ranges, removing inline information:\n";
+            Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
+          }
+          FI.Inline = std::nullopt;
+        }
       }
       Gsym.addFunctionInfo(std::move(FI));
     }