[llvm-debuginfo-analyzer] Add support for LLVM IR format.

Add support for the LLVM IR format and be able to generate
logical views.

Both textual representation (.ll) and bitcode (.bc) format
are supported.

Note: This patch requires:

Add DebugSSAUpdater class to track debug value liveness
#135349

Note: Address reviewers comments.

Author: CarlosAlbertoEnciso

llvm/docs/CommandGuide/llvm-debuginfo-analyzer.rst

@@ -2261,6 +2261,34 @@ layout and given the number of matches.
   -----------------------------
   Total           33         12
 
+The following prints all *symbols* and *types* that contain the exact **'INTPTR'**
+in their names or types, using a tab layout and given the number of matches.
+
+.. code-block:: none
+
+  llvm-debuginfo-analyzer --attribute=level
+                          --select=INTPTR
+                          --report=list
+                          --print=symbols,types,summary
+                          test-clang.ll
+
+  Logical View:
+  [000]           {File} 'test-clang.ll'
+
+  [001]           {CompileUnit} 'test.cpp'
+  [002]     1     {TypeAlias} 'INTPTR' -> '* const int'
+  [003]     2     {Parameter} 'ParamPtr' -> 'INTPTR'
+
+  -----------------------------
+  Element      Total    Printed
+  -----------------------------
+  Scopes           5          0
+  Symbols          4          1
+  Types            2          1
+  Lines           23          0
+  -----------------------------
+  Total           34          2
+
 COMPARISON MODE
 ^^^^^^^^^^^^^^^
 Given the previous example we found the above debug information issue

llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h

