[llvm-debuginfo-analyzer] 06 - Warning and internal options

[CarlosAlbertoEnciso]

Summary

LLVM debug information visual analyzer

For more information, see the RFC https://discourse.llvm.org/t/llvm-dev-rfc-llvm-dva-debug-information-visual-analyzer/62570

Patches:
01 - Interval Tree
02 - Driver and Documentation
03 - Logical Elements
04 - Locations and Ranges
05 - Select Elements
06 - Warning and Internal Options
07 - Compare Elements
08 - ELF Reader
09 - CodeView Reader
10 - Smart Pointers

This is a high level summary of the changes in this patch.

Warning and internal options

• Support for '--warning' options.
• Support for '--internal' options.

[psamolysov]

Some my comments repeat comments to previous patches, sorry if it looks noisy. Could you check the {A, B} replacement of the std::make_pair(A, B)? If it works, there is a couple of places where std::make_pair is used and they can be replaced with {A, B} too.

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

60

What about to add #include <list> to make the header more self-contained?

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

146

This is a bit inconsistent declaration: MapType is declared with typename while all the other types are declared with class. Something one should be used: either typename or class.

153

I'm sorry but I cannot find where the List is deleted. So, I get the Map takes ownership of the List but there is no destructor of function where the Map's entries (of the DebugTags map, for example) is deleted.

154

I believe this should work too.

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

41

I believe this should work.

44

To create an LVDuplicateEntry in place.

72

If format is the llvm::format function, the lambda captures nothing.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

1127

The code is mostly identical to LVScopeCompileUnit::addInvalidLocation(LVLocation *Location), it may make sense to extract the body in a static free function and pass into it an additional parameter: LVOffsetLocationsMap which is either &InvalidLocations or &InvalidRanges.

1199

I believe this should work too.

1210

I believe this should work too.

1223

I believe this should work too.

1236

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

93

A std::bad_alloc will be thrown if the test is out of memory. It makes sense to wrap the line in the try-catch block or use the non-throwing overload of the new operator.

177

There is an overload of the operator== for two StringRefs, so there is no needs in EXPECT_STREQ, moreover the data() method of StringRef doesn't guarantee that the returned string will be null terminated.

[psamolysov]

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

154

Or, it could be better Map->emplace(Key, List);.

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

41

Or, it could be better Integrity.emplace(Element, Scope);.

[psamolysov]

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

53–55

Here could be a bug: if AddressToLineData.upper_bound(Address) returns AddressToLineData.end(), AddressToLineData.end() is definitely not equal to AddressToLineData.begin(), Iter changes it's value to an element previous to the end and the check Iter != AddressToLineData.end() is forever be true.

[CarlosAlbertoEnciso]

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

60

Included <list>

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

146

Changed to use typename.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

1199

Nice change.

1210

Nice change.

1223

Nice change.

1236

Nice change.

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

93

Changed to use the non-throwing overload.

177

Changed to EXPECT_EQ(Element->getName(), Name);

[CarlosAlbertoEnciso]

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

153

Very good catch. The destructor part is missing.

// Delete the map contained list.
template <typename MapType> void deleteList(MapType &Map) {
  for (typename MapType::const_reference Entry : Map)
    delete Entry.second;
}

154

Replaced with Map->emplace(Key, List);.

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

41

Replaced with Integrity.emplace(Element, Scope);.

44

Replaced with Duplicate.emplace_back(Element, Scope, Iter->second);

72

