Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===-- LVObject.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 LVObject class, which is used to describe a debug

// information object.

//

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

#ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOBJECT_H

#define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOBJECT_H

#include "llvm/BinaryFormat/Dwarf.h"

#include "llvm/DebugInfo/CodeView/CodeView.h"

#include "llvm/DebugInfo/CodeView/TypeIndex.h"

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

#include <limits>

#include <list>

#include <map>

#include <string>

namespace llvm {

namespace dwarf {

// Support for CodeView ModifierOptions::Unaligned.

constexpr Tag DW_TAG_unaligned = Tag(dwarf::DW_TAG_hi_user + 1);

} // namespace dwarf

} // namespace llvm

namespace llvm {

namespace logicalview {

using LVSectionIndex = uint64_t;

using LVAddress = uint64_t;

using LVHalf = uint16_t;

using LVLevel = uint32_t;

using LVOffset = uint64_t;

using LVSigned = int64_t;

using LVUnsigned = uint64_t;

using LVSmall = uint8_t;

class LVElement;

class LVLine;

class LVLocation;

class LVLocationSymbol;

class LVObject;

class LVOperation;

class LVScope;

class LVSymbol;

class LVType;

class LVOptions;

class LVPatterns;

StringRef typeNone();

StringRef typeVoid();

StringRef typeInt();

StringRef typeUnknown();

StringRef emptyString();

using LVElementSetFunction = void (LVElement::*)();

using LVElementGetFunction = bool (LVElement::*)() const;

using LVLineSetFunction = void (LVLine::*)();

using LVLineGetFunction = bool (LVLine::*)() const;

using LVObjectSetFunction = void (LVObject::*)();

using LVObjectGetFunction = bool (LVObject::*)() const;

using LVScopeSetFunction = void (LVScope::*)();

using LVScopeGetFunction = bool (LVScope::*)() const;

using LVSymbolSetFunction = void (LVSymbol::*)();

using LVSymbolGetFunction = bool (LVSymbol::*)() const;

using LVTypeSetFunction = void (LVType::*)();

using LVTypeGetFunction = bool (LVType::*)() const;

// The LVScope class represents a logical scope and uses vectors to store its

// children, which are pointers to other allocated logical elements (types,

// symbols, lines, scopes, ranges). On destruction, we have to traverse each

// vector and destroy its elements. The other case is LVSymbol.

// These definitions are intended to be used by the LVScope and LVSymbol

// to support automatic vector cleanup.

using LVAutoLines = LVAutoSmallVector<LVLine *>;

using LVAutoLocations = LVAutoSmallVector<LVLocation *>;

using LVAutoOperations = LVAutoSmallVector<LVOperation *, 8>;

using LVAutoScopes = LVAutoSmallVector<LVScope *>;

using LVAutoSymbols = LVAutoSmallVector<LVSymbol *>;

using LVAutoTypes = LVAutoSmallVector<LVType *>;

// These definitions are intended to be used when the vector will be used

// just a container, with no automatic destruction.

using LVElements = SmallVector<LVElement *, 8>;

using LVLines = SmallVector<LVLine *, 8>;

using LVLocations = SmallVector<LVLocation *, 8>;

using LVOperations = SmallVector<LVOperation *, 8>;

using LVScopes = SmallVector<LVScope *, 8>;

using LVSymbols = SmallVector<LVSymbol *, 8>;

using LVTypes = SmallVector<LVType *, 8>;

using LVOffsets = SmallVector<LVOffset, 8>;

const LVAddress MaxAddress = std::numeric_limits<uint64_t>::max();

enum class LVBinaryType { NONE, ELF, COFF };

enum class LVComparePass { Missing, Added };

// Validate functions.

using LVValidLocation = bool (LVLocation::*)();

// Keep counters of objects.

struct LVCounter {

  unsigned Lines = 0;

  unsigned Scopes = 0;

  unsigned Symbols = 0;

  unsigned Types = 0;

  void reset() {

    Lines = 0;

    Scopes = 0;

    Symbols = 0;

    Types = 0;

  }

};

class LVObject {

  enum class Property {

    IsLocation,          // Location.

    IsGlobalReference,   // This object is being referenced from another CU.

    IsGeneratedName,     // The Object name was generated.

    IsResolved,          // Object has been resolved.

    IsResolvedName,      // Object name has been resolved.

    IsDiscarded,         // Object has been stripped by the linker.

    IsOptimized,         // Object has been optimized by the compiler.

    IsAdded,             // Object has been 'added'.

    IsMatched,           // Object has been matched to a given pattern.

    IsMissing,           // Object is 'missing'.

    IsMissingLink,       // Object is indirectly 'missing'.

    IsInCompare,         // In 'compare' mode.

    IsFileFromReference, // File ID from specification.

    IsLineFromReference, // Line No from specification.

    HasMoved,            // The object was moved from 'target' to 'reference'.

    HasPattern,          // The object has a pattern.

    IsFinalized,         // CodeView object is finalized.

    IsReferenced,        // CodeView object being referenced.

    HasCodeViewLocation, // CodeView object with debug location.

    LastEntry

  };

  // Typed bitvector with properties for this object.

  LVProperties<Property> Properties;

