llvm/lib/DWARFLinkerParallel/DIEAttributeCloner.h

   1 //===- DIEAttributeCloner.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_DIEATTRIBUTECLONER_H
  10 #define LLVM_LIB_DWARFLINKERPARALLEL_DIEATTRIBUTECLONER_H
  11
  12 #include "ArrayList.h"
  13 #include "DIEGenerator.h"
  14 #include "DWARFLinkerCompileUnit.h"
  15 #include "DWARFLinkerGlobalData.h"
  16
  17 namespace llvm {
  18 namespace dwarflinker_parallel {
  19
  20 /// Information gathered and exchanged between the various
  21 /// clone*Attr helpers about the attributes of a particular DIE.
  22 struct AttributesInfo {
  23   /// Short Name.
  24   StringEntry *Name = nullptr;
  25
  26   /// Mangled Name.
  27   StringEntry *MangledName = nullptr;
  28
  29   /// Does the DIE have an address pointing to live code section?
  30   bool HasLiveAddress = false;
  31
  32   /// Is this DIE only a declaration?
  33   bool IsDeclaration = false;
  34
  35   /// Does the DIE have a ranges attribute?
  36   bool HasRanges = false;
  37
  38   /// Does the DIE have a string offset attribute?
  39   bool HasStringOffsetBaseAttr = false;
  40 };
  41
  42 /// This class creates clones of input DIE attributes.
  43 /// It enumerates attributes of input DIE, creates clone for each
  44 /// attribute, adds cloned attribute to the output DIE.
  45 class DIEAttributeCloner {
  46 public:
  47   DIEAttributeCloner(DIE *OutDIE, CompileUnit &CU,
  48                      const DWARFDebugInfoEntry *InputDieEntry,
  49                      DIEGenerator &Generator,
  50                      std::optional<int64_t> FuncAddressAdjustment,
  51                      std::optional<int64_t> VarAddressAdjustment,
  52                      bool HasLocationExpressionAddress)
  53       : OutDIE(OutDIE), CU(CU),
  54         DebugInfoOutputSection(
  55             CU.getOrCreateSectionDescriptor(DebugSectionKind::DebugInfo)),
  56         InputDieEntry(InputDieEntry), Generator(Generator),
  57         FuncAddressAdjustment(FuncAddressAdjustment),
  58         VarAddressAdjustment(VarAddressAdjustment),
  59         HasLocationExpressionAddress(HasLocationExpressionAddress) {
  60     InputDIEIdx = CU.getDIEIndex(InputDieEntry);
  61   }
  62
  63   /// Clone attributes of input DIE.
  64   void clone();
  65
  66   /// Create abbreviations for the output DIE after all attributes are cloned.
  67   unsigned finalizeAbbreviations(bool HasChildrenToClone);
  68
  69   /// Cannot be used concurrently.
  70   AttributesInfo AttrInfo;
  71
  72 protected:
  73   /// Clone string attribute.
  74   size_t
  75   cloneStringAttr(const DWARFFormValue &Val,
  76                   const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec);
  77
  78   /// Clone attribute referencing another DIE.
  79   size_t
  80   cloneDieRefAttr(const DWARFFormValue &Val,
  81                   const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec);
  82
  83   /// Clone scalar attribute.
  84   size_t
  85   cloneScalarAttr(const DWARFFormValue &Val,
  86                   const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec);
  87
  88   /// Clone block or exprloc attribute.
  89   size_t
  90   cloneBlockAttr(const DWARFFormValue &Val,
  91                  const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec);
  92
  93   /// Clone address attribute.
  94   size_t
  95   cloneAddressAttr(const DWARFFormValue &Val,
  96                    const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec);
  97
  98   /// Returns true if attribute should be skipped.
  99   bool
 100   shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec);
 101
 102   /// Update patches offsets with the size of abbreviation number.
 103   void
 104   updatePatchesWithSizeOfAbbreviationNumber(unsigned SizeOfAbbreviationNumber) {
 105     for (uint64_t *OffsetPtr : PatchesOffsets)
 106       *OffsetPtr += SizeOfAbbreviationNumber;
 107   }
 108
 109   /// Output DIE.
 110   DIE *OutDIE = nullptr;
 111
 112   /// Compile unit for the output DIE.
 113   CompileUnit &CU;
 114
 115   /// .debug_info section descriptor.
 116   SectionDescriptor &DebugInfoOutputSection;
 117
 118   /// Input DIE entry.
 119   const DWARFDebugInfoEntry *InputDieEntry = nullptr;
 120
 121   /// Input DIE index.
 122   uint32_t InputDIEIdx = 0;
 123
 124   /// Output DIE generator.
 125   DIEGenerator &Generator;
 126
 127   /// Relocation adjustment for the function address ranges.
 128   std::optional<int64_t> FuncAddressAdjustment;
 129
 130   /// Relocation adjustment for the variable locations.
 131   std::optional<int64_t> VarAddressAdjustment;
 132
 133   /// Indicates whether InputDieEntry has an location attribute
 134   /// containg address expression.
 135   bool HasLocationExpressionAddress = false;
 136
 137   /// Output offset after all attributes.
 138   unsigned AttrOutOffset = 0;
 139
 140   /// Patches for the cloned attributes.
 141   OffsetsPtrVector PatchesOffsets;
 142 };
 143
 144 } // end of namespace dwarflinker_parallel
 145 } // end namespace llvm
 146
 147 #endif // LLVM_LIB_DWARFLINKERPARALLEL_DIEATTRIBUTECLONER_H