1 //===- MCCodeView.h - Machine Code CodeView support -------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Holds state from .cv_file and .cv_loc directives for later emission.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/MC/MCCodeView.h"
15 #include "llvm/MC/MCAsmLayout.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/DebugInfo/CodeView/CodeView.h"
18 #include "llvm/DebugInfo/CodeView/Line.h"
19 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCObjectStreamer.h"
22 #include "llvm/MC/MCValue.h"
23 #include "llvm/Support/COFF.h"
24 #include "llvm/Support/EndianStream.h"
27 using namespace llvm::codeview;
29 CodeViewContext::CodeViewContext() {}
31 CodeViewContext::~CodeViewContext() {
32 // If someone inserted strings into the string table but never actually
33 // emitted them somewhere, clean up the fragment.
34 if (!InsertedStrTabFragment)
35 delete StrTabFragment;
38 /// This is a valid number for use with .cv_loc if we've already seen a .cv_file
40 bool CodeViewContext::isValidFileNumber(unsigned FileNumber) const {
41 unsigned Idx = FileNumber - 1;
42 if (Idx < Filenames.size())
43 return !Filenames[Idx].empty();
47 bool CodeViewContext::addFile(unsigned FileNumber, StringRef Filename) {
48 assert(FileNumber > 0);
49 Filename = addToStringTable(Filename);
50 unsigned Idx = FileNumber - 1;
51 if (Idx >= Filenames.size())
52 Filenames.resize(Idx + 1);
57 if (!Filenames[Idx].empty())
60 // FIXME: We should store the string table offset of the filename, rather than
61 // the filename itself for efficiency.
62 Filename = addToStringTable(Filename);
64 Filenames[Idx] = Filename;
68 bool CodeViewContext::recordFunctionId(unsigned FuncId) {
69 if (FuncId >= Functions.size())
70 Functions.resize(FuncId + 1);
72 // Return false if this function info was already allocated.
73 if (!Functions[FuncId].isUnallocatedFunctionInfo())
76 // Mark this as an allocated normal function, and leave the rest alone.
77 Functions[FuncId].ParentFuncIdPlusOne = MCCVFunctionInfo::FunctionSentinel;
81 bool CodeViewContext::recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc,
82 unsigned IAFile, unsigned IALine,
84 if (FuncId >= Functions.size())
85 Functions.resize(FuncId + 1);
87 // Return false if this function info was already allocated.
88 if (!Functions[FuncId].isUnallocatedFunctionInfo())
91 MCCVFunctionInfo::LineInfo InlinedAt;
92 InlinedAt.File = IAFile;
93 InlinedAt.Line = IALine;
94 InlinedAt.Col = IACol;
96 // Mark this as an inlined call site and record call site line info.
97 MCCVFunctionInfo *Info = &Functions[FuncId];
98 Info->ParentFuncIdPlusOne = IAFunc + 1;
99 Info->InlinedAt = InlinedAt;
101 // Walk up the call chain adding this function id to the InlinedAtMap of all
102 // transitive callers until we hit a real function.
103 while (Info->isInlinedCallSite()) {
104 InlinedAt = Info->InlinedAt;
105 Info = getCVFunctionInfo(Info->getParentFuncId());
106 Info->InlinedAtMap[FuncId] = InlinedAt;
112 MCDataFragment *CodeViewContext::getStringTableFragment() {
113 if (!StrTabFragment) {
114 StrTabFragment = new MCDataFragment();
115 // Start a new string table out with a null byte.
116 StrTabFragment->getContents().push_back('\0');
118 return StrTabFragment;
121 StringRef CodeViewContext::addToStringTable(StringRef S) {
122 SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
124 StringTable.insert(std::make_pair(S, unsigned(Contents.size())));
125 // Return the string from the table, since it is stable.
126 S = Insertion.first->first();
127 if (Insertion.second) {
128 // The string map key is always null terminated.
129 Contents.append(S.begin(), S.end() + 1);
134 unsigned CodeViewContext::getStringTableOffset(StringRef S) {
135 // A string table offset of zero is always the empty string.
138 auto I = StringTable.find(S);
139 assert(I != StringTable.end());
143 void CodeViewContext::emitStringTable(MCObjectStreamer &OS) {
144 MCContext &Ctx = OS.getContext();
145 MCSymbol *StringBegin = Ctx.createTempSymbol("strtab_begin", false),
146 *StringEnd = Ctx.createTempSymbol("strtab_end", false);
148 OS.EmitIntValue(unsigned(ModuleSubstreamKind::StringTable), 4);
149 OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
150 OS.EmitLabel(StringBegin);
152 // Put the string table data fragment here, if we haven't already put it
153 // somewhere else. If somebody wants two string tables in their .s file, one
154 // will just be empty.
155 if (!InsertedStrTabFragment) {
156 OS.insert(getStringTableFragment());
157 InsertedStrTabFragment = true;
160 OS.EmitValueToAlignment(4, 0);
162 OS.EmitLabel(StringEnd);
165 void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) {
166 // Do nothing if there are no file checksums. Microsoft's linker rejects empty
167 // CodeView substreams.
168 if (Filenames.empty())
171 MCContext &Ctx = OS.getContext();
172 MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
173 *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
175 OS.EmitIntValue(unsigned(ModuleSubstreamKind::FileChecksums), 4);
176 OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
177 OS.EmitLabel(FileBegin);
179 // Emit an array of FileChecksum entries. We index into this table using the
180 // user-provided file number. Each entry is currently 8 bytes, as we don't
182 for (StringRef Filename : Filenames) {
183 OS.EmitIntValue(getStringTableOffset(Filename), 4);
184 // Zero the next two fields and align back to 4 bytes. This indicates that
185 // no checksum is present.
186 OS.EmitIntValue(0, 4);
189 OS.EmitLabel(FileEnd);
192 void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
194 const MCSymbol *FuncBegin,
195 const MCSymbol *FuncEnd) {
196 MCContext &Ctx = OS.getContext();
197 MCSymbol *LineBegin = Ctx.createTempSymbol("linetable_begin", false),
198 *LineEnd = Ctx.createTempSymbol("linetable_end", false);
200 OS.EmitIntValue(unsigned(ModuleSubstreamKind::Lines), 4);
201 OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
202 OS.EmitLabel(LineBegin);
203 OS.EmitCOFFSecRel32(FuncBegin, /*Offset=*/0);
204 OS.EmitCOFFSectionIndex(FuncBegin);
207 std::vector<MCCVLineEntry> Locs = getFunctionLineEntries(FuncId);
208 bool HaveColumns = any_of(Locs, [](const MCCVLineEntry &LineEntry) {
209 return LineEntry.getColumn() != 0;
211 OS.EmitIntValue(HaveColumns ? int(LineFlags::HaveColumns) : 0, 2);
212 OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
214 for (auto I = Locs.begin(), E = Locs.end(); I != E;) {
215 // Emit a file segment for the run of locations that share a file id.
216 unsigned CurFileNum = I->getFileNum();
218 std::find_if(I, E, [CurFileNum](const MCCVLineEntry &Loc) {
219 return Loc.getFileNum() != CurFileNum;
221 unsigned EntryCount = FileSegEnd - I;
222 OS.AddComment("Segment for file '" + Twine(Filenames[CurFileNum - 1]) +
224 OS.EmitIntValue(8 * (CurFileNum - 1), 4);
225 OS.EmitIntValue(EntryCount, 4);
226 uint32_t SegmentSize = 12;
227 SegmentSize += 8 * EntryCount;
229 SegmentSize += 4 * EntryCount;
230 OS.EmitIntValue(SegmentSize, 4);
232 for (auto J = I; J != FileSegEnd; ++J) {
233 OS.emitAbsoluteSymbolDiff(J->getLabel(), FuncBegin, 4);
234 unsigned LineData = J->getLine();
236 LineData |= LineInfo::StatementFlag;
237 OS.EmitIntValue(LineData, 4);
240 for (auto J = I; J != FileSegEnd; ++J) {
241 OS.EmitIntValue(J->getColumn(), 2);
242 OS.EmitIntValue(0, 2);
247 OS.EmitLabel(LineEnd);
250 static bool compressAnnotation(uint32_t Data, SmallVectorImpl<char> &Buffer) {
251 if (isUInt<7>(Data)) {
252 Buffer.push_back(Data);
256 if (isUInt<14>(Data)) {
257 Buffer.push_back((Data >> 8) | 0x80);
258 Buffer.push_back(Data & 0xff);
262 if (isUInt<29>(Data)) {
263 Buffer.push_back((Data >> 24) | 0xC0);
264 Buffer.push_back((Data >> 16) & 0xff);
265 Buffer.push_back((Data >> 8) & 0xff);
266 Buffer.push_back(Data & 0xff);
273 static bool compressAnnotation(BinaryAnnotationsOpCode Annotation,
274 SmallVectorImpl<char> &Buffer) {
275 return compressAnnotation(static_cast<uint32_t>(Annotation), Buffer);
278 static uint32_t encodeSignedNumber(uint32_t Data) {
280 return ((-Data) << 1) | 1;
284 void CodeViewContext::emitInlineLineTableForFunction(MCObjectStreamer &OS,
285 unsigned PrimaryFunctionId,
286 unsigned SourceFileId,
287 unsigned SourceLineNum,
288 const MCSymbol *FnStartSym,
289 const MCSymbol *FnEndSym) {
290 // Create and insert a fragment into the current section that will be encoded
292 new MCCVInlineLineTableFragment(PrimaryFunctionId, SourceFileId,
293 SourceLineNum, FnStartSym, FnEndSym,
294 OS.getCurrentSectionOnly());
297 void CodeViewContext::emitDefRange(
298 MCObjectStreamer &OS,
299 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
300 StringRef FixedSizePortion) {
301 // Create and insert a fragment into the current section that will be encoded
303 new MCCVDefRangeFragment(Ranges, FixedSizePortion,
304 OS.getCurrentSectionOnly());
307 static unsigned computeLabelDiff(MCAsmLayout &Layout, const MCSymbol *Begin,
308 const MCSymbol *End) {
309 MCContext &Ctx = Layout.getAssembler().getContext();
310 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
311 const MCExpr *BeginRef = MCSymbolRefExpr::create(Begin, Variant, Ctx),
312 *EndRef = MCSymbolRefExpr::create(End, Variant, Ctx);
313 const MCExpr *AddrDelta =
314 MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
316 bool Success = AddrDelta->evaluateKnownAbsolute(Result, Layout);
317 assert(Success && "failed to evaluate label difference as absolute");
319 assert(Result >= 0 && "negative label difference requested");
320 assert(Result < UINT_MAX && "label difference greater than 2GB");
321 return unsigned(Result);
324 void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
325 MCCVInlineLineTableFragment &Frag) {
328 std::tie(LocBegin, LocEnd) = getLineExtent(Frag.SiteFuncId);
330 // Include all child inline call sites in our .cv_loc extent.
331 MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(Frag.SiteFuncId);
332 for (auto &KV : SiteInfo->InlinedAtMap) {
333 unsigned ChildId = KV.first;
334 auto Extent = getLineExtent(ChildId);
335 LocBegin = std::min(LocBegin, Extent.first);
336 LocEnd = std::max(LocEnd, Extent.second);
339 if (LocBegin >= LocEnd)
341 ArrayRef<MCCVLineEntry> Locs = getLinesForExtent(LocBegin, LocEnd);
345 // Make an artificial start location using the function start and the inlinee
346 // lines start location information. All deltas start relative to this
348 MCCVLineEntry StartLoc(Frag.getFnStartSym(), MCCVLoc(Locs.front()));
349 StartLoc.setFileNum(Frag.StartFileId);
350 StartLoc.setLine(Frag.StartLineNum);
351 bool HaveOpenRange = false;
353 const MCSymbol *LastLabel = Frag.getFnStartSym();
354 MCCVFunctionInfo::LineInfo LastSourceLoc, CurSourceLoc;
355 LastSourceLoc.File = Frag.StartFileId;
356 LastSourceLoc.Line = Frag.StartLineNum;
358 SmallVectorImpl<char> &Buffer = Frag.getContents();
359 Buffer.clear(); // Clear old contents if we went through relaxation.
360 for (const MCCVLineEntry &Loc : Locs) {
361 // Exit early if our line table would produce an oversized InlineSiteSym
362 // record. Account for the ChangeCodeLength annotation emitted after the
364 constexpr uint32_t InlineSiteSize = 12;
365 constexpr uint32_t AnnotationSize = 8;
366 size_t MaxBufferSize = MaxRecordLength - InlineSiteSize - AnnotationSize;
367 if (Buffer.size() >= MaxBufferSize)
370 if (Loc.getFunctionId() == Frag.SiteFuncId) {
371 CurSourceLoc.File = Loc.getFileNum();
372 CurSourceLoc.Line = Loc.getLine();
374 auto I = SiteInfo->InlinedAtMap.find(Loc.getFunctionId());
375 if (I != SiteInfo->InlinedAtMap.end()) {
376 // This .cv_loc is from a child inline call site. Use the source
377 // location of the inlined call site instead of the .cv_loc directive
379 CurSourceLoc = I->second;
381 // We've hit a cv_loc not attributed to this inline call site. Use this
382 // label to end the PC range.
384 unsigned Length = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
385 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
386 compressAnnotation(Length, Buffer);
387 LastLabel = Loc.getLabel();
389 HaveOpenRange = false;
394 // Skip this .cv_loc if we have an open range and this isn't a meaningful
395 // source location update. The current table format does not support column
396 // info, so we can skip updates for those.
397 if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
398 CurSourceLoc.Line == LastSourceLoc.Line)
401 HaveOpenRange = true;
403 if (CurSourceLoc.File != LastSourceLoc.File) {
404 // File ids are 1 based, and each file checksum table entry is 8 bytes
405 // long. See emitFileChecksums above.
406 unsigned FileOffset = 8 * (CurSourceLoc.File - 1);
407 compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
408 compressAnnotation(FileOffset, Buffer);
411 int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
412 unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
413 unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
414 if (CodeDelta == 0 && LineDelta != 0) {
415 compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
416 compressAnnotation(EncodedLineDelta, Buffer);
417 } else if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) {
418 // The ChangeCodeOffsetAndLineOffset combination opcode is used when the
419 // encoded line delta uses 3 or fewer set bits and the code offset fits
421 unsigned Operand = (EncodedLineDelta << 4) | CodeDelta;
422 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset,
424 compressAnnotation(Operand, Buffer);
426 // Otherwise use the separate line and code deltas.
427 if (LineDelta != 0) {
428 compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
429 compressAnnotation(EncodedLineDelta, Buffer);
431 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffset, Buffer);
432 compressAnnotation(CodeDelta, Buffer);
435 LastLabel = Loc.getLabel();
436 LastSourceLoc = CurSourceLoc;
439 assert(HaveOpenRange);
441 unsigned EndSymLength =
442 computeLabelDiff(Layout, LastLabel, Frag.getFnEndSym());
443 unsigned LocAfterLength = ~0U;
444 ArrayRef<MCCVLineEntry> LocAfter = getLinesForExtent(LocEnd, LocEnd + 1);
445 if (!LocAfter.empty()) {
446 // Only try to compute this difference if we're in the same section.
447 const MCCVLineEntry &Loc = LocAfter[0];
448 if (&Loc.getLabel()->getSection(false) == &LastLabel->getSection(false))
449 LocAfterLength = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
452 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
453 compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
456 void CodeViewContext::encodeDefRange(MCAsmLayout &Layout,
457 MCCVDefRangeFragment &Frag) {
458 MCContext &Ctx = Layout.getAssembler().getContext();
459 SmallVectorImpl<char> &Contents = Frag.getContents();
461 SmallVectorImpl<MCFixup> &Fixups = Frag.getFixups();
463 raw_svector_ostream OS(Contents);
465 // Compute all the sizes up front.
466 SmallVector<std::pair<unsigned, unsigned>, 4> GapAndRangeSizes;
467 const MCSymbol *LastLabel = nullptr;
468 for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
470 LastLabel ? computeLabelDiff(Layout, LastLabel, Range.first) : 0;
471 unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
472 GapAndRangeSizes.push_back({GapSize, RangeSize});
473 LastLabel = Range.second;
476 // Write down each range where the variable is defined.
477 for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {
478 // If the range size of multiple consecutive ranges is under the max,
479 // combine the ranges and emit some gaps.
480 const MCSymbol *RangeBegin = Frag.getRanges()[I].first;
481 unsigned RangeSize = GapAndRangeSizes[I].second;
483 for (; J != E; ++J) {
484 unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
485 if (RangeSize + GapAndRangeSize > MaxDefRange)
487 RangeSize += GapAndRangeSize;
489 unsigned NumGaps = J - I - 1;
491 support::endian::Writer<support::little> LEWriter(OS);
494 // We must split the range into chunks of MaxDefRange, this is a fundamental
495 // limitation of the file format.
497 uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
499 const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);
500 const MCBinaryExpr *BE =
501 MCBinaryExpr::createAdd(SRE, MCConstantExpr::create(Bias, Ctx), Ctx);
503 BE->evaluateAsRelocatable(Res, &Layout, /*Fixup=*/nullptr);
505 // Each record begins with a 2-byte number indicating how large the record
507 StringRef FixedSizePortion = Frag.getFixedSizePortion();
508 // Our record is a fixed sized prefix and a LocalVariableAddrRange that we
509 // are artificially constructing.
510 size_t RecordSize = FixedSizePortion.size() +
511 sizeof(LocalVariableAddrRange) + 4 * NumGaps;
512 // Write out the record size.
513 LEWriter.write<uint16_t>(RecordSize);
514 // Write out the fixed size prefix.
515 OS << FixedSizePortion;
516 // Make space for a fixup that will eventually have a section relative
517 // relocation pointing at the offset where the variable becomes live.
518 Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_4));
519 LEWriter.write<uint32_t>(0); // Fixup for code start.
520 // Make space for a fixup that will record the section index for the code.
521 Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_2));
522 LEWriter.write<uint16_t>(0); // Fixup for section index.
523 // Write down the range's extent.
524 LEWriter.write<uint16_t>(Chunk);
526 // Move on to the next range.
529 } while (RangeSize > 0);
531 // Emit the gaps afterwards.
532 assert((NumGaps == 0 || Bias <= MaxDefRange) &&
533 "large ranges should not have gaps");
534 unsigned GapStartOffset = GapAndRangeSizes[I].second;
535 for (++I; I != J; ++I) {
536 unsigned GapSize, RangeSize;
537 assert(I < GapAndRangeSizes.size());
538 std::tie(GapSize, RangeSize) = GapAndRangeSizes[I];
539 LEWriter.write<uint16_t>(GapStartOffset);
540 LEWriter.write<uint16_t>(GapSize);
541 GapStartOffset += GapSize + RangeSize;
547 // This is called when an instruction is assembled into the specified section
548 // and if there is information from the last .cv_loc directive that has yet to have
549 // a line entry made for it is made.
551 void MCCVLineEntry::Make(MCObjectStreamer *MCOS) {
552 CodeViewContext &CVC = MCOS->getContext().getCVContext();
553 if (!CVC.getCVLocSeen())
556 // Create a symbol at in the current section for use in the line entry.
557 MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
558 // Set the value of the symbol to use for the MCCVLineEntry.
559 MCOS->EmitLabel(LineSym);
561 // Get the current .loc info saved in the context.
562 const MCCVLoc &CVLoc = CVC.getCurrentCVLoc();
564 // Create a (local) line entry with the symbol and the current .loc info.
565 MCCVLineEntry LineEntry(LineSym, CVLoc);
567 // clear CVLocSeen saying the current .loc info is now used.
568 CVC.clearCVLocSeen();
570 // Add the line entry to this section's entries.
571 CVC.addLineEntry(LineEntry);