  LVOffset Offset = 0;

  uint32_t LineNumber = 0;

  LVLevel ScopeLevel = 0;

  union {

    dwarf::Tag Tag;

    dwarf::Attribute Attr;

    LVSmall Opcode;

  } TagAttrOpcode = {dwarf::DW_TAG_null};

  // The parent of this object (nullptr if the root scope). For locations,

  // the parent is a symbol object; otherwise it is a scope object.

  union {

    LVElement *Element;

    LVScope *Scope;

    LVSymbol *Symbol;

  } 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() {

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

  PROPERTY(Property, IsDiscarded);

  PROPERTY(Property, IsOptimized);

  PROPERTY(Property, IsAdded);

  PROPERTY(Property, IsMatched);

  PROPERTY(Property, IsMissing);

  PROPERTY(Property, IsMissingLink);

  PROPERTY(Property, IsInCompare);

  PROPERTY(Property, IsFileFromReference);

  PROPERTY(Property, IsLineFromReference);

  PROPERTY(Property, HasMoved);

  PROPERTY(Property, HasPattern);

  PROPERTY(Property, IsFinalized);

  PROPERTY(Property, IsReferenced);

  PROPERTY(Property, HasCodeViewLocation);

  // True if the scope has been named or typed or with line number.

  virtual bool isNamed() const { return false; }

  virtual bool isTyped() const { return false; }

  virtual bool isFiled() const { return false; }

  bool isLined() const { return LineNumber != 0; }

  // DWARF tag, attribute or expression opcode.

  dwarf::Tag getTag() const { return TagAttrOpcode.Tag; }

  void setTag(dwarf::Tag Tag) { TagAttrOpcode.Tag = Tag; }

  dwarf::Attribute getAttr() const { return TagAttrOpcode.Attr; }

  void setAttr(dwarf::Attribute Attr) { TagAttrOpcode.Attr = Attr; }

  LVSmall getOpcode() const { return TagAttrOpcode.Opcode; }

  void setOpcode(LVSmall Opcode) { TagAttrOpcode.Opcode = Opcode; }

  // DIE offset.

  LVOffset getOffset() const { return Offset; }

  void setOffset(LVOffset DieOffset) { Offset = DieOffset; }

  // Level where this object is located.

  LVLevel getLevel() const { return ScopeLevel; }

  void setLevel(LVLevel Level) { ScopeLevel = Level; }

  virtual StringRef getName() const { return StringRef(); }

  virtual void setName(StringRef ObjectName) {}

  LVElement *getParent() const {

    assert((!Parent.Element ||

            (Parent.Element && static_cast<LVElement *>(Parent.Element))) &&

           "Invalid element");

    return Parent.Element;

  }

  LVScope *getParentScope() const {

    assert((!Parent.Scope ||

            (Parent.Scope && static_cast<LVScope *>(Parent.Scope))) &&

           "Invalid scope");

    return Parent.Scope;

  }

  LVSymbol *getParentSymbol() const {

    assert((!Parent.Symbol ||

            (Parent.Symbol && static_cast<LVSymbol *>(Parent.Symbol))) &&

           "Invalid symbol");

    return Parent.Symbol;

  }

  void setParent(LVScope *Scope);

  void setParent(LVSymbol *Symbol);

  void resetParent() { Parent = {nullptr}; }

  virtual LVAddress getLowerAddress() const { return 0; }

  virtual void setLowerAddress(LVAddress Address) {}

  virtual LVAddress getUpperAddress() const { return 0; }

  virtual void setUpperAddress(LVAddress Address) {}

  uint32_t getLineNumber() const { return LineNumber; }

  void setLineNumber(uint32_t Number) { LineNumber = Number; }

  virtual const char *kind() const { return nullptr; }

  std::string indentAsString() const;

  std::string indentAsString(LVLevel Level) const;

  // String used as padding for printing objects with no line number.

  virtual std::string noLineAsString(bool ShowZero) const;

  // Line number for display; in the case of inlined functions, we use the

  // DW_AT_call_line attribute; otherwise use DW_AT_decl_line attribute.

  virtual std::string lineNumberAsString(bool ShowZero = false) const {

    return lineAsString(getLineNumber(), 0, ShowZero);

  }

  std::string lineNumberAsStringStripped(bool ShowZero = false) const;

  // This function prints the logical view to an output stream.

  // Split: Prints the compilation unit view to a file.

  // Match: Prints the object only if it satisfies the patterns collected

  // from the command line. See the '--select' option.

  // Print: Print the object only if satisfies the conditions specified by

  // the different '--print' options.

  // Full: Prints full information for objects representing debug locations,

  // aggregated scopes, compile unit, functions and namespaces.

  virtual Error doPrint(bool Split, bool Match, bool Print, raw_ostream &OS,

                        bool Full = true) const;

  void printAttributes(raw_ostream &OS, bool Full = true) const;

  void printAttributes(raw_ostream &OS, bool Full, StringRef Name,

                       LVObject *Parent, StringRef Value,

                       bool UseQuotes = false, bool PrintRef = false) const;

  // Mark branch as missing (current element and parents).

  void markBranchAsMissing();

  // Prints the common information for an object (name, type, etc).

  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