Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- DWARFDebugLoc.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

//

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

#ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

#define LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

#include "llvm/ADT/SmallVector.h"

#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"

#include "llvm/Support/Errc.h"

#include <cstdint>

namespace llvm {

class DWARFUnit;

class MCRegisterInfo;

class raw_ostream;

class DWARFObject;

struct DIDumpOptions;

struct DWARFLocationExpression;

namespace object {

struct SectionedAddress;

}

/// A single location within a location list. Entries are stored in the DWARF5

/// form even if they originally come from a DWARF<=4 location list.

struct DWARFLocationEntry {

  /// The entry kind (DW_LLE_***).

  uint8_t Kind;

  /// The first value of the location entry (if applicable).

  uint64_t Value0;

  /// The second value of the location entry (if applicable).

  uint64_t Value1;

  /// The index of the section this entry is relative to (if applicable).

  uint64_t SectionIndex;

  /// The location expression itself (if applicable).

  SmallVector<uint8_t, 4> Loc;

};

/// An abstract base class for various kinds of location tables (.debug_loc,

/// .debug_loclists, and their dwo variants).

class DWARFLocationTable {

public:

  DWARFLocationTable(DWARFDataExtractor Data) : Data(std::move(Data)) {}

  virtual ~DWARFLocationTable() = default;

  /// Call the user-provided callback for each entry (including the end-of-list

  /// entry) in the location list starting at \p Offset. The callback can return

  /// false to terminate the iteration early. Returns an error if it was unable

  /// to parse the entire location list correctly. Upon successful termination

  /// \p Offset will be updated point past the end of the list.

  virtual Error visitLocationList(

      uint64_t *Offset,

      function_ref<bool(const DWARFLocationEntry &)> Callback) const = 0;

  /// Dump the location list at the given \p Offset. The function returns true

  /// iff it has successfully reched the end of the list. This means that one

  /// can attempt to parse another list after the current one (\p Offset will be

  /// updated to point past the end of the current list).

  bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,

                        std::optional<object::SectionedAddress> BaseAddr,

                        const DWARFObject &Obj, DWARFUnit *U,

                        DIDumpOptions DumpOpts, unsigned Indent) const;

  Error visitAbsoluteLocationList(

      uint64_t Offset, std::optional<object::SectionedAddress> BaseAddr,

      std::function<std::optional<object::SectionedAddress>(uint32_t)>

          LookupAddr,

      function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const;

  const DWARFDataExtractor &getData() { return Data; }

protected:

  DWARFDataExtractor Data;

  virtual void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,

                            unsigned Indent, DIDumpOptions DumpOpts,

                            const DWARFObject &Obj) const = 0;

};

class DWARFDebugLoc final : public DWARFLocationTable {

public:

  /// A list of locations that contain one variable.

  struct LocationList {

    /// The beginning offset where this location list is stored in the debug_loc

    /// section.

    uint64_t Offset;

    /// All the locations in which the variable is stored.

    SmallVector<DWARFLocationEntry, 2> Entries;

  };

private:

  using LocationLists = SmallVector<LocationList, 4>;

  /// A list of all the variables in the debug_loc section, each one describing

  /// the locations in which the variable is stored.

  LocationLists Locations;

public:

  DWARFDebugLoc(DWARFDataExtractor Data)

      : DWARFLocationTable(std::move(Data)) {}

  /// Print the location lists found within the debug_loc section.

  void dump(raw_ostream &OS, const DWARFObject &Obj, DIDumpOptions DumpOpts,

            std::optional<uint64_t> Offset) const;

  Error visitLocationList(

      uint64_t *Offset,

      function_ref<bool(const DWARFLocationEntry &)> Callback) const override;

protected:

  void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,

                    unsigned Indent, DIDumpOptions DumpOpts,

                    const DWARFObject &Obj) const override;

};

class DWARFDebugLoclists final : public DWARFLocationTable {

public:

  DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)

      : DWARFLocationTable(std::move(Data)), Version(Version) {}

  Error visitLocationList(

      uint64_t *Offset,

      function_ref<bool(const DWARFLocationEntry &)> Callback) const override;

  /// Dump all location lists within the given range.

  void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS,

                 const DWARFObject &Obj, DIDumpOptions DumpOpts);

protected:

  void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,

                    unsigned Indent, DIDumpOptions DumpOpts,

                    const DWARFObject &Obj) const override;

private:

  uint16_t Version;

};

class ResolverError : public ErrorInfo<ResolverError> {

public:

  static char ID;

  ResolverError(uint32_t Index, dwarf::LoclistEntries Kind) : Index(Index), Kind(Kind) {}

  void log(raw_ostream &OS) const override;

  std::error_code convertToErrorCode() const override {

    return llvm::errc::invalid_argument;

  }

private:

  uint32_t Index;

  dwarf::LoclistEntries Kind;

};

} // end namespace llvm

#endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H