EIC code displayed by LXR master/​include/​llvm/​DebugInfo/​LogicalView/​Core/​LVLine.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:43:42

 //===-- LVLine.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 LVLine class, which is used to describe a debug
 // information line.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLINE_H
 #define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLINE_H
 
 #include "llvm/DebugInfo/LogicalView/Core/LVElement.h"
 
 namespace llvm {
 namespace logicalview {
 
 enum class LVLineKind {
   IsBasicBlock,
   IsDiscriminator,
   IsEndSequence,
   IsEpilogueBegin,
   IsLineDebug,
   IsLineAssembler,
   IsNewStatement, // Shared with CodeView 'IsStatement' flag.
   IsPrologueEnd,
   IsAlwaysStepInto, // CodeView
   IsNeverStepInto,  // CodeView
   LastEntry
 };
 using LVLineKindSet = std::set<LVLineKind>;
 using LVLineDispatch = std::map<LVLineKind, LVLineGetFunction>;
 using LVLineRequest = std::vector<LVLineGetFunction>;
 
 // Class to represent a logical line.
 class LVLine : public LVElement {
   // Typed bitvector with kinds for this line.
   LVProperties<LVLineKind> Kinds;
   static LVLineDispatch Dispatch;
 
   // Find the current line in the given 'Targets'.
   LVLine *findIn(const LVLines *Targets) const;
 
 public:
   LVLine() : LVElement(LVSubclassID::LV_LINE) {
     setIsLine();
     setIncludeInPrint();
   }
   LVLine(const LVLine &) = delete;
   LVLine &operator=(const LVLine &) = delete;
   virtual ~LVLine() = default;
 
   static bool classof(const LVElement *Element) {
     return Element->getSubclassID() == LVSubclassID::LV_LINE;
   }
 
   KIND(LVLineKind, IsBasicBlock);
   KIND(LVLineKind, IsDiscriminator);
   KIND(LVLineKind, IsEndSequence);
   KIND(LVLineKind, IsEpilogueBegin);
   KIND(LVLineKind, IsLineDebug);
   KIND(LVLineKind, IsLineAssembler);
   KIND(LVLineKind, IsNewStatement);
   KIND(LVLineKind, IsPrologueEnd);
   KIND(LVLineKind, IsAlwaysStepInto);
   KIND(LVLineKind, IsNeverStepInto);
 
   const char *kind() const override;
 
   // Use the offset to store the line address.
   uint64_t getAddress() const { return getOffset(); }
   void setAddress(uint64_t address) { setOffset(address); }
 
   // String used for printing objects with no line number.
   std::string noLineAsString(bool ShowZero = false) const override;
 
   // 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.
   std::string lineNumberAsString(bool ShowZero = false) const override {
     return lineAsString(getLineNumber(), getDiscriminator(), ShowZero);
   }
 
   static LVLineDispatch &getDispatch() { return Dispatch; }
 
   // Iterate through the 'References' set and check that all its elements
   // are present in the 'Targets' set. For a missing element, mark its
   // parents as missing.
   static void markMissingParents(const LVLines *References,
                                  const LVLines *Targets);
 
   // Returns true if current line is logically equal to the given 'Line'.
   virtual bool equals(const LVLine *Line) const;
 
   // Returns true if the given 'References' are logically equal to the
   // given 'Targets'.
   static bool equals(const LVLines *References, const LVLines *Targets);
 
   // Report the current line as missing or added during comparison.
   void report(LVComparePass Pass) override;
 
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
 // Class to represent a DWARF line record object.
 class LVLineDebug final : public LVLine {
   // Discriminator value (DW_LNE_set_discriminator). The DWARF standard
   // defines the discriminator as an unsigned LEB128 integer.
   uint32_t Discriminator = 0;
 
 public:
   LVLineDebug() : LVLine() { setIsLineDebug(); }
   LVLineDebug(const LVLineDebug &) = delete;
   LVLineDebug &operator=(const LVLineDebug &) = delete;
   ~LVLineDebug() = default;
 
   // Additional line information. It includes attributes that describes
   // states in the machine instructions (basic block, end prologue, etc).
   std::string statesInfo(bool Formatted) const;
 
   // Access DW_LNE_set_discriminator attribute.
   uint32_t getDiscriminator() const override { return Discriminator; }
   void setDiscriminator(uint32_t Value) override {
     Discriminator = Value;
     setIsDiscriminator();
   }
 
   // Returns true if current line is logically equal to the given 'Line'.
   bool equals(const LVLine *Line) const override;
 
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent an assembler line extracted from the text section.
 class LVLineAssembler final : public LVLine {
 public:
   LVLineAssembler() : LVLine() { setIsLineAssembler(); }
   LVLineAssembler(const LVLineAssembler &) = delete;
   LVLineAssembler &operator=(const LVLineAssembler &) = delete;
   ~LVLineAssembler() = default;
 
   // Print blanks as the line number.
   std::string noLineAsString(bool ShowZero) const override {
     return std::string(8, ' ');
   };
 
   // Returns true if current line is logically equal to the given 'Line'.
   bool equals(const LVLine *Line) const override;
 
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLINE_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team