llvm/lib/DWARFLinkerParallel/DWARFLinkerUnit.h

   1 //===- DWARFLinkerUnit.h ----------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_LIB_DWARFLINKERPARALLEL_DWARFLINKERUNIT_H
  10 #define LLVM_LIB_DWARFLINKERPARALLEL_DWARFLINKERUNIT_H
  11
  12 #include "DWARFLinkerGlobalData.h"
  13 #include "OutputSections.h"
  14 #include "llvm/ADT/SmallString.h"
  15 #include "llvm/CodeGen/DIE.h"
  16 #include "llvm/DWARFLinkerParallel/DWARFLinker.h"
  17 #include "llvm/DWARFLinkerParallel/StringPool.h"
  18 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
  19 #include "llvm/Support/LEB128.h"
  20
  21 namespace llvm {
  22 namespace dwarflinker_parallel {
  23
  24 class DwarfUnit;
  25 using MacroOffset2UnitMapTy = DenseMap<uint64_t, DwarfUnit *>;
  26
  27 /// Base class for all Dwarf units(Compile unit/Type table unit).
  28 class DwarfUnit : public OutputSections {
  29 public:
  30   virtual ~DwarfUnit() {}
  31   DwarfUnit(LinkingGlobalData &GlobalData, unsigned ID,
  32             StringRef ClangModuleName)
  33       : OutputSections(GlobalData), ID(ID), ClangModuleName(ClangModuleName),
  34         OutUnitDIE(nullptr) {
  35     AcceleratorRecords.setAllocator(&GlobalData.getAllocator());
  36   }
  37
  38   /// Unique id of the unit.
  39   unsigned getUniqueID() const { return ID; }
  40
  41   /// Return language of this unit.
  42   uint16_t getLanguage() const { return Language; }
  43
  44   /// Returns size of this(newly generated) compile unit.
  45   uint64_t getUnitSize() const { return UnitSize; }
  46
  47   /// Returns this unit name.
  48   StringRef getUnitName() const { return UnitName; }
  49
  50   /// Return the DW_AT_LLVM_sysroot of the compile unit or an empty StringRef.
  51   StringRef getSysRoot() { return SysRoot; }
  52
  53   /// Return true if this compile unit is from Clang module.
  54   bool isClangModule() const { return !ClangModuleName.empty(); }
  55
  56   /// Return Clang module name;
  57   const std::string &getClangModuleName() const { return ClangModuleName; }
  58
  59   /// Return global data.
  60   LinkingGlobalData &getGlobalData() { return GlobalData; }
  61
  62   /// Returns true if unit is inter-connected(it references/referenced by other
  63   /// unit).
  64   bool isInterconnectedCU() const { return IsInterconnectedCU; }
  65
  66   /// Mark this unit as inter-connected(it references/referenced by other unit).
  67   void setInterconnectedCU() { IsInterconnectedCU = true; }
  68
  69   /// Adds \p Abbrev into unit`s abbreviation table.
  70   void assignAbbrev(DIEAbbrev &Abbrev);
  71
  72   /// Returns abbreviations for this compile unit.
  73   const std::vector<std::unique_ptr<DIEAbbrev>> &getAbbreviations() const {
  74     return Abbreviations;
  75   }
  76
  77   /// Returns output unit DIE.
  78   DIE *getOutUnitDIE() { return OutUnitDIE; }
  79
  80   /// Set output unit DIE.
  81   void setOutUnitDIE(DIE *UnitDie) {
  82     OutUnitDIE = UnitDie;
  83
  84     if (OutUnitDIE != nullptr)
  85       UnitSize = getDebugInfoHeaderSize() + OutUnitDIE->getSize();
  86   }
  87
  88   /// \defgroup Methods used to emit unit's debug info:
  89   ///
  90   /// @{
  91   /// Emit unit's abbreviations.
  92   Error emitAbbreviations();
  93
  94   /// Emit .debug_info section for unit DIEs.
  95   Error emitDebugInfo(Triple &TargetTriple);
  96
  97   /// Emit .debug_line section.
  98   Error emitDebugLine(Triple &TargetTriple,
  99                       const DWARFDebugLine::LineTable &OutLineTable);
 100   /// @}
 101
 102   /// \defgroup Methods used for reporting warnings and errors:
 103   ///
 104   /// @{
 105   void warn(const Twine &Warning) { GlobalData.warn(Warning, getUnitName()); }
 106
 107   void error(const Twine &Err) { GlobalData.warn(Err, getUnitName()); }
 108   /// @}
 109
 110   /// \defgroup Methods and data members used for building accelerator tables:
 111   ///
 112   /// @{
 113
 114   enum class AccelType : uint8_t { None, Name, Namespace, ObjC, Type };
 115
 116   /// This structure keeps fields which would be used for creating accelerator
 117   /// table.
 118   struct AccelInfo {
 119     AccelInfo() {
 120       AvoidForPubSections = false;
 121       ObjcClassImplementation = false;
 122     }
 123
 124     /// Name of the entry.
 125     StringEntry *String = nullptr;
 126
 127     /// Output offset of the DIE this entry describes.
 128     uint64_t OutOffset = 0;
 129
 130     /// Hash of the fully qualified name.
 131     uint32_t QualifiedNameHash = 0;
 132
 133     /// Tag of the DIE this entry describes.
 134     dwarf::Tag Tag = dwarf::DW_TAG_null;
 135
 136     /// Type of this accelerator record.
 137     AccelType Type = AccelType::None;
 138
 139     /// Avoid using this entry for pub sections.
 140     bool AvoidForPubSections : 1;
 141
 142     /// Is this an ObjC class implementation?
 143     bool ObjcClassImplementation : 1;
 144   };
 145
 146   void rememberNameForAccelerators(StringEntry *Name, uint64_t OutOffset,
 147                                    dwarf::Tag Tag, bool AvoidForPubSections) {
 148     AccelInfo Info;
 149
 150     Info.Type = AccelType::Name;
 151     Info.String = Name;
 152     Info.OutOffset = OutOffset;
 153     Info.Tag = Tag;
 154     Info.AvoidForPubSections = AvoidForPubSections;
 155
 156     AcceleratorRecords.add(Info);
 157   }
 158   void rememberNamespaceForAccelerators(StringEntry *Name, uint64_t OutOffset,
 159                                         dwarf::Tag Tag) {
 160     AccelInfo Info;
 161
 162     Info.Type = AccelType::Namespace;
 163     Info.String = Name;
 164     Info.OutOffset = OutOffset;
 165     Info.Tag = Tag;
 166
 167     AcceleratorRecords.add(Info);
 168   }
 169   void rememberObjCNameForAccelerators(StringEntry *Name, uint64_t OutOffset,
 170                                        dwarf::Tag Tag) {
 171     AccelInfo Info;
 172
 173     Info.Type = AccelType::ObjC;
 174     Info.String = Name;
 175     Info.OutOffset = OutOffset;
 176     Info.Tag = Tag;
 177     Info.AvoidForPubSections = true;
 178
 179     AcceleratorRecords.add(Info);
 180   }
 181   void rememberTypeForAccelerators(StringEntry *Name, uint64_t OutOffset,
 182                                    dwarf::Tag Tag, uint32_t QualifiedNameHash,
 183                                    bool ObjcClassImplementation) {
 184     AccelInfo Info;
 185
 186     Info.Type = AccelType::Type;
 187     Info.String = Name;
 188     Info.OutOffset = OutOffset;
 189     Info.Tag = Tag;
 190     Info.QualifiedNameHash = QualifiedNameHash;
 191     Info.ObjcClassImplementation = ObjcClassImplementation;
 192
 193     AcceleratorRecords.add(Info);
 194   }
 195
 196   /// Emit .debug_pubnames and .debug_pubtypes for \p Unit.
 197   void emitPubAccelerators();
 198
 199   /// Accelerator tables data.
 200   ArrayList<AccelInfo> AcceleratorRecords;
 201
 202   /// @}
 203
 204 protected:
 205   /// Emit single abbreviation entry.
 206   void emitDwarfAbbrevEntry(const DIEAbbrev &Abbrev,
 207                             SectionDescriptor &AbbrevSection);
 208
 209   /// Emit single pubnames/pubtypes accelerator entry.
 210   std::optional<uint64_t>
 211   emitPubAcceleratorEntry(SectionDescriptor &OutSection,
 212                           DwarfUnit::AccelInfo &Info,
 213                           std::optional<uint64_t> LengthOffset);
 214
 215   /// Unique ID for the unit.
 216   unsigned ID = 0;
 217
 218   /// The DW_AT_language of this unit.
 219   uint16_t Language = 0;
 220
 221   /// The name of this unit.
 222   std::string UnitName;
 223
 224   /// The DW_AT_LLVM_sysroot of this unit.
 225   std::string SysRoot;
 226
 227   /// If this is a Clang module, this holds the module's name.
 228   std::string ClangModuleName;
 229
 230   uint64_t UnitSize = 0;
 231
 232   /// true if current unit references_to/is_referenced by other unit.
 233   std::atomic<bool> IsInterconnectedCU = {false};
 234
 235   /// FoldingSet that uniques the abbreviations.
 236   FoldingSet<DIEAbbrev> AbbreviationsSet;
 237
 238   /// Storage for the unique Abbreviations.
 239   std::vector<std::unique_ptr<DIEAbbrev>> Abbreviations;
 240
 241   /// Output unit DIE.
 242   DIE *OutUnitDIE = nullptr;
 243 };
 244
 245 } // end of namespace dwarflinker_parallel
 246 } // end namespace llvm
 247
 248 #endif // LLVM_LIB_DWARFLINKERPARALLEL_DWARFLINKERUNIT_H