You are correct.
Changed to auto PrintIndex = [](unsigned Index) {.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

1127

Refactored as:

void LVScopeCompileUnit::addInvalidLocationOrRange(LVLocation *Location,
                                                   LVElement *Element,
                                                   LVOffsetLocationsMap *Map) {
  LVOffset Offset = Element->getOffset();
  addInvalidOffset(Offset, Element);
  addItem<LVOffsetLocationsMap, LVLocations, LVOffset, LVLocation *>(
      Map, Offset, Location);
}

// Record symbols with invalid locations.
void LVScopeCompileUnit::addInvalidLocation(LVLocation *Location) {
  addInvalidLocationOrRange(Location, Location->getParentSymbol(),
                            &InvalidLocations);
}

// Record scopes with invalid ranges.
void LVScopeCompileUnit::addInvalidRange(LVLocation *Location) {
  addInvalidLocationOrRange(Location, Location->getParentScope(),
                            &InvalidRanges);
}

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

53–55

Sorry, I'm afraid I don't follow you.

The logic behind that code, is to get a LVLine that corresponds to the given Address.

Let's assume we have the following values:

{ Address 100, Line-1 } => Line-1 represents the address range [100-199] and [...-100]
{ Address 200, Line-2 } => Line-2 represents the address range [200-299]
{ Address 300, Line-3 } => Line-3 represents the address range [300-...]

Then

lineUpperBound(50)  -> Line-1
lineUpperBound(100) -> Line-1
lineUpperBound(150) -> Line-1
lineUpperBound(200) -> Line-2
lineUpperBound(250) -> Line-2
lineUpperBound(300) -> Line-3
lineUpperBound(350) -> Line-3

[psamolysov]

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

53–55

Thank you for the explanation. I'm still not sure how you can get AddressToLineData.end() after std::prev(Iter). Only one case is possible: AddressToLineData is empty, in this case begin() is equals to end(), so the check (Iter != AddressToLineData.end()) is required in this case. Maybe it makes sense to add the check if (AddressToLineData.empty()) before the call to AddressToLineData.upper_bound(Address) and remove the ternary operator at the end? I believe it can improve the method's readability.

[CarlosAlbertoEnciso]

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

53–55

Thanks for your great suggestion. It improve the function's readability.

Changed version to:

LVLine *MyAddressToLine::lineUpperBound(LVAddress Address) {
  if (AddressToLineData.empty())
    return nullptr;
  LVAddressToLine::const_iterator Iter = AddressToLineData.upper_bound(Address);
  if (Iter != AddressToLineData.begin())
    Iter = std::prev(Iter);
  return Iter->second;
}

[psamolysov]

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

53–55

This method looks good for me. Thanks.

[CarlosAlbertoEnciso]

• Addressed the reviewer’s feedback.
• Tool renamed as: llvm-debuginfo-analyzer.

[CarlosAlbertoEnciso]

Ping.

[probinson]

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

43

54

LLVM style wants braces for this multiline if statement.
https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

103

exit in a library function?

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

95

Use ASSERT_NE so the test will abort if the allocation fails.

[CarlosAlbertoEnciso]

Update patch due to changes in previous patches.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

54

Added braces.

103

This is a good point.

During the development of the CodeView Reader, due to incorrect parsing of the debug information, in some cases the same logical element was added to more than one logical scope.

If this method detects an error, it means the tool will crash as the memory is corrupted: the same logical element being destroyed more than once. That is the reason to force the exit.

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

95

ASSERT_NE can be used only inside functions that don't return a value.

See https://google.github.io/googletest/advanced.html#assertion-placement

The one constraint is that assertions that generate a fatal failure (FAIL* and ASSERT_*) can only be used in void-returning functions.

[CarlosAlbertoEnciso]

Address points raised by @probinson.

[probinson]

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

43

ping.

103

Better to have this function return a bool status, and the caller can do the exit or whatever else is appropriate to its context.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

43

Changed to // We found a duplicate..

103

bool checkIntegrityScopesTree(LVScope *Root) {
  ...
  // Start traversing the scopes root and print any duplicates.
  TraverseScope(Root);
  bool PassIntegrity = true;
  if (Duplicate.size()) {
    ...
    PassIntegrity = false;
  }
  return PassIntegrity;
}

If the scopes tree integrity fails, propagate an Error condition to the caller LVReader::doLoad().

Error LVReader::doLoad() {
  ...
  if (options().getInternalIntegrity() && !checkIntegrityScopesTree(Root))
    return make_error<StringError>("Duplicated elements in Scopes Tree");
  ...
  return Error::success();
}

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

103

It should read:

Error LVReader::doLoad() {
  ...
  if (options().getInternalIntegrity() && !checkIntegrityScopesTree(Root))
    return llvm::make_error<StringError>("Duplicated elements in Scopes Tree",
                                         inconvertibleErrorCode());
  ...
  return Error::success();
}

[probinson]

Please upload the latest revision.

[CarlosAlbertoEnciso]

Updated patch to address reviews from @probinson.

[probinson]

LGTM

[CarlosAlbertoEnciso]

@psamolysov , @probinson Thanks very much for all your valuable reviews.

[CarlosAlbertoEnciso]

@hliao Thanks for fixing the multi-stage link issue.

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

public:
   // The following functions 'resolve' some of their properties, such as
   // name, references, parents, extra information based on the element kind.
   virtual void resolve();
   virtual void resolveExtra() {}
   virtual void resolveName();
   virtual void resolveReferences() {}
   void resolveParents();
 
-public:
   static LVElementDispatch &getDispatch() { return Dispatch; }
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVELEMENT_H

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

class LVObject {
   } Parent = {nullptr};
 
   // We do not support any object duplication, as they are created by parsing
   // the debug information. There is only the case where we need a very basic
   // object, to manipulate its offset, line number and scope level. Allow the
   // copy constructor to create that object; it is used to print a reference
   // to another object and in the case of templates, to print its encoded args.
   LVObject(const LVObject &Object) {
+#ifndef NDEBUG
+    incID();
+#endif
     Properties = Object.Properties;
     Offset = Object.Offset;
     LineNumber = Object.LineNumber;
     ScopeLevel = Object.ScopeLevel;
     TagAttrOpcode = Object.TagAttrOpcode;
     Parent = Object.Parent;
   }
 
+#ifndef NDEBUG
+  // This is an internal ID used for debugging logical elements. It is used
+  // for cases where an unique offset within the binary input file is not
+  // available.
+  static uint64_t GID;
+  uint64_t ID = 0;
+
+  void incID() {
+    ++GID;
+    ID = GID;
+  }
+#endif
+
 protected:
   // Get a string representation for the given number and discriminator.
   std::string lineAsString(uint32_t LineNumber, LVHalf Discriminator,
                            bool ShowZero) const;
 
   // Get a string representation for the given number.
   std::string referenceAsString(uint32_t LineNumber, bool Spaces) const;
 
   // Print the Filename or Pathname.
   // Empty implementation for those objects that do not have any user
   // source file references, such as debug locations.
   virtual void printFileIndex(raw_ostream &OS, bool Full = true) const {}
 
 public:
-  LVObject() = default;
+  LVObject() {
+#ifndef NDEBUG
+    incID();
+#endif
+  };
   LVObject &operator=(const LVObject &) = delete;
   virtual ~LVObject() = default;
 
   PROPERTY(Property, IsLocation);
   PROPERTY(Property, IsGlobalReference);
   PROPERTY(Property, IsGeneratedName);
   PROPERTY(Property, IsResolved);
   PROPERTY(Property, IsResolvedName);
#endif
   virtual void print(raw_ostream &OS, bool Full = true) const;
   // Prints additional information for an object, depending on its kind
   // (class attributes, debug ranges, files, directories, etc).
   virtual void printExtra(raw_ostream &OS, bool Full = true) const {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual void dump() const { print(dbgs()); }
 #endif
+
+  uint64_t getID() const {
+    return
+#ifndef NDEBUG
+        ID;
+#else
+        0;
+#endif
+  }
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOBJECT_H

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

public:
   bool doPrintType(const LVType *Type) const {
     return patterns().printElement(Type);
   }
 
   static LVReader &getInstance();
   static void setInstance(LVReader *Reader);
 
   void print(raw_ostream &OS) const;
+  virtual void printRecords(raw_ostream &OS) const {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { print(dbgs()); }
 #endif
 };
 
 inline LVReader &getReader() { return LVReader::getInstance(); }
 inline LVSplitContext &getReaderSplitContext() {

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H
 #define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H
 
 #include "llvm/DebugInfo/LogicalView/Core/LVElement.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLocation.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVSort.h"
+#include <list>
 #include <map>
 #include <set>
 
 namespace llvm {
 namespace logicalview {
 
 class LVRange;
 
enum class LVScopeKind {
   IsTryBlock,
   IsUnion,
   LastEntry
 };
 using LVScopeKindSet = std::set<LVScopeKind>;
 using LVScopeDispatch = std::map<LVScopeKind, LVScopeGetFunction>;
 using LVScopeRequest = std::vector<LVScopeGetFunction>;
 
+using LVOffsetList = std::list<LVOffset>;
 using LVOffsetElementMap = std::map<LVOffset, LVElement *>;
+using LVOffsetLinesMap = std::map<LVOffset, LVLines *>;
+using LVOffsetLocationsMap = std::map<LVOffset, LVLocations *>;
+using LVOffsetSymbolMap = std::map<LVOffset, LVSymbol *>;
+using LVTagOffsetsMap = std::map<dwarf::Tag, LVOffsetList *>;
 
 // Class to represent a DWARF Scope.
 class LVScope : public LVElement {
   enum class Property {
     HasDiscriminator,
     CanHaveRanges,
     CanHaveLines,
     HasGlobals,
public:
   void encodeTemplateArguments(std::string &Name, const LVTypes *Types) const;
 
   void resolveElements();
 
   static LVScopeDispatch &getDispatch() { return Dispatch; }
 
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
+  virtual void printWarnings(raw_ostream &OS, bool Full = true) const {}
   virtual void printMatchedElements(raw_ostream &OS, bool UseMatchedElements) {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
 // Class to represent a DWARF Union/Structure/Class.
class LVScopeCompileUnit final : public LVScope {
   LVScopes MatchedScopes;
 
   // It records the mapping between logical lines representing a debug line
   // entry and its address in the text section. It is used to find a line
   // giving its exact or closest address.
   using LVAddressToLine = std::map<LVAddress, LVLine *>;
   LVAddressToLine AddressToLine;
 
+  // DWARF Tags (Tag, Element list).
+  LVTagOffsetsMap DebugTags;
+
+  // Offsets associated with objects being flagged as having invalid data
+  // (ranges, locations, lines zero or coverages).
+  LVOffsetElementMap WarningOffsets;
+
+  // Symbols with invalid locations. (Symbol, Location List).
+  LVOffsetLocationsMap InvalidLocations;
+
+  // Symbols with invalid coverage values.
+  LVOffsetSymbolMap InvalidCoverages;
+
+  // Scopes with invalid ranges (Scope, Range list).
+  LVOffsetLocationsMap InvalidRanges;
+
+  // Scopes with lines zero (Scope, Line list).
+  LVOffsetLinesMap LinesZero;
+
   // Record scopes contribution in bytes to the debug information.
   using LVSizesMap = std::map<const LVScope *, LVOffset>;
   LVSizesMap Sizes;
   LVOffset CUContributionSize = 0;
 
+  // Helper function to add an invalid location/range.
+  void addInvalidLocationOrRange(LVLocation *Location, LVElement *Element,
+                                 LVOffsetLocationsMap *Map) {
+    LVOffset Offset = Element->getOffset();
+    addInvalidOffset(Offset, Element);
+    addItem<LVOffsetLocationsMap, LVLocations, LVOffset, LVLocation *>(
+        Map, Offset, Location);
+  }
+
   // Record scope sizes indexed by lexical level.
   // Setting an initial size that will cover a very deep nested scopes.
   const size_t TotalInitialSize = 8;
   using LVTotalsEntry = std::pair<unsigned, float>;
   SmallVector<LVTotalsEntry> Totals;
   // Maximum seen lexical level. It is used to control how many entries
   // in the 'Totals' vector are valid values.
   LVLevel MaxSeenLevel = 0;
protected:
   void printSummary(raw_ostream &OS) const override;
 
 public:
   LVScopeCompileUnit() : LVScope(), Totals(TotalInitialSize, {0, 0.0}) {
     setIsCompileUnit();
   }
   LVScopeCompileUnit(const LVScopeCompileUnit &) = delete;
   LVScopeCompileUnit &operator=(const LVScopeCompileUnit &) = delete;
-  ~LVScopeCompileUnit() = default;
+  ~LVScopeCompileUnit() {
+    deleteList<LVTagOffsetsMap>(DebugTags);
+    deleteList<LVOffsetLocationsMap>(InvalidLocations);
+    deleteList<LVOffsetLocationsMap>(InvalidRanges);
+    deleteList<LVOffsetLinesMap>(LinesZero);
+  }
 
   LVScope *getCompileUnitParent() const override {
     return static_cast<LVScope *>(const_cast<LVScopeCompileUnit *>(this));
   }
 
   // Get the line located at the given address.
   LVLine *lineLowerBound(LVAddress Address) const;
   LVLine *lineUpperBound(LVAddress Address) const;
public:
 
   StringRef getProducer() const override {
     return getStringPool().getString(ProducerIndex);
   }
   void setProducer(StringRef ProducerName) override {
     ProducerIndex = getStringPool().getIndex(ProducerName);
   }
 
+  // Record DWARF tags.
+  void addDebugTag(dwarf::Tag Target, LVOffset Offset);
+  // Record elements with invalid offsets.
+  void addInvalidOffset(LVOffset Offset, LVElement *Element);
+  // Record symbols with invalid coverage values.
+  void addInvalidCoverage(LVSymbol *Symbol);
+  // Record symbols with invalid locations.
+  void addInvalidLocation(LVLocation *Location);
+  // Record scopes with invalid ranges.
+  void addInvalidRange(LVLocation *Location);
+  // Record line zero.
+  void addLineZero(LVLine *Line);
+
+  const LVTagOffsetsMap getDebugTags() const { return DebugTags; }
+  const LVOffsetElementMap getWarningOffsets() const { return WarningOffsets; }
+  const LVOffsetLocationsMap getInvalidLocations() const {
+    return InvalidLocations;
+  }
+  const LVOffsetSymbolMap getInvalidCoverages() const {
+    return InvalidCoverages;
+  }
+  const LVOffsetLocationsMap getInvalidRanges() const { return InvalidRanges; }
+  const LVOffsetLinesMap getLinesZero() const { return LinesZero; }
+
   // Process ranges, locations and calculate coverage.
   void processRangeLocationCoverage(
       LVValidLocation ValidLocation = &LVLocation::validateRanges);
 
   // Add matched element.
   void addMatched(LVElement *Element) { MatchedElements.push_back(Element); }
   void addMatched(LVScope *Scope) { MatchedScopes.push_back(Scope); }
   void propagatePatternMatch();
public:
   void addedElement(LVScope *Scope);
   void addedElement(LVSymbol *Symbol);
   void addedElement(LVType *Type);
 
   void addSize(LVScope *Scope, LVOffset Lower, LVOffset Upper);
 
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
+  void printWarnings(raw_ostream &OS, bool Full = true) const override;
   void printMatchedElements(raw_ostream &OS, bool UseMatchedElements) override;
 };
 
 // Class to represent a DWARF enumerator (DW_TAG_enumeration_type).
 class LVScopeEnumeration final : public LVScope {
 public:
   LVScopeEnumeration() : LVScope() { setIsEnumeration(); }
   LVScopeEnumeration(const LVScopeEnumeration &) = delete;

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

std::string formatAttributes(const StringRef First, Args... Others) {
   for (const StringRef &Item : List) {
     Stream << (Size ? " " : "") << Item.str();
     Size = Item.size();
   }
   Stream << (Size ? " " : "");
   return Stream.str();
 }
 
+// Add an item to a map with second being a list.
+template <typename MapType, typename ListType, typename KeyType,
+          typename ValueType>
+void addItem(MapType *Map, KeyType Key, ValueType Value) {
+  ListType *List = nullptr;
+  typename MapType::const_iterator Iter = Map->find(Key);
+  if (Iter != Map->end())
+    List = Iter->second;
+  else {
+    List = new ListType();
+    Map->emplace(Key, List);
+  }
+  List->push_back(Value);
+}
+
+// Delete the map contained list.
+template <typename MapType> void deleteList(MapType &Map) {
+  for (typename MapType::const_reference Entry : Map)
+    delete Entry.second;
+}
+
 // Unified and flattened pathnames.
 std::string transformPath(StringRef Path);
 std::string flattenedFilePath(StringRef Path);
 
 inline std::string formattedKind(StringRef Kind) {
   return (Twine("{") + Twine(Kind) + Twine("}")).str();
 }
 

llvm/lib/DebugInfo/LogicalView/Core/LVLine.cpp

LVLineDispatch LVLine::Dispatch = {
     {LVLineKind::IsNewStatement, &LVLine::getIsNewStatement},
     {LVLineKind::IsEpilogueBegin, &LVLine::getIsEpilogueBegin},
     {LVLineKind::IsPrologueEnd, &LVLine::getIsPrologueEnd},
     {LVLineKind::IsAlwaysStepInto, &LVLine::getIsAlwaysStepInto},
     {LVLineKind::IsNeverStepInto, &LVLine::getIsNeverStepInto}};
 
 // String used as padding for printing elements with no line number.
 std::string LVLine::noLineAsString(bool ShowZero) const {
+  if (options().getInternalNone())
+    return LVObject::noLineAsString(ShowZero);
   return (ShowZero || options().getAttributeZero()) ? ("    0   ")
                                                     : ("    -   ");
 }
 
 void LVLine::print(raw_ostream &OS, bool Full) const {
   if (getReader().doPrintLine(this)) {
     getReaderCompileUnit()->incrementPrintedLines();
     LVElement::print(OS, Full);

llvm/lib/DebugInfo/LogicalView/Core/LVObject.cpp

 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
 #include <iomanip>
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Object"
 
+#ifndef NDEBUG
+uint64_t LVObject::GID = 0;
+#endif
+
 StringRef llvm::logicalview::typeNone() { return StringRef(); }
 StringRef llvm::logicalview::typeVoid() { return "void"; }
 StringRef llvm::logicalview::typeInt() { return "int"; }
 StringRef llvm::logicalview::typeUnknown() { return "?"; }
 StringRef llvm::logicalview::emptyString() { return StringRef(); }
 
 // Get a string representing the indentation level.
 std::string LVObject::indentAsString(LVLevel Level) const {
if (LineNumber) {
     if (Discriminator && options().getAttributeDiscriminator())
       Stream << std::setw(5) << LineNumber << "," << std::left << std::setw(2)
              << Discriminator;
     else
       Stream << std::setw(5) << LineNumber << "   ";
   } else
     Stream << noLineAsString(ShowZero);
 
+  if (options().getInternalNone())
+    Stream.str(noLineAsString(ShowZero));
+
   return Stream.str();
 }
 
 // Same as 'LineString' but with stripped whitespaces.
 std::string LVObject::lineNumberAsStringStripped(bool ShowZero) const {
   return std::string(StringRef(lineNumberAsString(ShowZero)).trim());
 }
 
if (PrintRef && options().getAttributeOffset())
     OS << hexSquareString(getOffset());
   if (UseQuotes)
     OS << formattedName(Value) << "\n";
   else
     OS << Value << "\n";
 }
 
 void LVObject::printAttributes(raw_ostream &OS, bool Full) const {
+#ifndef NDEBUG
+  if (options().getInternalID())
+    OS << hexSquareString(getID());
+#endif
   if (options().getAttributeOffset())
     OS << hexSquareString(getOffset());
   if (options().getAttributeLevel()) {
     std::stringstream Stream;
     Stream.str(std::string());
     Stream << "[" << std::setfill('0') << std::setw(3) << getLevel() << "]";
     std::string TheLevel(Stream.str());
     OS << TheLevel;

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

 #include "llvm/Support/FormatVariadic.h"
 #include <tuple>
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Reader"
 
+// Detect elements that are inserted more than once at different scopes,
+// causing a crash on the reader destruction, as the element is already
+// deleted from other scope. Helper for CodeView reader.
+bool checkIntegrityScopesTree(LVScope *Root) {
+  using LVDuplicateEntry = std::tuple<LVElement *, LVScope *, LVScope *>;
+  using LVDuplicate = std::vector<LVDuplicateEntry>;
+  LVDuplicate Duplicate;
+
+  using LVIntegrity = std::map<LVElement *, LVScope *>;
+  LVIntegrity Integrity;
+
+  // Add the given element to the integrity map.
+  auto AddElement = [&](LVElement *Element, LVScope *Scope) {
+    LVIntegrity::iterator Iter = Integrity.find(Element);
+    if (Iter == Integrity.end())
+      Integrity.emplace(Element, Scope);
+    else
+      // We found a duplicate.
+      Duplicate.emplace_back(Element, Scope, Iter->second);
+  };
+
+  // Recursively add all the elements in the scope.
+  std::function<void(LVScope * Parent)> TraverseScope = [&](LVScope *Parent) {
+    auto Traverse = [&](const auto *Set) {
+      if (Set)
+        for (const auto &Entry : *Set)
+          AddElement(Entry, Parent);
+    };
+    if (const LVScopes *Scopes = Parent->getScopes()) {
+      for (LVScope *Scope : *Scopes) {
+        AddElement(Scope, Parent);
+        TraverseScope(Scope);
+      }
+    }
+    Traverse(Parent->getSymbols());
+    Traverse(Parent->getTypes());
+    Traverse(Parent->getLines());
+  };
+
+  // Start traversing the scopes root and print any duplicates.
+  TraverseScope(Root);
+  bool PassIntegrity = true;
+  if (Duplicate.size()) {
+    std::stable_sort(begin(Duplicate), end(Duplicate),
+                     [](const auto &l, const auto &r) {
+                       return std::get<0>(l)->getID() < std::get<0>(r)->getID();
+                     });
+
+    auto PrintIndex = [](unsigned Index) {
+      if (Index)
+        dbgs() << format("%8d: ", Index);
+      else
+        dbgs() << format("%8c: ", ' ');
+    };
+    auto PrintElement = [&](LVElement *Element, unsigned Index = 0) {
+      PrintIndex(Index);
+      std::string ElementName(Element->getName());
+      dbgs() << format("%15s ID=0x%08x '%s'\n", Element->kind(),
+                       Element->getID(), ElementName.c_str());
+    };
+
+    std::string RootName(Root->getName());
+    dbgs() << formatv("{0}\n", fmt_repeat('=', 72));
+    dbgs() << format("Root: '%s'\nDuplicated elements: %d\n", RootName.c_str(),
+                     Duplicate.size());
+    dbgs() << formatv("{0}\n", fmt_repeat('=', 72));
+
+    unsigned Index = 0;
+    for (const LVDuplicateEntry &Entry : Duplicate) {
+      LVElement *Element;
+      LVScope *First;
+      LVScope *Second;
+      std::tie(Element, First, Second) = Entry;
+      dbgs() << formatv("\n{0}\n", fmt_repeat('-', 72));
+      PrintElement(Element, ++Index);
+      PrintElement(First);
+      PrintElement(Second);
+      dbgs() << formatv("{0}\n", fmt_repeat('-', 72));
+    }
+    PassIntegrity = false;
+  }
+  return PassIntegrity;
+}
+
 //===----------------------------------------------------------------------===//
 // Class to represent a split context.
 //===----------------------------------------------------------------------===//
 Error LVSplitContext::createSplitFolder(StringRef Where) {
   // The 'location' will represent the root directory for the output created
   // by the context. It will contain the different CUs files, that will be
   // extracted from a single ELF.
   Location = std::string(Where);
Error LVReader::doLoad() {
   // Once we have processed the requests for any particular kind of elements,
   // we need to update the report options, in order to have a default value.
   patterns().updateReportOptions();
 
   // Delegate the scope tree creation to the specific reader.
   if (Error Err = createScopes())
     return Err;
 
+  if (options().getInternalIntegrity() && !checkIntegrityScopesTree(Root))
+    return llvm::make_error<StringError>("Duplicated elements in Scopes Tree",
+                                         inconvertibleErrorCode());
+
   // Calculate symbol coverage and detect invalid debug locations and ranges.
   Root->processRangeInformation();
 
   // As the elements can depend on elements from a different compile unit,
   // information such as name and file/line source information needs to be
   // updated.
   Root->resolveElements();
 

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

for (const LVType *Type : *Types) {
       AddComma = true;
     }
   }
 
   Name.append(">");
 }
 
 bool LVScope::resolvePrinting() const {
+  // The warnings collected during the scope creation as per compile unit.
+  // If there is a request for printing warnings, always print its associate
+  // Compile Unit.
+  if (options().getPrintWarnings() && (getIsRoot() || getIsCompileUnit()))
+    return true;
+
   // In selection mode, always print the root scope regardless of the
   // number of matched elements. If no matches, the root by itself will
   // indicate no matches.
   if (options().getSelectExecute()) {
     return getIsRoot() || getIsCompileUnit() || getHasPattern();
   }
 
   bool Globals = options().getAttributeGlobal();
if ((getIsRoot() || options().getPrintAnyElement()) &&
       if (Lines)
         for (const LVLine *Line : *Lines) {
           if (Match && !Line->getHasPattern())
             continue;
           if (Error Err =
                   Line->doPrint(Split, Match, Print, *StreamSplit, Full))
             return Err;
         }
+
+      // Print the warnings.
+      if (options().getPrintWarnings())
+        printWarnings(*StreamSplit, Full);
     }
   }
 
   // Done printing the compile unit. Print any requested summary and
   // restore the original output context.
   if (getIsCompileUnit()) {
     if (options().getPrintSummary())
       printSummary(*StreamSplit);
     if (options().getPrintSizes())
       printSizes(*StreamSplit);
     if (Split) {
       getReaderSplitContext().close();
       StreamSplit = &getReader().outputStream();
     }
   }
 
+  if (getIsRoot() && options().getPrintWarnings()) {
+    getReader().printRecords(*StreamSplit);
+  }
+
   return Error::success();
 }
 
 void LVScope::sort() {
   // Preserve the lines order as they are associated with user code.
   LVSortFunction SortFunction = getSortFunction();
   if (SortFunction) {
     std::function<void(LVScope * Parent, LVSortFunction SortFunction)> Sort =
void LVScopeCompileUnit::propagatePatternMatch() {
   }
 }
 
 void LVScopeCompileUnit::processRangeLocationCoverage(
     LVValidLocation ValidLocation) {
   if (options().getAttributeRange()) {
     // Traverse the scopes to get scopes that have invalid ranges.
     LVLocations Locations;
-    bool RecordInvalid = false;
+    bool RecordInvalid = options().getWarningRanges();
     getRanges(Locations, ValidLocation, RecordInvalid);
+
+    // Validate ranges associated with scopes.
+    if (RecordInvalid)
+      for (LVLocation *Location : Locations)
+        addInvalidRange(Location);
   }
 
   if (options().getAttributeLocation()) {
     // Traverse the scopes to get locations that have invalid ranges.
     LVLocations Locations;
-    bool RecordInvalid = false;
+    bool RecordInvalid = options().getWarningLocations();
     getLocations(Locations, ValidLocation, RecordInvalid);
+
+    // Validate ranges associated with locations.
+    if (RecordInvalid)
+      for (LVLocation *Location : Locations)
+        addInvalidLocation(Location);
   }
 }
 
 LVLine *LVScopeCompileUnit::lineLowerBound(LVAddress Address) const {
   LVAddressToLine::const_iterator Iter = AddressToLine.lower_bound(Address);
   return (Iter != AddressToLine.end()) ? Iter->second : nullptr;
 }
 
 LVLine *LVScopeCompileUnit::lineUpperBound(LVAddress Address) const {
+  if (AddressToLine.empty())
+    return nullptr;
   LVAddressToLine::const_iterator Iter = AddressToLine.upper_bound(Address);
   if (Iter != AddressToLine.begin())
     Iter = std::prev(Iter);
-  return (Iter != AddressToLine.end()) ? Iter->second : nullptr;
+  return Iter->second;
 }
 
 StringRef LVScopeCompileUnit::getFilename(size_t Index) const {
   if (Index <= 0 || Index > Filenames.size())
     return StringRef();
   return getStringPool().getString(Filenames[Index - 1]);
 }
 

 
 // A new element has been added to the scopes tree. Take the following steps:
 // Increase the added element counters, for printing summary.
 void LVScopeCompileUnit::addedElement(LVLine *Line) { increment(Line); }
 void LVScopeCompileUnit::addedElement(LVScope *Scope) { increment(Scope); }
 void LVScopeCompileUnit::addedElement(LVSymbol *Symbol) { increment(Symbol); }
 void LVScopeCompileUnit::addedElement(LVType *Type) { increment(Type); }
 
+// Record unsuported DWARF tags.
+void LVScopeCompileUnit::addDebugTag(dwarf::Tag Target, LVOffset Offset) {
+  addItem<LVTagOffsetsMap, LVOffsetList, dwarf::Tag, LVOffset>(&DebugTags,
+                                                               Target, Offset);
+}
+
+// Record elements with invalid offsets.
+void LVScopeCompileUnit::addInvalidOffset(LVOffset Offset, LVElement *Element) {
+  if (WarningOffsets.find(Offset) == WarningOffsets.end())
+    WarningOffsets.emplace(Offset, Element);
+}
+
+// Record symbols with invalid coverage values.
+void LVScopeCompileUnit::addInvalidCoverage(LVSymbol *Symbol) {
+  LVOffset Offset = Symbol->getOffset();
+  if (InvalidCoverages.find(Offset) == InvalidCoverages.end())
+    InvalidCoverages.emplace(Offset, Symbol);
+}
+
+// Record symbols with invalid locations.
+void LVScopeCompileUnit::addInvalidLocation(LVLocation *Location) {
+  addInvalidLocationOrRange(Location, Location->getParentSymbol(),
+                            &InvalidLocations);
+}
+
+// Record scopes with invalid ranges.
+void LVScopeCompileUnit::addInvalidRange(LVLocation *Location) {
+  addInvalidLocationOrRange(Location, Location->getParentScope(),
+                            &InvalidRanges);
+}
+
+// Record line zero.
+void LVScopeCompileUnit::addLineZero(LVLine *Line) {
+  LVScope *Scope = Line->getParentScope();
+  LVOffset Offset = Scope->getOffset();
+  addInvalidOffset(Offset, Scope);
+  addItem<LVOffsetLinesMap, LVLines, LVOffset, LVLine *>(&LinesZero, Offset,
+                                                         Line);
+}
+
 void LVScopeCompileUnit::printLocalNames(raw_ostream &OS, bool Full) const {
   if (!options().getPrintFormatting())
     return;
 
   // Calculate an indentation value, to preserve a nice layout.
   size_t Indentation = options().indentationSize() +
                        lineNumberAsString().length() +
                        indentAsString(getLevel() + 1).length() + 3;
void LVScopeCompileUnit::printLocalNames(raw_ostream &OS, bool Full) const {
   };
 
   if (options().getAttributeDirectories())
     PrintNames(Option::Directory);
   if (options().getAttributeFiles())
     PrintNames(Option::File);
 }
 
+void LVScopeCompileUnit::printWarnings(raw_ostream &OS, bool Full) const {
+  auto PrintHeader = [&](const char *Header) { OS << "\n" << Header << ":\n"; };
+  auto PrintFooter = [&](auto &Set) {
+    if (Set.empty())
+      OS << "None\n";
+  };
+  auto PrintOffset = [&](unsigned &Count, LVOffset Offset) {
+    if (Count == 5) {
+      Count = 0;
+      OS << "\n";
+    }
+    ++Count;
+    OS << hexSquareString(Offset) << " ";
+  };
+  auto PrintElement = [&](const LVOffsetElementMap &Map, LVOffset Offset) {
+    LVOffsetElementMap::const_iterator Iter = Map.find(Offset);
+    LVElement *Element = Iter != Map.end() ? Iter->second : nullptr;
+    OS << "[" << hexString(Offset) << "]";
+    if (Element)
+      OS << " " << formattedKind(Element->kind()) << " "
+         << formattedName(Element->getName());
+    OS << "\n";
+  };
+  auto PrintInvalidLocations = [&](const LVOffsetLocationsMap &Map,
+                                   const char *Header) {
+    PrintHeader(Header);
+    for (LVOffsetLocationsMap::const_reference Entry : Map) {
+      PrintElement(WarningOffsets, Entry.first);
+      for (const LVLocation *Location : *Entry.second)
+        OS << hexSquareString(Location->getOffset()) << " "
+           << Location->getIntervalInfo() << "\n";
+    }
+    PrintFooter(Map);
+  };
+
+  if (options().getInternalTag() && getReader().isBinaryTypeELF()) {
+    PrintHeader("Unsupported DWARF Tags");
+    for (LVTagOffsetsMap::const_reference Entry : DebugTags) {
+      OS << format("\n0x%02x", (unsigned)Entry.first) << ", "
+         << dwarf::TagString(Entry.first) << "\n";
+      unsigned Count = 0;
+      for (const LVOffset &Offset : *Entry.second)
+        PrintOffset(Count, Offset);
+      OS << "\n";
+    }
+    PrintFooter(DebugTags);
+  }
+
+  if (options().getWarningCoverages()) {
+    PrintHeader("Symbols Invalid Coverages");
+    for (LVOffsetSymbolMap::const_reference Entry : InvalidCoverages) {
+      // Symbol basic information.
+      LVSymbol *Symbol = Entry.second;
+      OS << hexSquareString(Entry.first) << " {Coverage} "
+         << format("%.2f%%", Symbol->getCoveragePercentage()) << " "
+         << formattedKind(Symbol->kind()) << " "
+         << formattedName(Symbol->getName()) << "\n";
+    }
+    PrintFooter(InvalidCoverages);
+  }
+
+  if (options().getWarningLines()) {
+    PrintHeader("Lines Zero References");
+    for (LVOffsetLinesMap::const_reference Entry : LinesZero) {
+      PrintElement(WarningOffsets, Entry.first);
+      unsigned Count = 0;
+      for (const LVLine *Line : *Entry.second)
+        PrintOffset(Count, Line->getOffset());
+      OS << "\n";
+    }
+    PrintFooter(LinesZero);
+  }
+
+  if (options().getWarningLocations())
+    PrintInvalidLocations(InvalidLocations, "Invalid Location Ranges");
+
+  if (options().getWarningRanges())
+    PrintInvalidLocations(InvalidRanges, "Invalid Code Ranges");
+}
+
 void LVScopeCompileUnit::printTotals(raw_ostream &OS) const {
   OS << "\nTotals by lexical level:\n";
   for (size_t Index = 1; Index <= MaxSeenLevel; ++Index)
     OS << format("[%03d]: %10d (%6.2f%%)\n", Index, Totals[Index].first,
                  Totals[Index].second);
 }
 
 void LVScopeCompileUnit::printScopeSize(const LVScope *Scope, raw_ostream &OS) {

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

if (!LVLocation::calculateCoverage(Locations, CoverageFactor,
     unsigned CoverageParent = Parent->getCoverageFactor();
     // Get a percentage rounded to two decimal digits. This avoids
     // implementation-defined rounding inside printing functions.
     CoveragePercentage =
         CoverageParent
             ? rint((double(CoverageFactor) / CoverageParent) * 100.0 * 100.0) /
                   100.0
             : 0;
+    // Record invalid coverage entry.
+    if (options().getWarningCoverages() && CoveragePercentage > 100)
+      getReaderCompileUnit()->addInvalidCoverage(this);
   }
 }
 
 void LVSymbol::resolveName() {
   if (getIsResolvedName())
     return;
   setIsResolvedName();
 

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoLogicalView
   )
 
 add_llvm_unittest(DebugInfoLogicalViewTests
   CommandLineOptionsTest.cpp
   SelectElementsTest.cpp
   LocationRangesTest.cpp
   LogicalElementsTest.cpp
   StringPoolTest.cpp
+  WarningInternalTest.cpp
   )
 
 target_link_libraries(DebugInfoLogicalViewTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/LogicalView/WarningInternalTest.cpp

+//===- llvm/unittest/DebugInfo/LogicalView/WarningInternalTest.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/DebugInfo/LogicalView/Core/LVLine.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Testing/Support/Error.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::logicalview;
+
+namespace {
+
+class MyLocation;
+
+// This code emulates the work done by the Readers when processing the
+// binary files and the creation of the AddressToLine mapping is done
+// automatically, using the text sections.
+class MyAddressToLine {
+  using LVAddressToLine = std::map<LVAddress, LVLine *>;
+  LVAddressToLine AddressToLineData;
+
+public:
+  MyAddressToLine() = default;
+
+  void insert(LVLine *Line) {
+    AddressToLineData.emplace(Line->getOffset(), Line);
+  }
+
+  LVLine *lineLowerBound(LVAddress Address);
+  LVLine *lineUpperBound(LVAddress Address);
+};
+
+LVLine *MyAddressToLine::lineLowerBound(LVAddress Address) {
+  LVAddressToLine::const_iterator Iter = AddressToLineData.lower_bound(Address);
+  return (Iter != AddressToLineData.end()) ? Iter->second : nullptr;
+}
+
+LVLine *MyAddressToLine::lineUpperBound(LVAddress Address) {
+  if (AddressToLineData.empty())
+    return nullptr;
+  LVAddressToLine::const_iterator Iter = AddressToLineData.upper_bound(Address);
+  if (Iter != AddressToLineData.begin())
+    Iter = std::prev(Iter);
+  return Iter->second;
+}
+
+MyAddressToLine AddressToLine;
+
+class ReaderTestWarningInternal : public LVReader {
+  // Types.
+  LVType *IntegerType = nullptr;
+
+  // Scopes.
+  LVScope *NestedScope = nullptr;
+  LVScopeFunction *Function = nullptr;
+
+  // Symbols.
+  LVSymbol *LocalVariable = nullptr;
+  LVSymbol *NestedVariable = nullptr;
+  LVSymbol *Parameter = nullptr;
+
+  // Lines.
+  LVLine *LineOne = nullptr;
+  LVLine *LineTwo = nullptr;
+  LVLine *LineThree = nullptr;
+  LVLine *LineFour = nullptr;
+  LVLine *LineFive = nullptr;
+  LVLine *LineSix = nullptr;
+
+  // Locations.
+  MyLocation *LocationOne = nullptr;
+  MyLocation *LocationTwo = nullptr;
+  MyLocation *LocationThree = nullptr;
+  MyLocation *LocationFour = nullptr;
+  MyLocation *LocationFive = nullptr;
+  MyLocation *LocationSix = nullptr;
+
+protected:
+  void add(LVScope *Parent, LVElement *Element);
+  template <typename T> T *create() {
+    T *Element = new (std::nothrow) T();
+    EXPECT_NE(Element, nullptr);
+    return Element;
+  }
+  void set(LVElement *Element, StringRef Name, LVOffset Offset,
+           uint32_t LineNumber = 0, LVElement *Type = nullptr);
+  void set(MyLocation *Location, LVLine *LowerLine, LVLine *UpperLine,
+           LVAddress LowerAddress, LVAddress UpperAddress);
+  void add(LVSymbol *Symbol, LVLine *LowerLine, LVLine *UpperLine);
+
+public:
+  ReaderTestWarningInternal(ScopedPrinter &W) : LVReader("", "", W) {
+    setInstance(this);
+  }
+
+  Error createScopes() { return LVReader::createScopes(); }
+
+  void setMapping();
+  void createElements();
+  void addElements();
+  void initElements();
+  void resolveElements();
+  void checkWarnings();
+};
+
+class MyLocation : public LVLocation {
+public:
+  bool validateRanges();
+};
+
+bool MyLocation::validateRanges() {
+  // Traverse the locations and validate them against the address to line
+  // mapping in the current compile unit. Record those invalid ranges.
+  // A valid range must meet the following conditions:
+  // a) line(lopc) <= line(hipc)
+  // b) line(lopc) and line(hipc) are valid.
+
+  LVLine *LowLine = AddressToLine.lineLowerBound(getLowerAddress());
+  LVLine *HighLine = AddressToLine.lineUpperBound(getUpperAddress());
+  if (LowLine)
+    setLowerLine(LowLine);
+  else {
+    setIsInvalidLower();
+    return false;
+  }
+  if (HighLine)
+    setUpperLine(HighLine);
+  else {
+    setIsInvalidUpper();
+    return false;
+  }
+  // Check for a valid interval.
+  if (LowLine->getLineNumber() > HighLine->getLineNumber()) {
+    setIsInvalidRange();
+    return false;
+  }
+
+  return true;
+}
+
+// Map all logical lines with their addresses.
+void ReaderTestWarningInternal::setMapping() {
+  AddressToLine.insert(LineOne);
+  AddressToLine.insert(LineTwo);
+  AddressToLine.insert(LineThree);
+  AddressToLine.insert(LineFour);
+  AddressToLine.insert(LineFive);
+  AddressToLine.insert(LineSix);
+}
+
+// Helper function to add a logical element to a given scope.
+void ReaderTestWarningInternal::add(LVScope *Parent, LVElement *Child) {
+  Parent->addElement(Child);
+  EXPECT_EQ(Child->getParent(), Parent);
+  EXPECT_EQ(Child->getLevel(), Parent->getLevel() + 1);
+}
+
+// Helper function to set the initial values for a given logical element.
+void ReaderTestWarningInternal::set(LVElement *Element, StringRef Name,
+                                    LVOffset Offset, uint32_t LineNumber,
+                                    LVElement *Type) {
+  Element->setName(Name);
+  Element->setOffset(Offset);
+  Element->setLineNumber(LineNumber);
+  Element->setType(Type);
+  EXPECT_EQ(Element->getName(), Name);
+  EXPECT_EQ(Element->getOffset(), Offset);
+  EXPECT_EQ(Element->getLineNumber(), LineNumber);
+  EXPECT_EQ(Element->getType(), Type);
+}
+
+// Helper function to set the initial values for a given logical location.
+void ReaderTestWarningInternal::set(MyLocation *Location, LVLine *LowerLine,
+                                    LVLine *UpperLine, LVAddress LowerAddress,
+                                    LVAddress UpperAddress) {
+  Location->setLowerLine(LowerLine);
+  Location->setUpperLine(UpperLine);
+  Location->setLowerAddress(LowerAddress);
+  Location->setUpperAddress(UpperAddress);
+  EXPECT_EQ(Location->getLowerLine(), LowerLine);
+  EXPECT_EQ(Location->getUpperLine(), UpperLine);
+  EXPECT_EQ(Location->getLowerAddress(), LowerAddress);
+  EXPECT_EQ(Location->getUpperAddress(), UpperAddress);
+}
+
+// Helper function to add a logical location to a logical symbol.
+void ReaderTestWarningInternal::add(LVSymbol *Symbol, LVLine *LowerLine,
+                                    LVLine *UpperLine) {
+  dwarf::Attribute Attr = dwarf::DW_AT_location;
+
+  Symbol->addLocation(Attr, LowerLine->getAddress(), UpperLine->getAddress(),
+                      /*SectionOffset=*/0, /*LocDesOffset=*/0);
+}
+
+// Create the logical elements.
+void ReaderTestWarningInternal::createElements() {
+  // Create scope root.
+  Error Err = createScopes();
+  ASSERT_THAT_ERROR(std::move(Err), Succeeded());
+  Root = getScopesRoot();
+  EXPECT_NE(Root, nullptr);
+
+  // Create the logical types.
+  IntegerType = create<LVType>();
+
+  // Create the logical scopes.
+  NestedScope = create<LVScope>();
+  CompileUnit = create<LVScopeCompileUnit>();
+  Function = create<LVScopeFunction>();
+
+  // Create the logical symbols.
+  LocalVariable = create<LVSymbol>();
+  NestedVariable = create<LVSymbol>();
+  Parameter = create<LVSymbol>();
+
+  // Create the logical lines.
+  LineOne = create<LVLine>();
+  LineTwo = create<LVLine>();
+  LineThree = create<LVLine>();
+  LineFour = create<LVLine>();
+  LineFive = create<LVLine>();
+  LineSix = create<LVLine>();
+
+  // Create the logical locations.
+  LocationOne = create<MyLocation>();
+  LocationTwo = create<MyLocation>();
+  LocationThree = create<MyLocation>();
+  LocationFour = create<MyLocation>();
+  LocationFive = create<MyLocation>();
+  LocationSix = create<MyLocation>();
+}
+
+// Create the logical view adding the created logical elements.
+void ReaderTestWarningInternal::addElements() {
+  setCompileUnit(CompileUnit);
+
+  // Root
+  //   CompileUnit
+  //     IntegerType
+  //     Function
+  //       LocationOne
+  //       LocationTwo
+  //       LocationFive
+  //       LocationSix
+  //       Parameter
+  //       LocalVariable
+  //       LineOne
+  //       LineTwo
+  //       NestedScope
+  //         LocationThree
+  //         LocationFour
+  //         NestedVariable
+  //         LineThree
+  //         LineFour
+  //       LineFive
+  //       LineSix
+
+  // Add elements to Root.
+  add(Root, CompileUnit);
+
+  // Add elements to CompileUnit.
+  add(CompileUnit, IntegerType);
+  add(CompileUnit, Function);
+
+  // Add elements to Function.
+  add(Function, Parameter);
+  add(Function, LocalVariable);
+  add(Function, LineOne);
+  add(Function, LineTwo);
+  add(Function, LineFive);
+  add(Function, LineSix);
+  add(Function, NestedScope);
+
+  // Add elements to NestedScope.
+  add(NestedScope, NestedVariable);
+  add(NestedScope, LineThree);
+  add(NestedScope, LineFour);
+}
+
+void ReaderTestWarningInternal::resolveElements() {
+  // Traverse the given scope and its children checking for any warnings.
+  std::function<void(LVScope * Parent)> TraverseScope = [&](LVScope *Parent) {
+    auto Warnings = [&](auto *Entry) {
+      if (Entry->getIsLine()) {
+        LVLine *Line = (LVLine *)Entry;
+        if (options().getWarningLines() && Line->getIsLineDebug() &&
+            !Line->getLineNumber())
+          CompileUnit->addLineZero(Line);
+      }
+    };
+    auto Traverse = [&](const auto *Set) {
+      if (Set)
+        for (const auto &Entry : *Set) {
+          Warnings(Entry);
+        }
+    };
+
+    Warnings(Parent);
+
+    Traverse(Parent->getSymbols());
+    Traverse(Parent->getTypes());
+    Traverse(Parent->getLines());
+
+    if (const LVScopes *Scopes = Parent->getScopes())
+      for (LVScope *Scope : *Scopes) {
+        Warnings(Scope);
+        TraverseScope(Scope);
+      }
+  };
+
+  // Start traversing the scopes root and resolve the elements.
+  TraverseScope(Root);
+}
+
+// Set initial values to logical elements.
+void ReaderTestWarningInternal::initElements() {
+  // Types.
+  set(IntegerType, "int", 0x1000);
+
+  // Scopes.
+  set(CompileUnit, "foo.cpp", 0x2000);
+  set(Function, "foo", 0x2010, 100, IntegerType);
+  set(NestedScope, "", 0x2020, 300);
+
+  // Symbols.
+  set(Parameter, "Param", 0x3000, 110, IntegerType);
+  set(LocalVariable, "LocalVariable", 0x3020, 120, IntegerType);
+  set(NestedVariable, "NestedVariable", 0x3010, 310, IntegerType);
+
+  // Lines.
+  set(LineOne, "", 0x5000, 100);
+  LineOne->setIsLineDebug();
+  set(LineTwo, "", 0x5200, 000);
+  LineTwo->setIsLineDebug();
+  set(LineThree, "", 0x5400, 300);
+  LineThree->setIsLineDebug();
+  set(LineFour, "", 0x5600, 000);
+  LineFour->setIsLineDebug();
+  set(LineFive, "", 0x5800, 500);
+  LineOne->setIsLineDebug();
+  set(LineSix, "", 0x6000, 600);
+  LineSix->setIsLineDebug();
+
+  // Locations.
+  set(LocationOne, LineOne, LineOne, 0x5000, 0x5100);
+  EXPECT_STREQ(LocationOne->getIntervalInfo().c_str(),
+               " Lines 100:100 [0x0000005000:0x0000005100]");
+
+  // Uses a Line zero.
+  set(LocationTwo, LineTwo, LineTwo, 0x5200, 0x5300);
+  EXPECT_STREQ(LocationTwo->getIntervalInfo().c_str(),
+               " Lines -:- [0x0000005200:0x0000005300]");
+
+  set(LocationThree, LineThree, LineThree, 0x5400, 0x5500);
+  EXPECT_STREQ(LocationThree->getIntervalInfo().c_str(),
+               " Lines 300:300 [0x0000005400:0x0000005500]");
+
+  // Uses a Line zero.
+  set(LocationFour, LineFour, LineFour, 0x5600, 0x5700);
+  LocationFour->setIsAddressRange();
+  EXPECT_STREQ(LocationFour->getIntervalInfo().c_str(),
+               "{Range} Lines -:- [0x0000005600:0x0000005700]");
+
+  // Invalid range.
+  set(LocationFive, LineFive, LineFive, 0x7800, 0x5900);
+  LocationFive->setIsAddressRange();
+  EXPECT_STREQ(LocationFive->getIntervalInfo().c_str(),
+               "{Range} Lines 500:500 [0x0000007800:0x0000005900]");
+
+  set(LocationSix, LineSix, LineSix, 0x6000, 0x6100);
+  LocationSix->setIsAddressRange();
+  EXPECT_STREQ(LocationSix->getIntervalInfo().c_str(),
+               "{Range} Lines 600:600 [0x0000006000:0x0000006100]");
+
+  // Add ranges to Function.
+  // Function: LocationOne, LocationTwo, LocationFive, LocationSix
+  Function->addObject(LocationOne);
+  Function->addObject(LocationTwo);
+  Function->addObject(LocationFive);
+  Function->addObject(LocationSix);
+  EXPECT_EQ(Function->rangeCount(), 4u);
+
+  // Add ranges to NestedScope.
+  // NestedScope: LocationThree, LocationFour
+  NestedScope->addObject(LocationThree);
+  NestedScope->addObject(LocationFour);
+  EXPECT_EQ(NestedScope->rangeCount(), 2u);
+
+  // Get all ranges.
+  LVRange Ranges;
+  CompileUnit->getRanges(Ranges);
+  Ranges.startSearch();
+  EXPECT_EQ(Ranges.getEntry(0x4000), nullptr);
+
+  EXPECT_EQ(Ranges.getEntry(0x5060), Function);
+  EXPECT_EQ(Ranges.getEntry(0x5850), nullptr);
+  EXPECT_EQ(Ranges.getEntry(0x5010, 0x5090), Function);
+  EXPECT_EQ(Ranges.getEntry(0x5210, 0x5290), Function);
+  EXPECT_EQ(Ranges.getEntry(0x5810, 0x5890), nullptr);
+  EXPECT_EQ(Ranges.getEntry(0x6010, 0x6090), Function);
+
+  EXPECT_EQ(Ranges.getEntry(0x5400), NestedScope);
+  EXPECT_EQ(Ranges.getEntry(0x5650), NestedScope);
+  EXPECT_EQ(Ranges.getEntry(0x5410, 0x5490), NestedScope);
+  EXPECT_EQ(Ranges.getEntry(0x5610, 0x5690), NestedScope);
+
+  EXPECT_EQ(Ranges.getEntry(0x8000), nullptr);
+  Ranges.endSearch();
+
+  // Add locations to symbols.
+  // Parameter:       [LineOne, LineSix]
+  // LocalVariable:   [LineTwo, LineSix], [LineFour, LineFive]
+  // NestedVariable:  [LineThree, LineFour]
+  add(Parameter, LineOne, LineSix);
+  add(LocalVariable, LineTwo, LineSix);
+  add(LocalVariable, LineFour, LineFive);
+  add(NestedVariable, LineThree, LineFour);
+  add(NestedVariable, LineOne, LineSix);
+}
+
+// Check logical elements warnigs.
+void ReaderTestWarningInternal::checkWarnings() {
+  // Map all lines with their addresses.
+  setMapping();
+
+  // Check for lines with line zero.
+  resolveElements();
+
+  // Check invalid locations and ranges using a customized validation.
+  CompileUnit->processRangeLocationCoverage(
+      (LVValidLocation)(&MyLocation::validateRanges));
+
+  // Get lines with line zero. [Parent, Line]
+  //   Function, LineTwo
+  //   NestedScope, LineFour
+  LVOffsetLinesMap LinesZero = CompileUnit->getLinesZero();
+  ASSERT_EQ(LinesZero.size(), 2u);
+
+  LVOffsetLinesMap::iterator IterZero = LinesZero.begin();
+  EXPECT_EQ(IterZero->first, Function->getOffset());
+  LVLines *Lines = IterZero->second;
+  EXPECT_NE(Lines, nullptr);
+  ASSERT_EQ(Lines->size(), 1u);
+  LVLine *Line = *(Lines->begin());
+  EXPECT_NE(Line, nullptr);
+  EXPECT_EQ(Line, LineTwo);
+
+  ++IterZero;
+  EXPECT_EQ(IterZero->first, NestedScope->getOffset());
+  Lines = IterZero->second;
+  EXPECT_NE(Lines, nullptr);
+  ASSERT_EQ(Lines->size(), 1u);
+  Line = *(Lines->begin());
+  EXPECT_NE(Line, nullptr);
+  EXPECT_EQ(Line, LineFour);
+
+  // Elements with invalid offsets.
+  //   Function (line zero)
+  //   NestedScope (line zero)
+  //   NestedVariable (invalid location)
+  LVOffsetElementMap InvalidOffsets = CompileUnit->getWarningOffsets();
+  ASSERT_EQ(InvalidOffsets.size(), 3u);
+
+  LVOffsetElementMap::iterator IterOffset = InvalidOffsets.begin();
+  EXPECT_EQ(IterOffset->second, Function);
+  ++IterOffset;
+  EXPECT_EQ(IterOffset->second, NestedScope);
+  ++IterOffset;
+  EXPECT_EQ(IterOffset->second, NestedVariable);
+
+  // Invalid ranges.
+  //   Function
+  LVOffsetLocationsMap InvalidRanges = CompileUnit->getInvalidRanges();
+  ASSERT_EQ(InvalidRanges.size(), 1u);
+
+  LVOffsetLocationsMap::iterator IterRange = InvalidRanges.begin();
+  EXPECT_EQ(IterRange->first, Function->getOffset());
+  LVLocations *Locations = IterRange->second;
+  EXPECT_NE(Locations, nullptr);
+  ASSERT_EQ(Locations->size(), 1u);
+  LVLocation *Location = *(Locations->begin());
+  EXPECT_NE(Location, nullptr);
+  EXPECT_EQ(Location, LocationFive);
+
+  // Invalid location.
+  //   NestedVariable
+  LVOffsetLocationsMap InvalidLocations = CompileUnit->getInvalidLocations();
+  ASSERT_EQ(InvalidLocations.size(), 1u);
+
+  LVOffsetLocationsMap::iterator IterLocations = InvalidLocations.begin();
+  EXPECT_EQ(IterLocations->first, NestedVariable->getOffset());
+  Locations = IterLocations->second;
+  EXPECT_NE(Locations, nullptr);
+  ASSERT_EQ(Locations->size(), 1u);
+  Location = *(Locations->begin());
+  EXPECT_NE(Location, nullptr);
+  EXPECT_EQ(Location->getLowerAddress(), LocationThree->getLowerAddress());
+  EXPECT_EQ(Location->getUpperAddress(), LocationFour->getLowerAddress());
+  EXPECT_EQ(Location->getLowerLine()->getLineNumber(),
+            LineThree->getLineNumber());
+  EXPECT_EQ(Location->getUpperLine()->getLineNumber(), 0u);
+
+  // Invalid coverages.
+  //   NestedVariable
+  LVOffsetSymbolMap InvalidCoverages = CompileUnit->getInvalidCoverages();
+  ASSERT_EQ(InvalidCoverages.size(), 1u);
+
+  LVOffsetSymbolMap::iterator IterCoverages = InvalidCoverages.begin();
+  EXPECT_EQ(IterCoverages->first, NestedVariable->getOffset());
+  EXPECT_EQ(IterCoverages->second, NestedVariable);
+  EXPECT_GE((int)NestedVariable->getCoveragePercentage(), 100);
+  EXPECT_EQ((int)NestedVariable->getCoveragePercentage(), 900);
+  EXPECT_EQ(NestedVariable->getCoverageFactor(), 0x1200u);
+
+  EXPECT_EQ((unsigned)Parameter->getCoveragePercentage(), 100u);
+  EXPECT_EQ(Parameter->getCoverageFactor(), 100u);
+
+  EXPECT_EQ((unsigned)LocalVariable->getCoveragePercentage(), 47u);
+  EXPECT_EQ(LocalVariable->getCoverageFactor(),
+            LineSix->getAddress() - LineOne->getAddress());
+}
+
+TEST(LogicalViewTest, WarningInternal) {
+  ScopedPrinter W(outs());
+  ReaderTestWarningInternal Reader(W);
+
+  // Reader options.
+  LVOptions ReaderOptions;
+  ReaderOptions.setAttributeOffset();
+  ReaderOptions.setAttributeRange();
+  ReaderOptions.setAttributeLocation();
+  ReaderOptions.setPrintAll();
+  ReaderOptions.setWarningCoverages();
+  ReaderOptions.setWarningLines();
+  ReaderOptions.setWarningLocations();
+  ReaderOptions.setWarningRanges();
+  ReaderOptions.resolveDependencies();
+  options().setOptions(&ReaderOptions);
+
+  Reader.createElements();
+  Reader.addElements();
+  Reader.initElements();
+  Reader.checkWarnings();
+}
+
+} // namespace