Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 1 | //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===// |
Paul Robinson | 3443575 | 2017-03-01 00:14:42 +0000 | [diff] [blame] | 2 | // |
Chandler Carruth | 2946cd7 | 2019-01-19 08:50:56 +0000 | [diff] [blame] | 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 |
Paul Robinson | 3443575 | 2017-03-01 00:14:42 +0000 | [diff] [blame] | 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file contains support for constructing a dwarf compile unit. |
| 10 | // |
| 11 | //===----------------------------------------------------------------------===// |
| 12 | |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 13 | #include "DwarfCompileUnit.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 14 | #include "AddressPool.h" |
| 15 | #include "DwarfDebug.h" |
Adrian Prantl | 7813d9c | 2015-01-14 01:01:30 +0000 | [diff] [blame] | 16 | #include "DwarfExpression.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 17 | #include "DwarfUnit.h" |
| 18 | #include "llvm/ADT/None.h" |
| 19 | #include "llvm/ADT/STLExtras.h" |
Markus Lavin | b86ce21 | 2019-03-19 13:16:28 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/SmallString.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/SmallVector.h" |
| 22 | #include "llvm/ADT/StringRef.h" |
| 23 | #include "llvm/BinaryFormat/Dwarf.h" |
| 24 | #include "llvm/CodeGen/AsmPrinter.h" |
| 25 | #include "llvm/CodeGen/DIE.h" |
| 26 | #include "llvm/CodeGen/LexicalScopes.h" |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 27 | #include "llvm/CodeGen/MachineFunction.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 28 | #include "llvm/CodeGen/MachineInstr.h" |
| 29 | #include "llvm/CodeGen/MachineOperand.h" |
David Blaikie | b3bde2e | 2017-11-17 01:07:10 +0000 | [diff] [blame] | 30 | #include "llvm/CodeGen/TargetFrameLowering.h" |
David Blaikie | b3bde2e | 2017-11-17 01:07:10 +0000 | [diff] [blame] | 31 | #include "llvm/CodeGen/TargetRegisterInfo.h" |
| 32 | #include "llvm/CodeGen/TargetSubtargetInfo.h" |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 33 | #include "llvm/IR/DataLayout.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 34 | #include "llvm/IR/DebugInfo.h" |
| 35 | #include "llvm/IR/DebugInfoMetadata.h" |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 36 | #include "llvm/IR/GlobalVariable.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 37 | #include "llvm/MC/MCSection.h" |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 38 | #include "llvm/MC/MCStreamer.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 39 | #include "llvm/MC/MCSymbol.h" |
David Blaikie | b3bde2e | 2017-11-17 01:07:10 +0000 | [diff] [blame] | 40 | #include "llvm/MC/MachineLocation.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 41 | #include "llvm/Support/Casting.h" |
David Blaikie | 6054e65 | 2018-03-23 23:58:19 +0000 | [diff] [blame] | 42 | #include "llvm/Target/TargetLoweringObjectFile.h" |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 43 | #include "llvm/Target/TargetMachine.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 44 | #include "llvm/Target/TargetOptions.h" |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 45 | #include <algorithm> |
| 46 | #include <cassert> |
| 47 | #include <cstdint> |
| 48 | #include <iterator> |
| 49 | #include <memory> |
| 50 | #include <string> |
| 51 | #include <utility> |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 52 | |
Eugene Zelenko | 6e07bfd | 2017-08-17 21:26:39 +0000 | [diff] [blame] | 53 | using namespace llvm; |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 54 | |
Alexey Lapshin | 789e257 | 2019-11-30 23:48:32 +0300 | [diff] [blame] | 55 | static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) { |
| 56 | |
| 57 | // According to DWARF Debugging Information Format Version 5, |
| 58 | // 3.1.2 Skeleton Compilation Unit Entries: |
| 59 | // "When generating a split DWARF object file (see Section 7.3.2 |
| 60 | // on page 187), the compilation unit in the .debug_info section |
| 61 | // is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit" |
| 62 | if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton) |
| 63 | return dwarf::DW_TAG_skeleton_unit; |
| 64 | |
| 65 | return dwarf::DW_TAG_compile_unit; |
| 66 | } |
| 67 | |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 68 | DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 69 | AsmPrinter *A, DwarfDebug *DW, |
Alexey Lapshin | 789e257 | 2019-11-30 23:48:32 +0300 | [diff] [blame] | 70 | DwarfFile *DWU, UnitKind Kind) |
| 71 | : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU), UniqueID(UID) { |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 72 | insertDIE(Node, &getUnitDie()); |
Amjad Aboud | 8bbce8a | 2016-02-01 14:09:41 +0000 | [diff] [blame] | 73 | MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin"); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 74 | } |
| 75 | |
| 76 | /// addLabelAddress - Add a dwarf label attribute data and value using |
| 77 | /// DW_FORM_addr or DW_FORM_GNU_addr_index. |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 78 | void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute, |
| 79 | const MCSymbol *Label) { |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 80 | // Don't use the address pool in non-fission or in the skeleton unit itself. |
David Blaikie | 161dd3c | 2018-10-20 06:02:15 +0000 | [diff] [blame] | 81 | if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5) |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 82 | return addLocalLabelAddress(Die, Attribute, Label); |
| 83 | |
| 84 | if (Label) |
| 85 | DD->addArangeLabel(SymbolCU(this, Label)); |
| 86 | |
| 87 | unsigned idx = DD->getAddressPool().getIndex(Label); |
David Blaikie | 161dd3c | 2018-10-20 06:02:15 +0000 | [diff] [blame] | 88 | Die.addValue(DIEValueAllocator, Attribute, |
| 89 | DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx |
| 90 | : dwarf::DW_FORM_GNU_addr_index, |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 91 | DIEInteger(idx)); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 92 | } |
| 93 | |
| 94 | void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, |
| 95 | dwarf::Attribute Attribute, |
| 96 | const MCSymbol *Label) { |
| 97 | if (Label) |
| 98 | DD->addArangeLabel(SymbolCU(this, Label)); |
| 99 | |
Duncan P. N. Exon Smith | 815a6eb5 | 2015-05-27 22:31:41 +0000 | [diff] [blame] | 100 | if (Label) |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 101 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, |
| 102 | DIELabel(Label)); |
Duncan P. N. Exon Smith | 815a6eb5 | 2015-05-27 22:31:41 +0000 | [diff] [blame] | 103 | else |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 104 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, |
| 105 | DIEInteger(0)); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 106 | } |
| 107 | |
Paul Robinson | 612e89d | 2018-01-12 19:17:50 +0000 | [diff] [blame] | 108 | unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) { |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 109 | // If we print assembly, we can't separate .file entries according to |
| 110 | // compile units. Thus all files will belong to the default compile unit. |
| 111 | |
| 112 | // FIXME: add a better feature test than hasRawTextSupport. Even better, |
| 113 | // extend .file to support this. |
Paul Robinson | 612e89d | 2018-01-12 19:17:50 +0000 | [diff] [blame] | 114 | unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID(); |
| 115 | if (!File) |
Fangrui Song | 0bc77a0 | 2020-02-13 13:26:21 -0800 | [diff] [blame^] | 116 | return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None, |
| 117 | CUID); |
| 118 | return Asm->OutStreamer->emitDwarfFileDirective( |
Scott Linder | 16c7bda | 2018-02-23 23:01:06 +0000 | [diff] [blame] | 119 | 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File), |
| 120 | File->getSource(), CUID); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 121 | } |
| 122 | |
Duncan P. N. Exon Smith | 60635e3 | 2015-04-21 18:44:06 +0000 | [diff] [blame] | 123 | DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE( |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 124 | const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) { |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 125 | // Check for pre-existence. |
| 126 | if (DIE *Die = getDIE(GV)) |
| 127 | return Die; |
| 128 | |
Duncan P. N. Exon Smith | e686f15 | 2015-04-06 23:27:40 +0000 | [diff] [blame] | 129 | assert(GV); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 130 | |
Duncan P. N. Exon Smith | be9e4fe | 2015-04-20 18:32:29 +0000 | [diff] [blame] | 131 | auto *GVContext = GV->getScope(); |
Fangrui Song | da82ce9 | 2019-05-07 02:06:37 +0000 | [diff] [blame] | 132 | const DIType *GTy = GV->getType(); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 133 | |
David Blaikie | 49cfc8c | 2014-10-23 19:12:43 +0000 | [diff] [blame] | 134 | // Construct the context before querying for the existence of the DIE in |
| 135 | // case such construction creates the DIE. |
Adrian Prantl | 6ed5706 | 2019-04-08 19:13:55 +0000 | [diff] [blame] | 136 | auto *CB = GVContext ? dyn_cast<DICommonBlock>(GVContext) : nullptr; |
| 137 | DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs) |
| 138 | : getOrCreateContextDIE(GVContext); |
David Blaikie | 49cfc8c | 2014-10-23 19:12:43 +0000 | [diff] [blame] | 139 | |
Amjad Aboud | 72da939 | 2016-04-30 01:44:07 +0000 | [diff] [blame] | 140 | // Add to map. |
| 141 | DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV); |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 142 | DIScope *DeclContext; |
Duncan P. N. Exon Smith | b105564 | 2015-04-16 01:01:28 +0000 | [diff] [blame] | 143 | if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) { |
Fangrui Song | da82ce9 | 2019-05-07 02:06:37 +0000 | [diff] [blame] | 144 | DeclContext = SDMDecl->getScope(); |
Duncan P. N. Exon Smith | b105564 | 2015-04-16 01:01:28 +0000 | [diff] [blame] | 145 | assert(SDMDecl->isStaticMember() && "Expected static member decl"); |
Duncan P. N. Exon Smith | 7348dda | 2015-04-14 02:22:36 +0000 | [diff] [blame] | 146 | assert(GV->isDefinition()); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 147 | // We need the declaration DIE that is in the static member's class. |
David Blaikie | 49cfc8c | 2014-10-23 19:12:43 +0000 | [diff] [blame] | 148 | DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl); |
| 149 | addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE); |
Adrian Prantl | 3502f20 | 2016-11-08 22:11:38 +0000 | [diff] [blame] | 150 | // If the global variable's type is different from the one in the class |
| 151 | // member type, assume that it's more specific and also emit it. |
Fangrui Song | da82ce9 | 2019-05-07 02:06:37 +0000 | [diff] [blame] | 152 | if (GTy != SDMDecl->getBaseType()) |
Adrian Prantl | 3502f20 | 2016-11-08 22:11:38 +0000 | [diff] [blame] | 153 | addType(*VariableDIE, GTy); |
David Blaikie | 49cfc8c | 2014-10-23 19:12:43 +0000 | [diff] [blame] | 154 | } else { |
Duncan P. N. Exon Smith | 7348dda | 2015-04-14 02:22:36 +0000 | [diff] [blame] | 155 | DeclContext = GV->getScope(); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 156 | // Add name and type. |
Duncan P. N. Exon Smith | 7348dda | 2015-04-14 02:22:36 +0000 | [diff] [blame] | 157 | addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName()); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 158 | addType(*VariableDIE, GTy); |
| 159 | |
| 160 | // Add scoping info. |
Duncan P. N. Exon Smith | 7348dda | 2015-04-14 02:22:36 +0000 | [diff] [blame] | 161 | if (!GV->isLocalToUnit()) |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 162 | addFlag(*VariableDIE, dwarf::DW_AT_external); |
| 163 | |
| 164 | // Add line number info. |
| 165 | addSourceLine(*VariableDIE, GV); |
| 166 | } |
| 167 | |
Duncan P. N. Exon Smith | 7348dda | 2015-04-14 02:22:36 +0000 | [diff] [blame] | 168 | if (!GV->isDefinition()) |
David Blaikie | 49cfc8c | 2014-10-23 19:12:43 +0000 | [diff] [blame] | 169 | addFlag(*VariableDIE, dwarf::DW_AT_declaration); |
David Blaikie | 877354a | 2015-04-14 18:08:25 +0000 | [diff] [blame] | 170 | else |
| 171 | addGlobalName(GV->getName(), *VariableDIE, DeclContext); |
David Blaikie | 49cfc8c | 2014-10-23 19:12:43 +0000 | [diff] [blame] | 172 | |
Victor Leschuk | 3c98998 | 2016-10-26 11:59:03 +0000 | [diff] [blame] | 173 | if (uint32_t AlignInBytes = GV->getAlignInBytes()) |
| 174 | addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, |
| 175 | AlignInBytes); |
| 176 | |
Matthew Voss | f8ab35a | 2018-10-03 18:44:53 +0000 | [diff] [blame] | 177 | if (MDTuple *TP = GV->getTemplateParams()) |
| 178 | addTemplateParams(*VariableDIE, DINodeArray(TP)); |
| 179 | |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 180 | // Add location. |
Adrian Prantl | 6ed5706 | 2019-04-08 19:13:55 +0000 | [diff] [blame] | 181 | addLocationAttribute(VariableDIE, GV, GlobalExprs); |
| 182 | |
| 183 | return VariableDIE; |
| 184 | } |
| 185 | |
| 186 | void DwarfCompileUnit::addLocationAttribute( |
| 187 | DIE *VariableDIE, const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) { |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 188 | bool addToAccelTable = false; |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 189 | DIELoc *Loc = nullptr; |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 190 | Optional<unsigned> NVPTXAddressSpace; |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 191 | std::unique_ptr<DIEDwarfExpression> DwarfExpr; |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 192 | for (const auto &GE : GlobalExprs) { |
| 193 | const GlobalVariable *Global = GE.Var; |
| 194 | const DIExpression *Expr = GE.Expr; |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 195 | |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 196 | // For compatibility with DWARF 3 and earlier, |
| 197 | // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes |
| 198 | // DW_AT_const_value(X). |
| 199 | if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) { |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 200 | addToAccelTable = true; |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 201 | addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1)); |
| 202 | break; |
| 203 | } |
| 204 | |
| 205 | // We cannot describe the location of dllimport'd variables: the |
| 206 | // computation of their address requires loads from the IAT. |
| 207 | if (Global && Global->hasDLLImportStorageClass()) |
| 208 | continue; |
| 209 | |
| 210 | // Nothing to describe without address or constant. |
| 211 | if (!Global && (!Expr || !Expr->isConstant())) |
| 212 | continue; |
| 213 | |
Lei Liu | 8e422b8 | 2018-08-01 23:46:49 +0000 | [diff] [blame] | 214 | if (Global && Global->isThreadLocal() && |
| 215 | !Asm->getObjFileLowering().supportDebugThreadLocalLocation()) |
| 216 | continue; |
| 217 | |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 218 | if (!Loc) { |
| 219 | addToAccelTable = true; |
| 220 | Loc = new (DIEValueAllocator) DIELoc; |
Jonas Devlieghere | 0eaee54 | 2019-08-15 15:54:37 +0000 | [diff] [blame] | 221 | DwarfExpr = std::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc); |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 222 | } |
| 223 | |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 224 | if (Expr) { |
| 225 | // According to |
| 226 | // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf |
| 227 | // cuda-gdb requires DW_AT_address_class for all variables to be able to |
| 228 | // correctly interpret address space of the variable address. |
| 229 | // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef |
| 230 | // sequence for the NVPTX + gdb target. |
| 231 | unsigned LocalNVPTXAddressSpace; |
| 232 | if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { |
| 233 | const DIExpression *NewExpr = |
| 234 | DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace); |
| 235 | if (NewExpr != Expr) { |
| 236 | Expr = NewExpr; |
| 237 | NVPTXAddressSpace = LocalNVPTXAddressSpace; |
| 238 | } |
| 239 | } |
Mikael Holmen | a9e3153 | 2018-01-29 12:37:30 +0000 | [diff] [blame] | 240 | DwarfExpr->addFragmentOffset(Expr); |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 241 | } |
Mikael Holmen | a9e3153 | 2018-01-29 12:37:30 +0000 | [diff] [blame] | 242 | |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 243 | if (Global) { |
| 244 | const MCSymbol *Sym = Asm->getSymbol(Global); |
| 245 | if (Global->isThreadLocal()) { |
Chih-Hung Hsieh | 9f9e468 | 2018-02-28 17:48:55 +0000 | [diff] [blame] | 246 | if (Asm->TM.useEmulatedTLS()) { |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 247 | // TODO: add debug info for emulated thread local mode. |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 248 | } else { |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 249 | // FIXME: Make this work with -gsplit-dwarf. |
| 250 | unsigned PointerSize = Asm->getDataLayout().getPointerSize(); |
| 251 | assert((PointerSize == 4 || PointerSize == 8) && |
| 252 | "Add support for other sizes if necessary"); |
| 253 | // Based on GCC's support for TLS: |
| 254 | if (!DD->useSplitDwarf()) { |
| 255 | // 1) Start with a constNu of the appropriate pointer size |
| 256 | addUInt(*Loc, dwarf::DW_FORM_data1, |
| 257 | PointerSize == 4 ? dwarf::DW_OP_const4u |
| 258 | : dwarf::DW_OP_const8u); |
| 259 | // 2) containing the (relocated) offset of the TLS variable |
| 260 | // within the module's TLS block. |
| 261 | addExpr(*Loc, dwarf::DW_FORM_udata, |
| 262 | Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); |
| 263 | } else { |
| 264 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); |
| 265 | addUInt(*Loc, dwarf::DW_FORM_udata, |
| 266 | DD->getAddressPool().getIndex(Sym, /* TLS */ true)); |
| 267 | } |
| 268 | // 3) followed by an OP to make the debugger do a TLS lookup. |
| 269 | addUInt(*Loc, dwarf::DW_FORM_data1, |
| 270 | DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address |
| 271 | : dwarf::DW_OP_form_tls_address); |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 272 | } |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 273 | } else { |
| 274 | DD->addArangeLabel(SymbolCU(this, Sym)); |
| 275 | addOpAddress(*Loc, Sym); |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 276 | } |
Adrian Prantl | b216e3e | 2017-03-23 23:35:09 +0000 | [diff] [blame] | 277 | } |
Adrian Prantl | 4b542c6 | 2018-04-27 22:05:31 +0000 | [diff] [blame] | 278 | // Global variables attached to symbols are memory locations. |
| 279 | // It would be better if this were unconditional, but malformed input that |
| 280 | // mixes non-fragments and fragments for the same variable is too expensive |
| 281 | // to detect in the verifier. |
Adrian Prantl | 3edc63a | 2018-05-04 16:10:43 +0000 | [diff] [blame] | 282 | if (DwarfExpr->isUnknownLocation()) |
Adrian Prantl | 4b542c6 | 2018-04-27 22:05:31 +0000 | [diff] [blame] | 283 | DwarfExpr->setMemoryLocationKind(); |
| 284 | DwarfExpr->addExpression(Expr); |
Adrian Prantl | 73ec065 | 2016-12-16 19:39:01 +0000 | [diff] [blame] | 285 | } |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 286 | if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { |
| 287 | // According to |
| 288 | // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf |
| 289 | // cuda-gdb requires DW_AT_address_class for all variables to be able to |
| 290 | // correctly interpret address space of the variable address. |
| 291 | const unsigned NVPTX_ADDR_global_space = 5; |
| 292 | addUInt(*VariableDIE, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1, |
| 293 | NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_global_space); |
| 294 | } |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 295 | if (Loc) |
| 296 | addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize()); |
| 297 | |
| 298 | if (DD->useAllLinkageNames()) |
| 299 | addLinkageName(*VariableDIE, GV->getLinkageName()); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 300 | |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 301 | if (addToAccelTable) { |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 302 | DD->addAccelName(*CUNode, GV->getName(), *VariableDIE); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 303 | |
| 304 | // If the linkage name is different than the name, go ahead and output |
| 305 | // that as well into the name table. |
Pavel Labath | 2a6afe5 | 2018-05-14 14:13:20 +0000 | [diff] [blame] | 306 | if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() && |
| 307 | DD->useAllLinkageNames()) |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 308 | DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 309 | } |
Adrian Prantl | 6ed5706 | 2019-04-08 19:13:55 +0000 | [diff] [blame] | 310 | } |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 311 | |
Adrian Prantl | 6ed5706 | 2019-04-08 19:13:55 +0000 | [diff] [blame] | 312 | DIE *DwarfCompileUnit::getOrCreateCommonBlock( |
| 313 | const DICommonBlock *CB, ArrayRef<GlobalExpr> GlobalExprs) { |
| 314 | // Construct the context before querying for the existence of the DIE in case |
| 315 | // such construction creates the DIE. |
| 316 | DIE *ContextDIE = getOrCreateContextDIE(CB->getScope()); |
| 317 | |
| 318 | if (DIE *NDie = getDIE(CB)) |
| 319 | return NDie; |
| 320 | DIE &NDie = createAndAddDIE(dwarf::DW_TAG_common_block, *ContextDIE, CB); |
| 321 | StringRef Name = CB->getName().empty() ? "_BLNK_" : CB->getName(); |
| 322 | addString(NDie, dwarf::DW_AT_name, Name); |
| 323 | addGlobalName(Name, NDie, CB->getScope()); |
| 324 | if (CB->getFile()) |
| 325 | addSourceLine(NDie, CB->getLineNo(), CB->getFile()); |
| 326 | if (DIGlobalVariable *V = CB->getDecl()) |
| 327 | getCU().addLocationAttribute(&NDie, V, GlobalExprs); |
| 328 | return &NDie; |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | void DwarfCompileUnit::addRange(RangeSpan Range) { |
David Blaikie | 58b10df | 2020-01-17 18:12:34 -0800 | [diff] [blame] | 332 | DD->insertSectionLabel(Range.Begin); |
| 333 | |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 334 | bool SameAsPrevCU = this == DD->getPrevCU(); |
| 335 | DD->setPrevCU(this); |
| 336 | // If we have no current ranges just add the range and return, otherwise, |
| 337 | // check the current section and CU against the previous section and CU we |
| 338 | // emitted into and the subprogram was contained within. If these are the |
| 339 | // same then extend our current range, otherwise add this as a new range. |
| 340 | if (CURanges.empty() || !SameAsPrevCU || |
David Blaikie | b677cb8d | 2019-10-02 22:27:24 +0000 | [diff] [blame] | 341 | (&CURanges.back().End->getSection() != |
| 342 | &Range.End->getSection())) { |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 343 | CURanges.push_back(Range); |
| 344 | return; |
| 345 | } |
| 346 | |
David Blaikie | b677cb8d | 2019-10-02 22:27:24 +0000 | [diff] [blame] | 347 | CURanges.back().End = Range.End; |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 348 | } |
| 349 | |
Rafael Espindola | 063d725 | 2015-03-10 16:58:10 +0000 | [diff] [blame] | 350 | void DwarfCompileUnit::initStmtList() { |
Alexey Bataev | d4dd721 | 2018-08-01 19:38:20 +0000 | [diff] [blame] | 351 | if (CUNode->isDebugDirectivesOnly()) |
| 352 | return; |
| 353 | |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 354 | // Define start line table label for each Compile Unit. |
Alexey Bataev | bff3608 | 2018-03-23 13:35:54 +0000 | [diff] [blame] | 355 | MCSymbol *LineTableStartSym; |
| 356 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); |
| 357 | if (DD->useSectionsAsReferences()) { |
| 358 | LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol(); |
| 359 | } else { |
| 360 | LineTableStartSym = |
| 361 | Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); |
| 362 | } |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 363 | |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 364 | // DW_AT_stmt_list is a offset of line number information for this |
| 365 | // compile unit in debug_line section. For split dwarf this is |
| 366 | // left in the skeleton CU and so not included. |
| 367 | // The line table entries are not always emitted in assembly, so it |
| 368 | // is not okay to use line_table_start here. |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 369 | StmtListValue = |
Greg Clayton | 35630c3 | 2016-12-01 18:56:29 +0000 | [diff] [blame] | 370 | addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym, |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 371 | TLOF.getDwarfLineSection()->getBeginSymbol()); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | void DwarfCompileUnit::applyStmtList(DIE &D) { |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 375 | D.addValue(DIEValueAllocator, *StmtListValue); |
David Blaikie | 37c5231 | 2014-10-04 15:49:50 +0000 | [diff] [blame] | 376 | } |
| 377 | |
David Blaikie | 14499a7 | 2014-10-04 15:58:47 +0000 | [diff] [blame] | 378 | void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, |
| 379 | const MCSymbol *End) { |
| 380 | assert(Begin && "Begin label should not be null!"); |
| 381 | assert(End && "End label should not be null!"); |
| 382 | assert(Begin->isDefined() && "Invalid starting label"); |
| 383 | assert(End->isDefined() && "Invalid end label"); |
| 384 | |
| 385 | addLabelAddress(D, dwarf::DW_AT_low_pc, Begin); |
| 386 | if (DD->getDwarfVersion() < 4) |
| 387 | addLabelAddress(D, dwarf::DW_AT_high_pc, End); |
| 388 | else |
| 389 | addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin); |
| 390 | } |
| 391 | |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 392 | // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc |
| 393 | // and DW_AT_high_pc attributes. If there are global variables in this |
| 394 | // scope then create and insert DIEs for these variables. |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 395 | DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) { |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 396 | DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes()); |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 397 | |
Rafael Espindola | 07c03d3 | 2015-03-05 02:05:42 +0000 | [diff] [blame] | 398 | attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd()); |
David Blaikie | c53e18d | 2016-05-24 21:19:28 +0000 | [diff] [blame] | 399 | if (DD->useAppleExtensionAttributes() && |
| 400 | !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim( |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 401 | *DD->getCurrentFunction())) |
| 402 | addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr); |
| 403 | |
| 404 | // Only include DW_AT_frame_base in full debug info |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 405 | if (!includeMinimalInlineScopes()) { |
Derek Schuff | ff171ac | 2019-12-18 14:50:19 -0800 | [diff] [blame] | 406 | const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); |
| 407 | TargetFrameLowering::DwarfFrameBase FrameBase = |
| 408 | TFI->getDwarfFrameBase(*Asm->MF); |
| 409 | switch (FrameBase.Kind) { |
| 410 | case TargetFrameLowering::DwarfFrameBase::Register: { |
| 411 | if (Register::isPhysicalRegister(FrameBase.Location.Reg)) { |
| 412 | MachineLocation Location(FrameBase.Location.Reg); |
| 413 | addAddress(*SPDie, dwarf::DW_AT_frame_base, Location); |
| 414 | } |
| 415 | break; |
| 416 | } |
| 417 | case TargetFrameLowering::DwarfFrameBase::CFA: { |
Alexey Bataev | 7ae86fe | 2018-07-26 16:10:05 +0000 | [diff] [blame] | 418 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
| 419 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa); |
| 420 | addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); |
Derek Schuff | ff171ac | 2019-12-18 14:50:19 -0800 | [diff] [blame] | 421 | break; |
| 422 | } |
| 423 | case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: { |
| 424 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
| 425 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); |
| 426 | DIExpressionCursor Cursor({}); |
| 427 | DwarfExpr.addWasmLocation(FrameBase.Location.WasmLoc.Kind, |
| 428 | FrameBase.Location.WasmLoc.Index); |
| 429 | DwarfExpr.addExpression(std::move(Cursor)); |
| 430 | addBlock(*SPDie, dwarf::DW_AT_frame_base, DwarfExpr.finalize()); |
| 431 | break; |
| 432 | } |
Alexey Bataev | 7ae86fe | 2018-07-26 16:10:05 +0000 | [diff] [blame] | 433 | } |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 434 | } |
| 435 | |
| 436 | // Add name to the name table, we do this here because we're guaranteed |
| 437 | // to have concrete versions of our DW_TAG_subprogram nodes. |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 438 | DD->addSubprogramNames(*CUNode, SP, *SPDie); |
David Blaikie | cda2aa8 | 2014-10-04 16:24:00 +0000 | [diff] [blame] | 439 | |
| 440 | return *SPDie; |
| 441 | } |
| 442 | |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 443 | // Construct a DIE for this scope. |
| 444 | void DwarfCompileUnit::constructScopeDIE( |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 445 | LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) { |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 446 | if (!Scope || !Scope->getScopeNode()) |
| 447 | return; |
| 448 | |
Duncan P. N. Exon Smith | be9e4fe | 2015-04-20 18:32:29 +0000 | [diff] [blame] | 449 | auto *DS = Scope->getScopeNode(); |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 450 | |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 451 | assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 452 | "Only handle inlined subprograms here, use " |
| 453 | "constructSubprogramScopeDIE for non-inlined " |
| 454 | "subprograms"); |
| 455 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 456 | SmallVector<DIE *, 8> Children; |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 457 | |
| 458 | // We try to create the scope DIE first, then the children DIEs. This will |
| 459 | // avoid creating un-used children then removing them later when we find out |
| 460 | // the scope DIE is null. |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 461 | DIE *ScopeDIE; |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 462 | if (Scope->getParent() && isa<DISubprogram>(DS)) { |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 463 | ScopeDIE = constructInlinedScopeDIE(Scope); |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 464 | if (!ScopeDIE) |
| 465 | return; |
| 466 | // We create children when the scope DIE is not null. |
David Blaikie | 8b2fdb8 | 2014-10-09 18:24:28 +0000 | [diff] [blame] | 467 | createScopeChildrenDIE(Scope, Children); |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 468 | } else { |
| 469 | // Early exit when we know the scope DIE is going to be null. |
| 470 | if (DD->isLexicalScopeDIENull(Scope)) |
| 471 | return; |
| 472 | |
David Blaikie | 2195e13 | 2017-07-27 00:06:53 +0000 | [diff] [blame] | 473 | bool HasNonScopeChildren = false; |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 474 | |
| 475 | // We create children here when we know the scope DIE is not going to be |
| 476 | // null and the children will be added to the scope DIE. |
David Blaikie | 2195e13 | 2017-07-27 00:06:53 +0000 | [diff] [blame] | 477 | createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren); |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 478 | |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 479 | // If there are only other scopes as children, put them directly in the |
| 480 | // parent instead, as this scope would serve no purpose. |
David Blaikie | 2195e13 | 2017-07-27 00:06:53 +0000 | [diff] [blame] | 481 | if (!HasNonScopeChildren) { |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 482 | FinalChildren.insert(FinalChildren.end(), |
| 483 | std::make_move_iterator(Children.begin()), |
| 484 | std::make_move_iterator(Children.end())); |
| 485 | return; |
| 486 | } |
David Blaikie | 0fbf8bd | 2014-10-09 17:08:42 +0000 | [diff] [blame] | 487 | ScopeDIE = constructLexicalScopeDIE(Scope); |
David Blaikie | 9c65b13 | 2014-10-08 22:20:02 +0000 | [diff] [blame] | 488 | assert(ScopeDIE && "Scope DIE should not be null."); |
| 489 | } |
| 490 | |
| 491 | // Add children |
| 492 | for (auto &I : Children) |
| 493 | ScopeDIE->addChild(std::move(I)); |
| 494 | |
| 495 | FinalChildren.push_back(std::move(ScopeDIE)); |
| 496 | } |
| 497 | |
David Blaikie | 5b02a19 | 2014-11-03 23:10:59 +0000 | [diff] [blame] | 498 | void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, |
| 499 | SmallVector<RangeSpan, 2> Range) { |
David Blaikie | 5240020 | 2014-10-09 00:11:39 +0000 | [diff] [blame] | 500 | |
David Blaikie | c4af8bf | 2018-10-20 07:36:39 +0000 | [diff] [blame] | 501 | HasRangeLists = true; |
| 502 | |
| 503 | // Add the range list to the set of ranges to be emitted. |
| 504 | auto IndexAndList = |
| 505 | (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU) |
David Blaikie | c8f7e6c | 2018-11-08 00:35:54 +0000 | [diff] [blame] | 506 | ->addRange(*(Skeleton ? Skeleton : this), std::move(Range)); |
David Blaikie | c4af8bf | 2018-10-20 07:36:39 +0000 | [diff] [blame] | 507 | |
| 508 | uint32_t Index = IndexAndList.first; |
| 509 | auto &List = *IndexAndList.second; |
David Blaikie | 5b02a19 | 2014-11-03 23:10:59 +0000 | [diff] [blame] | 510 | |
David Blaikie | 5240020 | 2014-10-09 00:11:39 +0000 | [diff] [blame] | 511 | // Under fission, ranges are specified by constant offsets relative to the |
| 512 | // CU's DW_AT_GNU_ranges_base. |
Wolfgang Pieb | fcf3810 | 2018-07-12 18:18:21 +0000 | [diff] [blame] | 513 | // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under |
| 514 | // fission until we support the forms using the .debug_addr section |
| 515 | // (DW_RLE_startx_endx etc.). |
David Blaikie | 32e09de | 2018-10-20 08:12:36 +0000 | [diff] [blame] | 516 | if (DD->getDwarfVersion() >= 5) |
| 517 | addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index); |
David Blaikie | de9aa37 | 2019-10-11 23:51:24 +0000 | [diff] [blame] | 518 | else { |
| 519 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); |
| 520 | const MCSymbol *RangeSectionSym = |
| 521 | TLOF.getDwarfRangesSection()->getBeginSymbol(); |
| 522 | if (isDwoUnit()) |
David Blaikie | 64fa76e | 2019-12-16 15:19:25 -0800 | [diff] [blame] | 523 | addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.Label, |
David Blaikie | de9aa37 | 2019-10-11 23:51:24 +0000 | [diff] [blame] | 524 | RangeSectionSym); |
| 525 | else |
David Blaikie | 64fa76e | 2019-12-16 15:19:25 -0800 | [diff] [blame] | 526 | addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.Label, |
David Blaikie | de9aa37 | 2019-10-11 23:51:24 +0000 | [diff] [blame] | 527 | RangeSectionSym); |
| 528 | } |
David Blaikie | 5240020 | 2014-10-09 00:11:39 +0000 | [diff] [blame] | 529 | } |
| 530 | |
David Blaikie | de12375 | 2014-10-09 00:21:42 +0000 | [diff] [blame] | 531 | void DwarfCompileUnit::attachRangesOrLowHighPC( |
David Blaikie | 5b02a19 | 2014-11-03 23:10:59 +0000 | [diff] [blame] | 532 | DIE &Die, SmallVector<RangeSpan, 2> Ranges) { |
Alexey Bataev | 858a7dd | 2018-03-20 20:21:38 +0000 | [diff] [blame] | 533 | if (Ranges.size() == 1 || !DD->useRangesSection()) { |
| 534 | const RangeSpan &Front = Ranges.front(); |
| 535 | const RangeSpan &Back = Ranges.back(); |
David Blaikie | b677cb8d | 2019-10-02 22:27:24 +0000 | [diff] [blame] | 536 | attachLowHighPC(Die, Front.Begin, Back.End); |
David Blaikie | 5b02a19 | 2014-11-03 23:10:59 +0000 | [diff] [blame] | 537 | } else |
| 538 | addScopeRangeList(Die, std::move(Ranges)); |
| 539 | } |
| 540 | |
| 541 | void DwarfCompileUnit::attachRangesOrLowHighPC( |
David Blaikie | de12375 | 2014-10-09 00:21:42 +0000 | [diff] [blame] | 542 | DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) { |
David Blaikie | 5b02a19 | 2014-11-03 23:10:59 +0000 | [diff] [blame] | 543 | SmallVector<RangeSpan, 2> List; |
| 544 | List.reserve(Ranges.size()); |
| 545 | for (const InsnRange &R : Ranges) |
David Blaikie | b677cb8d | 2019-10-02 22:27:24 +0000 | [diff] [blame] | 546 | List.push_back( |
| 547 | {DD->getLabelBeforeInsn(R.first), DD->getLabelAfterInsn(R.second)}); |
David Blaikie | 5b02a19 | 2014-11-03 23:10:59 +0000 | [diff] [blame] | 548 | attachRangesOrLowHighPC(Die, std::move(List)); |
David Blaikie | de12375 | 2014-10-09 00:21:42 +0000 | [diff] [blame] | 549 | } |
| 550 | |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 551 | // This scope represents inlined body of a function. Construct DIE to |
| 552 | // represent this concrete inlined copy of the function. |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 553 | DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) { |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 554 | assert(Scope->getScopeNode()); |
Duncan P. N. Exon Smith | be9e4fe | 2015-04-20 18:32:29 +0000 | [diff] [blame] | 555 | auto *DS = Scope->getScopeNode(); |
| 556 | auto *InlinedSP = getDISubprogram(DS); |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 557 | // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram |
| 558 | // was inlined from another compile unit. |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 559 | DIE *OriginDIE = getAbstractSPDies()[InlinedSP]; |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 560 | assert(OriginDIE && "Unable to find original DIE for an inlined subprogram."); |
| 561 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 562 | auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine); |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 563 | addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE); |
| 564 | |
| 565 | attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); |
| 566 | |
| 567 | // Add the call site information to the DIE. |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 568 | const DILocation *IA = Scope->getInlinedAt(); |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 569 | addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None, |
Paul Robinson | 612e89d | 2018-01-12 19:17:50 +0000 | [diff] [blame] | 570 | getOrCreateSourceID(IA->getFile())); |
Duncan P. N. Exon Smith | b7e221b | 2015-04-14 01:35:55 +0000 | [diff] [blame] | 571 | addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine()); |
David Blaikie | 40580d3 | 2019-07-16 21:15:19 +0000 | [diff] [blame] | 572 | if (IA->getColumn()) |
| 573 | addUInt(*ScopeDIE, dwarf::DW_AT_call_column, None, IA->getColumn()); |
Dehao Chen | 6e0c844 | 2016-10-07 15:21:31 +0000 | [diff] [blame] | 574 | if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4) |
Dehao Chen | 5451135 | 2015-11-11 18:09:47 +0000 | [diff] [blame] | 575 | addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None, |
| 576 | IA->getDiscriminator()); |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 577 | |
| 578 | // Add name to the name table, we do this here because we're guaranteed |
| 579 | // to have concrete versions of our DW_TAG_inlined_subprogram nodes. |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 580 | DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE); |
David Blaikie | 01b48a8 | 2014-10-09 16:50:53 +0000 | [diff] [blame] | 581 | |
| 582 | return ScopeDIE; |
| 583 | } |
| 584 | |
David Blaikie | 0fbf8bd | 2014-10-09 17:08:42 +0000 | [diff] [blame] | 585 | // Construct new DW_TAG_lexical_block for this scope and attach |
| 586 | // DW_AT_low_pc/DW_AT_high_pc labels. |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 587 | DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) { |
David Blaikie | 0fbf8bd | 2014-10-09 17:08:42 +0000 | [diff] [blame] | 588 | if (DD->isLexicalScopeDIENull(Scope)) |
| 589 | return nullptr; |
| 590 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 591 | auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block); |
David Blaikie | 0fbf8bd | 2014-10-09 17:08:42 +0000 | [diff] [blame] | 592 | if (Scope->isAbstractScope()) |
| 593 | return ScopeDIE; |
| 594 | |
| 595 | attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); |
| 596 | |
| 597 | return ScopeDIE; |
| 598 | } |
| 599 | |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 600 | /// constructVariableDIE - Construct a DIE for the given DbgVariable. |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 601 | DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) { |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 602 | auto D = constructVariableDIEImpl(DV, Abstract); |
| 603 | DV.setDIE(*D); |
| 604 | return D; |
| 605 | } |
| 606 | |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 607 | DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL, |
| 608 | const LexicalScope &Scope) { |
| 609 | auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag()); |
| 610 | insertDIE(DL.getLabel(), LabelDie); |
| 611 | DL.setDIE(*LabelDie); |
| 612 | |
| 613 | if (Scope.isAbstractScope()) |
| 614 | applyLabelAttributes(DL, *LabelDie); |
| 615 | |
| 616 | return LabelDie; |
| 617 | } |
| 618 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 619 | DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV, |
| 620 | bool Abstract) { |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 621 | // Define variable debug information entry. |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 622 | auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag()); |
Sander de Smalen | dc00bec | 2018-01-24 13:35:54 +0000 | [diff] [blame] | 623 | insertDIE(DV.getVariable(), VariableDie); |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 624 | |
| 625 | if (Abstract) { |
| 626 | applyVariableAttributes(DV, *VariableDie); |
| 627 | return VariableDie; |
| 628 | } |
| 629 | |
| 630 | // Add variable address. |
| 631 | |
Duncan P. N. Exon Smith | 364a300 | 2015-04-17 21:34:47 +0000 | [diff] [blame] | 632 | unsigned Offset = DV.getDebugLocListIndex(); |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 633 | if (Offset != ~0U) { |
| 634 | addLocationList(*VariableDie, dwarf::DW_AT_location, Offset); |
Evgenii Stepanov | dabd262 | 2019-11-25 17:47:30 -0800 | [diff] [blame] | 635 | auto TagOffset = DV.getDebugLocListTagOffset(); |
| 636 | if (TagOffset) |
| 637 | addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, |
| 638 | *TagOffset); |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 639 | return VariableDie; |
| 640 | } |
| 641 | |
Nikola Prica | abc1dff | 2019-06-10 08:41:06 +0000 | [diff] [blame] | 642 | // Check if variable has a single location description. |
| 643 | if (auto *DVal = DV.getValueLoc()) { |
| 644 | if (DVal->isLocation()) |
| 645 | addVariableAddress(DV, *VariableDie, DVal->getLoc()); |
| 646 | else if (DVal->isInt()) { |
Adrian Prantl | 3b89e66 | 2016-02-17 22:20:08 +0000 | [diff] [blame] | 647 | auto *Expr = DV.getSingleExpression(); |
| 648 | if (Expr && Expr->getNumElements()) { |
| 649 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
| 650 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); |
| 651 | // If there is an expression, emit raw unsigned bytes. |
Adrian Prantl | 8fafb8d | 2016-12-09 20:43:40 +0000 | [diff] [blame] | 652 | DwarfExpr.addFragmentOffset(Expr); |
Nikola Prica | abc1dff | 2019-06-10 08:41:06 +0000 | [diff] [blame] | 653 | DwarfExpr.addUnsignedConstant(DVal->getInt()); |
Adrian Prantl | a63b8e8 | 2017-03-16 17:42:45 +0000 | [diff] [blame] | 654 | DwarfExpr.addExpression(Expr); |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 655 | addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); |
Evgenii Stepanov | dabd262 | 2019-11-25 17:47:30 -0800 | [diff] [blame] | 656 | if (DwarfExpr.TagOffset) |
| 657 | addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, |
| 658 | dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); |
| 659 | |
Adrian Prantl | 3b89e66 | 2016-02-17 22:20:08 +0000 | [diff] [blame] | 660 | } else |
Nikola Prica | abc1dff | 2019-06-10 08:41:06 +0000 | [diff] [blame] | 661 | addConstantValue(*VariableDie, DVal->getInt(), DV.getType()); |
| 662 | } else if (DVal->isConstantFP()) { |
| 663 | addConstantFPValue(*VariableDie, DVal->getConstantFP()); |
| 664 | } else if (DVal->isConstantInt()) { |
| 665 | addConstantValue(*VariableDie, DVal->getConstantInt(), DV.getType()); |
| 666 | } |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 667 | return VariableDie; |
| 668 | } |
| 669 | |
| 670 | // .. else use frame index. |
Adrian Prantl | 67c2442 | 2017-02-17 19:42:32 +0000 | [diff] [blame] | 671 | if (!DV.hasFrameIndexExprs()) |
Adrian Prantl | ca7e470 | 2015-02-10 23:18:28 +0000 | [diff] [blame] | 672 | return VariableDie; |
| 673 | |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 674 | Optional<unsigned> NVPTXAddressSpace; |
Duncan P. N. Exon Smith | e7e1d0c | 2015-05-27 22:14:58 +0000 | [diff] [blame] | 675 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
Adrian Prantl | ca7e470 | 2015-02-10 23:18:28 +0000 | [diff] [blame] | 676 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); |
Adrian Prantl | 67c2442 | 2017-02-17 19:42:32 +0000 | [diff] [blame] | 677 | for (auto &Fragment : DV.getFrameIndexExprs()) { |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 678 | unsigned FrameReg = 0; |
Adrian Prantl | 6825fb6 | 2017-04-18 01:21:53 +0000 | [diff] [blame] | 679 | const DIExpression *Expr = Fragment.Expr; |
Eric Christopher | d4e723f | 2015-02-20 22:36:11 +0000 | [diff] [blame] | 680 | const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); |
Adrian Prantl | 67c2442 | 2017-02-17 19:42:32 +0000 | [diff] [blame] | 681 | int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg); |
Adrian Prantl | 6825fb6 | 2017-04-18 01:21:53 +0000 | [diff] [blame] | 682 | DwarfExpr.addFragmentOffset(Expr); |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 683 | SmallVector<uint64_t, 8> Ops; |
Bjorn Pettersson | 2b698a1 | 2019-09-07 11:40:10 +0000 | [diff] [blame] | 684 | DIExpression::appendOffset(Ops, Offset); |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 685 | // According to |
| 686 | // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf |
| 687 | // cuda-gdb requires DW_AT_address_class for all variables to be able to |
| 688 | // correctly interpret address space of the variable address. |
| 689 | // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef |
| 690 | // sequence for the NVPTX + gdb target. |
| 691 | unsigned LocalNVPTXAddressSpace; |
| 692 | if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { |
| 693 | const DIExpression *NewExpr = |
| 694 | DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace); |
| 695 | if (NewExpr != Expr) { |
| 696 | Expr = NewExpr; |
| 697 | NVPTXAddressSpace = LocalNVPTXAddressSpace; |
| 698 | } |
| 699 | } |
| 700 | if (Expr) |
| 701 | Ops.append(Expr->elements_begin(), Expr->elements_end()); |
Adrian Prantl | 6825fb6 | 2017-04-18 01:21:53 +0000 | [diff] [blame] | 702 | DIExpressionCursor Cursor(Ops); |
Adrian Prantl | c12cee3 | 2017-04-19 23:42:25 +0000 | [diff] [blame] | 703 | DwarfExpr.setMemoryLocationKind(); |
Alexey Bataev | 4dd7558 | 2018-07-26 16:29:52 +0000 | [diff] [blame] | 704 | if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol()) |
| 705 | addOpAddress(*Loc, FrameSymbol); |
| 706 | else |
| 707 | DwarfExpr.addMachineRegExpression( |
| 708 | *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg); |
Adrian Prantl | 6825fb6 | 2017-04-18 01:21:53 +0000 | [diff] [blame] | 709 | DwarfExpr.addExpression(std::move(Cursor)); |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 710 | } |
Alexey Bataev | f3a9150 | 2019-02-05 19:33:47 +0000 | [diff] [blame] | 711 | if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { |
| 712 | // According to |
| 713 | // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf |
| 714 | // cuda-gdb requires DW_AT_address_class for all variables to be able to |
| 715 | // correctly interpret address space of the variable address. |
| 716 | const unsigned NVPTX_ADDR_local_space = 6; |
| 717 | addUInt(*VariableDie, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1, |
| 718 | NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_local_space); |
| 719 | } |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 720 | addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); |
Peter Collingbourne | fb9ce10 | 2019-06-17 23:39:41 +0000 | [diff] [blame] | 721 | if (DwarfExpr.TagOffset) |
| 722 | addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, |
| 723 | *DwarfExpr.TagOffset); |
David Blaikie | ee7df55 | 2014-10-09 17:56:36 +0000 | [diff] [blame] | 724 | |
| 725 | return VariableDie; |
| 726 | } |
| 727 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 728 | DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, |
| 729 | const LexicalScope &Scope, |
| 730 | DIE *&ObjectPointer) { |
David Blaikie | 4a1a44e | 2014-10-09 17:56:39 +0000 | [diff] [blame] | 731 | auto Var = constructVariableDIE(DV, Scope.isAbstractScope()); |
| 732 | if (DV.isObjectPointer()) |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 733 | ObjectPointer = Var; |
David Blaikie | 4a1a44e | 2014-10-09 17:56:39 +0000 | [diff] [blame] | 734 | return Var; |
| 735 | } |
| 736 | |
Adrian Prantl | 03dd6f5 | 2018-02-08 23:21:15 +0000 | [diff] [blame] | 737 | /// Return all DIVariables that appear in count: expressions. |
| 738 | static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) { |
| 739 | SmallVector<const DIVariable *, 2> Result; |
| 740 | auto *Array = dyn_cast<DICompositeType>(Var->getType()); |
Adrian Prantl | c929f7a | 2018-02-06 22:17:45 +0000 | [diff] [blame] | 741 | if (!Array || Array->getTag() != dwarf::DW_TAG_array_type) |
Adrian Prantl | 03dd6f5 | 2018-02-08 23:21:15 +0000 | [diff] [blame] | 742 | return Result; |
| 743 | for (auto *El : Array->getElements()) { |
Adrian Prantl | c929f7a | 2018-02-06 22:17:45 +0000 | [diff] [blame] | 744 | if (auto *Subrange = dyn_cast<DISubrange>(El)) { |
| 745 | auto Count = Subrange->getCount(); |
Adrian Prantl | 03dd6f5 | 2018-02-08 23:21:15 +0000 | [diff] [blame] | 746 | if (auto *Dependency = Count.dyn_cast<DIVariable *>()) |
| 747 | Result.push_back(Dependency); |
Adrian Prantl | c929f7a | 2018-02-06 22:17:45 +0000 | [diff] [blame] | 748 | } |
Adrian Prantl | 03dd6f5 | 2018-02-08 23:21:15 +0000 | [diff] [blame] | 749 | } |
| 750 | return Result; |
Adrian Prantl | c929f7a | 2018-02-06 22:17:45 +0000 | [diff] [blame] | 751 | } |
| 752 | |
| 753 | /// Sort local variables so that variables appearing inside of helper |
| 754 | /// expressions come first. |
Adrian Prantl | 03dd6f5 | 2018-02-08 23:21:15 +0000 | [diff] [blame] | 755 | static SmallVector<DbgVariable *, 8> |
| 756 | sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) { |
| 757 | SmallVector<DbgVariable *, 8> Result; |
| 758 | SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList; |
| 759 | // Map back from a DIVariable to its containing DbgVariable. |
| 760 | SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar; |
| 761 | // Set of DbgVariables in Result. |
| 762 | SmallDenseSet<DbgVariable *, 8> Visited; |
| 763 | // For cycle detection. |
| 764 | SmallDenseSet<DbgVariable *, 8> Visiting; |
| 765 | |
| 766 | // Initialize the worklist and the DIVariable lookup table. |
| 767 | for (auto Var : reverse(Input)) { |
| 768 | DbgVar.insert({Var->getVariable(), Var}); |
| 769 | WorkList.push_back({Var, 0}); |
| 770 | } |
| 771 | |
| 772 | // Perform a stable topological sort by doing a DFS. |
| 773 | while (!WorkList.empty()) { |
| 774 | auto Item = WorkList.back(); |
| 775 | DbgVariable *Var = Item.getPointer(); |
| 776 | bool visitedAllDependencies = Item.getInt(); |
| 777 | WorkList.pop_back(); |
| 778 | |
| 779 | // Dependency is in a different lexical scope or a global. |
| 780 | if (!Var) |
| 781 | continue; |
| 782 | |
| 783 | // Already handled. |
| 784 | if (Visited.count(Var)) |
| 785 | continue; |
| 786 | |
| 787 | // Add to Result if all dependencies are visited. |
| 788 | if (visitedAllDependencies) { |
| 789 | Visited.insert(Var); |
| 790 | Result.push_back(Var); |
| 791 | continue; |
| 792 | } |
| 793 | |
| 794 | // Detect cycles. |
| 795 | auto Res = Visiting.insert(Var); |
| 796 | if (!Res.second) { |
| 797 | assert(false && "dependency cycle in local variables"); |
| 798 | return Result; |
| 799 | } |
| 800 | |
| 801 | // Push dependencies and this node onto the worklist, so that this node is |
| 802 | // visited again after all of its dependencies are handled. |
| 803 | WorkList.push_back({Var, 1}); |
| 804 | for (auto *Dependency : dependencies(Var)) { |
| 805 | auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency); |
| 806 | WorkList.push_back({DbgVar[Dep], 0}); |
| 807 | } |
| 808 | } |
| 809 | return Result; |
Adrian Prantl | c929f7a | 2018-02-06 22:17:45 +0000 | [diff] [blame] | 810 | } |
| 811 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 812 | DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope, |
| 813 | SmallVectorImpl<DIE *> &Children, |
David Blaikie | 2195e13 | 2017-07-27 00:06:53 +0000 | [diff] [blame] | 814 | bool *HasNonScopeChildren) { |
| 815 | assert(Children.empty()); |
David Blaikie | 8b2fdb8 | 2014-10-09 18:24:28 +0000 | [diff] [blame] | 816 | DIE *ObjectPointer = nullptr; |
| 817 | |
Adrian Prantl | c929f7a | 2018-02-06 22:17:45 +0000 | [diff] [blame] | 818 | // Emit function arguments (order is significant). |
| 819 | auto Vars = DU->getScopeVariables().lookup(Scope); |
| 820 | for (auto &DV : Vars.Args) |
| 821 | Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer)); |
| 822 | |
| 823 | // Emit local variables. |
Adrian Prantl | 03dd6f5 | 2018-02-08 23:21:15 +0000 | [diff] [blame] | 824 | auto Locals = sortLocalVars(Vars.Locals); |
| 825 | for (DbgVariable *DV : Locals) |
David Blaikie | 8b2fdb8 | 2014-10-09 18:24:28 +0000 | [diff] [blame] | 826 | Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer)); |
| 827 | |
David Blaikie | 2195e13 | 2017-07-27 00:06:53 +0000 | [diff] [blame] | 828 | // Skip imported directives in gmlt-like data. |
| 829 | if (!includeMinimalInlineScopes()) { |
| 830 | // There is no need to emit empty lexical block DIE. |
| 831 | for (const auto *IE : ImportedEntities[Scope->getScopeNode()]) |
| 832 | Children.push_back( |
| 833 | constructImportedEntityDIE(cast<DIImportedEntity>(IE))); |
| 834 | } |
| 835 | |
| 836 | if (HasNonScopeChildren) |
| 837 | *HasNonScopeChildren = !Children.empty(); |
David Blaikie | 8b2fdb8 | 2014-10-09 18:24:28 +0000 | [diff] [blame] | 838 | |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 839 | for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope)) |
| 840 | Children.push_back(constructLabelDIE(*DL, *Scope)); |
| 841 | |
David Blaikie | 8b2fdb8 | 2014-10-09 18:24:28 +0000 | [diff] [blame] | 842 | for (LexicalScope *LS : Scope->getChildren()) |
| 843 | constructScopeDIE(LS, Children); |
| 844 | |
David Blaikie | 8b2fdb8 | 2014-10-09 18:24:28 +0000 | [diff] [blame] | 845 | return ObjectPointer; |
| 846 | } |
| 847 | |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 848 | DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, |
| 849 | LexicalScope *Scope) { |
David Blaikie | 1d07234 | 2014-10-09 20:21:36 +0000 | [diff] [blame] | 850 | DIE &ScopeDIE = updateSubprogramScopeDIE(Sub); |
| 851 | |
David Blaikie | 3e3eb33 | 2016-12-15 23:17:52 +0000 | [diff] [blame] | 852 | if (Scope) { |
| 853 | assert(!Scope->getInlinedAt()); |
| 854 | assert(!Scope->isAbstractScope()); |
| 855 | // Collect lexical scope children first. |
| 856 | // ObjectPointer might be a local (non-argument) local variable if it's a |
| 857 | // block's synthetic this pointer. |
| 858 | if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE)) |
| 859 | addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer); |
| 860 | } |
| 861 | |
David Blaikie | 1d07234 | 2014-10-09 20:21:36 +0000 | [diff] [blame] | 862 | // If this is a variadic function, add an unspecified parameter. |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 863 | DITypeRefArray FnArgs = Sub->getType()->getTypeArray(); |
David Blaikie | 1dd573d | 2014-10-23 22:27:50 +0000 | [diff] [blame] | 864 | |
David Blaikie | 1d07234 | 2014-10-09 20:21:36 +0000 | [diff] [blame] | 865 | // If we have a single element of null, it is a function that returns void. |
| 866 | // If we have more than one elements and the last one is null, it is a |
| 867 | // variadic function. |
Duncan P. N. Exon Smith | 000fa2c | 2015-04-07 04:14:33 +0000 | [diff] [blame] | 868 | if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] && |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 869 | !includeMinimalInlineScopes()) |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 870 | ScopeDIE.addChild( |
| 871 | DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters)); |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 872 | |
| 873 | return ScopeDIE; |
David Blaikie | 1d07234 | 2014-10-09 20:21:36 +0000 | [diff] [blame] | 874 | } |
| 875 | |
David Blaikie | 78b65b6 | 2014-10-09 20:26:15 +0000 | [diff] [blame] | 876 | DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope, |
| 877 | DIE &ScopeDIE) { |
| 878 | // We create children when the scope DIE is not null. |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 879 | SmallVector<DIE *, 8> Children; |
David Blaikie | 78b65b6 | 2014-10-09 20:26:15 +0000 | [diff] [blame] | 880 | DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children); |
| 881 | |
| 882 | // Add children |
| 883 | for (auto &I : Children) |
| 884 | ScopeDIE.addChild(std::move(I)); |
| 885 | |
| 886 | return ObjectPointer; |
| 887 | } |
| 888 | |
Dehao Chen | 5451135 | 2015-11-11 18:09:47 +0000 | [diff] [blame] | 889 | void DwarfCompileUnit::constructAbstractSubprogramScopeDIE( |
| 890 | LexicalScope *Scope) { |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 891 | DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()]; |
David Blaikie | 49be5b3 | 2014-10-31 21:57:02 +0000 | [diff] [blame] | 892 | if (AbsDef) |
| 893 | return; |
| 894 | |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 895 | auto *SP = cast<DISubprogram>(Scope->getScopeNode()); |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 896 | |
| 897 | DIE *ContextDIE; |
Jonas Devlieghere | 294e689 | 2017-11-15 10:57:05 +0000 | [diff] [blame] | 898 | DwarfCompileUnit *ContextCU = this; |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 899 | |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 900 | if (includeMinimalInlineScopes()) |
| 901 | ContextDIE = &getUnitDie(); |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 902 | // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with |
Duncan P. N. Exon Smith | 7c60f20 | 2015-04-18 00:35:36 +0000 | [diff] [blame] | 903 | // the important distinction that the debug node is not associated with the |
| 904 | // DIE (since the debug node will be associated with the concrete DIE, if |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 905 | // any). It could be refactored to some common utility function. |
Duncan P. N. Exon Smith | 537b4a8 | 2015-04-14 03:40:37 +0000 | [diff] [blame] | 906 | else if (auto *SPDecl = SP->getDeclaration()) { |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 907 | ContextDIE = &getUnitDie(); |
| 908 | getOrCreateSubprogramDIE(SPDecl); |
Jonas Devlieghere | 294e689 | 2017-11-15 10:57:05 +0000 | [diff] [blame] | 909 | } else { |
Fangrui Song | da82ce9 | 2019-05-07 02:06:37 +0000 | [diff] [blame] | 910 | ContextDIE = getOrCreateContextDIE(SP->getScope()); |
Jonas Devlieghere | 294e689 | 2017-11-15 10:57:05 +0000 | [diff] [blame] | 911 | // The scope may be shared with a subprogram that has already been |
| 912 | // constructed in another CU, in which case we need to construct this |
| 913 | // subprogram in the same CU. |
| 914 | ContextCU = DD->lookupCU(ContextDIE->getUnitDie()); |
| 915 | } |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 916 | |
Duncan P. N. Exon Smith | 7c60f20 | 2015-04-18 00:35:36 +0000 | [diff] [blame] | 917 | // Passing null as the associated node because the abstract definition |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 918 | // shouldn't be found by lookup. |
Jonas Devlieghere | 294e689 | 2017-11-15 10:57:05 +0000 | [diff] [blame] | 919 | AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr); |
| 920 | ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef); |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 921 | |
Jonas Devlieghere | 294e689 | 2017-11-15 10:57:05 +0000 | [diff] [blame] | 922 | if (!ContextCU->includeMinimalInlineScopes()) |
| 923 | ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined); |
| 924 | if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef)) |
| 925 | ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer); |
David Blaikie | 58410f2 | 2014-10-10 06:39:26 +0000 | [diff] [blame] | 926 | } |
| 927 | |
Vedant Kumar | 533dd02 | 2019-08-26 20:53:12 +0000 | [diff] [blame] | 928 | /// Whether to use the GNU analog for a DWARF5 tag, attribute, or location atom. |
| 929 | static bool useGNUAnalogForDwarf5Feature(DwarfDebug *DD) { |
| 930 | return DD->getDwarfVersion() == 4 && DD->tuneForGDB(); |
| 931 | } |
| 932 | |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 933 | dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const { |
Vedant Kumar | 533dd02 | 2019-08-26 20:53:12 +0000 | [diff] [blame] | 934 | if (!useGNUAnalogForDwarf5Feature(DD)) |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 935 | return Tag; |
| 936 | switch (Tag) { |
| 937 | case dwarf::DW_TAG_call_site: |
| 938 | return dwarf::DW_TAG_GNU_call_site; |
| 939 | case dwarf::DW_TAG_call_site_parameter: |
| 940 | return dwarf::DW_TAG_GNU_call_site_parameter; |
| 941 | default: |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 942 | llvm_unreachable("DWARF5 tag with no GNU analog"); |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 943 | } |
| 944 | } |
| 945 | |
| 946 | dwarf::Attribute |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 947 | DwarfCompileUnit::getDwarf5OrGNUAttr(dwarf::Attribute Attr) const { |
Vedant Kumar | 533dd02 | 2019-08-26 20:53:12 +0000 | [diff] [blame] | 948 | if (!useGNUAnalogForDwarf5Feature(DD)) |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 949 | return Attr; |
| 950 | switch (Attr) { |
| 951 | case dwarf::DW_AT_call_all_calls: |
| 952 | return dwarf::DW_AT_GNU_all_call_sites; |
| 953 | case dwarf::DW_AT_call_target: |
| 954 | return dwarf::DW_AT_GNU_call_site_target; |
| 955 | case dwarf::DW_AT_call_origin: |
| 956 | return dwarf::DW_AT_abstract_origin; |
Vedant Kumar | 4346450 | 2020-01-15 14:15:45 -0800 | [diff] [blame] | 957 | case dwarf::DW_AT_call_return_pc: |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 958 | return dwarf::DW_AT_low_pc; |
| 959 | case dwarf::DW_AT_call_value: |
| 960 | return dwarf::DW_AT_GNU_call_site_value; |
| 961 | case dwarf::DW_AT_call_tail_call: |
| 962 | return dwarf::DW_AT_GNU_tail_call; |
| 963 | default: |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 964 | llvm_unreachable("DWARF5 attribute with no GNU analog"); |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 965 | } |
| 966 | } |
| 967 | |
Vedant Kumar | 533dd02 | 2019-08-26 20:53:12 +0000 | [diff] [blame] | 968 | dwarf::LocationAtom |
| 969 | DwarfCompileUnit::getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const { |
| 970 | if (!useGNUAnalogForDwarf5Feature(DD)) |
| 971 | return Loc; |
| 972 | switch (Loc) { |
| 973 | case dwarf::DW_OP_entry_value: |
| 974 | return dwarf::DW_OP_GNU_entry_value; |
| 975 | default: |
| 976 | llvm_unreachable("DWARF5 location atom with no GNU analog"); |
| 977 | } |
| 978 | } |
| 979 | |
Vedant Kumar | f012055 | 2020-01-09 18:00:33 -0800 | [diff] [blame] | 980 | DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE, |
Vedant Kumar | e08f205 | 2020-01-25 12:52:47 -0800 | [diff] [blame] | 981 | DIE *CalleeDIE, |
Vedant Kumar | f012055 | 2020-01-09 18:00:33 -0800 | [diff] [blame] | 982 | bool IsTail, |
| 983 | const MCSymbol *PCAddr, |
| 984 | unsigned CallReg) { |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 985 | // Insert a call site entry DIE within ScopeDIE. |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 986 | DIE &CallSiteDIE = createAndAddDIE(getDwarf5OrGNUTag(dwarf::DW_TAG_call_site), |
| 987 | ScopeDIE, nullptr); |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 988 | |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 989 | if (CallReg) { |
| 990 | // Indirect call. |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 991 | addAddress(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_target), |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 992 | MachineLocation(CallReg)); |
Djordje Todorovic | 0739ccd | 2019-07-12 09:45:12 +0000 | [diff] [blame] | 993 | } else { |
Vedant Kumar | e08f205 | 2020-01-25 12:52:47 -0800 | [diff] [blame] | 994 | assert(CalleeDIE && "No DIE for call site entry origin"); |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 995 | addDIEEntry(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_origin), |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 996 | *CalleeDIE); |
| 997 | } |
| 998 | |
| 999 | if (IsTail) |
| 1000 | // Attach DW_AT_call_tail_call to tail calls for standards compliance. |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 1001 | addFlag(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_tail_call)); |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 1002 | |
| 1003 | // Attach the return PC to allow the debugger to disambiguate call paths |
| 1004 | // from one function to another. |
Vedant Kumar | 4346450 | 2020-01-15 14:15:45 -0800 | [diff] [blame] | 1005 | // |
| 1006 | // The return PC is only really needed when the call /isn't/ a tail call, but |
| 1007 | // for some reason GDB always expects it. |
| 1008 | if (!IsTail || DD->tuneForGDB()) { |
Vedant Kumar | f012055 | 2020-01-09 18:00:33 -0800 | [diff] [blame] | 1009 | assert(PCAddr && "Missing return PC information for a call"); |
Vedant Kumar | 4346450 | 2020-01-15 14:15:45 -0800 | [diff] [blame] | 1010 | addLabelAddress(CallSiteDIE, |
| 1011 | getDwarf5OrGNUAttr(dwarf::DW_AT_call_return_pc), PCAddr); |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 1012 | } |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 1013 | |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 1014 | return CallSiteDIE; |
| 1015 | } |
| 1016 | |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 1017 | void DwarfCompileUnit::constructCallSiteParmEntryDIEs( |
| 1018 | DIE &CallSiteDIE, SmallVector<DbgCallSiteParam, 4> &Params) { |
| 1019 | for (const auto &Param : Params) { |
| 1020 | unsigned Register = Param.getRegister(); |
| 1021 | auto CallSiteDieParam = |
| 1022 | DIE::get(DIEValueAllocator, |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 1023 | getDwarf5OrGNUTag(dwarf::DW_TAG_call_site_parameter)); |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 1024 | insertDIE(CallSiteDieParam); |
| 1025 | addAddress(*CallSiteDieParam, dwarf::DW_AT_location, |
| 1026 | MachineLocation(Register)); |
| 1027 | |
| 1028 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
| 1029 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); |
| 1030 | DwarfExpr.setCallSiteParamValueFlag(); |
| 1031 | |
| 1032 | DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr); |
| 1033 | |
Vedant Kumar | 58a0714 | 2019-08-26 20:53:34 +0000 | [diff] [blame] | 1034 | addBlock(*CallSiteDieParam, getDwarf5OrGNUAttr(dwarf::DW_AT_call_value), |
Djordje Todorovic | b9973f8 | 2019-07-31 16:51:28 +0000 | [diff] [blame] | 1035 | DwarfExpr.finalize()); |
| 1036 | |
| 1037 | CallSiteDIE.addChild(CallSiteDieParam); |
| 1038 | } |
| 1039 | } |
| 1040 | |
Duncan P. N. Exon Smith | 827200c | 2015-06-25 23:52:10 +0000 | [diff] [blame] | 1041 | DIE *DwarfCompileUnit::constructImportedEntityDIE( |
| 1042 | const DIImportedEntity *Module) { |
Amjad Aboud | 72da939 | 2016-04-30 01:44:07 +0000 | [diff] [blame] | 1043 | DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag()); |
| 1044 | insertDIE(Module, IMDie); |
Frederic Riss | 987fe22 | 2014-10-24 21:31:09 +0000 | [diff] [blame] | 1045 | DIE *EntityDie; |
Fangrui Song | da82ce9 | 2019-05-07 02:06:37 +0000 | [diff] [blame] | 1046 | auto *Entity = Module->getEntity(); |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1047 | if (auto *NS = dyn_cast<DINamespace>(Entity)) |
Duncan P. N. Exon Smith | e686f15 | 2015-04-06 23:27:40 +0000 | [diff] [blame] | 1048 | EntityDie = getOrCreateNameSpace(NS); |
Adrian Prantl | 08a388b | 2015-06-30 02:13:04 +0000 | [diff] [blame] | 1049 | else if (auto *M = dyn_cast<DIModule>(Entity)) |
| 1050 | EntityDie = getOrCreateModule(M); |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1051 | else if (auto *SP = dyn_cast<DISubprogram>(Entity)) |
Duncan P. N. Exon Smith | e686f15 | 2015-04-06 23:27:40 +0000 | [diff] [blame] | 1052 | EntityDie = getOrCreateSubprogramDIE(SP); |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1053 | else if (auto *T = dyn_cast<DIType>(Entity)) |
Duncan P. N. Exon Smith | e686f15 | 2015-04-06 23:27:40 +0000 | [diff] [blame] | 1054 | EntityDie = getOrCreateTypeDIE(T); |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1055 | else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity)) |
Adrian Prantl | bceaaa9 | 2016-12-20 02:09:43 +0000 | [diff] [blame] | 1056 | EntityDie = getOrCreateGlobalVariableDIE(GV, {}); |
Frederic Riss | 987fe22 | 2014-10-24 21:31:09 +0000 | [diff] [blame] | 1057 | else |
| 1058 | EntityDie = getDIE(Entity); |
| 1059 | assert(EntityDie); |
Paul Robinson | 612e89d | 2018-01-12 19:17:50 +0000 | [diff] [blame] | 1060 | addSourceLine(*IMDie, Module->getLine(), Module->getFile()); |
Frederic Riss | 987fe22 | 2014-10-24 21:31:09 +0000 | [diff] [blame] | 1061 | addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie); |
Duncan P. N. Exon Smith | de8e427 | 2015-04-14 01:46:44 +0000 | [diff] [blame] | 1062 | StringRef Name = Module->getName(); |
Frederic Riss | 987fe22 | 2014-10-24 21:31:09 +0000 | [diff] [blame] | 1063 | if (!Name.empty()) |
| 1064 | addString(*IMDie, dwarf::DW_AT_name, Name); |
| 1065 | |
| 1066 | return IMDie; |
| 1067 | } |
| 1068 | |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1069 | void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) { |
Amjad Aboud | 72da939 | 2016-04-30 01:44:07 +0000 | [diff] [blame] | 1070 | DIE *D = getDIE(SP); |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 1071 | if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) { |
Amjad Aboud | 72da939 | 2016-04-30 01:44:07 +0000 | [diff] [blame] | 1072 | if (D) |
David Blaikie | 4191cbc | 2014-10-10 06:39:29 +0000 | [diff] [blame] | 1073 | // If this subprogram has an abstract definition, reference that |
| 1074 | addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE); |
Amjad Aboud | 72da939 | 2016-04-30 01:44:07 +0000 | [diff] [blame] | 1075 | } else { |
David Blaikie | 3e3eb33 | 2016-12-15 23:17:52 +0000 | [diff] [blame] | 1076 | assert(D || includeMinimalInlineScopes()); |
Amjad Aboud | 72da939 | 2016-04-30 01:44:07 +0000 | [diff] [blame] | 1077 | if (D) |
David Blaikie | 4191cbc | 2014-10-10 06:39:29 +0000 | [diff] [blame] | 1078 | // And attach the attributes |
| 1079 | applySubprogramAttributesToDefinition(SP, *D); |
| 1080 | } |
| 1081 | } |
| 1082 | |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1083 | void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) { |
| 1084 | DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity()); |
| 1085 | |
| 1086 | auto *Die = Entity->getDIE(); |
| 1087 | /// Label may be used to generate DW_AT_low_pc, so put it outside |
| 1088 | /// if/else block. |
| 1089 | const DbgLabel *Label = nullptr; |
| 1090 | if (AbsEntity && AbsEntity->getDIE()) { |
| 1091 | addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE()); |
| 1092 | Label = dyn_cast<const DbgLabel>(Entity); |
| 1093 | } else { |
| 1094 | if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity)) |
| 1095 | applyVariableAttributes(*Var, *Die); |
| 1096 | else if ((Label = dyn_cast<const DbgLabel>(Entity))) |
| 1097 | applyLabelAttributes(*Label, *Die); |
| 1098 | else |
| 1099 | llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel."); |
| 1100 | } |
| 1101 | |
Hsiangkai Wang | 55321d8 | 2018-09-26 04:19:23 +0000 | [diff] [blame] | 1102 | if (Label) |
| 1103 | if (const auto *Sym = Label->getSymbol()) |
| 1104 | addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym); |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 1105 | } |
| 1106 | |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1107 | DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) { |
| 1108 | auto &AbstractEntities = getAbstractEntities(); |
| 1109 | auto I = AbstractEntities.find(Node); |
| 1110 | if (I != AbstractEntities.end()) |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 1111 | return I->second.get(); |
| 1112 | return nullptr; |
| 1113 | } |
| 1114 | |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1115 | void DwarfCompileUnit::createAbstractEntity(const DINode *Node, |
| 1116 | LexicalScope *Scope) { |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 1117 | assert(Scope && Scope->isAbstractScope()); |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1118 | auto &Entity = getAbstractEntities()[Node]; |
| 1119 | if (isa<const DILocalVariable>(Node)) { |
Jonas Devlieghere | 0eaee54 | 2019-08-15 15:54:37 +0000 | [diff] [blame] | 1120 | Entity = std::make_unique<DbgVariable>( |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1121 | cast<const DILocalVariable>(Node), nullptr /* IA */);; |
| 1122 | DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get())); |
| 1123 | } else if (isa<const DILabel>(Node)) { |
Jonas Devlieghere | 0eaee54 | 2019-08-15 15:54:37 +0000 | [diff] [blame] | 1124 | Entity = std::make_unique<DbgLabel>( |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1125 | cast<const DILabel>(Node), nullptr /* IA */); |
| 1126 | DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get())); |
| 1127 | } |
David Blaikie | 488393f | 2017-05-12 01:13:45 +0000 | [diff] [blame] | 1128 | } |
| 1129 | |
Rafael Espindola | 063d725 | 2015-03-10 16:58:10 +0000 | [diff] [blame] | 1130 | void DwarfCompileUnit::emitHeader(bool UseOffsets) { |
David Blaikie | b6726a9 | 2014-11-02 02:26:24 +0000 | [diff] [blame] | 1131 | // Don't bother labeling the .dwo unit, as its offset isn't used. |
Alexey Bataev | bff3608 | 2018-03-23 13:35:54 +0000 | [diff] [blame] | 1132 | if (!Skeleton && !DD->useSectionsAsReferences()) { |
Rafael Espindola | 9ab0923 | 2015-03-17 20:07:06 +0000 | [diff] [blame] | 1133 | LabelBegin = Asm->createTempSymbol("cu_begin"); |
Lang Hames | 9ff69c8 | 2015-04-24 19:11:51 +0000 | [diff] [blame] | 1134 | Asm->OutStreamer->EmitLabel(LabelBegin); |
Rafael Espindola | 3c31114 | 2015-03-10 03:11:11 +0000 | [diff] [blame] | 1135 | } |
David Blaikie | ae57e66 | 2014-11-01 23:59:23 +0000 | [diff] [blame] | 1136 | |
Paul Robinson | cddd604 | 2017-02-28 20:24:55 +0000 | [diff] [blame] | 1137 | dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile |
| 1138 | : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton |
| 1139 | : dwarf::DW_UT_compile; |
| 1140 | DwarfUnit::emitCommonHeader(UseOffsets, UT); |
Paul Robinson | 543c0e1 | 2018-05-22 17:27:31 +0000 | [diff] [blame] | 1141 | if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile) |
| 1142 | Asm->emitInt64(getDWOId()); |
David Blaikie | ae57e66 | 2014-11-01 23:59:23 +0000 | [diff] [blame] | 1143 | } |
| 1144 | |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1145 | bool DwarfCompileUnit::hasDwarfPubSections() const { |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 1146 | switch (CUNode->getNameTableKind()) { |
| 1147 | case DICompileUnit::DebugNameTableKind::None: |
| 1148 | return false; |
| 1149 | // Opting in to GNU Pubnames/types overrides the default to ensure these are |
| 1150 | // generated for things like Gold's gdb_index generation. |
| 1151 | case DICompileUnit::DebugNameTableKind::GNU: |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1152 | return true; |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 1153 | case DICompileUnit::DebugNameTableKind::Default: |
David Blaikie | 0e03047 | 2018-08-16 23:57:15 +0000 | [diff] [blame] | 1154 | return DD->tuneForGDB() && !includeMinimalInlineScopes() && |
David Blaikie | 2f51176 | 2019-04-23 19:00:45 +0000 | [diff] [blame] | 1155 | !CUNode->isDebugDirectivesOnly() && |
| 1156 | DD->getAccelTableKind() != AccelTableKind::Apple && |
| 1157 | DD->getDwarfVersion() < 5; |
David Blaikie | 66cf14d | 2018-08-16 21:29:55 +0000 | [diff] [blame] | 1158 | } |
Simon Pilgrim | 22d580f2 | 2018-08-17 09:47:52 +0000 | [diff] [blame] | 1159 | llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum"); |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1160 | } |
| 1161 | |
David Blaikie | 192b45c | 2014-11-02 06:16:39 +0000 | [diff] [blame] | 1162 | /// addGlobalName - Add a new global name to the compile unit. |
David Blaikie | a0e3c75 | 2017-02-03 00:44:18 +0000 | [diff] [blame] | 1163 | void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die, |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1164 | const DIScope *Context) { |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1165 | if (!hasDwarfPubSections()) |
David Blaikie | 192b45c | 2014-11-02 06:16:39 +0000 | [diff] [blame] | 1166 | return; |
| 1167 | std::string FullName = getParentContextString(Context) + Name.str(); |
| 1168 | GlobalNames[FullName] = &Die; |
| 1169 | } |
| 1170 | |
David Blaikie | a0e3c75 | 2017-02-03 00:44:18 +0000 | [diff] [blame] | 1171 | void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name, |
| 1172 | const DIScope *Context) { |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1173 | if (!hasDwarfPubSections()) |
David Blaikie | a0e3c75 | 2017-02-03 00:44:18 +0000 | [diff] [blame] | 1174 | return; |
| 1175 | std::string FullName = getParentContextString(Context) + Name.str(); |
| 1176 | // Insert, allowing the entry to remain as-is if it's already present |
| 1177 | // This way the CU-level type DIE is preferred over the "can't describe this |
| 1178 | // type as a unit offset because it's not really in the CU at all, it's only |
| 1179 | // in a type unit" |
| 1180 | GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie())); |
| 1181 | } |
| 1182 | |
David Blaikie | 192b45c | 2014-11-02 06:16:39 +0000 | [diff] [blame] | 1183 | /// Add a new global type to the unit. |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1184 | void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die, |
| 1185 | const DIScope *Context) { |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1186 | if (!hasDwarfPubSections()) |
David Blaikie | 192b45c | 2014-11-02 06:16:39 +0000 | [diff] [blame] | 1187 | return; |
Duncan P. N. Exon Smith | b105564 | 2015-04-16 01:01:28 +0000 | [diff] [blame] | 1188 | std::string FullName = getParentContextString(Context) + Ty->getName().str(); |
David Blaikie | 192b45c | 2014-11-02 06:16:39 +0000 | [diff] [blame] | 1189 | GlobalTypes[FullName] = &Die; |
| 1190 | } |
David Blaikie | ae57e66 | 2014-11-01 23:59:23 +0000 | [diff] [blame] | 1191 | |
David Blaikie | a0e3c75 | 2017-02-03 00:44:18 +0000 | [diff] [blame] | 1192 | void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty, |
| 1193 | const DIScope *Context) { |
Peter Collingbourne | b52e236 | 2017-09-12 21:50:41 +0000 | [diff] [blame] | 1194 | if (!hasDwarfPubSections()) |
David Blaikie | a0e3c75 | 2017-02-03 00:44:18 +0000 | [diff] [blame] | 1195 | return; |
| 1196 | std::string FullName = getParentContextString(Context) + Ty->getName().str(); |
| 1197 | // Insert, allowing the entry to remain as-is if it's already present |
| 1198 | // This way the CU-level type DIE is preferred over the "can't describe this |
| 1199 | // type as a unit offset because it's not really in the CU at all, it's only |
| 1200 | // in a type unit" |
| 1201 | GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie())); |
| 1202 | } |
| 1203 | |
David Blaikie | 7d48be2 | 2014-11-02 06:37:23 +0000 | [diff] [blame] | 1204 | void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die, |
| 1205 | MachineLocation Location) { |
Duncan P. N. Exon Smith | e6cc531 | 2015-06-21 16:50:43 +0000 | [diff] [blame] | 1206 | if (DV.hasComplexAddress()) |
David Blaikie | 7d48be2 | 2014-11-02 06:37:23 +0000 | [diff] [blame] | 1207 | addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); |
David Blaikie | 7d48be2 | 2014-11-02 06:37:23 +0000 | [diff] [blame] | 1208 | else |
Adrian Prantl | 5883af3 | 2015-01-19 17:57:29 +0000 | [diff] [blame] | 1209 | addAddress(Die, dwarf::DW_AT_location, Location); |
David Blaikie | 7d48be2 | 2014-11-02 06:37:23 +0000 | [diff] [blame] | 1210 | } |
David Blaikie | f7435ee | 2014-11-02 06:46:40 +0000 | [diff] [blame] | 1211 | |
| 1212 | /// Add an address attribute to a die based on the location provided. |
| 1213 | void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute, |
Adrian Prantl | 5883af3 | 2015-01-19 17:57:29 +0000 | [diff] [blame] | 1214 | const MachineLocation &Location) { |
Duncan P. N. Exon Smith | e7e1d0c | 2015-05-27 22:14:58 +0000 | [diff] [blame] | 1215 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1216 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); |
Adrian Prantl | c12cee3 | 2017-04-19 23:42:25 +0000 | [diff] [blame] | 1217 | if (Location.isIndirect()) |
| 1218 | DwarfExpr.setMemoryLocationKind(); |
David Blaikie | f7435ee | 2014-11-02 06:46:40 +0000 | [diff] [blame] | 1219 | |
Adrian Prantl | 2049c0d | 2017-08-02 15:22:17 +0000 | [diff] [blame] | 1220 | DIExpressionCursor Cursor({}); |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1221 | const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); |
Adrian Prantl | c12cee3 | 2017-04-19 23:42:25 +0000 | [diff] [blame] | 1222 | if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) |
Adrian Prantl | ab255fc | 2014-12-05 01:02:46 +0000 | [diff] [blame] | 1223 | return; |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1224 | DwarfExpr.addExpression(std::move(Cursor)); |
Adrian Prantl | ab255fc | 2014-12-05 01:02:46 +0000 | [diff] [blame] | 1225 | |
David Blaikie | f7435ee | 2014-11-02 06:46:40 +0000 | [diff] [blame] | 1226 | // Now attach the location information to the DIE. |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1227 | addBlock(Die, Attribute, DwarfExpr.finalize()); |
Evgenii Stepanov | dabd262 | 2019-11-25 17:47:30 -0800 | [diff] [blame] | 1228 | |
| 1229 | if (DwarfExpr.TagOffset) |
| 1230 | addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, |
| 1231 | *DwarfExpr.TagOffset); |
David Blaikie | f7435ee | 2014-11-02 06:46:40 +0000 | [diff] [blame] | 1232 | } |
David Blaikie | 77895fb | 2014-11-02 06:58:44 +0000 | [diff] [blame] | 1233 | |
| 1234 | /// Start with the address based on the location provided, and generate the |
| 1235 | /// DWARF information necessary to find the actual variable given the extra |
| 1236 | /// address information encoded in the DbgVariable, starting from the starting |
| 1237 | /// location. Add the DWARF information to the die. |
| 1238 | void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die, |
| 1239 | dwarf::Attribute Attribute, |
| 1240 | const MachineLocation &Location) { |
Duncan P. N. Exon Smith | e7e1d0c | 2015-05-27 22:14:58 +0000 | [diff] [blame] | 1241 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
Adrian Prantl | 7813d9c | 2015-01-14 01:01:30 +0000 | [diff] [blame] | 1242 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1243 | const DIExpression *DIExpr = DV.getSingleExpression(); |
| 1244 | DwarfExpr.addFragmentOffset(DIExpr); |
Adrian Prantl | c12cee3 | 2017-04-19 23:42:25 +0000 | [diff] [blame] | 1245 | if (Location.isIndirect()) |
| 1246 | DwarfExpr.setMemoryLocationKind(); |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1247 | |
Adrian Prantl | 2049c0d | 2017-08-02 15:22:17 +0000 | [diff] [blame] | 1248 | DIExpressionCursor Cursor(DIExpr); |
Djordje Todorovic | 12aca5d | 2019-07-09 08:36:34 +0000 | [diff] [blame] | 1249 | |
| 1250 | if (DIExpr->isEntryValue()) { |
| 1251 | DwarfExpr.setEntryValueFlag(); |
David Stenberg | 1ae2d9a | 2019-10-15 11:31:21 +0000 | [diff] [blame] | 1252 | DwarfExpr.beginEntryValueExpression(Cursor); |
Djordje Todorovic | 12aca5d | 2019-07-09 08:36:34 +0000 | [diff] [blame] | 1253 | } |
| 1254 | |
Peter Collingbourne | 96c9ae6 | 2016-05-20 19:35:17 +0000 | [diff] [blame] | 1255 | const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); |
Adrian Prantl | c12cee3 | 2017-04-19 23:42:25 +0000 | [diff] [blame] | 1256 | if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) |
Adrian Prantl | 54286bd | 2016-11-02 16:12:20 +0000 | [diff] [blame] | 1257 | return; |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1258 | DwarfExpr.addExpression(std::move(Cursor)); |
David Blaikie | 77895fb | 2014-11-02 06:58:44 +0000 | [diff] [blame] | 1259 | |
| 1260 | // Now attach the location information to the DIE. |
Adrian Prantl | 956484b | 2017-03-20 21:35:09 +0000 | [diff] [blame] | 1261 | addBlock(Die, Attribute, DwarfExpr.finalize()); |
Evgenii Stepanov | dabd262 | 2019-11-25 17:47:30 -0800 | [diff] [blame] | 1262 | |
| 1263 | if (DwarfExpr.TagOffset) |
| 1264 | addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, |
| 1265 | *DwarfExpr.TagOffset); |
David Blaikie | 77895fb | 2014-11-02 06:58:44 +0000 | [diff] [blame] | 1266 | } |
David Blaikie | 4bc0881 | 2014-11-02 07:03:19 +0000 | [diff] [blame] | 1267 | |
| 1268 | /// Add a Dwarf loclistptr attribute data and value. |
| 1269 | void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, |
| 1270 | unsigned Index) { |
David Blaikie | 77cfcd7 | 2019-11-12 14:15:37 -0800 | [diff] [blame] | 1271 | dwarf::Form Form = dwarf::DW_FORM_data4; |
| 1272 | if (DD->getDwarfVersion() == 4) |
| 1273 | Form =dwarf::DW_FORM_sec_offset; |
| 1274 | if (DD->getDwarfVersion() >= 5) |
| 1275 | Form =dwarf::DW_FORM_loclistx; |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 1276 | Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index)); |
David Blaikie | 4bc0881 | 2014-11-02 07:03:19 +0000 | [diff] [blame] | 1277 | } |
David Blaikie | 02a6333 | 2014-11-02 07:06:51 +0000 | [diff] [blame] | 1278 | |
David Blaikie | 8c485b5 | 2014-11-02 07:08:12 +0000 | [diff] [blame] | 1279 | void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, |
| 1280 | DIE &VariableDie) { |
David Blaikie | 02a6333 | 2014-11-02 07:06:51 +0000 | [diff] [blame] | 1281 | StringRef Name = Var.getName(); |
| 1282 | if (!Name.empty()) |
| 1283 | addString(VariableDie, dwarf::DW_AT_name, Name); |
Victor Leschuk | 3c98998 | 2016-10-26 11:59:03 +0000 | [diff] [blame] | 1284 | const auto *DIVar = Var.getVariable(); |
| 1285 | if (DIVar) |
| 1286 | if (uint32_t AlignInBytes = DIVar->getAlignInBytes()) |
| 1287 | addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, |
| 1288 | AlignInBytes); |
| 1289 | |
| 1290 | addSourceLine(VariableDie, DIVar); |
David Blaikie | 02a6333 | 2014-11-02 07:06:51 +0000 | [diff] [blame] | 1291 | addType(VariableDie, Var.getType()); |
| 1292 | if (Var.isArtificial()) |
| 1293 | addFlag(VariableDie, dwarf::DW_AT_artificial); |
| 1294 | } |
David Blaikie | 9780208 | 2014-11-02 07:11:55 +0000 | [diff] [blame] | 1295 | |
Hsiangkai Wang | 2532ac8 | 2018-08-17 15:22:04 +0000 | [diff] [blame] | 1296 | void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label, |
| 1297 | DIE &LabelDie) { |
| 1298 | StringRef Name = Label.getName(); |
| 1299 | if (!Name.empty()) |
| 1300 | addString(LabelDie, dwarf::DW_AT_name, Name); |
| 1301 | const auto *DILabel = Label.getLabel(); |
| 1302 | addSourceLine(LabelDie, DILabel); |
| 1303 | } |
| 1304 | |
David Blaikie | 9780208 | 2014-11-02 07:11:55 +0000 | [diff] [blame] | 1305 | /// Add a Dwarf expression attribute data and value. |
| 1306 | void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, |
| 1307 | const MCExpr *Expr) { |
Duncan P. N. Exon Smith | 4fb1f9c | 2015-06-25 23:46:41 +0000 | [diff] [blame] | 1308 | Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr)); |
David Blaikie | 9780208 | 2014-11-02 07:11:55 +0000 | [diff] [blame] | 1309 | } |
David Blaikie | 3363a57 | 2014-11-02 08:09:09 +0000 | [diff] [blame] | 1310 | |
Duncan P. N. Exon Smith | 2fbe135 | 2015-04-20 22:10:08 +0000 | [diff] [blame] | 1311 | void DwarfCompileUnit::applySubprogramAttributesToDefinition( |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 1312 | const DISubprogram *SP, DIE &SPDie) { |
Duncan P. N. Exon Smith | 537b4a8 | 2015-04-14 03:40:37 +0000 | [diff] [blame] | 1313 | auto *SPDecl = SP->getDeclaration(); |
Fangrui Song | da82ce9 | 2019-05-07 02:06:37 +0000 | [diff] [blame] | 1314 | auto *Context = SPDecl ? SPDecl->getScope() : SP->getScope(); |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 1315 | applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes()); |
Duncan P. N. Exon Smith | 537b4a8 | 2015-04-14 03:40:37 +0000 | [diff] [blame] | 1316 | addGlobalName(SP->getName(), SPDie, Context); |
David Blaikie | 3363a57 | 2014-11-02 08:09:09 +0000 | [diff] [blame] | 1317 | } |
David Blaikie | cafd962 | 2014-11-02 08:51:37 +0000 | [diff] [blame] | 1318 | |
| 1319 | bool DwarfCompileUnit::isDwoUnit() const { |
| 1320 | return DD->useSplitDwarf() && Skeleton; |
| 1321 | } |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 1322 | |
David Blaikie | 832c7d9 | 2019-04-24 18:09:44 +0000 | [diff] [blame] | 1323 | void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) { |
| 1324 | constructTypeDIE(D, CTy); |
| 1325 | } |
| 1326 | |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 1327 | bool DwarfCompileUnit::includeMinimalInlineScopes() const { |
Adrian Prantl | b939a25 | 2016-03-31 23:56:58 +0000 | [diff] [blame] | 1328 | return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly || |
David Blaikie | 3a443c2 | 2014-11-04 22:12:25 +0000 | [diff] [blame] | 1329 | (DD->useSplitDwarf() && !Skeleton); |
| 1330 | } |
David Blaikie | 61c127c | 2018-12-14 22:34:03 +0000 | [diff] [blame] | 1331 | |
| 1332 | void DwarfCompileUnit::addAddrTableBase() { |
| 1333 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); |
| 1334 | MCSymbol *Label = DD->getAddressPool().getLabel(); |
| 1335 | addSectionLabel(getUnitDie(), |
| 1336 | getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base |
| 1337 | : dwarf::DW_AT_GNU_addr_base, |
| 1338 | Label, TLOF.getDwarfAddrSection()->getBeginSymbol()); |
| 1339 | } |
Markus Lavin | b86ce21 | 2019-03-19 13:16:28 +0000 | [diff] [blame] | 1340 | |
| 1341 | void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) { |
| 1342 | Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, dwarf::DW_FORM_udata, |
| 1343 | new (DIEValueAllocator) DIEBaseTypeRef(this, Idx)); |
| 1344 | } |
| 1345 | |
| 1346 | void DwarfCompileUnit::createBaseTypeDIEs() { |
| 1347 | // Insert the base_type DIEs directly after the CU so that their offsets will |
| 1348 | // fit in the fixed size ULEB128 used inside the location expressions. |
| 1349 | // Maintain order by iterating backwards and inserting to the front of CU |
| 1350 | // child list. |
| 1351 | for (auto &Btr : reverse(ExprRefedBaseTypes)) { |
| 1352 | DIE &Die = getUnitDie().addChildFront( |
| 1353 | DIE::get(DIEValueAllocator, dwarf::DW_TAG_base_type)); |
| 1354 | SmallString<32> Str; |
| 1355 | addString(Die, dwarf::DW_AT_name, |
| 1356 | Twine(dwarf::AttributeEncodingString(Btr.Encoding) + |
| 1357 | "_" + Twine(Btr.BitSize)).toStringRef(Str)); |
| 1358 | addUInt(Die, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Btr.Encoding); |
| 1359 | addUInt(Die, dwarf::DW_AT_byte_size, None, Btr.BitSize / 8); |
| 1360 | |
| 1361 | Btr.Die = &Die; |
| 1362 | } |
| 1363 | } |