1 //===- DWARFLinkerCompileUnit.cpp -----------------------------------------===//
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 #include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
10 #include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
11 
12 namespace llvm {
13 
14 /// Check if the DIE at \p Idx is in the scope of a function.
15 static bool inFunctionScope(CompileUnit &U, unsigned Idx) {
16   while (Idx) {
17     if (U.getOrigUnit().getDIEAtIndex(Idx).getTag() == dwarf::DW_TAG_subprogram)
18       return true;
19     Idx = U.getInfo(Idx).ParentIdx;
20   }
21   return false;
22 }
23 
24 uint16_t CompileUnit::getLanguage() {
25   if (!Language) {
26     DWARFDie CU = getOrigUnit().getUnitDIE();
27     Language = dwarf::toUnsigned(CU.find(dwarf::DW_AT_language), 0);
28   }
29   return Language;
30 }
31 
32 StringRef CompileUnit::getSysRoot() {
33   if (SysRoot.empty()) {
34     DWARFDie CU = getOrigUnit().getUnitDIE();
35     SysRoot = dwarf::toStringRef(CU.find(dwarf::DW_AT_LLVM_sysroot)).str();
36   }
37   return SysRoot;
38 }
39 
40 void CompileUnit::markEverythingAsKept() {
41   unsigned Idx = 0;
42 
43   for (auto &I : Info) {
44     // Mark everything that wasn't explicit marked for pruning.
45     I.Keep = !I.Prune;
46     auto DIE = OrigUnit.getDIEAtIndex(Idx++);
47 
48     // Try to guess which DIEs must go to the accelerator tables. We do that
49     // just for variables, because functions will be handled depending on
50     // whether they carry a DW_AT_low_pc attribute or not.
51     if (DIE.getTag() != dwarf::DW_TAG_variable &&
52         DIE.getTag() != dwarf::DW_TAG_constant)
53       continue;
54 
55     Optional<DWARFFormValue> Value;
56     if (!(Value = DIE.find(dwarf::DW_AT_location))) {
57       if ((Value = DIE.find(dwarf::DW_AT_const_value)) &&
58           !inFunctionScope(*this, I.ParentIdx))
59         I.InDebugMap = true;
60       continue;
61     }
62     if (auto Block = Value->getAsBlock()) {
63       if (Block->size() > OrigUnit.getAddressByteSize() &&
64           (*Block)[0] == dwarf::DW_OP_addr)
65         I.InDebugMap = true;
66     }
67   }
68 }
69 
70 uint64_t CompileUnit::computeNextUnitOffset(uint16_t DwarfVersion) {
71   NextUnitOffset = StartOffset;
72   if (NewUnit) {
73     NextUnitOffset += (DwarfVersion >= 5) ? 12 : 11; // Header size
74     NextUnitOffset += NewUnit->getUnitDie().getSize();
75   }
76   return NextUnitOffset;
77 }
78 
79 /// Keep track of a forward cross-cu reference from this unit
80 /// to \p Die that lives in \p RefUnit.
81 void CompileUnit::noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
82                                        DeclContext *Ctxt, PatchLocation Attr) {
83   ForwardDIEReferences.emplace_back(Die, RefUnit, Ctxt, Attr);
84 }
85 
86 void CompileUnit::fixupForwardReferences() {
87   for (const auto &Ref : ForwardDIEReferences) {
88     DIE *RefDie;
89     const CompileUnit *RefUnit;
90     PatchLocation Attr;
91     DeclContext *Ctxt;
92     std::tie(RefDie, RefUnit, Ctxt, Attr) = Ref;
93     if (Ctxt && Ctxt->hasCanonicalDIE()) {
94       assert(Ctxt->getCanonicalDIEOffset() &&
95              "Canonical die offset is not set");
96       Attr.set(Ctxt->getCanonicalDIEOffset());
97     } else
98       Attr.set(RefDie->getOffset() + RefUnit->getStartOffset());
99   }
100 }
101 
102 void CompileUnit::addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset) {
103   Labels.insert({LabelLowPc, PcOffset});
104 }
105 
106 void CompileUnit::addFunctionRange(uint64_t FuncLowPc, uint64_t FuncHighPc,
107                                    int64_t PcOffset) {
108   //  Don't add empty ranges to the interval map.  They are a problem because
109   //  the interval map expects half open intervals. This is safe because they
110   //  are empty anyway.
111   if (FuncHighPc != FuncLowPc)
112     Ranges.insert(FuncLowPc, FuncHighPc, PcOffset);
113   this->LowPc = std::min(LowPc, FuncLowPc + PcOffset);
114   this->HighPc = std::max(HighPc, FuncHighPc + PcOffset);
115 }
116 
117 void CompileUnit::noteRangeAttribute(const DIE &Die, PatchLocation Attr) {
118   if (Die.getTag() != dwarf::DW_TAG_compile_unit)
119     RangeAttributes.push_back(Attr);
120   else
121     UnitRangeAttribute = Attr;
122 }
123 
124 void CompileUnit::noteLocationAttribute(PatchLocation Attr, int64_t PcOffset) {
125   LocationAttributes.emplace_back(Attr, PcOffset);
126 }
127 
128 void CompileUnit::addNamespaceAccelerator(const DIE *Die,
129                                           DwarfStringPoolEntryRef Name) {
130   Namespaces.emplace_back(Name, Die);
131 }
132 
133 void CompileUnit::addObjCAccelerator(const DIE *Die,
134                                      DwarfStringPoolEntryRef Name,
135                                      bool SkipPubSection) {
136   ObjC.emplace_back(Name, Die, SkipPubSection);
137 }
138 
139 void CompileUnit::addNameAccelerator(const DIE *Die,
140                                      DwarfStringPoolEntryRef Name,
141                                      bool SkipPubSection) {
142   Pubnames.emplace_back(Name, Die, SkipPubSection);
143 }
144 
145 void CompileUnit::addTypeAccelerator(const DIE *Die,
146                                      DwarfStringPoolEntryRef Name,
147                                      bool ObjcClassImplementation,
148                                      uint32_t QualifiedNameHash) {
149   Pubtypes.emplace_back(Name, Die, QualifiedNameHash, ObjcClassImplementation);
150 }
151 
152 } // namespace llvm
153