void WinCodeViewLineTables::emitDebugInfoForFunction(const Function *GV) { // For each function there is a separate subsection // which holds the PC to file:line table. const MCSymbol *Fn = Asm->getSymbol(GV); assert(Fn); const FunctionInfo &FI = FnDebugInfo[GV]; if (FI.Instrs.empty()) return; assert(FI.End && "Don't know where the function ends?"); StringRef GVName = GV->getName(); StringRef FuncName; if (DISubprogram SP = getDISubprogram(GV)) FuncName = SP.getDisplayName(); // FIXME Clang currently sets DisplayName to "bar" for a C++ // "namespace_foo::bar" function, see PR21528. Luckily, dbghelp.dll is trying // to demangle display names anyways, so let's just put a mangled name into // the symbols subsection until Clang gives us what we need. if (GVName.startswith("\01?")) FuncName = GVName.substr(1); // Emit a symbol subsection, required by VS2012+ to find function boundaries. MCSymbol *SymbolsBegin = Asm->MMI->getContext().CreateTempSymbol(), *SymbolsEnd = Asm->MMI->getContext().CreateTempSymbol(); Asm->OutStreamer.AddComment("Symbol subsection for " + Twine(FuncName)); Asm->EmitInt32(COFF::DEBUG_SYMBOL_SUBSECTION); EmitLabelDiff(Asm->OutStreamer, SymbolsBegin, SymbolsEnd); Asm->OutStreamer.EmitLabel(SymbolsBegin); { MCSymbol *ProcSegmentBegin = Asm->MMI->getContext().CreateTempSymbol(), *ProcSegmentEnd = Asm->MMI->getContext().CreateTempSymbol(); EmitLabelDiff(Asm->OutStreamer, ProcSegmentBegin, ProcSegmentEnd, 2); Asm->OutStreamer.EmitLabel(ProcSegmentBegin); Asm->EmitInt16(COFF::DEBUG_SYMBOL_TYPE_PROC_START); // Some bytes of this segment don't seem to be required for basic debugging, // so just fill them with zeroes. Asm->OutStreamer.EmitFill(12, 0); // This is the important bit that tells the debugger where the function // code is located and what's its size: EmitLabelDiff(Asm->OutStreamer, Fn, FI.End); Asm->OutStreamer.EmitFill(12, 0); Asm->OutStreamer.EmitCOFFSecRel32(Fn); Asm->OutStreamer.EmitCOFFSectionIndex(Fn); Asm->EmitInt8(0); // Emit the function display name as a null-terminated string. Asm->OutStreamer.EmitBytes(FuncName); Asm->EmitInt8(0); Asm->OutStreamer.EmitLabel(ProcSegmentEnd); // We're done with this function. Asm->EmitInt16(0x0002); Asm->EmitInt16(COFF::DEBUG_SYMBOL_TYPE_PROC_END); } Asm->OutStreamer.EmitLabel(SymbolsEnd); // Every subsection must be aligned to a 4-byte boundary. Asm->OutStreamer.EmitFill((-FuncName.size()) % 4, 0); // PCs/Instructions are grouped into segments sharing the same filename. // Pre-calculate the lengths (in instructions) of these segments and store // them in a map for convenience. Each index in the map is the sequential // number of the respective instruction that starts a new segment. DenseMap<size_t, size_t> FilenameSegmentLengths; size_t LastSegmentEnd = 0; StringRef PrevFilename = InstrInfo[FI.Instrs[0]].Filename; for (size_t J = 1, F = FI.Instrs.size(); J != F; ++J) { if (PrevFilename == InstrInfo[FI.Instrs[J]].Filename) continue; FilenameSegmentLengths[LastSegmentEnd] = J - LastSegmentEnd; LastSegmentEnd = J; PrevFilename = InstrInfo[FI.Instrs[J]].Filename; } FilenameSegmentLengths[LastSegmentEnd] = FI.Instrs.size() - LastSegmentEnd; // Emit a line table subsection, requred to do PC-to-file:line lookup. Asm->OutStreamer.AddComment("Line table subsection for " + Twine(FuncName)); Asm->EmitInt32(COFF::DEBUG_LINE_TABLE_SUBSECTION); MCSymbol *LineTableBegin = Asm->MMI->getContext().CreateTempSymbol(), *LineTableEnd = Asm->MMI->getContext().CreateTempSymbol(); EmitLabelDiff(Asm->OutStreamer, LineTableBegin, LineTableEnd); Asm->OutStreamer.EmitLabel(LineTableBegin); // Identify the function this subsection is for. Asm->OutStreamer.EmitCOFFSecRel32(Fn); Asm->OutStreamer.EmitCOFFSectionIndex(Fn); // Insert padding after a 16-bit section index. Asm->EmitInt16(0); // Length of the function's code, in bytes. EmitLabelDiff(Asm->OutStreamer, Fn, FI.End); // PC-to-linenumber lookup table: MCSymbol *FileSegmentEnd = nullptr; for (size_t J = 0, F = FI.Instrs.size(); J != F; ++J) { MCSymbol *Instr = FI.Instrs[J]; assert(InstrInfo.count(Instr)); if (FilenameSegmentLengths.count(J)) { // We came to a beginning of a new filename segment. if (FileSegmentEnd) Asm->OutStreamer.EmitLabel(FileSegmentEnd); StringRef CurFilename = InstrInfo[FI.Instrs[J]].Filename; assert(FileNameRegistry.Infos.count(CurFilename)); size_t IndexInStringTable = FileNameRegistry.Infos[CurFilename].FilenameID; // Each segment starts with the offset of the filename // in the string table. Asm->OutStreamer.AddComment( "Segment for file '" + Twine(CurFilename) + "' begins"); MCSymbol *FileSegmentBegin = Asm->MMI->getContext().CreateTempSymbol(); Asm->OutStreamer.EmitLabel(FileSegmentBegin); Asm->EmitInt32(8 * IndexInStringTable); // Number of PC records in the lookup table. size_t SegmentLength = FilenameSegmentLengths[J]; Asm->EmitInt32(SegmentLength); // Full size of the segment for this filename, including the prev two // records. FileSegmentEnd = Asm->MMI->getContext().CreateTempSymbol(); EmitLabelDiff(Asm->OutStreamer, FileSegmentBegin, FileSegmentEnd); } // The first PC with the given linenumber and the linenumber itself. EmitLabelDiff(Asm->OutStreamer, Fn, Instr); Asm->EmitInt32(InstrInfo[Instr].LineNumber); } if (FileSegmentEnd) Asm->OutStreamer.EmitLabel(FileSegmentEnd); Asm->OutStreamer.EmitLabel(LineTableEnd); }
void CodeViewDebug::emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI) { // For each function there is a separate subsection // which holds the PC to file:line table. const MCSymbol *Fn = Asm->getSymbol(GV); assert(Fn); StringRef FuncName; if (auto *SP = getDISubprogram(GV)) FuncName = SP->getDisplayName(); // If our DISubprogram name is empty, use the mangled name. if (FuncName.empty()) FuncName = GlobalValue::getRealLinkageName(GV->getName()); // Emit a symbol subsection, required by VS2012+ to find function boundaries. MCSymbol *SymbolsBegin = Asm->MMI->getContext().createTempSymbol(), *SymbolsEnd = Asm->MMI->getContext().createTempSymbol(); Asm->OutStreamer->AddComment("Symbol subsection for " + Twine(FuncName)); Asm->EmitInt32(unsigned(ModuleSubstreamKind::Symbols)); EmitLabelDiff(*Asm->OutStreamer, SymbolsBegin, SymbolsEnd); Asm->OutStreamer->EmitLabel(SymbolsBegin); { MCSymbol *ProcSegmentBegin = Asm->MMI->getContext().createTempSymbol(), *ProcSegmentEnd = Asm->MMI->getContext().createTempSymbol(); EmitLabelDiff(*Asm->OutStreamer, ProcSegmentBegin, ProcSegmentEnd, 2); Asm->OutStreamer->EmitLabel(ProcSegmentBegin); Asm->EmitInt16(unsigned(SymbolRecordKind::S_GPROC32_ID)); // Some bytes of this segment don't seem to be required for basic debugging, // so just fill them with zeroes. Asm->OutStreamer->EmitFill(12, 0); // This is the important bit that tells the debugger where the function // code is located and what's its size: EmitLabelDiff(*Asm->OutStreamer, Fn, FI.End); Asm->OutStreamer->EmitFill(12, 0); Asm->OutStreamer->EmitCOFFSecRel32(Fn); Asm->OutStreamer->EmitCOFFSectionIndex(Fn); Asm->EmitInt8(0); // Emit the function display name as a null-terminated string. Asm->OutStreamer->EmitBytes(FuncName); Asm->EmitInt8(0); Asm->OutStreamer->EmitLabel(ProcSegmentEnd); // Emit inlined call site information. Only emit functions inlined directly // into the parent function. We'll emit the other sites recursively as part // of their parent inline site. for (auto &KV : FI.InlineSites) { const DILocation *InlinedAt = KV.first; if (!InlinedAt->getInlinedAt()) emitInlinedCallSite(FI, InlinedAt, KV.second); } // We're done with this function. Asm->EmitInt16(0x0002); Asm->EmitInt16(unsigned(SymbolRecordKind::S_PROC_ID_END)); } Asm->OutStreamer->EmitLabel(SymbolsEnd); // Every subsection must be aligned to a 4-byte boundary. Asm->OutStreamer->EmitFill((-FuncName.size()) % 4, 0); // We have an assembler directive that takes care of the whole line table. Asm->OutStreamer->EmitCVLinetableDirective(FI.FuncId, Fn, FI.End); }