1 //===-- llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp -------*- C++ -*--===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Common functionality for different debug information format backends. 10 // LLVM currently supports DWARF and CodeView. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/CodeGen/DebugHandlerBase.h" 15 #include "llvm/CodeGen/AsmPrinter.h" 16 #include "llvm/CodeGen/MachineFunction.h" 17 #include "llvm/CodeGen/MachineInstr.h" 18 #include "llvm/CodeGen/MachineModuleInfo.h" 19 #include "llvm/CodeGen/TargetSubtargetInfo.h" 20 #include "llvm/IR/DebugInfo.h" 21 #include "llvm/MC/MCStreamer.h" 22 #include "llvm/Support/CommandLine.h" 23 24 using namespace llvm; 25 26 #define DEBUG_TYPE "dwarfdebug" 27 28 /// If true, we drop variable location ranges which exist entirely outside the 29 /// variable's lexical scope instruction ranges. 30 static cl::opt<bool> TrimVarLocs("trim-var-locs", cl::Hidden, cl::init(true)); 31 32 std::optional<DbgVariableLocation> 33 DbgVariableLocation::extractFromMachineInstruction( 34 const MachineInstr &Instruction) { 35 DbgVariableLocation Location; 36 // Variables calculated from multiple locations can't be represented here. 37 if (Instruction.getNumDebugOperands() != 1) 38 return std::nullopt; 39 if (!Instruction.getDebugOperand(0).isReg()) 40 return std::nullopt; 41 Location.Register = Instruction.getDebugOperand(0).getReg(); 42 Location.FragmentInfo.reset(); 43 // We only handle expressions generated by DIExpression::appendOffset, 44 // which doesn't require a full stack machine. 45 int64_t Offset = 0; 46 const DIExpression *DIExpr = Instruction.getDebugExpression(); 47 auto Op = DIExpr->expr_op_begin(); 48 // We can handle a DBG_VALUE_LIST iff it has exactly one location operand that 49 // appears exactly once at the start of the expression. 50 if (Instruction.isDebugValueList()) { 51 if (Instruction.getNumDebugOperands() == 1 && 52 Op->getOp() == dwarf::DW_OP_LLVM_arg) 53 ++Op; 54 else 55 return std::nullopt; 56 } 57 while (Op != DIExpr->expr_op_end()) { 58 switch (Op->getOp()) { 59 case dwarf::DW_OP_constu: { 60 int Value = Op->getArg(0); 61 ++Op; 62 if (Op != DIExpr->expr_op_end()) { 63 switch (Op->getOp()) { 64 case dwarf::DW_OP_minus: 65 Offset -= Value; 66 break; 67 case dwarf::DW_OP_plus: 68 Offset += Value; 69 break; 70 default: 71 continue; 72 } 73 } 74 } break; 75 case dwarf::DW_OP_plus_uconst: 76 Offset += Op->getArg(0); 77 break; 78 case dwarf::DW_OP_LLVM_fragment: 79 Location.FragmentInfo = {Op->getArg(1), Op->getArg(0)}; 80 break; 81 case dwarf::DW_OP_deref: 82 Location.LoadChain.push_back(Offset); 83 Offset = 0; 84 break; 85 default: 86 return std::nullopt; 87 } 88 ++Op; 89 } 90 91 // Do one final implicit DW_OP_deref if this was an indirect DBG_VALUE 92 // instruction. 93 // FIXME: Replace these with DIExpression. 94 if (Instruction.isIndirectDebugValue()) 95 Location.LoadChain.push_back(Offset); 96 97 return Location; 98 } 99 100 DebugHandlerBase::DebugHandlerBase(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {} 101 102 void DebugHandlerBase::beginModule(Module *M) { 103 if (M->debug_compile_units().empty()) 104 Asm = nullptr; 105 } 106 107 // Each LexicalScope has first instruction and last instruction to mark 108 // beginning and end of a scope respectively. Create an inverse map that list 109 // scopes starts (and ends) with an instruction. One instruction may start (or 110 // end) multiple scopes. Ignore scopes that are not reachable. 111 void DebugHandlerBase::identifyScopeMarkers() { 112 SmallVector<LexicalScope *, 4> WorkList; 113 WorkList.push_back(LScopes.getCurrentFunctionScope()); 114 while (!WorkList.empty()) { 115 LexicalScope *S = WorkList.pop_back_val(); 116 117 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren(); 118 if (!Children.empty()) 119 WorkList.append(Children.begin(), Children.end()); 120 121 if (S->isAbstractScope()) 122 continue; 123 124 for (const InsnRange &R : S->getRanges()) { 125 assert(R.first && "InsnRange does not have first instruction!"); 126 assert(R.second && "InsnRange does not have second instruction!"); 127 requestLabelBeforeInsn(R.first); 128 requestLabelAfterInsn(R.second); 129 } 130 } 131 } 132 133 // Return Label preceding the instruction. 134 MCSymbol *DebugHandlerBase::getLabelBeforeInsn(const MachineInstr *MI) { 135 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 136 assert(Label && "Didn't insert label before instruction"); 137 return Label; 138 } 139 140 // Return Label immediately following the instruction. 141 MCSymbol *DebugHandlerBase::getLabelAfterInsn(const MachineInstr *MI) { 142 return LabelsAfterInsn.lookup(MI); 143 } 144 145 /// If this type is derived from a base type then return base type size. 146 uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) { 147 assert(Ty); 148 const DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty); 149 if (!DDTy) 150 return Ty->getSizeInBits(); 151 152 unsigned Tag = DDTy->getTag(); 153 154 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 155 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 156 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type && 157 Tag != dwarf::DW_TAG_immutable_type) 158 return DDTy->getSizeInBits(); 159 160 DIType *BaseType = DDTy->getBaseType(); 161 162 if (!BaseType) 163 return 0; 164 165 // If this is a derived type, go ahead and get the base type, unless it's a 166 // reference then it's just the size of the field. Pointer types have no need 167 // of this since they're a different type of qualification on the type. 168 if (BaseType->getTag() == dwarf::DW_TAG_reference_type || 169 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type) 170 return Ty->getSizeInBits(); 171 172 return getBaseTypeSize(BaseType); 173 } 174 175 bool DebugHandlerBase::isUnsignedDIType(const DIType *Ty) { 176 if (isa<DIStringType>(Ty)) { 177 // Some transformations (e.g. instcombine) may decide to turn a Fortran 178 // character object into an integer, and later ones (e.g. SROA) may 179 // further inject a constant integer in a llvm.dbg.value call to track 180 // the object's value. Here we trust the transformations are doing the 181 // right thing, and treat the constant as unsigned to preserve that value 182 // (i.e. avoid sign extension). 183 return true; 184 } 185 186 if (auto *CTy = dyn_cast<DICompositeType>(Ty)) { 187 if (CTy->getTag() == dwarf::DW_TAG_enumeration_type) { 188 if (!(Ty = CTy->getBaseType())) 189 // FIXME: Enums without a fixed underlying type have unknown signedness 190 // here, leading to incorrectly emitted constants. 191 return false; 192 } else 193 // (Pieces of) aggregate types that get hacked apart by SROA may be 194 // represented by a constant. Encode them as unsigned bytes. 195 return true; 196 } 197 198 if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) { 199 dwarf::Tag T = (dwarf::Tag)Ty->getTag(); 200 // Encode pointer constants as unsigned bytes. This is used at least for 201 // null pointer constant emission. 202 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed 203 // here, but accept them for now due to a bug in SROA producing bogus 204 // dbg.values. 205 if (T == dwarf::DW_TAG_pointer_type || 206 T == dwarf::DW_TAG_ptr_to_member_type || 207 T == dwarf::DW_TAG_reference_type || 208 T == dwarf::DW_TAG_rvalue_reference_type) 209 return true; 210 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || 211 T == dwarf::DW_TAG_volatile_type || 212 T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type || 213 T == dwarf::DW_TAG_immutable_type); 214 assert(DTy->getBaseType() && "Expected valid base type"); 215 return isUnsignedDIType(DTy->getBaseType()); 216 } 217 218 auto *BTy = cast<DIBasicType>(Ty); 219 unsigned Encoding = BTy->getEncoding(); 220 assert((Encoding == dwarf::DW_ATE_unsigned || 221 Encoding == dwarf::DW_ATE_unsigned_char || 222 Encoding == dwarf::DW_ATE_signed || 223 Encoding == dwarf::DW_ATE_signed_char || 224 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || 225 Encoding == dwarf::DW_ATE_boolean || 226 Encoding == dwarf::DW_ATE_complex_float || 227 Encoding == dwarf::DW_ATE_signed_fixed || 228 Encoding == dwarf::DW_ATE_unsigned_fixed || 229 (Ty->getTag() == dwarf::DW_TAG_unspecified_type && 230 Ty->getName() == "decltype(nullptr)")) && 231 "Unsupported encoding"); 232 return Encoding == dwarf::DW_ATE_unsigned || 233 Encoding == dwarf::DW_ATE_unsigned_char || 234 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || 235 Encoding == llvm::dwarf::DW_ATE_unsigned_fixed || 236 Ty->getTag() == dwarf::DW_TAG_unspecified_type; 237 } 238 239 static bool hasDebugInfo(const MachineModuleInfo *MMI, 240 const MachineFunction *MF) { 241 if (!MMI->hasDebugInfo()) 242 return false; 243 auto *SP = MF->getFunction().getSubprogram(); 244 if (!SP) 245 return false; 246 assert(SP->getUnit()); 247 auto EK = SP->getUnit()->getEmissionKind(); 248 if (EK == DICompileUnit::NoDebug) 249 return false; 250 return true; 251 } 252 253 void DebugHandlerBase::beginFunction(const MachineFunction *MF) { 254 PrevInstBB = nullptr; 255 256 if (!Asm || !hasDebugInfo(MMI, MF)) { 257 skippedNonDebugFunction(); 258 return; 259 } 260 261 // Grab the lexical scopes for the function, if we don't have any of those 262 // then we're not going to be able to do anything. 263 LScopes.initialize(*MF); 264 if (LScopes.empty()) { 265 beginFunctionImpl(MF); 266 return; 267 } 268 269 // Make sure that each lexical scope will have a begin/end label. 270 identifyScopeMarkers(); 271 272 // Calculate history for local variables. 273 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!"); 274 assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!"); 275 calculateDbgEntityHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(), 276 DbgValues, DbgLabels); 277 InstOrdering.initialize(*MF); 278 if (TrimVarLocs) 279 DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering); 280 LLVM_DEBUG(DbgValues.dump(MF->getName())); 281 282 // Request labels for the full history. 283 for (const auto &I : DbgValues) { 284 const auto &Entries = I.second; 285 if (Entries.empty()) 286 continue; 287 288 auto IsDescribedByReg = [](const MachineInstr *MI) { 289 return any_of(MI->debug_operands(), 290 [](auto &MO) { return MO.isReg() && MO.getReg(); }); 291 }; 292 293 // The first mention of a function argument gets the CurrentFnBegin label, 294 // so arguments are visible when breaking at function entry. 295 // 296 // We do not change the label for values that are described by registers, 297 // as that could place them above their defining instructions. We should 298 // ideally not change the labels for constant debug values either, since 299 // doing that violates the ranges that are calculated in the history map. 300 // However, we currently do not emit debug values for constant arguments 301 // directly at the start of the function, so this code is still useful. 302 const DILocalVariable *DIVar = 303 Entries.front().getInstr()->getDebugVariable(); 304 if (DIVar->isParameter() && 305 getDISubprogram(DIVar->getScope())->describes(&MF->getFunction())) { 306 if (!IsDescribedByReg(Entries.front().getInstr())) 307 LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin(); 308 if (Entries.front().getInstr()->getDebugExpression()->isFragment()) { 309 // Mark all non-overlapping initial fragments. 310 for (const auto *I = Entries.begin(); I != Entries.end(); ++I) { 311 if (!I->isDbgValue()) 312 continue; 313 const DIExpression *Fragment = I->getInstr()->getDebugExpression(); 314 if (std::any_of(Entries.begin(), I, 315 [&](DbgValueHistoryMap::Entry Pred) { 316 return Pred.isDbgValue() && 317 Fragment->fragmentsOverlap( 318 Pred.getInstr()->getDebugExpression()); 319 })) 320 break; 321 // The code that generates location lists for DWARF assumes that the 322 // entries' start labels are monotonically increasing, and since we 323 // don't change the label for fragments that are described by 324 // registers, we must bail out when encountering such a fragment. 325 if (IsDescribedByReg(I->getInstr())) 326 break; 327 LabelsBeforeInsn[I->getInstr()] = Asm->getFunctionBegin(); 328 } 329 } 330 } 331 332 for (const auto &Entry : Entries) { 333 if (Entry.isDbgValue()) 334 requestLabelBeforeInsn(Entry.getInstr()); 335 else 336 requestLabelAfterInsn(Entry.getInstr()); 337 } 338 } 339 340 // Ensure there is a symbol before DBG_LABEL. 341 for (const auto &I : DbgLabels) { 342 const MachineInstr *MI = I.second; 343 requestLabelBeforeInsn(MI); 344 } 345 346 PrevInstLoc = DebugLoc(); 347 PrevLabel = Asm->getFunctionBegin(); 348 beginFunctionImpl(MF); 349 } 350 351 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) { 352 if (!Asm || !MMI->hasDebugInfo()) 353 return; 354 355 assert(CurMI == nullptr); 356 CurMI = MI; 357 358 // Insert labels where requested. 359 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 360 LabelsBeforeInsn.find(MI); 361 362 // No label needed. 363 if (I == LabelsBeforeInsn.end()) 364 return; 365 366 // Label already assigned. 367 if (I->second) 368 return; 369 370 if (!PrevLabel) { 371 PrevLabel = MMI->getContext().createTempSymbol(); 372 Asm->OutStreamer->emitLabel(PrevLabel); 373 } 374 I->second = PrevLabel; 375 } 376 377 void DebugHandlerBase::endInstruction() { 378 if (!Asm || !MMI->hasDebugInfo()) 379 return; 380 381 assert(CurMI != nullptr); 382 // Don't create a new label after DBG_VALUE and other instructions that don't 383 // generate code. 384 if (!CurMI->isMetaInstruction()) { 385 PrevLabel = nullptr; 386 PrevInstBB = CurMI->getParent(); 387 } 388 389 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 390 LabelsAfterInsn.find(CurMI); 391 392 // No label needed or label already assigned. 393 if (I == LabelsAfterInsn.end() || I->second) { 394 CurMI = nullptr; 395 return; 396 } 397 398 // We need a label after this instruction. With basic block sections, just 399 // use the end symbol of the section if this is the last instruction of the 400 // section. This reduces the need for an additional label and also helps 401 // merging ranges. 402 if (CurMI->getParent()->isEndSection() && CurMI->getNextNode() == nullptr) { 403 PrevLabel = CurMI->getParent()->getEndSymbol(); 404 } else if (!PrevLabel) { 405 PrevLabel = MMI->getContext().createTempSymbol(); 406 Asm->OutStreamer->emitLabel(PrevLabel); 407 } 408 I->second = PrevLabel; 409 CurMI = nullptr; 410 } 411 412 void DebugHandlerBase::endFunction(const MachineFunction *MF) { 413 if (Asm && hasDebugInfo(MMI, MF)) 414 endFunctionImpl(MF); 415 DbgValues.clear(); 416 DbgLabels.clear(); 417 LabelsBeforeInsn.clear(); 418 LabelsAfterInsn.clear(); 419 InstOrdering.clear(); 420 } 421 422 void DebugHandlerBase::beginBasicBlockSection(const MachineBasicBlock &MBB) { 423 EpilogBeginBlock = nullptr; 424 if (!MBB.isEntryBlock()) 425 PrevLabel = MBB.getSymbol(); 426 } 427 428 void DebugHandlerBase::endBasicBlockSection(const MachineBasicBlock &MBB) { 429 PrevLabel = nullptr; 430 } 431