tools/dsymutil/CompileUnit.h

   1 //===- tools/dsymutil/CompileUnit.h - Dwarf debug info linker ---*- 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_TOOLS_DSYMUTIL_COMPILEUNIT_H
  10 #define LLVM_TOOLS_DSYMUTIL_COMPILEUNIT_H
  11
  12 #include "llvm/ADT/IntervalMap.h"
  13 #include "llvm/CodeGen/DIE.h"
  14 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
  15
  16 namespace llvm {
  17 namespace dsymutil {
  18
  19 class DeclContext;
  20
  21 template <typename KeyT, typename ValT>
  22 using HalfOpenIntervalMap =
  23     IntervalMap<KeyT, ValT, IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
  24                 IntervalMapHalfOpenInfo<KeyT>>;
  25
  26 using FunctionIntervals = HalfOpenIntervalMap<uint64_t, int64_t>;
  27
  28 // FIXME: Delete this structure.
  29 struct PatchLocation {
  30   DIE::value_iterator I;
  31
  32   PatchLocation() = default;
  33   PatchLocation(DIE::value_iterator I) : I(I) {}
  34
  35   void set(uint64_t New) const {
  36     assert(I);
  37     const auto &Old = *I;
  38     assert(Old.getType() == DIEValue::isInteger);
  39     *I = DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New));
  40   }
  41
  42   uint64_t get() const {
  43     assert(I);
  44     return I->getDIEInteger().getValue();
  45   }
  46 };
  47
  48 /// Stores all information relating to a compile unit, be it in its original
  49 /// instance in the object file to its brand new cloned and linked DIE tree.
  50 class CompileUnit {
  51 public:
  52   /// Information gathered about a DIE in the object file.
  53   struct DIEInfo {
  54     /// Address offset to apply to the described entity.
  55     int64_t AddrAdjust;
  56
  57     /// ODR Declaration context.
  58     DeclContext *Ctxt;
  59
  60     /// Cloned version of that DIE.
  61     DIE *Clone;
  62
  63     /// The index of this DIE's parent.
  64     uint32_t ParentIdx;
  65
  66     /// Is the DIE part of the linked output?
  67     bool Keep : 1;
  68
  69     /// Was this DIE's entity found in the map?
  70     bool InDebugMap : 1;
  71
  72     /// Is this a pure forward declaration we can strip?
  73     bool Prune : 1;
  74
  75     /// Does DIE transitively refer an incomplete decl?
  76     bool Incomplete : 1;
  77   };
  78
  79   CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
  80               StringRef ClangModuleName)
  81       : OrigUnit(OrigUnit), ID(ID), Ranges(RangeAlloc),
  82         ClangModuleName(ClangModuleName) {
  83     Info.resize(OrigUnit.getNumDIEs());
  84
  85     auto CUDie = OrigUnit.getUnitDIE(false);
  86     if (!CUDie) {
  87       HasODR = false;
  88       return;
  89     }
  90     if (auto Lang = dwarf::toUnsigned(CUDie.find(dwarf::DW_AT_language)))
  91       HasODR = CanUseODR && (*Lang == dwarf::DW_LANG_C_plus_plus ||
  92                              *Lang == dwarf::DW_LANG_C_plus_plus_03 ||
  93                              *Lang == dwarf::DW_LANG_C_plus_plus_11 ||
  94                              *Lang == dwarf::DW_LANG_C_plus_plus_14 ||
  95                              *Lang == dwarf::DW_LANG_ObjC_plus_plus);
  96     else
  97       HasODR = false;
  98   }
  99
 100   DWARFUnit &getOrigUnit() const { return OrigUnit; }
 101
 102   unsigned getUniqueID() const { return ID; }
 103
 104   void createOutputDIE() {
 105     NewUnit.emplace(OrigUnit.getVersion(), OrigUnit.getAddressByteSize(),
 106                     OrigUnit.getUnitDIE().getTag());
 107   }
 108
 109   DIE *getOutputUnitDIE() const {
 110     if (NewUnit)
 111       return &const_cast<BasicDIEUnit &>(*NewUnit).getUnitDie();
 112     return nullptr;
 113   }
 114
 115   bool hasODR() const { return HasODR; }
 116   bool isClangModule() const { return !ClangModuleName.empty(); }
 117   uint16_t getLanguage();
 118
 119   const std::string &getClangModuleName() const { return ClangModuleName; }
 120
 121   DIEInfo &getInfo(unsigned Idx) { return Info[Idx]; }
 122   const DIEInfo &getInfo(unsigned Idx) const { return Info[Idx]; }
 123
 124   uint64_t getStartOffset() const { return StartOffset; }
 125   uint64_t getNextUnitOffset() const { return NextUnitOffset; }
 126   void setStartOffset(uint64_t DebugInfoSize) { StartOffset = DebugInfoSize; }
 127
 128   uint64_t getLowPc() const { return LowPc; }
 129   uint64_t getHighPc() const { return HighPc; }
 130   bool hasLabelAt(uint64_t Addr) const { return Labels.count(Addr); }
 131
 132   Optional<PatchLocation> getUnitRangesAttribute() const {
 133     return UnitRangeAttribute;
 134   }
 135
 136   const FunctionIntervals &getFunctionRanges() const { return Ranges; }
 137
 138   const std::vector<PatchLocation> &getRangesAttributes() const {
 139     return RangeAttributes;
 140   }
 141
 142   const std::vector<std::pair<PatchLocation, int64_t>> &
 143   getLocationAttributes() const {
 144     return LocationAttributes;
 145   }
 146
 147   void setHasInterestingContent() { HasInterestingContent = true; }
 148   bool hasInterestingContent() { return HasInterestingContent; }
 149
 150   /// Mark every DIE in this unit as kept. This function also
 151   /// marks variables as InDebugMap so that they appear in the
 152   /// reconstructed accelerator tables.
 153   void markEverythingAsKept();
 154
 155   /// Compute the end offset for this unit. Must be called after the CU's DIEs
 156   /// have been cloned.  \returns the next unit offset (which is also the
 157   /// current debug_info section size).
 158   uint64_t computeNextUnitOffset();
 159
 160   /// Keep track of a forward reference to DIE \p Die in \p RefUnit by \p
 161   /// Attr. The attribute should be fixed up later to point to the absolute
 162   /// offset of \p Die in the debug_info section or to the canonical offset of
 163   /// \p Ctxt if it is non-null.
 164   void noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
 165                             DeclContext *Ctxt, PatchLocation Attr);
 166
 167   /// Apply all fixups recorded by noteForwardReference().
 168   void fixupForwardReferences();
 169
 170   /// Add the low_pc of a label that is relocated by applying
 171   /// offset \p PCOffset.
 172   void addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset);
 173
 174   /// Add a function range [\p LowPC, \p HighPC) that is relocated by applying
 175   /// offset \p PCOffset.
 176   void addFunctionRange(uint64_t LowPC, uint64_t HighPC, int64_t PCOffset);
 177
 178   /// Keep track of a DW_AT_range attribute that we will need to patch up later.
 179   void noteRangeAttribute(const DIE &Die, PatchLocation Attr);
 180
 181   /// Keep track of a location attribute pointing to a location list in the
 182   /// debug_loc section.
 183   void noteLocationAttribute(PatchLocation Attr, int64_t PcOffset);
 184
 185   /// Add a name accelerator entry for \a Die with \a Name.
 186   void addNamespaceAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name);
 187
 188   /// Add a name accelerator entry for \a Die with \a Name.
 189   void addNameAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
 190                           bool SkipPubnamesSection = false);
 191
 192   /// Add various accelerator entries for \p Die with \p Name which is stored
 193   /// in the string table at \p Offset. \p Name must be an Objective-C
 194   /// selector.
 195   void addObjCAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
 196                           bool SkipPubnamesSection = false);
 197
 198   /// Add a type accelerator entry for \p Die with \p Name which is stored in
 199   /// the string table at \p Offset.
 200   void addTypeAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
 201                           bool ObjcClassImplementation,
 202                           uint32_t QualifiedNameHash);
 203
 204   struct AccelInfo {
 205     /// Name of the entry.
 206     DwarfStringPoolEntryRef Name;
 207
 208     /// DIE this entry describes.
 209     const DIE *Die;
 210
 211     /// Hash of the fully qualified name.
 212     uint32_t QualifiedNameHash;
 213
 214     /// Emit this entry only in the apple_* sections.
 215     bool SkipPubSection;
 216
 217     /// Is this an ObjC class implementation?
 218     bool ObjcClassImplementation;
 219
 220     AccelInfo(DwarfStringPoolEntryRef Name, const DIE *Die,
 221               bool SkipPubSection = false)
 222         : Name(Name), Die(Die), SkipPubSection(SkipPubSection) {}
 223
 224     AccelInfo(DwarfStringPoolEntryRef Name, const DIE *Die,
 225               uint32_t QualifiedNameHash, bool ObjCClassIsImplementation)
 226         : Name(Name), Die(Die), QualifiedNameHash(QualifiedNameHash),
 227           SkipPubSection(false),
 228           ObjcClassImplementation(ObjCClassIsImplementation) {}
 229   };
 230
 231   const std::vector<AccelInfo> &getPubnames() const { return Pubnames; }
 232   const std::vector<AccelInfo> &getPubtypes() const { return Pubtypes; }
 233   const std::vector<AccelInfo> &getNamespaces() const { return Namespaces; }
 234   const std::vector<AccelInfo> &getObjC() const { return ObjC; }
 235
 236   /// Get the full path for file \a FileNum in the line table
 237   StringRef getResolvedPath(unsigned FileNum) {
 238     if (FileNum >= ResolvedPaths.size())
 239       return StringRef();
 240     return ResolvedPaths[FileNum];
 241   }
 242
 243   /// Set the fully resolved path for the line-table's file \a FileNum
 244   /// to \a Path.
 245   void setResolvedPath(unsigned FileNum, StringRef Path) {
 246     if (ResolvedPaths.size() <= FileNum)
 247       ResolvedPaths.resize(FileNum + 1);
 248     ResolvedPaths[FileNum] = Path;
 249   }
 250
 251   MCSymbol *getLabelBegin() { return LabelBegin; }
 252   void setLabelBegin(MCSymbol *S) { LabelBegin = S; }
 253
 254 private:
 255   DWARFUnit &OrigUnit;
 256   unsigned ID;
 257   std::vector<DIEInfo> Info; ///< DIE info indexed by DIE index.
 258   Optional<BasicDIEUnit> NewUnit;
 259   MCSymbol *LabelBegin = nullptr;
 260
 261   uint64_t StartOffset;
 262   uint64_t NextUnitOffset;
 263
 264   uint64_t LowPc = std::numeric_limits<uint64_t>::max();
 265   uint64_t HighPc = 0;
 266
 267   /// A list of attributes to fixup with the absolute offset of
 268   /// a DIE in the debug_info section.
 269   ///
 270   /// The offsets for the attributes in this array couldn't be set while
 271   /// cloning because for cross-cu forward references the target DIE's offset
 272   /// isn't known you emit the reference attribute.
 273   std::vector<
 274       std::tuple<DIE *, const CompileUnit *, DeclContext *, PatchLocation>>
 275       ForwardDIEReferences;
 276
 277   FunctionIntervals::Allocator RangeAlloc;
 278
 279   /// The ranges in that interval map are the PC ranges for
 280   /// functions in this unit, associated with the PC offset to apply
 281   /// to the addresses to get the linked address.
 282   FunctionIntervals Ranges;
 283
 284   /// The DW_AT_low_pc of each DW_TAG_label.
 285   SmallDenseMap<uint64_t, uint64_t, 1> Labels;
 286
 287   /// DW_AT_ranges attributes to patch after we have gathered
 288   /// all the unit's function addresses.
 289   /// @{
 290   std::vector<PatchLocation> RangeAttributes;
 291   Optional<PatchLocation> UnitRangeAttribute;
 292   /// @}
 293
 294   /// Location attributes that need to be transferred from the
 295   /// original debug_loc section to the liked one. They are stored
 296   /// along with the PC offset that is to be applied to their
 297   /// function's address.
 298   std::vector<std::pair<PatchLocation, int64_t>> LocationAttributes;
 299
 300   /// Accelerator entries for the unit, both for the pub*
 301   /// sections and the apple* ones.
 302   /// @{
 303   std::vector<AccelInfo> Pubnames;
 304   std::vector<AccelInfo> Pubtypes;
 305   std::vector<AccelInfo> Namespaces;
 306   std::vector<AccelInfo> ObjC;
 307   /// @}
 308
 309   /// Cached resolved paths from the line table.
 310   /// Note, the StringRefs here point in to the intern (uniquing) string pool.
 311   /// This means that a StringRef returned here doesn't need to then be uniqued
 312   /// for the purposes of getting a unique address for each string.
 313   std::vector<StringRef> ResolvedPaths;
 314
 315   /// Is this unit subject to the ODR rule?
 316   bool HasODR;
 317
 318   /// Did a DIE actually contain a valid reloc?
 319   bool HasInterestingContent;
 320
 321   /// The DW_AT_language of this unit.
 322   uint16_t Language = 0;
 323
 324   /// If this is a Clang module, this holds the module's name.
 325   std::string ClangModuleName;
 326 };
 327
 328 } // end namespace dsymutil
 329 } // end namespace llvm
 330
 331 #endif // LLVM_TOOLS_DSYMUTIL_COMPILEUNIT_H