Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- DWARFLinkerCompileUnit.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_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H

#define LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H

#include "llvm/ADT/AddressRanges.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/CodeGen/DIE.h"

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

#include <optional>

namespace llvm {

class DeclContext;

/// Mapped value in the address map is the offset to apply to the

/// linked address.

using RangesTy = AddressRangesMap<int64_t>;

// FIXME: Delete this structure.

struct PatchLocation {

  DIE::value_iterator I;

  PatchLocation() = default;

  PatchLocation(DIE::value_iterator I) : I(I) {}

  void set(uint64_t New) const {

    assert(I);

    const auto &Old = *I;

    assert(Old.getType() == DIEValue::isInteger);

    *I = DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New));

  }

  uint64_t get() const {

    assert(I);

    return I->getDIEInteger().getValue();

  }

};

/// Stores all information relating to a compile unit, be it in its original

/// instance in the object file to its brand new cloned and generated DIE tree.

class CompileUnit {

public:

  /// Information gathered about a DIE in the object file.

  struct DIEInfo {

    /// Address offset to apply to the described entity.

    int64_t AddrAdjust;

    /// ODR Declaration context.

    DeclContext *Ctxt;

    /// Cloned version of that DIE.

    DIE *Clone;

    /// The index of this DIE's parent.

    uint32_t ParentIdx;

    /// Is the DIE part of the linked output?

    bool Keep : 1;

    /// Was this DIE's entity found in the map?

    bool InDebugMap : 1;

    /// Is this a pure forward declaration we can strip?

    bool Prune : 1;

    /// Does DIE transitively refer an incomplete decl?

    bool Incomplete : 1;

    /// Is DIE in the clang module scope?

    bool InModuleScope : 1;

    /// Is ODR marking done?

    bool ODRMarkingDone : 1;

    /// Is this a reference to a DIE that hasn't been cloned yet?

    bool UnclonedReference : 1;

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

    LLVM_DUMP_METHOD void dump();

#endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

  };

  CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,

              StringRef ClangModuleName)

      : OrigUnit(OrigUnit), ID(ID), ClangModuleName(ClangModuleName) {

    Info.resize(OrigUnit.getNumDIEs());

    auto CUDie = OrigUnit.getUnitDIE(false);

    if (!CUDie) {

      HasODR = false;

      return;

    }

    if (auto Lang = dwarf::toUnsigned(CUDie.find(dwarf::DW_AT_language)))

      HasODR = CanUseODR && (*Lang == dwarf::DW_LANG_C_plus_plus ||

                             *Lang == dwarf::DW_LANG_C_plus_plus_03 ||

                             *Lang == dwarf::DW_LANG_C_plus_plus_11 ||

                             *Lang == dwarf::DW_LANG_C_plus_plus_14 ||

                             *Lang == dwarf::DW_LANG_ObjC_plus_plus);

    else

      HasODR = false;

  }

  DWARFUnit &getOrigUnit() const { return OrigUnit; }

  unsigned getUniqueID() const { return ID; }

  void createOutputDIE() { NewUnit.emplace(OrigUnit.getUnitDIE().getTag()); }

  DIE *getOutputUnitDIE() const {

    if (NewUnit)

      return &const_cast<BasicDIEUnit &>(*NewUnit).getUnitDie();

    return nullptr;

  }

  bool hasODR() const { return HasODR; }

  bool isClangModule() const { return !ClangModuleName.empty(); }

  uint16_t getLanguage();

  /// Return the DW_AT_LLVM_sysroot of the compile unit or an empty StringRef.

  StringRef getSysRoot();

  const std::string &getClangModuleName() const { return ClangModuleName; }

  DIEInfo &getInfo(unsigned Idx) { return Info[Idx]; }

  const DIEInfo &getInfo(unsigned Idx) const { return Info[Idx]; }

  DIEInfo &getInfo(const DWARFDie &Die) {

    unsigned Idx = getOrigUnit().getDIEIndex(Die);

    return Info[Idx];

  }

  uint64_t getStartOffset() const { return StartOffset; }

  uint64_t getNextUnitOffset() const { return NextUnitOffset; }

  void setStartOffset(uint64_t DebugInfoSize) { StartOffset = DebugInfoSize; }

  std::optional<uint64_t> getLowPc() const { return LowPc; }

  uint64_t getHighPc() const { return HighPc; }

  bool hasLabelAt(uint64_t Addr) const { return Labels.count(Addr); }

  std::optional<PatchLocation> getUnitRangesAttribute() const {

    return UnitRangeAttribute;

  }

  const RangesTy &getFunctionRanges() const { return Ranges; }

  const std::vector<PatchLocation> &getRangesAttributes() const {

    return RangeAttributes;

  }

  const std::vector<std::pair<PatchLocation, int64_t>> &

  getLocationAttributes() const {

    return LocationAttributes;

  }

  /// Mark every DIE in this unit as kept. This function also

  /// marks variables as InDebugMap so that they appear in the

  /// reconstructed accelerator tables.

  void markEverythingAsKept();

  /// Compute the end offset for this unit. Must be called after the CU's DIEs

  /// have been cloned.  \returns the next unit offset (which is also the

  /// current debug_info section size).

  uint64_t computeNextUnitOffset(uint16_t DwarfVersion);

  /// Keep track of a forward reference to DIE \p Die in \p RefUnit by \p

  /// Attr. The attribute should be fixed up later to point to the absolute

  /// offset of \p Die in the debug_info section or to the canonical offset of

  /// \p Ctxt if it is non-null.

  void noteForwardReference(DIE *Die, const CompileUnit *RefUnit,

                            DeclContext *Ctxt, PatchLocation Attr);

  /// Apply all fixups recorded by noteForwardReference().

  void fixupForwardReferences();

  /// Add the low_pc of a label that is relocated by applying

  /// offset \p PCOffset.

  void addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset);

  /// Add a function range [\p LowPC, \p HighPC) that is relocated by applying

  /// offset \p PCOffset.

  void addFunctionRange(uint64_t LowPC, uint64_t HighPC, int64_t PCOffset);

  /// Keep track of a DW_AT_range attribute that we will need to patch up later.

  void noteRangeAttribute(const DIE &Die, PatchLocation Attr);

  /// Keep track of a location attribute pointing to a location list in the

  /// debug_loc section.

  void noteLocationAttribute(PatchLocation Attr, int64_t PcOffset);

  /// Add a name accelerator entry for \a Die with \a Name.

  void addNamespaceAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name);

  /// Add a name accelerator entry for \a Die with \a Name.

  void addNameAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,

                          bool SkipPubnamesSection = false);

  /// Add various accelerator entries for \p Die with \p Name which is stored

  /// in the string table at \p Offset. \p Name must be an Objective-C

  /// selector.

  void addObjCAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,

                          bool SkipPubnamesSection = false);

  /// Add a type accelerator entry for \p Die with \p Name which is stored in

  /// the string table at \p Offset.

  void addTypeAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,

                          bool ObjcClassImplementation,

                          uint32_t QualifiedNameHash);

  struct AccelInfo {

    /// Name of the entry.

    DwarfStringPoolEntryRef Name;

    /// DIE this entry describes.

    const DIE *Die;

    /// Hash of the fully qualified name.

    uint32_t QualifiedNameHash;

    /// Emit this entry only in the apple_* sections.

    bool SkipPubSection;

    /// Is this an ObjC class implementation?

    bool ObjcClassImplementation;

    AccelInfo(DwarfStringPoolEntryRef Name, const DIE *Die,

              bool SkipPubSection = false)

        : Name(Name), Die(Die), SkipPubSection(SkipPubSection) {}

    AccelInfo(DwarfStringPoolEntryRef Name, const DIE *Die,

              uint32_t QualifiedNameHash, bool ObjCClassIsImplementation)

        : Name(Name), Die(Die), QualifiedNameHash(QualifiedNameHash),

          SkipPubSection(false),

          ObjcClassImplementation(ObjCClassIsImplementation) {}

  };

  const std::vector<AccelInfo> &getPubnames() const { return Pubnames; }

  const std::vector<AccelInfo> &getPubtypes() const { return Pubtypes; }

  const std::vector<AccelInfo> &getNamespaces() const { return Namespaces; }

  const std::vector<AccelInfo> &getObjC() const { return ObjC; }

  MCSymbol *getLabelBegin() { return LabelBegin; }

  void setLabelBegin(MCSymbol *S) { LabelBegin = S; }

