Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===-- LVElement.h ---------------------------------------------*- C++ -*-===//

//

// 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

//

//===----------------------------------------------------------------------===//

//

// This file defines the LVElement class, which is used to describe a debug

// information element.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVELEMENT_H

#define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVELEMENT_H

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

#include "llvm/Support/Casting.h"

#include <map>

#include <set>

#include <vector>

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>;

using LVElementDispatch = std::map<LVElementKind, LVElementGetFunction>;

using LVElementRequest = std::vector<LVElementGetFunction>;

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;

  static LVElementDispatch Dispatch;

  /// 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(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();

  bool referenceMatch(const LVElement *Element) const;

  // Returns true if current element is logically equal to the given 'Element'.

  bool equals(const LVElement *Element) const;

  // Report the current element as missing or added during comparison.

  virtual void report(LVComparePass Pass) {}

  static LVElementDispatch &getDispatch() { return Dispatch; }

};

} // end namespace logicalview

} // end namespace llvm

#endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVELEMENT_H