[llvm-debuginfo-analyzer] Fix crash with WebAssembly dead code

llvm/include/llvm/DebugInfo/LogicalView/Core/LVObject.h

@@ -83,7 +83,17 @@ using LVTypes = SmallVector<LVType *, 8>;
 
 using LVOffsets = SmallVector<LVOffset, 8>;
 
+// The following DWARF documents detail the 'tombstone' concept:
+//   https://dwarfstd.org/issues/231013.1.html
+//   https://dwarfstd.org/issues/200609.1.html
+//
+// The value of the largest representable address offset (for example,
+// 0xffffffff when the size of an address is 32 bits).
+//
+// -1 (0xffffffff) => Valid tombstone
+// -2 (0xfffffffe) => Undefined tomstone
 const LVAddress MaxAddress = std::numeric_limits<uint64_t>::max();
+const LVAddress InvalidTombstone = MaxAddress - 1;
 
 enum class LVBinaryType { NONE, ELF, COFF };
 enum class LVComparePass { Missing, Added };

llvm/include/llvm/DebugInfo/LogicalView/Core/LVRange.h

@@ -54,11 +54,14 @@ class LVRange final : public LVObject {
   LVAllocator Allocator;
   LVRangesTree RangesTree;
   LVRangeEntries RangeEntries;
-  LVAddress Lower = MaxAddress;
+  LVAddress TombstoneAddress;
+  LVAddress Lower;
   LVAddress Upper = 0;
 
 public:
-  LVRange() : LVObject(), RangesTree(Allocator) {}
+  LVRange(LVAddress Address = InvalidTombstone)
+      : LVObject(), RangesTree(Allocator), TombstoneAddress(Address),
+        Lower(Address) {}
   LVRange(const LVRange &) = delete;
   LVRange &operator=(const LVRange &) = delete;
   ~LVRange() = default;
@@ -75,7 +78,7 @@ class LVRange final : public LVObject {
 
   void clear() {
     RangeEntries.clear();
-    Lower = MaxAddress;
+    Lower = TombstoneAddress;
     Upper = 0;
   }
   bool empty() const { return RangeEntries.empty(); }

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

@@ -133,6 +133,9 @@ class LVReader {
   // Only for ELF format. The CodeView is handled in a different way.
   LVSectionIndex DotTextSectionIndex = UndefinedSectionIndex;
 
+  // The value is updated for each Compile Unit that is processed.
+  LVAddress TombstoneAddress = InvalidTombstone;
+
   // Record Compilation Unit entry.
   void addCompileUnitOffset(LVOffset Offset, LVScopeCompileUnit *CompileUnit) {
     CompileUnits.emplace(Offset, CompileUnit);
@@ -257,6 +260,12 @@ class LVReader {
     return CompileUnit->getCPUType();
   }
 
+  void setTombstoneAddress(LVAddress Address) { TombstoneAddress = Address; }
+  LVAddress getTombstoneAddress() const {
+    assert(TombstoneAddress != InvalidTombstone && "Invalid tombstone value");
+    return TombstoneAddress;
+  }
+
   // Access to the scopes root.
   LVScopeRoot *getScopesRoot() const { return Root; }
 

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVCodeViewReader.h

@@ -193,11 +193,17 @@ class LVCodeViewReader final : public LVBinaryReader {
                    llvm::object::COFFObjectFile &Obj, ScopedPrinter &W,
                    StringRef ExePath)
       : LVBinaryReader(Filename, FileFormatName, W, LVBinaryType::COFF),
-        Input(&Obj), ExePath(ExePath), LogicalVisitor(this, W, Input) {}
+        Input(&Obj), ExePath(ExePath), LogicalVisitor(this, W, Input) {
+    // CodeView does not have the concept of 'tombstone' address.
+    setTombstoneAddress(MaxAddress);
+  }
   LVCodeViewReader(StringRef Filename, StringRef FileFormatName,
                    llvm::pdb::PDBFile &Pdb, ScopedPrinter &W, StringRef ExePath)
       : LVBinaryReader(Filename, FileFormatName, W, LVBinaryType::COFF),
-        Input(&Pdb), ExePath(ExePath), LogicalVisitor(this, W, Input) {}
+        Input(&Pdb), ExePath(ExePath), LogicalVisitor(this, W, Input) {
+    // CodeView does not have the concept of 'tombstone' address.
+    setTombstoneAddress(MaxAddress);
+  }
   LVCodeViewReader(const LVCodeViewReader &) = delete;
   LVCodeViewReader &operator=(const LVCodeViewReader &) = delete;
   ~LVCodeViewReader() = default;

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

@@ -384,8 +384,10 @@ LVRange *LVBinaryReader::getSectionRanges(LVSectionIndex SectionIndex) {
   // Check if we already have a mapping for this section index.
   LVSectionRanges::iterator IterSection = SectionRanges.find(SectionIndex);
   if (IterSection == SectionRanges.end())
-    IterSection =
-        SectionRanges.emplace(SectionIndex, std::make_unique<LVRange>()).first;
+    IterSection = SectionRanges
+                      .emplace(SectionIndex,
+                               std::make_unique<LVRange>(getTombstoneAddress()))
+                      .first;
   LVRange *Range = IterSection->second.get();
   assert(Range && "Range is null.");
   return Range;

llvm/lib/DebugInfo/LogicalView/Readers/LVDWARFReader.cpp

@@ -426,10 +426,11 @@ void LVDWARFReader::processOneAttribute(const DWARFDie &Die,
         }
       }
       if (FoundLowPC) {
-        if (CurrentLowPC == MaxAddress)
+        if (CurrentLowPC == getTombstoneAddress())
           CurrentElement->setIsDiscarded();
-        // Consider the case of WebAssembly.
-        CurrentLowPC += WasmCodeSectionOffset;
+        else
+          // Consider the case of WebAssembly.
+          CurrentLowPC += WasmCodeSectionOffset;
         if (CurrentElement->isCompileUnit())
           setCUBaseAddress(CurrentLowPC);
       }
@@ -483,7 +484,8 @@ void LVDWARFReader::processOneAttribute(const DWARFDie &Die,
       DWARFAddressRangesVector Ranges = RangesOrError.get();
       for (DWARFAddressRange &Range : Ranges) {
         // This seems to be a tombstone for empty ranges.
-        if (Range.LowPC == Range.HighPC)
+        if ((Range.LowPC == Range.HighPC) ||
+            (Range.LowPC = getTombstoneAddress()))
           continue;
         // Store the real upper limit for the address range.
         if (UpdateHighAddress && Range.HighPC > 0)
@@ -841,6 +843,11 @@ Error LVDWARFReader::createScopes() {
                                          : DwarfContext->dwo_compile_units();
   for (const std::unique_ptr<DWARFUnit> &CU : CompileUnits) {
 
+    // Take into account the address byte size for a correct 'tombstone'
+    // value identification.
+    setTombstoneAddress(
+        dwarf::computeTombstoneAddress(CU->getAddressByteSize()));
+
     // Deduction of index used for the line records.
     //
     // For the following test case: test.cpp