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/ADT/Optional.h"
  16 #include "llvm/CodeGen/AsmPrinter.h"
  17 #include "llvm/CodeGen/MachineFunction.h"
  18 #include "llvm/CodeGen/MachineInstr.h"
  19 #include "llvm/CodeGen/MachineModuleInfo.h"
  20 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  21 #include "llvm/IR/DebugInfo.h"
  22 #include "llvm/MC/MCStreamer.h"
  23 #include "llvm/Support/CommandLine.h"
  24
  25 using namespace llvm;
  26
  27 #define DEBUG_TYPE "dwarfdebug"
  28
  29 /// If true, we drop variable location ranges which exist entirely outside the
  30 /// variable's lexical scope instruction ranges.
  31 static cl::opt<bool> TrimVarLocs("trim-var-locs", cl::Hidden, cl::init(true));
  32
  33 Optional<DbgVariableLocation>
  34 DbgVariableLocation::extractFromMachineInstruction(
  35     const MachineInstr &Instruction) {
  36   DbgVariableLocation Location;
  37   // Variables calculated from multiple locations can't be represented here.
  38   if (Instruction.getNumDebugOperands() != 1)
  39     return None;
  40   if (!Instruction.getDebugOperand(0).isReg())
  41     return None;
  42   Location.Register = Instruction.getDebugOperand(0).getReg();
  43   Location.FragmentInfo.reset();
  44   // We only handle expressions generated by DIExpression::appendOffset,
  45   // which doesn't require a full stack machine.
  46   int64_t Offset = 0;
  47   const DIExpression *DIExpr = Instruction.getDebugExpression();
  48   auto Op = DIExpr->expr_op_begin();
  49   // We can handle a DBG_VALUE_LIST iff it has exactly one location operand that
  50   // appears exactly once at the start of the expression.
  51   if (Instruction.isDebugValueList()) {
  52     if (Instruction.getNumDebugOperands() == 1 &&
  53         Op->getOp() == dwarf::DW_OP_LLVM_arg)
  54       ++Op;
  55     else
  56       return None;
  57   }
  58   while (Op != DIExpr->expr_op_end()) {
  59     switch (Op->getOp()) {
  60     case dwarf::DW_OP_constu: {
  61       int Value = Op->getArg(0);
  62       ++Op;
  63       if (Op != DIExpr->expr_op_end()) {
  64         switch (Op->getOp()) {
  65         case dwarf::DW_OP_minus:
  66           Offset -= Value;
  67           break;
  68         case dwarf::DW_OP_plus:
  69           Offset += Value;
  70           break;
  71         default:
  72           continue;
  73         }
  74       }
  75     } break;
  76     case dwarf::DW_OP_plus_uconst:
  77       Offset += Op->getArg(0);
  78       break;
  79     case dwarf::DW_OP_LLVM_fragment:
  80       Location.FragmentInfo = {Op->getArg(1), Op->getArg(0)};
  81       break;
  82     case dwarf::DW_OP_deref:
  83       Location.LoadChain.push_back(Offset);
  84       Offset = 0;
  85       break;
  86     default:
  87       return None;
  88     }
  89     ++Op;
  90   }
  91
  92   // Do one final implicit DW_OP_deref if this was an indirect DBG_VALUE
  93   // instruction.
  94   // FIXME: Replace these with DIExpression.
  95   if (Instruction.isIndirectDebugValue())
  96     Location.LoadChain.push_back(Offset);
  97
  98   return Location;
  99 }
 100
 101 DebugHandlerBase::DebugHandlerBase(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
 102
 103 void DebugHandlerBase::beginModule(Module *M) {
 104   if (M->debug_compile_units().empty())
 105     Asm = nullptr;
 106 }
 107
 108 // Each LexicalScope has first instruction and last instruction to mark
 109 // beginning and end of a scope respectively. Create an inverse map that list
 110 // scopes starts (and ends) with an instruction. One instruction may start (or
 111 // end) multiple scopes. Ignore scopes that are not reachable.
 112 void DebugHandlerBase::identifyScopeMarkers() {
 113   SmallVector<LexicalScope *, 4> WorkList;
 114   WorkList.push_back(LScopes.getCurrentFunctionScope());
 115   while (!WorkList.empty()) {
 116     LexicalScope *S = WorkList.pop_back_val();
 117
 118     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
 119     if (!Children.empty())
 120       WorkList.append(Children.begin(), Children.end());
 121
 122     if (S->isAbstractScope())
 123       continue;
 124
 125     for (const InsnRange &R : S->getRanges()) {
 126       assert(R.first && "InsnRange does not have first instruction!");
 127       assert(R.second && "InsnRange does not have second instruction!");
 128       requestLabelBeforeInsn(R.first);
 129       requestLabelAfterInsn(R.second);
 130     }
 131   }
 132 }
 133
 134 // Return Label preceding the instruction.
 135 MCSymbol *DebugHandlerBase::getLabelBeforeInsn(const MachineInstr *MI) {
 136   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
 137   assert(Label && "Didn't insert label before instruction");
 138   return Label;
 139 }
 140
 141 // Return Label immediately following the instruction.
 142 MCSymbol *DebugHandlerBase::getLabelAfterInsn(const MachineInstr *MI) {
 143   return LabelsAfterInsn.lookup(MI);
 144 }
 145
 146 /// If this type is derived from a base type then return base type size.
 147 uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) {
 148   assert(Ty);
 149   const DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty);
 150   if (!DDTy)
 151     return Ty->getSizeInBits();
 152
 153   unsigned Tag = DDTy->getTag();
 154
 155   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 156       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 157       Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type &&
 158       Tag != dwarf::DW_TAG_immutable_type)
 159     return DDTy->getSizeInBits();
 160
 161   DIType *BaseType = DDTy->getBaseType();
 162
 163   if (!BaseType)
 164     return 0;
 165
 166   // If this is a derived type, go ahead and get the base type, unless it's a
 167   // reference then it's just the size of the field. Pointer types have no need
 168   // of this since they're a different type of qualification on the type.
 169   if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
 170       BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
 171     return Ty->getSizeInBits();
 172
 173   return getBaseTypeSize(BaseType);
 174 }
 175
 176 bool DebugHandlerBase::isUnsignedDIType(const DIType *Ty) {
 177   if (isa<DIStringType>(Ty)) {
 178     // Some transformations (e.g. instcombine) may decide to turn a Fortran
 179     // character object into an integer, and later ones (e.g. SROA) may
 180     // further inject a constant integer in a llvm.dbg.value call to track
 181     // the object's value. Here we trust the transformations are doing the
 182     // right thing, and treat the constant as unsigned to preserve that value
 183     // (i.e. avoid sign extension).
 184     return true;
 185   }
 186
 187   if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 188     if (CTy->getTag() == dwarf::DW_TAG_enumeration_type) {
 189       if (!(Ty = CTy->getBaseType()))
 190         // FIXME: Enums without a fixed underlying type have unknown signedness
 191         // here, leading to incorrectly emitted constants.
 192         return false;
 193     } else
 194       // (Pieces of) aggregate types that get hacked apart by SROA may be
 195       // represented by a constant. Encode them as unsigned bytes.
 196       return true;
 197   }
 198
 199   if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
 200     dwarf::Tag T = (dwarf::Tag)Ty->getTag();
 201     // Encode pointer constants as unsigned bytes. This is used at least for
 202     // null pointer constant emission.
 203     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
 204     // here, but accept them for now due to a bug in SROA producing bogus
 205     // dbg.values.
 206     if (T == dwarf::DW_TAG_pointer_type ||
 207         T == dwarf::DW_TAG_ptr_to_member_type ||
 208         T == dwarf::DW_TAG_reference_type ||
 209         T == dwarf::DW_TAG_rvalue_reference_type)
 210       return true;
 211     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 212            T == dwarf::DW_TAG_volatile_type ||
 213            T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type ||
 214            T == dwarf::DW_TAG_immutable_type);
 215     assert(DTy->getBaseType() && "Expected valid base type");
 216     return isUnsignedDIType(DTy->getBaseType());
 217   }
 218
 219   auto *BTy = cast<DIBasicType>(Ty);
 220   unsigned Encoding = BTy->getEncoding();
 221   assert((Encoding == dwarf::DW_ATE_unsigned ||
 222           Encoding == dwarf::DW_ATE_unsigned_char ||
 223           Encoding == dwarf::DW_ATE_signed ||
 224           Encoding == dwarf::DW_ATE_signed_char ||
 225           Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
 226           Encoding == dwarf::DW_ATE_boolean ||
 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());
 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::beginBasicBlock(const MachineBasicBlock &MBB) {
 420   if (!MBB.isBeginSection())
 421     return;
 422
 423   PrevLabel = MBB.getSymbol();
 424 }
 425
 426 void DebugHandlerBase::endBasicBlock(const MachineBasicBlock &MBB) {
 427   if (!MBB.isEndSection())
 428     return;
 429
 430   PrevLabel = nullptr;
 431 }