1 //===-- llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp -------*- C++ -*--===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // Common functionality for different debug information format backends. 11 // LLVM currently supports DWARF and CodeView. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "DebugHandlerBase.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/IR/DebugInfo.h" 21 #include "llvm/MC/MCStreamer.h" 22 #include "llvm/Target/TargetSubtargetInfo.h" 23 24 using namespace llvm; 25 26 DebugHandlerBase::DebugHandlerBase(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {} 27 28 // Each LexicalScope has first instruction and last instruction to mark 29 // beginning and end of a scope respectively. Create an inverse map that list 30 // scopes starts (and ends) with an instruction. One instruction may start (or 31 // end) multiple scopes. Ignore scopes that are not reachable. 32 void DebugHandlerBase::identifyScopeMarkers() { 33 SmallVector<LexicalScope *, 4> WorkList; 34 WorkList.push_back(LScopes.getCurrentFunctionScope()); 35 while (!WorkList.empty()) { 36 LexicalScope *S = WorkList.pop_back_val(); 37 38 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren(); 39 if (!Children.empty()) 40 WorkList.append(Children.begin(), Children.end()); 41 42 if (S->isAbstractScope()) 43 continue; 44 45 for (const InsnRange &R : S->getRanges()) { 46 assert(R.first && "InsnRange does not have first instruction!"); 47 assert(R.second && "InsnRange does not have second instruction!"); 48 requestLabelBeforeInsn(R.first); 49 requestLabelAfterInsn(R.second); 50 } 51 } 52 } 53 54 // Return Label preceding the instruction. 55 MCSymbol *DebugHandlerBase::getLabelBeforeInsn(const MachineInstr *MI) { 56 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 57 assert(Label && "Didn't insert label before instruction"); 58 return Label; 59 } 60 61 // Return Label immediately following the instruction. 62 MCSymbol *DebugHandlerBase::getLabelAfterInsn(const MachineInstr *MI) { 63 return LabelsAfterInsn.lookup(MI); 64 } 65 66 int DebugHandlerBase::fragmentCmp(const DIExpression *P1, 67 const DIExpression *P2) { 68 auto Fragment1 = *P1->getFragmentInfo(); 69 auto Fragment2 = *P2->getFragmentInfo(); 70 unsigned l1 = Fragment1.OffsetInBits; 71 unsigned l2 = Fragment2.OffsetInBits; 72 unsigned r1 = l1 + Fragment1.SizeInBits; 73 unsigned r2 = l2 + Fragment2.SizeInBits; 74 if (r1 <= l2) 75 return -1; 76 else if (r2 <= l1) 77 return 1; 78 else 79 return 0; 80 } 81 82 bool DebugHandlerBase::fragmentsOverlap(const DIExpression *P1, 83 const DIExpression *P2) { 84 if (!P1->isFragment() || !P2->isFragment()) 85 return true; 86 return fragmentCmp(P1, P2) == 0; 87 } 88 89 /// If this type is derived from a base type then return base type size. 90 uint64_t DebugHandlerBase::getBaseTypeSize(const DITypeRef TyRef) { 91 DIType *Ty = TyRef.resolve(); 92 assert(Ty); 93 DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty); 94 if (!DDTy) 95 return Ty->getSizeInBits(); 96 97 unsigned Tag = DDTy->getTag(); 98 99 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 100 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 101 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type) 102 return DDTy->getSizeInBits(); 103 104 DIType *BaseType = DDTy->getBaseType().resolve(); 105 106 assert(BaseType && "Unexpected invalid base type"); 107 108 // If this is a derived type, go ahead and get the base type, unless it's a 109 // reference then it's just the size of the field. Pointer types have no need 110 // of this since they're a different type of qualification on the type. 111 if (BaseType->getTag() == dwarf::DW_TAG_reference_type || 112 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type) 113 return Ty->getSizeInBits(); 114 115 return getBaseTypeSize(BaseType); 116 } 117 118 bool hasDebugInfo(const MachineModuleInfo *MMI, const MachineFunction *MF) { 119 if (!MMI->hasDebugInfo()) 120 return false; 121 auto *SP = MF->getFunction()->getSubprogram(); 122 if (!SP) 123 return false; 124 assert(SP->getUnit()); 125 auto EK = SP->getUnit()->getEmissionKind(); 126 if (EK == DICompileUnit::NoDebug) 127 return false; 128 return true; 129 } 130 131 void DebugHandlerBase::beginFunction(const MachineFunction *MF) { 132 assert(Asm); 133 PrevInstBB = nullptr; 134 135 if (!hasDebugInfo(MMI, MF)) { 136 skippedNonDebugFunction(); 137 return; 138 } 139 140 // Grab the lexical scopes for the function, if we don't have any of those 141 // then we're not going to be able to do anything. 142 LScopes.initialize(*MF); 143 if (LScopes.empty()) { 144 beginFunctionImpl(MF); 145 return; 146 } 147 148 // Make sure that each lexical scope will have a begin/end label. 149 identifyScopeMarkers(); 150 151 // Calculate history for local variables. 152 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!"); 153 calculateDbgValueHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(), 154 DbgValues); 155 156 // Request labels for the full history. 157 for (const auto &I : DbgValues) { 158 const auto &Ranges = I.second; 159 if (Ranges.empty()) 160 continue; 161 162 // The first mention of a function argument gets the CurrentFnBegin 163 // label, so arguments are visible when breaking at function entry. 164 const DILocalVariable *DIVar = Ranges.front().first->getDebugVariable(); 165 if (DIVar->isParameter() && 166 getDISubprogram(DIVar->getScope())->describes(MF->getFunction())) { 167 LabelsBeforeInsn[Ranges.front().first] = Asm->getFunctionBegin(); 168 if (Ranges.front().first->getDebugExpression()->isFragment()) { 169 // Mark all non-overlapping initial fragments. 170 for (auto I = Ranges.begin(); I != Ranges.end(); ++I) { 171 const DIExpression *Fragment = I->first->getDebugExpression(); 172 if (std::all_of(Ranges.begin(), I, 173 [&](DbgValueHistoryMap::InstrRange Pred) { 174 return !fragmentsOverlap( 175 Fragment, Pred.first->getDebugExpression()); 176 })) 177 LabelsBeforeInsn[I->first] = Asm->getFunctionBegin(); 178 else 179 break; 180 } 181 } 182 } 183 184 for (const auto &Range : Ranges) { 185 requestLabelBeforeInsn(Range.first); 186 if (Range.second) 187 requestLabelAfterInsn(Range.second); 188 } 189 } 190 191 PrevInstLoc = DebugLoc(); 192 PrevLabel = Asm->getFunctionBegin(); 193 beginFunctionImpl(MF); 194 } 195 196 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) { 197 if (!MMI->hasDebugInfo()) 198 return; 199 200 assert(CurMI == nullptr); 201 CurMI = MI; 202 203 // Insert labels where requested. 204 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 205 LabelsBeforeInsn.find(MI); 206 207 // No label needed. 208 if (I == LabelsBeforeInsn.end()) 209 return; 210 211 // Label already assigned. 212 if (I->second) 213 return; 214 215 if (!PrevLabel) { 216 PrevLabel = MMI->getContext().createTempSymbol(); 217 Asm->OutStreamer->EmitLabel(PrevLabel); 218 } 219 I->second = PrevLabel; 220 } 221 222 void DebugHandlerBase::endInstruction() { 223 if (!MMI->hasDebugInfo()) 224 return; 225 226 assert(CurMI != nullptr); 227 // Don't create a new label after DBG_VALUE instructions. 228 // They don't generate code. 229 if (!CurMI->isDebugValue()) { 230 PrevLabel = nullptr; 231 PrevInstBB = CurMI->getParent(); 232 } 233 234 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 235 LabelsAfterInsn.find(CurMI); 236 CurMI = nullptr; 237 238 // No label needed. 239 if (I == LabelsAfterInsn.end()) 240 return; 241 242 // Label already assigned. 243 if (I->second) 244 return; 245 246 // We need a label after this instruction. 247 if (!PrevLabel) { 248 PrevLabel = MMI->getContext().createTempSymbol(); 249 Asm->OutStreamer->EmitLabel(PrevLabel); 250 } 251 I->second = PrevLabel; 252 } 253 254 void DebugHandlerBase::endFunction(const MachineFunction *MF) { 255 if (hasDebugInfo(MMI, MF)) 256 endFunctionImpl(MF); 257 DbgValues.clear(); 258 LabelsBeforeInsn.clear(); 259 LabelsAfterInsn.clear(); 260 } 261