[llvm-debuginfo-analyzer] (03/09) - Logical elements

llvm-debuginfo-analyzer is a command line tool that processes debug
info contained in a binary file and produces a debug information
format agnostic “Logical View”, which is a high-level semantic
representation of the debug info, independent of the low-level
format.

The code has been divided into the following patches:

1) Interval tree
2) Driver and documentation
3) Logical elements
4) Locations and ranges
5) Select elements
6) Warning and internal options
7) Compare elements
8) ELF Reader
9) CodeView Reader

Full details:
https://discourse.llvm.org/t/llvm-dev-rfc-llvm-dva-debug-information-visual-analyzer/62570

This patch:

Logical elements
- All basic functionality for the logical elements:
  LVScope, LVLine, LVSymbol, LVType.
- The logical reader:
  LVReader.h

Reviewed By: psamolysov, probinson

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

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

@@ -16,37 +16,320 @@
 
 #include "llvm/DebugInfo/LogicalView/Core/LVObject.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVStringPool.h"
+#include "llvm/Support/Casting.h"
 #include <set>
 
 namespace llvm {
 namespace logicalview {
 
+// RTTI Subclasses ID.
+enum class LVSubclassID : unsigned char {
+  LV_ELEMENT,
+  LV_LINE_FIRST,
+  LV_LINE,
+  LV_LINE_DEBUG,
+  LV_LINE_ASSEMBLER,
+  LV_LINE_LAST,
+  lV_SCOPE_FIRST,
+  LV_SCOPE,
+  LV_SCOPE_AGGREGATE,
+  LV_SCOPE_ALIAS,
+  LV_SCOPE_ARRAY,
+  LV_SCOPE_COMPILE_UNIT,
+  LV_SCOPE_ENUMERATION,
+  LV_SCOPE_FORMAL_PACK,
+  LV_SCOPE_FUNCTION,
+  LV_SCOPE_FUNCTION_INLINED,
+  LV_SCOPE_FUNCTION_TYPE,
+  LV_SCOPE_NAMESPACE,
+  LV_SCOPE_ROOT,
+  LV_SCOPE_TEMPLATE_PACK,
+  LV_SCOPE_LAST,
+  LV_SYMBOL_FIRST,
+  LV_SYMBOL,
+  LV_SYMBOL_LAST,
+  LV_TYPE_FIRST,
+  LV_TYPE,
+  LV_TYPE_DEFINITION,
+  LV_TYPE_ENUMERATOR,
+  LV_TYPE_IMPORT,
+  LV_TYPE_PARAM,
+  LV_TYPE_SUBRANGE,
+  LV_TYPE_LAST
+};
+
 enum class LVElementKind { Discarded, Global, Optimized, LastEntry };
 using LVElementKindSet = std::set<LVElementKind>;
 
 class LVElement : public LVObject {
+  enum class Property {
+    IsLine,   // A logical line.
+    IsScope,  // A logical scope.
+    IsSymbol, // A logical symbol.
+    IsType,   // A logical type.
+    IsEnumClass,
+    IsExternal,
+    HasType,
+    HasAugmentedName,
+    IsTypedefReduced,
+    IsArrayResolved,
+    IsMemberPointerResolved,
+    IsTemplateResolved,
+    IsInlined,
+    IsInlinedAbstract,
+    InvalidFilename,
+    HasReference,
+    HasReferenceAbstract,
+    HasReferenceExtension,
+    HasReferenceSpecification,
+    QualifiedResolved,
+    IncludeInPrint,
+    IsStatic,
+    TransformName,
+    IsScoped,        // CodeView local type.
+    IsNested,        // CodeView nested type.
+    IsScopedAlready, // CodeView nested type inserted in correct scope.
+    IsArtificial,
+    IsReferencedType,
+    IsSystem,
+    OffsetFromTypeIndex,
+    IsAnonymous,
+    LastEntry
+  };
+  // Typed bitvector with properties for this element.
+  LVProperties<Property> Properties;
+
+  /// RTTI.
+  const LVSubclassID SubclassID;
+
   // Indexes in the String Pool.
   size_t NameIndex = 0;
+  size_t QualifiedNameIndex = 0;
   size_t FilenameIndex = 0;
 
+  uint16_t AccessibilityCode : 2; // DW_AT_accessibility.
+  uint16_t InlineCode : 2;        // DW_AT_inline.
+  uint16_t VirtualityCode : 2;    // DW_AT_virtuality.
+
+  // The given Specification points to an element that is connected via the
+  // DW_AT_specification, DW_AT_abstract_origin or DW_AT_extension attribute.
+  void setFileLine(LVElement *Specification);
+
+  // Get the qualified name that include its parents name.
+  void resolveQualifiedName();
+
+protected:
+  // Type of this element.
+  LVElement *ElementType = nullptr;
+
+  // Print the FileName Index.
+  void printFileIndex(raw_ostream &OS, bool Full = true) const override;
+
 public:
-  LVElement() = default;
+  LVElement(LVSubclassID ID)
+      : LVObject(), SubclassID(ID), AccessibilityCode(0), InlineCode(0),
+        VirtualityCode(0) {}
+  LVElement(const LVElement &) = delete;
+  LVElement &operator=(const LVElement &) = delete;
   virtual ~LVElement() = default;
 
+  LVSubclassID getSubclassID() const { return SubclassID; }
+
+  PROPERTY(Property, IsLine);
+  PROPERTY(Property, IsScope);
+  PROPERTY(Property, IsSymbol);
+  PROPERTY(Property, IsType);
+  PROPERTY(Property, IsEnumClass);
+  PROPERTY(Property, IsExternal);
+  PROPERTY(Property, HasType);
+  PROPERTY(Property, HasAugmentedName);
+  PROPERTY(Property, IsTypedefReduced);
+  PROPERTY(Property, IsArrayResolved);
+  PROPERTY(Property, IsMemberPointerResolved);
+  PROPERTY(Property, IsTemplateResolved);
+  PROPERTY(Property, IsInlined);
+  PROPERTY(Property, IsInlinedAbstract);
+  PROPERTY(Property, InvalidFilename);
+  PROPERTY(Property, HasReference);
+  PROPERTY(Property, HasReferenceAbstract);
+  PROPERTY(Property, HasReferenceExtension);
+  PROPERTY(Property, HasReferenceSpecification);
+  PROPERTY(Property, QualifiedResolved);
+  PROPERTY(Property, IncludeInPrint);
+  PROPERTY(Property, IsStatic);
+  PROPERTY(Property, TransformName);
+  PROPERTY(Property, IsScoped);
+  PROPERTY(Property, IsNested);
+  PROPERTY(Property, IsScopedAlready);
+  PROPERTY(Property, IsArtificial);
+  PROPERTY(Property, IsReferencedType);
+  PROPERTY(Property, IsSystem);
+  PROPERTY(Property, OffsetFromTypeIndex);
+  PROPERTY(Property, IsAnonymous);
+
   bool isNamed() const override { return NameIndex != 0; }
+  bool isTyped() const override { return ElementType != nullptr; }
+  bool isFiled() const override { return FilenameIndex != 0; }
+
+  // The Element class type can point to a Type or Scope.
+  bool getIsKindType() const { return ElementType && ElementType->getIsType(); }
+  bool getIsKindScope() const {
+    return ElementType && ElementType->getIsScope();
+  }
 
   StringRef getName() const override {
     return getStringPool().getString(NameIndex);
   }
+  void setName(StringRef ElementName) override;
 
   // Get pathname associated with the Element.
   StringRef getPathname() const {
     return getStringPool().getString(getFilenameIndex());
   }
 
+  // Set filename associated with the Element.
+  void setFilename(StringRef Filename);
+
+  // Set the Element qualified name.
+  void setQualifiedName(StringRef Name) {
+    QualifiedNameIndex = getStringPool().getIndex(Name);
+  }
+  StringRef getQualifiedName() const {
+    return getStringPool().getString(QualifiedNameIndex);
+  }
+
+  size_t getNameIndex() const { return NameIndex; }
+  size_t getQualifiedNameIndex() const { return QualifiedNameIndex; }
+
   // Element type name.
   StringRef getTypeName() const;
+
+  virtual StringRef getProducer() const { return StringRef(); }
+  virtual void setProducer(StringRef ProducerName) {}
+
+  virtual bool isCompileUnit() const { return false; }
+  virtual bool isRoot() const { return false; }
+
+  virtual void setReference(LVElement *Element) {}
+  virtual void setReference(LVScope *Scope) {}
+  virtual void setReference(LVSymbol *Symbol) {}
+  virtual void setReference(LVType *Type) {}
+
+  virtual void setLinkageName(StringRef LinkageName) {}
+  virtual StringRef getLinkageName() const { return StringRef(); }
+  virtual size_t getLinkageNameIndex() const { return 0; }
+
+  virtual uint32_t getCallLineNumber() const { return 0; }
+  virtual void setCallLineNumber(uint32_t Number) {}
+  virtual size_t getCallFilenameIndex() const { return 0; }
+  virtual void setCallFilenameIndex(size_t Index) {}
   size_t getFilenameIndex() const { return FilenameIndex; }
+  void setFilenameIndex(size_t Index) { FilenameIndex = Index; }
+
+  // Set the File location for the Element.
+  void setFile(LVElement *Reference = nullptr);
+
+  virtual bool isBase() const { return false; }
+  virtual bool isTemplateParam() const { return false; }
+
+  virtual uint32_t getBitSize() const { return 0; }
+  virtual void setBitSize(uint32_t Size) {}
+
+  virtual int64_t getCount() const { return 0; }
+  virtual void setCount(int64_t Value) {}
+  virtual int64_t getLowerBound() const { return 0; }
+  virtual void setLowerBound(int64_t Value) {}
+  virtual int64_t getUpperBound() const { return 0; }
+  virtual void setUpperBound(int64_t Value) {}
+  virtual std::pair<unsigned, unsigned> getBounds() const { return {}; }
+  virtual void setBounds(unsigned Lower, unsigned Upper) {}
+
+  // Access DW_AT_GNU_discriminator attribute.
+  virtual uint32_t getDiscriminator() const { return 0; }
+  virtual void setDiscriminator(uint32_t Value) {}
+
+  // Process the values for a DW_TAG_enumerator.
+  virtual std::string getValue() const { return {}; }
+  virtual void setValue(StringRef Value) {}
+  virtual size_t getValueIndex() const { return 0; }
+
+  // DWARF Accessibility Codes.
+  uint32_t getAccessibilityCode() const { return AccessibilityCode; }
+  void setAccessibilityCode(uint32_t Access) { AccessibilityCode = Access; }
+  StringRef
+  accessibilityString(uint32_t Access = dwarf::DW_ACCESS_private) const;
+
+  // DWARF Inline Codes.
+  uint32_t getInlineCode() const { return InlineCode; }
+  void setInlineCode(uint32_t Code) { InlineCode = Code; }
+  StringRef inlineCodeString(uint32_t Code) const;
+
+  // DWARF Virtuality Codes.
+  uint32_t getVirtualityCode() const { return VirtualityCode; }
+  void setVirtualityCode(uint32_t Virtuality) { VirtualityCode = Virtuality; }
+  StringRef
+  virtualityString(uint32_t Virtuality = dwarf::DW_VIRTUALITY_none) const;
+
+  // DWARF Extern Codes.
+  StringRef externalString() const;
+
+  LVElement *getType() const { return ElementType; }
+  LVType *getTypeAsType() const;
+  LVScope *getTypeAsScope() const;
+
+  void setType(LVElement *Element = nullptr) {
+    ElementType = Element;
+    if (Element) {
+      setHasType();
+      Element->setIsReferencedType();
+    }
+  }
+
+  // Set the type for the element, handling template parameters.
+  void setGenericType(LVElement *Element);
+
+  StringRef getTypeQualifiedName() const {
+    return ElementType ? ElementType->getQualifiedName() : "";
+  }
+
+  StringRef typeAsString() const;
+  std::string typeOffsetAsString() const;
+  std::string discriminatorAsString() const;
+
+  LVScope *traverseParents(LVScopeGetFunction GetFunction) const;
+
+  LVScope *getFunctionParent() const;
+  virtual LVScope *getCompileUnitParent() const;
+
+  // Print any referenced element.
+  void printReference(raw_ostream &OS, bool Full, LVElement *Parent) const;
+
+  // Print the linkage name (Symbols and functions).
+  void printLinkageName(raw_ostream &OS, bool Full, LVElement *Parent,
+                        LVScope *Scope) const;
+  void printLinkageName(raw_ostream &OS, bool Full, LVElement *Parent) const;
+
+  // Generate the full name for the Element.
+  void resolveFullname(LVElement *BaseType, StringRef Name = emptyString());
+
+  // Generate a name for unnamed elements.
+  void generateName(std::string &Prefix) const;
+  void generateName();
+
+  virtual bool removeElement(LVElement *Element) { return false; }
+  virtual void updateLevel(LVScope *Parent, bool Moved = false);
+
+  // During the parsing of the debug information, the logical elements are
+  // created with information extracted from its description entries (DIE).
+  // But they are not complete for the logical view concept. A second pass
+  // is executed in order to collect their additional information.
+  // 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();
 };
 
 } // end namespace logicalview