private:

  DWARFUnit &OrigUnit;

  unsigned ID;

  std::vector<DIEInfo> Info; ///< DIE info indexed by DIE index.

  std::optional<BasicDIEUnit> NewUnit;

  MCSymbol *LabelBegin = nullptr;

  uint64_t StartOffset;

  uint64_t NextUnitOffset;

  std::optional<uint64_t> LowPc;

  uint64_t HighPc = 0;

  /// A list of attributes to fixup with the absolute offset of

  /// a DIE in the debug_info section.

  ///

  /// The offsets for the attributes in this array couldn't be set while

  /// cloning because for cross-cu forward references the target DIE's offset

  /// isn't known you emit the reference attribute.

  std::vector<

      std::tuple<DIE *, const CompileUnit *, DeclContext *, PatchLocation>>

      ForwardDIEReferences;

  /// The ranges in that map are the PC ranges for functions in this unit,

  /// associated with the PC offset to apply to the addresses to get

  /// the linked address.

  RangesTy Ranges;

  /// The DW_AT_low_pc of each DW_TAG_label.

  SmallDenseMap<uint64_t, uint64_t, 1> Labels;

  /// DW_AT_ranges attributes to patch after we have gathered

  /// all the unit's function addresses.

  /// @{

  std::vector<PatchLocation> RangeAttributes;

  std::optional<PatchLocation> UnitRangeAttribute;

  /// @}

  /// Location attributes that need to be transferred from the

  /// original debug_loc section to the liked one. They are stored

  /// along with the PC offset that is to be applied to their

  /// function's address.

  std::vector<std::pair<PatchLocation, int64_t>> LocationAttributes;

  /// Accelerator entries for the unit, both for the pub*

  /// sections and the apple* ones.

  /// @{

  std::vector<AccelInfo> Pubnames;

  std::vector<AccelInfo> Pubtypes;

  std::vector<AccelInfo> Namespaces;

  std::vector<AccelInfo> ObjC;

  /// @}

  /// Is this unit subject to the ODR rule?

  bool HasODR;

  /// The DW_AT_language of this unit.

  uint16_t Language = 0;

  /// The DW_AT_LLVM_sysroot of this unit.

  std::string SysRoot;

  /// If this is a Clang module, this holds the module's name.

  std::string ClangModuleName;

};

} // end namespace llvm

#endif // LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H