llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

   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           (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
 228            Ty->getName() == "decltype(nullptr)")) &&
 229          "Unsupported encoding");
 230   return Encoding == dwarf::DW_ATE_unsigned ||
 231          Encoding == dwarf::DW_ATE_unsigned_char ||
 232          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 233          Ty->getTag() == dwarf::DW_TAG_unspecified_type;
 234 }
 235
 236 static bool hasDebugInfo(const MachineModuleInfo *MMI,
 237                          const MachineFunction *MF) {
 238   if (!MMI->hasDebugInfo())
 239     return false;
 240   auto *SP = MF->getFunction().getSubprogram();
 241   if (!SP)
 242     return false;
 243   assert(SP->getUnit());
 244   auto EK = SP->getUnit()->getEmissionKind();
 245   if (EK == DICompileUnit::NoDebug)
 246     return false;
 247   return true;
 248 }
 249
 250 void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
 251   PrevInstBB = nullptr;
 252
 253   if (!Asm || !hasDebugInfo(MMI, MF)) {
 254     skippedNonDebugFunction();
 255     return;
 256   }
 257
 258   // Grab the lexical scopes for the function, if we don't have any of those
 259   // then we're not going to be able to do anything.
 260   LScopes.initialize(*MF);
 261   if (LScopes.empty()) {
 262     beginFunctionImpl(MF);
 263     return;
 264   }
 265
 266   // Make sure that each lexical scope will have a begin/end label.
 267   identifyScopeMarkers();
 268
 269   // Calculate history for local variables.
 270   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
 271   assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!");
 272   calculateDbgEntityHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
 273                             DbgValues, DbgLabels);
 274   InstOrdering.initialize(*MF);
 275   if (TrimVarLocs)
 276     DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering);
 277   LLVM_DEBUG(DbgValues.dump(MF->getName()));
 278
 279   // Request labels for the full history.
 280   for (const auto &I : DbgValues) {
 281     const auto &Entries = I.second;
 282     if (Entries.empty())
 283       continue;
 284
 285     auto IsDescribedByReg = [](const MachineInstr *MI) {
 286       return any_of(MI->debug_operands(),
 287                     [](auto &MO) { return MO.isReg() && MO.getReg(); });
 288     };
 289
 290     // The first mention of a function argument gets the CurrentFnBegin label,
 291     // so arguments are visible when breaking at function entry.
 292     //
 293     // We do not change the label for values that are described by registers,
 294     // as that could place them above their defining instructions. We should
 295     // ideally not change the labels for constant debug values either, since
 296     // doing that violates the ranges that are calculated in the history map.
 297     // However, we currently do not emit debug values for constant arguments
 298     // directly at the start of the function, so this code is still useful.
 299     const DILocalVariable *DIVar =
 300         Entries.front().getInstr()->getDebugVariable();
 301     if (DIVar->isParameter() &&
 302         getDISubprogram(DIVar->getScope())->describes(&MF->getFunction())) {
 303       if (!IsDescribedByReg(Entries.front().getInstr()))
 304         LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
 305       if (Entries.front().getInstr()->getDebugExpression()->isFragment()) {
 306         // Mark all non-overlapping initial fragments.
 307         for (const auto *I = Entries.begin(); I != Entries.end(); ++I) {
 308           if (!I->isDbgValue())
 309             continue;
 310           const DIExpression *Fragment = I->getInstr()->getDebugExpression();
 311           if (std::any_of(Entries.begin(), I,
 312                           [&](DbgValueHistoryMap::Entry Pred) {
 313                             return Pred.isDbgValue() &&
 314                                    Fragment->fragmentsOverlap(
 315                                        Pred.getInstr()->getDebugExpression());
 316                           }))
 317             break;
 318           // The code that generates location lists for DWARF assumes that the
 319           // entries' start labels are monotonically increasing, and since we
 320           // don't change the label for fragments that are described by
 321           // registers, we must bail out when encountering such a fragment.
 322           if (IsDescribedByReg(I->getInstr()))
 323             break;
 324           LabelsBeforeInsn[I->getInstr()] = Asm->getFunctionBegin();
 325         }
 326       }
 327     }
 328
 329     for (const auto &Entry : Entries) {
 330       if (Entry.isDbgValue())
 331         requestLabelBeforeInsn(Entry.getInstr());
 332       else
 333         requestLabelAfterInsn(Entry.getInstr());
 334     }
 335   }
 336
 337   // Ensure there is a symbol before DBG_LABEL.
 338   for (const auto &I : DbgLabels) {
 339     const MachineInstr *MI = I.second;
 340     requestLabelBeforeInsn(MI);
 341   }
 342
 343   PrevInstLoc = DebugLoc();
 344   PrevLabel = Asm->getFunctionBegin();
 345   beginFunctionImpl(MF);
 346 }
 347
 348 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
 349   if (!Asm || !MMI->hasDebugInfo())
 350     return;
 351
 352   assert(CurMI == nullptr);
 353   CurMI = MI;
 354
 355   // Insert labels where requested.
 356   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
 357       LabelsBeforeInsn.find(MI);
 358
 359   // No label needed.
 360   if (I == LabelsBeforeInsn.end())
 361     return;
 362
 363   // Label already assigned.
 364   if (I->second)
 365     return;
 366
 367   if (!PrevLabel) {
 368     PrevLabel = MMI->getContext().createTempSymbol();
 369     Asm->OutStreamer->emitLabel(PrevLabel);
 370   }
 371   I->second = PrevLabel;
 372 }
 373
 374 void DebugHandlerBase::endInstruction() {
 375   if (!Asm || !MMI->hasDebugInfo())
 376     return;
 377
 378   assert(CurMI != nullptr);
 379   // Don't create a new label after DBG_VALUE and other instructions that don't
 380   // generate code.
 381   if (!CurMI->isMetaInstruction()) {
 382     PrevLabel = nullptr;
 383     PrevInstBB = CurMI->getParent();
 384   }
 385
 386   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
 387       LabelsAfterInsn.find(CurMI);
 388
 389   // No label needed or label already assigned.
 390   if (I == LabelsAfterInsn.end() || I->second) {
 391     CurMI = nullptr;
 392     return;
 393   }
 394
 395   // We need a label after this instruction.  With basic block sections, just
 396   // use the end symbol of the section if this is the last instruction of the
 397   // section.  This reduces the need for an additional label and also helps
 398   // merging ranges.
 399   if (CurMI->getParent()->isEndSection() && CurMI->getNextNode() == nullptr) {
 400     PrevLabel = CurMI->getParent()->getEndSymbol();
 401   } else if (!PrevLabel) {
 402     PrevLabel = MMI->getContext().createTempSymbol();
 403     Asm->OutStreamer->emitLabel(PrevLabel);
 404   }
 405   I->second = PrevLabel;
 406   CurMI = nullptr;
 407 }
 408
 409 void DebugHandlerBase::endFunction(const MachineFunction *MF) {
 410   if (Asm && hasDebugInfo(MMI, MF))
 411     endFunctionImpl(MF);
 412   DbgValues.clear();
 413   DbgLabels.clear();
 414   LabelsBeforeInsn.clear();
 415   LabelsAfterInsn.clear();
 416   InstOrdering.clear();
 417 }
 418
 419 void DebugHandlerBase::beginBasicBlockSection(const MachineBasicBlock &MBB) {
 420   EpilogBeginBlock = nullptr;
 421   if (!MBB.isEntryBlock())
 422     PrevLabel = MBB.getSymbol();
 423 }
 424
 425 void DebugHandlerBase::endBasicBlockSection(const MachineBasicBlock &MBB) {
 426   PrevLabel = nullptr;
 427 }