@@ -30,7 +30,7 @@ namespace logicalview {
 
 using LVReaders = std::vector<std::unique_ptr<LVReader>>;
 using ArgVector = std::vector<std::string>;
-using PdbOrObjOrIr =
+using InputHandle =
     PointerUnion<object::ObjectFile *, pdb::PDBFile *, object::IRObjectFile *,
                  MemoryBufferRef *, StringRef *>;
 
@@ -66,9 +66,8 @@ class LVReaderHandler {
   Error handleObject(LVReaders &Readers, StringRef Filename,
                      MemoryBufferRef Buffer);
 
-  Error createReader(StringRef Filename, LVReaders &Readers,
-                     PdbOrObjOrIr &Input, StringRef FileFormatName,
-                     StringRef ExePath = {});
+  Error createReader(StringRef Filename, LVReaders &Readers, InputHandle &Input,
+                     StringRef FileFormatName, StringRef ExePath = {});
 
 public:
   LVReaderHandler() = delete;

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

@@ -58,18 +58,17 @@ class LVIRReader final : public LVReader {
   // Whether to emit all linkage names, or just abstract subprograms.
   bool UseAllLinkageNames = true;
 
-  // Dependencies on external options (llc, etc).
+  // Looking at IR generated with the '-gdwarf -gsplit-dwarf=split' the only
+  // difference is setting the 'DICompileUnit::splitDebugFilename' to the
+  // name of the split filename: "xxx.dwo".
   bool includeMinimalInlineScopes() const;
   bool useAllLinkageNames() const { return UseAllLinkageNames; }
 
   bool LanguageIsFortran = false;
   void mapFortranLanguage(unsigned DWLang);
   bool moduleIsInFortran() const { return LanguageIsFortran; }
 
-  // Generate logical debug line before prologue.
-  bool GenerateLineBeforePrologue = true;
-
-  // We assume a constante increase between instructions.
+  // We assume a constant instruction-size increase between instructions.
   const unsigned OffsetIncrease = 4;
   void updateLineOffset() { CurrentOffset += OffsetIncrease; }
 
@@ -79,6 +78,7 @@ class LVIRReader final : public LVReader {
   std::unique_ptr<DbgValueRangeTable> DbgValueRanges;
 
   // Record the last assigned file index for each compile unit.
+  // This data structure is to aid mapping DIFiles onto a DWARF-like file table.
   using LVIndexFiles = std::map<LVScopeCompileUnit *, size_t>;
   LVIndexFiles IndexFiles;
 
@@ -99,13 +99,13 @@ class LVIRReader final : public LVReader {
     return FileIndex;
   }
 
-  // Collect the compile unit metadata files.
+  // Store a FileID number for each DIFile seen.
   using LVCompileUnitFiles = std::map<const DIFile *, size_t>;
   LVCompileUnitFiles CompileUnitFiles;
 
   size_t getOrCreateSourceID(const DIFile *File);
 
-  // Associate the logical elements to metadata objects.
+  // Associate the metadata objects to logical elements.
   using LVMDObjects = std::map<const MDNode *, LVElement *>;
   LVMDObjects MDObjects;
 
@@ -130,18 +130,23 @@ class LVIRReader final : public LVReader {
     return static_cast<LVType *>(getElementForSeenMD(MD));
   }
 
-  // Inlined concrete scopes with its associated inlined abstract scopes.
-  // When creating abstract scopes, there is no direct information to find
+  // Abstract scopes mapped to the associated inlined scopes.
+  // When creating inlined scopes, there is no direct information to find
   // the correct lexical scope.
-  using LVInlinedScopes = std::map<LVScope *, LVScope *>;
+  using LVScopeEntry = std::pair<LVScope *, const DILocation *>;
+  using LVInlinedScopes = std::map<LVScopeEntry, LVScope *>;
   LVInlinedScopes InlinedScopes;
 
-  void addInlinedScope(LVScope *ConcreteScope, LVScope *AbstractScope) {
-    if (InlinedScopes.find(ConcreteScope) == InlinedScopes.end())
-      InlinedScopes.emplace(ConcreteScope, AbstractScope);
+  void addInlinedScope(LVScope *AbstractScope, const DILocation *InlinedAt,
+                       LVScope *InlinedScope) {
+    auto Entry = LVScopeEntry(AbstractScope, InlinedAt);
+    if (InlinedScopes.find(Entry) == InlinedScopes.end())
+      InlinedScopes.emplace(Entry, InlinedScope);
   }
-  LVScope *getInlinedScope(LVScope *ConcreteScope) const {
-    LVInlinedScopes::const_iterator Iter = InlinedScopes.find(ConcreteScope);
+  LVScope *getInlinedScope(LVScope *AbstractScope,
+                           const DILocation *InlinedAt) const {
+    auto Entry = LVScopeEntry(AbstractScope, InlinedAt);
+    LVInlinedScopes::const_iterator Iter = InlinedScopes.find(Entry);
     return Iter != InlinedScopes.end() ? Iter->second : nullptr;
   }
 
@@ -163,9 +168,6 @@ class LVIRReader final : public LVReader {
 
   void processBasicBlocks(Function &F, const DISubprogram *SP);
 
-  void addGlobalName(StringRef Name, LVElement *Element,
-                     const DIScope *Context);
-
   void addAccess(LVElement *Element, DINode::DIFlags Flags);
 
   void addConstantValue(LVElement *Element, const DIExpression *DIExpr);
@@ -175,7 +177,7 @@ class LVIRReader final : public LVReader {
                         const DIType *Ty);
   void addConstantValue(LVElement *Element, const APInt &Value, bool Unsigned);
   void addConstantValue(LVElement *Element, uint64_t Value, const DIType *Ty);
-  void addConstantValue(LVElement *Element, bool Unsigned, uint64_t Value);
+  void addConstantValue(LVElement *Element, uint64_t Value, bool Unsigned);
 
   void addString(LVElement *Element, StringRef Str);
 
@@ -197,8 +199,6 @@ class LVIRReader final : public LVReader {
   bool applySubprogramDefinitionAttributes(LVScope *Function,
                                            const DISubprogram *SP,
                                            bool Minimal = false);
-  void applySubprogramAttributesToDefinition(LVScope *Function,
-                                             const DISubprogram *SP);
 
   void constructAggregate(LVScopeAggregate *Aggregate,
                           const DICompositeType *CTy);
@@ -210,7 +210,8 @@ class LVIRReader final : public LVReader {
                                 LVType *IndexType);
   void constructImportedEntity(LVElement *Element, const DIImportedEntity *IE);
 
-  void constructLine(LVScope *Scope, const DISubprogram *SP, Instruction &I);
+  void constructLine(LVScope *Scope, const DISubprogram *SP, Instruction &I,
+                     bool &GenerateLineBeforePrologue);
 
   LVSymbol *getOrCreateMember(LVScope *Aggregate, const DIDerivedType *DT);
   LVSymbol *getOrCreateStaticMember(LVScope *Aggregate,
@@ -220,14 +221,15 @@ class LVIRReader final : public LVReader {
   LVScope *getOrCreateScope(const DIScope *Context);
   void constructScope(LVElement *Element, const DIScope *Context);
 
-  LVScope *getOrCreateSubprogram(const DISubprogram *SP, bool Minimal = false);
+  LVScope *getOrCreateSubprogram(const DISubprogram *SP);
   LVScope *getOrCreateSubprogram(LVScope *Function, const DISubprogram *SP,
                                  bool Minimal = false);
   void constructSubprogramArguments(LVScope *Function,
                                     const DITypeRefArray Args);
 
-  LVScope *getOrCreateInlinedScope(LVScope *Parent, const DILocation *DL);
-  LVScope *getOrCreateAbstractScope(LVScope *OriginScope, const DILocation *DL);
+  LVScope *getOrCreateAbstractScope(LVScope *Parent, const DILocation *DL);
+  LVScope *getOrCreateInlinedScope(LVScope *AbstractScope,
+                                   const DILocation *DL);
 
   void constructSubrange(LVScopeArray *Array, const DISubrange *GSR,
                          LVType *IndexType);
@@ -245,8 +247,8 @@ class LVIRReader final : public LVReader {
   LVSymbol *getOrCreateVariable(const DIGlobalVariableExpression *GVE);
   LVSymbol *getOrCreateVariable(const DIVariable *Var,
                                 const DILocation *DL = nullptr);
-  LVSymbol *getOrCreateAbstractVariable(LVSymbol *OriginSymbol,
-                                        const DILocation *DL);
+  LVSymbol *getOrCreateInlinedVariable(LVSymbol *OriginSymbol,
+                                       const DILocation *DL);
 
   LVElement *constructElement(const DINode *DN);
 

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

@@ -41,7 +41,7 @@ Error LVReaderHandler::process() {
 }
 
 Error LVReaderHandler::createReader(StringRef Filename, LVReaders &Readers,
-                                    PdbOrObjOrIr &Input,
+                                    InputHandle &Input,
                                     StringRef FileFormatName,
                                     StringRef ExePath) {
   auto CreateOneReader = [&]() -> std::unique_ptr<LVReader> {
@@ -66,7 +66,7 @@ Error LVReaderHandler::createReader(StringRef Filename, LVReaders &Readers,
       return std::make_unique<LVIRReader>(Filename, FileFormatName, Ir, W);
     }
     if (isa<MemoryBufferRef *>(Input)) {
-      // If the filename extension is '.ll' create a IR reader.
+      // If the filename extension is '.ll' create an IR reader.
       const StringRef IRFileExt = ".ll";
       MemoryBufferRef *MemBuf = cast<MemoryBufferRef *>(Input);
       if (llvm::sys::path::extension(Filename) == IRFileExt)
@@ -240,7 +240,7 @@ Error LVReaderHandler::handleMach(LVReaders &Readers, StringRef Filename,
     if (Expected<std::unique_ptr<MachOObjectFile>> MachOOrErr =
             ObjForArch.getAsObjectFile()) {
       MachOObjectFile &Obj = **MachOOrErr;
-      PdbOrObjOrIr Input = &Obj;
+      InputHandle Input = &Obj;
       if (Error Err =
               createReader(Filename, Readers, Input, Obj.getFileFormatName()))
         return Err;
@@ -260,7 +260,7 @@ Error LVReaderHandler::handleMach(LVReaders &Readers, StringRef Filename,
 
 Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
                                     Binary &Binary) {
-  if (PdbOrObjOrIr Input = dyn_cast<ObjectFile>(&Binary))
+  if (InputHandle Input = dyn_cast<ObjectFile>(&Binary))
     return createReader(Filename, Readers, Input,
                         cast<ObjectFile *>(Input)->getFileFormatName());
 
@@ -270,7 +270,7 @@ Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
   if (Archive *Arch = dyn_cast<Archive>(&Binary))
     return handleArchive(Readers, Filename, *Arch);
 
-  if (PdbOrObjOrIr Input = dyn_cast<IRObjectFile>(&Binary))
+  if (InputHandle Input = dyn_cast<IRObjectFile>(&Binary))
     return createReader(Filename, Readers, Input, "Bitcode IR");
 
   return createStringError(errc::not_supported,
@@ -287,7 +287,7 @@ Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
 
   std::unique_ptr<NativeSession> PdbSession;
   PdbSession.reset(static_cast<NativeSession *>(Session.release()));
-  PdbOrObjOrIr Input = &PdbSession->getPDBFile();
+  InputHandle Input = &PdbSession->getPDBFile();
   StringRef FileFormatName;
   size_t Pos = Buffer.find_first_of("\r\n");
   if (Pos)
@@ -297,7 +297,7 @@ Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
 
 Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
                                     MemoryBufferRef Buffer) {
-  if (PdbOrObjOrIr Input = dyn_cast<MemoryBufferRef>(&Buffer))
+  if (InputHandle Input = dyn_cast<MemoryBufferRef>(&Buffer))
     return createReader(Filename, Readers, Input, IRFileFormat);
 
   return createStringError(errc::not_supported,

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

@@ -517,16 +517,14 @@ void LVDWARFReader::createLineAndFileRecords(
     for (const DWARFDebugLine::FileNameEntry &Entry :
          Lines->Prologue.FileNames) {
       std::string Directory;
-      Lines->getDirectoryForEntry(Entry, Directory);
+      if (Lines->getDirectoryForEntry(Entry, Directory))
+        Directory = transformPath(Directory);
       if (Directory.empty())
         Directory = std::string(CompileUnit->getCompilationDirectory());
-      // Take just the filename component, as it may be contain the full
-      // path that would be added to the already existing path in Directory.
-      StringRef File =
-          llvm::sys::path::filename(dwarf::toStringRef(Entry.Name));
+      std::string File = transformPath(dwarf::toStringRef(Entry.Name));
       std::string String;
       raw_string_ostream(String) << Directory << "/" << File;
-      CompileUnit->addFilename(transformPath(String));
+      CompileUnit->addFilename(String);
     }
 
   // In DWARF5 the file indexes start at 0;