LLVM 19.0.0git
MCCodeView.cpp
Go to the documentation of this file.
1//===- MCCodeView.h - Machine Code CodeView support -------------*- 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// Holds state from .cv_file and .cv_loc directives for later emission.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/MC/MCCodeView.h"
14#include "llvm/ADT/STLExtras.h"
19#include "llvm/MC/MCAsmLayout.h"
20#include "llvm/MC/MCAssembler.h"
21#include "llvm/MC/MCContext.h"
23#include "llvm/MC/MCValue.h"
25
26using namespace llvm;
27using namespace llvm::codeview;
28
30
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;
36}
37
38/// This is a valid number for use with .cv_loc if we've already seen a .cv_file
39/// for it.
40bool CodeViewContext::isValidFileNumber(unsigned FileNumber) const {
41 unsigned Idx = FileNumber - 1;
42 if (Idx < Files.size())
43 return Files[Idx].Assigned;
44 return false;
45}
46
47bool CodeViewContext::addFile(MCStreamer &OS, unsigned FileNumber,
48 StringRef Filename,
49 ArrayRef<uint8_t> ChecksumBytes,
50 uint8_t ChecksumKind) {
51 assert(FileNumber > 0);
52 auto FilenameOffset = addToStringTable(Filename);
53 Filename = FilenameOffset.first;
54 unsigned Idx = FileNumber - 1;
55 if (Idx >= Files.size())
56 Files.resize(Idx + 1);
57
58 if (Filename.empty())
59 Filename = "<stdin>";
60
61 if (Files[Idx].Assigned)
62 return false;
63
64 FilenameOffset = addToStringTable(Filename);
65 Filename = FilenameOffset.first;
66 unsigned Offset = FilenameOffset.second;
67
68 auto ChecksumOffsetSymbol =
69 OS.getContext().createTempSymbol("checksum_offset", false);
70 Files[Idx].StringTableOffset = Offset;
71 Files[Idx].ChecksumTableOffset = ChecksumOffsetSymbol;
72 Files[Idx].Assigned = true;
73 Files[Idx].Checksum = ChecksumBytes;
74 Files[Idx].ChecksumKind = ChecksumKind;
75
76 return true;
77}
78
80 if (FuncId >= Functions.size())
81 return nullptr;
82 if (Functions[FuncId].isUnallocatedFunctionInfo())
83 return nullptr;
84 return &Functions[FuncId];
85}
86
88 if (FuncId >= Functions.size())
89 Functions.resize(FuncId + 1);
90
91 // Return false if this function info was already allocated.
92 if (!Functions[FuncId].isUnallocatedFunctionInfo())
93 return false;
94
95 // Mark this as an allocated normal function, and leave the rest alone.
96 Functions[FuncId].ParentFuncIdPlusOne = MCCVFunctionInfo::FunctionSentinel;
97 return true;
98}
99
101 unsigned IAFile, unsigned IALine,
102 unsigned IACol) {
103 if (FuncId >= Functions.size())
104 Functions.resize(FuncId + 1);
105
106 // Return false if this function info was already allocated.
107 if (!Functions[FuncId].isUnallocatedFunctionInfo())
108 return false;
109
111 InlinedAt.File = IAFile;
112 InlinedAt.Line = IALine;
113 InlinedAt.Col = IACol;
114
115 // Mark this as an inlined call site and record call site line info.
116 MCCVFunctionInfo *Info = &Functions[FuncId];
117 Info->ParentFuncIdPlusOne = IAFunc + 1;
118 Info->InlinedAt = InlinedAt;
119
120 // Walk up the call chain adding this function id to the InlinedAtMap of all
121 // transitive callers until we hit a real function.
122 while (Info->isInlinedCallSite()) {
123 InlinedAt = Info->InlinedAt;
124 Info = getCVFunctionInfo(Info->getParentFuncId());
125 Info->InlinedAtMap[FuncId] = InlinedAt;
126 }
127
128 return true;
129}
130
132 unsigned FunctionId, unsigned FileNo,
133 unsigned Line, unsigned Column,
134 bool PrologueEnd, bool IsStmt) {
136 Label, FunctionId, FileNo, Line, Column, PrologueEnd, IsStmt});
137}
138
139MCDataFragment *CodeViewContext::getStringTableFragment() {
140 if (!StrTabFragment) {
141 StrTabFragment = new MCDataFragment();
142 // Start a new string table out with a null byte.
143 StrTabFragment->getContents().push_back('\0');
144 }
145 return StrTabFragment;
146}
147
148std::pair<StringRef, unsigned> CodeViewContext::addToStringTable(StringRef S) {
149 SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
150 auto Insertion =
151 StringTable.insert(std::make_pair(S, unsigned(Contents.size())));
152 // Return the string from the table, since it is stable.
153 std::pair<StringRef, unsigned> Ret =
154 std::make_pair(Insertion.first->first(), Insertion.first->second);
155 if (Insertion.second) {
156 // The string map key is always null terminated.
157 Contents.append(Ret.first.begin(), Ret.first.end() + 1);
158 }
159 return Ret;
160}
161
162unsigned CodeViewContext::getStringTableOffset(StringRef S) {
163 // A string table offset of zero is always the empty string.
164 if (S.empty())
165 return 0;
166 auto I = StringTable.find(S);
167 assert(I != StringTable.end());
168 return I->second;
169}
170
172 MCContext &Ctx = OS.getContext();
173 MCSymbol *StringBegin = Ctx.createTempSymbol("strtab_begin", false),
174 *StringEnd = Ctx.createTempSymbol("strtab_end", false);
175
176 OS.emitInt32(uint32_t(DebugSubsectionKind::StringTable));
177 OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
178 OS.emitLabel(StringBegin);
179
180 // Put the string table data fragment here, if we haven't already put it
181 // somewhere else. If somebody wants two string tables in their .s file, one
182 // will just be empty.
183 if (!InsertedStrTabFragment) {
184 OS.insert(getStringTableFragment());
185 InsertedStrTabFragment = true;
186 }
187
188 OS.emitValueToAlignment(Align(4), 0);
189
190 OS.emitLabel(StringEnd);
191}
192
194 // Do nothing if there are no file checksums. Microsoft's linker rejects empty
195 // CodeView substreams.
196 if (Files.empty())
197 return;
198
199 MCContext &Ctx = OS.getContext();
200 MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
201 *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
202
203 OS.emitInt32(uint32_t(DebugSubsectionKind::FileChecksums));
204 OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
205 OS.emitLabel(FileBegin);
206
207 unsigned CurrentOffset = 0;
208
209 // Emit an array of FileChecksum entries. We index into this table using the
210 // user-provided file number. Each entry may be a variable number of bytes
211 // determined by the checksum kind and size.
212 for (auto File : Files) {
213 OS.emitAssignment(File.ChecksumTableOffset,
214 MCConstantExpr::create(CurrentOffset, Ctx));
215 CurrentOffset += 4; // String table offset.
216 if (!File.ChecksumKind) {
217 CurrentOffset +=
218 4; // One byte each for checksum size and kind, then align to 4 bytes.
219 } else {
220 CurrentOffset += 2; // One byte each for checksum size and kind.
221 CurrentOffset += File.Checksum.size();
222 CurrentOffset = alignTo(CurrentOffset, 4);
223 }
224
225 OS.emitInt32(File.StringTableOffset);
226
227 if (!File.ChecksumKind) {
228 // There is no checksum. Therefore zero the next two fields and align
229 // back to 4 bytes.
230 OS.emitInt32(0);
231 continue;
232 }
233 OS.emitInt8(static_cast<uint8_t>(File.Checksum.size()));
234 OS.emitInt8(File.ChecksumKind);
235 OS.emitBytes(toStringRef(File.Checksum));
236 OS.emitValueToAlignment(Align(4));
237 }
238
239 OS.emitLabel(FileEnd);
240
241 ChecksumOffsetsAssigned = true;
242}
243
244// Output checksum table offset of the given file number. It is possible that
245// not all files have been registered yet, and so the offset cannot be
246// calculated. In this case a symbol representing the offset is emitted, and
247// the value of this symbol will be fixed up at a later time.
249 unsigned FileNo) {
250 unsigned Idx = FileNo - 1;
251
252 if (Idx >= Files.size())
253 Files.resize(Idx + 1);
254
255 if (ChecksumOffsetsAssigned) {
256 OS.emitSymbolValue(Files[Idx].ChecksumTableOffset, 4);
257 return;
258 }
259
260 const MCSymbolRefExpr *SRE =
261 MCSymbolRefExpr::create(Files[Idx].ChecksumTableOffset, OS.getContext());
262
263 OS.emitValueImpl(SRE, 4);
264}
265
267 size_t Offset = MCCVLines.size();
268 auto I = MCCVLineStartStop.insert(
269 {LineEntry.getFunctionId(), {Offset, Offset + 1}});
270 if (!I.second)
271 I.first->second.second = Offset + 1;
272 MCCVLines.push_back(LineEntry);
273}
274
275std::vector<MCCVLoc>
277 std::vector<MCCVLoc> FilteredLines;
278 size_t LocBegin;
279 size_t LocEnd;
280 std::tie(LocBegin, LocEnd) = getLineExtentIncludingInlinees(FuncId);
281 if (LocBegin >= LocEnd) {
282 return FilteredLines;
283 }
284
286 for (size_t Idx = LocBegin; Idx != LocEnd; ++Idx) {
287 unsigned LocationFuncId = MCCVLines[Idx].getFunctionId();
288 if (LocationFuncId == FuncId) {
289 // This was a .cv_loc directly for FuncId, so record it.
290 FilteredLines.push_back(MCCVLines[Idx]);
291 } else {
292 // Check if the current location is inlined in this function. If it is,
293 // synthesize a statement .cv_loc at the original inlined call site.
294 auto I = SiteInfo->InlinedAtMap.find(LocationFuncId);
295 if (I != SiteInfo->InlinedAtMap.end()) {
296 MCCVFunctionInfo::LineInfo &IA = I->second;
297 // Only add the location if it differs from the previous location.
298 // Large inlined calls will have many .cv_loc entries and we only need
299 // one line table entry in the parent function.
300 if (FilteredLines.empty() ||
301 FilteredLines.back().getFileNum() != IA.File ||
302 FilteredLines.back().getLine() != IA.Line ||
303 FilteredLines.back().getColumn() != IA.Col) {
304 FilteredLines.push_back(MCCVLoc(MCCVLines[Idx].getLabel(), FuncId,
305 IA.File, IA.Line, IA.Col, false,
306 false));
307 }
308 }
309 }
310 }
311 return FilteredLines;
312}
313
314std::pair<size_t, size_t> CodeViewContext::getLineExtent(unsigned FuncId) {
315 auto I = MCCVLineStartStop.find(FuncId);
316 // Return an empty extent if there are no cv_locs for this function id.
317 if (I == MCCVLineStartStop.end())
318 return {~0ULL, 0};
319 return I->second;
320}
321
322std::pair<size_t, size_t>
324 size_t LocBegin;
325 size_t LocEnd;
326 std::tie(LocBegin, LocEnd) = getLineExtent(FuncId);
327
328 // Include all child inline call sites in our extent.
330 if (SiteInfo) {
331 for (auto &KV : SiteInfo->InlinedAtMap) {
332 unsigned ChildId = KV.first;
333 auto Extent = getLineExtent(ChildId);
334 LocBegin = std::min(LocBegin, Extent.first);
335 LocEnd = std::max(LocEnd, Extent.second);
336 }
337 }
338
339 return {LocBegin, LocEnd};
340}
341
343 if (R <= L)
344 return std::nullopt;
345 if (L >= MCCVLines.size())
346 return std::nullopt;
347 return ArrayRef(&MCCVLines[L], R - L);
348}
349
351 unsigned FuncId,
352 const MCSymbol *FuncBegin,
353 const MCSymbol *FuncEnd) {
354 MCContext &Ctx = OS.getContext();
355 MCSymbol *LineBegin = Ctx.createTempSymbol("linetable_begin", false),
356 *LineEnd = Ctx.createTempSymbol("linetable_end", false);
357
358 OS.emitInt32(uint32_t(DebugSubsectionKind::Lines));
359 OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
360 OS.emitLabel(LineBegin);
361 OS.emitCOFFSecRel32(FuncBegin, /*Offset=*/0);
362 OS.emitCOFFSectionIndex(FuncBegin);
363
364 // Actual line info.
365 std::vector<MCCVLoc> Locs = getFunctionLineEntries(FuncId);
366 bool HaveColumns = any_of(Locs, [](const MCCVLoc &LineEntry) {
367 return LineEntry.getColumn() != 0;
368 });
369 OS.emitInt16(HaveColumns ? int(LF_HaveColumns) : 0);
370 OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
371
372 for (auto I = Locs.begin(), E = Locs.end(); I != E;) {
373 // Emit a file segment for the run of locations that share a file id.
374 unsigned CurFileNum = I->getFileNum();
375 auto FileSegEnd =
376 std::find_if(I, E, [CurFileNum](const MCCVLoc &Loc) {
377 return Loc.getFileNum() != CurFileNum;
378 });
379 unsigned EntryCount = FileSegEnd - I;
380 OS.AddComment(
381 "Segment for file '" +
382 Twine(getStringTableFragment()
383 ->getContents()[Files[CurFileNum - 1].StringTableOffset]) +
384 "' begins");
385 OS.emitCVFileChecksumOffsetDirective(CurFileNum);
386 OS.emitInt32(EntryCount);
387 uint32_t SegmentSize = 12;
388 SegmentSize += 8 * EntryCount;
389 if (HaveColumns)
390 SegmentSize += 4 * EntryCount;
391 OS.emitInt32(SegmentSize);
392
393 for (auto J = I; J != FileSegEnd; ++J) {
394 OS.emitAbsoluteSymbolDiff(J->getLabel(), FuncBegin, 4);
395 unsigned LineData = J->getLine();
396 if (J->isStmt())
397 LineData |= LineInfo::StatementFlag;
398 OS.emitInt32(LineData);
399 }
400 if (HaveColumns) {
401 for (auto J = I; J != FileSegEnd; ++J) {
402 OS.emitInt16(J->getColumn());
403 OS.emitInt16(0);
404 }
405 }
406 I = FileSegEnd;
407 }
408 OS.emitLabel(LineEnd);
409}
410
412 if (isUInt<7>(Data)) {
413 Buffer.push_back(Data);
414 return true;
415 }
416
417 if (isUInt<14>(Data)) {
418 Buffer.push_back((Data >> 8) | 0x80);
419 Buffer.push_back(Data & 0xff);
420 return true;
421 }
422
423 if (isUInt<29>(Data)) {
424 Buffer.push_back((Data >> 24) | 0xC0);
425 Buffer.push_back((Data >> 16) & 0xff);
426 Buffer.push_back((Data >> 8) & 0xff);
427 Buffer.push_back(Data & 0xff);
428 return true;
429 }
430
431 return false;
432}
433
435 SmallVectorImpl<char> &Buffer) {
436 return compressAnnotation(static_cast<uint32_t>(Annotation), Buffer);
437}
438
440 if (Data >> 31)
441 return ((-Data) << 1) | 1;
442 return Data << 1;
443}
444
446 unsigned PrimaryFunctionId,
447 unsigned SourceFileId,
448 unsigned SourceLineNum,
449 const MCSymbol *FnStartSym,
450 const MCSymbol *FnEndSym) {
451 // Create and insert a fragment into the current section that will be encoded
452 // later.
453 new MCCVInlineLineTableFragment(PrimaryFunctionId, SourceFileId,
454 SourceLineNum, FnStartSym, FnEndSym,
455 OS.getCurrentSectionOnly());
456}
457
460 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
461 StringRef FixedSizePortion) {
462 // Create and insert a fragment into the current section that will be encoded
463 // later.
464 return new MCCVDefRangeFragment(Ranges, FixedSizePortion,
465 OS.getCurrentSectionOnly());
466}
467
468static unsigned computeLabelDiff(MCAsmLayout &Layout, const MCSymbol *Begin,
469 const MCSymbol *End) {
470 MCContext &Ctx = Layout.getAssembler().getContext();
472 const MCExpr *BeginRef = MCSymbolRefExpr::create(Begin, Variant, Ctx),
473 *EndRef = MCSymbolRefExpr::create(End, Variant, Ctx);
474 const MCExpr *AddrDelta =
475 MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
476 int64_t Result;
477 bool Success = AddrDelta->evaluateKnownAbsolute(Result, Layout);
478 assert(Success && "failed to evaluate label difference as absolute");
479 (void)Success;
480 assert(Result >= 0 && "negative label difference requested");
481 assert(Result < UINT_MAX && "label difference greater than 2GB");
482 return unsigned(Result);
483}
484
487 size_t LocBegin;
488 size_t LocEnd;
489 std::tie(LocBegin, LocEnd) = getLineExtentIncludingInlinees(Frag.SiteFuncId);
490
491 if (LocBegin >= LocEnd)
492 return;
493 ArrayRef<MCCVLoc> Locs = getLinesForExtent(LocBegin, LocEnd);
494 if (Locs.empty())
495 return;
496
497 // Check that the locations are all in the same section.
498#ifndef NDEBUG
499 const MCSection *FirstSec = &Locs.front().getLabel()->getSection();
500 for (const MCCVLoc &Loc : Locs) {
501 if (&Loc.getLabel()->getSection() != FirstSec) {
502 errs() << ".cv_loc " << Loc.getFunctionId() << ' ' << Loc.getFileNum()
503 << ' ' << Loc.getLine() << ' ' << Loc.getColumn()
504 << " is in the wrong section\n";
505 llvm_unreachable(".cv_loc crosses sections");
506 }
507 }
508#endif
509
510 // Make an artificial start location using the function start and the inlinee
511 // lines start location information. All deltas start relative to this
512 // location.
513 MCCVLoc StartLoc = Locs.front();
514 StartLoc.setLabel(Frag.getFnStartSym());
515 StartLoc.setFileNum(Frag.StartFileId);
516 StartLoc.setLine(Frag.StartLineNum);
517 bool HaveOpenRange = false;
518
519 const MCSymbol *LastLabel = Frag.getFnStartSym();
520 MCCVFunctionInfo::LineInfo LastSourceLoc, CurSourceLoc;
521 LastSourceLoc.File = Frag.StartFileId;
522 LastSourceLoc.Line = Frag.StartLineNum;
523
524 MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(Frag.SiteFuncId);
525
526 SmallVectorImpl<char> &Buffer = Frag.getContents();
527 Buffer.clear(); // Clear old contents if we went through relaxation.
528 for (const MCCVLoc &Loc : Locs) {
529 // Exit early if our line table would produce an oversized InlineSiteSym
530 // record. Account for the ChangeCodeLength annotation emitted after the
531 // loop ends.
532 constexpr uint32_t InlineSiteSize = 12;
533 constexpr uint32_t AnnotationSize = 8;
534 size_t MaxBufferSize = MaxRecordLength - InlineSiteSize - AnnotationSize;
535 if (Buffer.size() >= MaxBufferSize)
536 break;
537
538 if (Loc.getFunctionId() == Frag.SiteFuncId) {
539 CurSourceLoc.File = Loc.getFileNum();
540 CurSourceLoc.Line = Loc.getLine();
541 } else {
542 auto I = SiteInfo->InlinedAtMap.find(Loc.getFunctionId());
543 if (I != SiteInfo->InlinedAtMap.end()) {
544 // This .cv_loc is from a child inline call site. Use the source
545 // location of the inlined call site instead of the .cv_loc directive
546 // source location.
547 CurSourceLoc = I->second;
548 } else {
549 // We've hit a cv_loc not attributed to this inline call site. Use this
550 // label to end the PC range.
551 if (HaveOpenRange) {
552 unsigned Length = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
553 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
554 compressAnnotation(Length, Buffer);
555 LastLabel = Loc.getLabel();
556 }
557 HaveOpenRange = false;
558 continue;
559 }
560 }
561
562 // Skip this .cv_loc if we have an open range and this isn't a meaningful
563 // source location update. The current table format does not support column
564 // info, so we can skip updates for those.
565 if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
566 CurSourceLoc.Line == LastSourceLoc.Line)
567 continue;
568
569 HaveOpenRange = true;
570
571 if (CurSourceLoc.File != LastSourceLoc.File) {
572 unsigned FileOffset = static_cast<const MCConstantExpr *>(
573 Files[CurSourceLoc.File - 1]
574 .ChecksumTableOffset->getVariableValue())
575 ->getValue();
576 compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
577 compressAnnotation(FileOffset, Buffer);
578 }
579
580 int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
581 unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
582 unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
583 if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) {
584 // The ChangeCodeOffsetAndLineOffset combination opcode is used when the
585 // encoded line delta uses 3 or fewer set bits and the code offset fits
586 // in one nibble.
587 unsigned Operand = (EncodedLineDelta << 4) | CodeDelta;
588 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset,
589 Buffer);
590 compressAnnotation(Operand, Buffer);
591 } else {
592 // Otherwise use the separate line and code deltas.
593 if (LineDelta != 0) {
594 compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
595 compressAnnotation(EncodedLineDelta, Buffer);
596 }
597 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffset, Buffer);
598 compressAnnotation(CodeDelta, Buffer);
599 }
600
601 LastLabel = Loc.getLabel();
602 LastSourceLoc = CurSourceLoc;
603 }
604
605 assert(HaveOpenRange);
606
607 unsigned EndSymLength =
608 computeLabelDiff(Layout, LastLabel, Frag.getFnEndSym());
609 unsigned LocAfterLength = ~0U;
610 ArrayRef<MCCVLoc> LocAfter = getLinesForExtent(LocEnd, LocEnd + 1);
611 if (!LocAfter.empty()) {
612 // Only try to compute this difference if we're in the same section.
613 const MCCVLoc &Loc = LocAfter[0];
614 if (&Loc.getLabel()->getSection() == &LastLabel->getSection())
615 LocAfterLength = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
616 }
617
618 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
619 compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
620}
621
623 MCCVDefRangeFragment &Frag) {
624 MCContext &Ctx = Layout.getAssembler().getContext();
625 SmallVectorImpl<char> &Contents = Frag.getContents();
626 Contents.clear();
627 SmallVectorImpl<MCFixup> &Fixups = Frag.getFixups();
628 Fixups.clear();
629 raw_svector_ostream OS(Contents);
630
631 // Compute all the sizes up front.
633 const MCSymbol *LastLabel = nullptr;
634 for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
635 unsigned GapSize =
636 LastLabel ? computeLabelDiff(Layout, LastLabel, Range.first) : 0;
637 unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
638 GapAndRangeSizes.push_back({GapSize, RangeSize});
639 LastLabel = Range.second;
640 }
641
642 // Write down each range where the variable is defined.
643 for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {
644 // If the range size of multiple consecutive ranges is under the max,
645 // combine the ranges and emit some gaps.
646 const MCSymbol *RangeBegin = Frag.getRanges()[I].first;
647 unsigned RangeSize = GapAndRangeSizes[I].second;
648 size_t J = I + 1;
649 for (; J != E; ++J) {
650 unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
651 if (RangeSize + GapAndRangeSize > MaxDefRange)
652 break;
653 RangeSize += GapAndRangeSize;
654 }
655 unsigned NumGaps = J - I - 1;
656
658
659 unsigned Bias = 0;
660 // We must split the range into chunks of MaxDefRange, this is a fundamental
661 // limitation of the file format.
662 do {
663 uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
664
665 const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);
666 const MCBinaryExpr *BE =
668
669 // Each record begins with a 2-byte number indicating how large the record
670 // is.
671 StringRef FixedSizePortion = Frag.getFixedSizePortion();
672 // Our record is a fixed sized prefix and a LocalVariableAddrRange that we
673 // are artificially constructing.
674 size_t RecordSize = FixedSizePortion.size() +
675 sizeof(LocalVariableAddrRange) + 4 * NumGaps;
676 // Write out the record size.
677 LEWriter.write<uint16_t>(RecordSize);
678 // Write out the fixed size prefix.
679 OS << FixedSizePortion;
680 // Make space for a fixup that will eventually have a section relative
681 // relocation pointing at the offset where the variable becomes live.
682 Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_4));
683 LEWriter.write<uint32_t>(0); // Fixup for code start.
684 // Make space for a fixup that will record the section index for the code.
685 Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_2));
686 LEWriter.write<uint16_t>(0); // Fixup for section index.
687 // Write down the range's extent.
688 LEWriter.write<uint16_t>(Chunk);
689
690 // Move on to the next range.
691 Bias += Chunk;
692 RangeSize -= Chunk;
693 } while (RangeSize > 0);
694
695 // Emit the gaps afterwards.
696 assert((NumGaps == 0 || Bias <= MaxDefRange) &&
697 "large ranges should not have gaps");
698 unsigned GapStartOffset = GapAndRangeSizes[I].second;
699 for (++I; I != J; ++I) {
700 unsigned GapSize, RangeSize;
701 assert(I < GapAndRangeSizes.size());
702 std::tie(GapSize, RangeSize) = GapAndRangeSizes[I];
703 LEWriter.write<uint16_t>(GapStartOffset);
704 LEWriter.write<uint16_t>(GapSize);
705 GapStartOffset += GapSize + RangeSize;
706 }
707 }
708}
#define Success
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
bool End
Definition: ELF_riscv.cpp:480
static unsigned computeLabelDiff(MCAsmLayout &Layout, const MCSymbol *Begin, const MCSymbol *End)
Definition: MCCodeView.cpp:468
static uint32_t encodeSignedNumber(uint32_t Data)
Definition: MCCodeView.cpp:439
static bool compressAnnotation(uint32_t Data, SmallVectorImpl< char > &Buffer)
Definition: MCCodeView.cpp:411
#define I(x, y, z)
Definition: MD5.cpp:58
Profile::FuncID FuncId
Definition: Profile.cpp:321
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file contains some functions that are useful when dealing with strings.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:168
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
ArrayRef< MCCVLoc > getLinesForExtent(size_t L, size_t R)
Definition: MCCodeView.cpp:342
std::pair< size_t, size_t > getLineExtent(unsigned FuncId)
Definition: MCCodeView.cpp:314
void emitLineTableForFunction(MCObjectStreamer &OS, unsigned FuncId, const MCSymbol *FuncBegin, const MCSymbol *FuncEnd)
Emits a line table substream.
Definition: MCCodeView.cpp:350
void emitFileChecksums(MCObjectStreamer &OS)
Emits the file checksum substream.
Definition: MCCodeView.cpp:193
void recordCVLoc(MCContext &Ctx, const MCSymbol *Label, unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt)
Saves the information from the currently parsed .cv_loc directive and sets CVLocSeen.
Definition: MCCodeView.cpp:131
bool addFile(MCStreamer &OS, unsigned FileNumber, StringRef Filename, ArrayRef< uint8_t > ChecksumBytes, uint8_t ChecksumKind)
Definition: MCCodeView.cpp:47
MCCVFunctionInfo * getCVFunctionInfo(unsigned FuncId)
Retreive the function info if this is a valid function id, or nullptr.
Definition: MCCodeView.cpp:79
bool recordFunctionId(unsigned FuncId)
Records the function id of a normal function.
Definition: MCCodeView.cpp:87
void emitFileChecksumOffset(MCObjectStreamer &OS, unsigned FileNo)
Emits the offset into the checksum table of the given file number.
Definition: MCCodeView.cpp:248
void encodeInlineLineTable(MCAsmLayout &Layout, MCCVInlineLineTableFragment &F)
Encodes the binary annotations once we have a layout.
Definition: MCCodeView.cpp:485
std::vector< MCCVLoc > getFunctionLineEntries(unsigned FuncId)
Definition: MCCodeView.cpp:276
void addLineEntry(const MCCVLoc &LineEntry)
Add a line entry.
Definition: MCCodeView.cpp:266
bool recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc, unsigned IAFile, unsigned IALine, unsigned IACol)
Records the function id of an inlined call site.
Definition: MCCodeView.cpp:100
std::pair< size_t, size_t > getLineExtentIncludingInlinees(unsigned FuncId)
Definition: MCCodeView.cpp:323
void emitInlineLineTableForFunction(MCObjectStreamer &OS, unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
Definition: MCCodeView.cpp:445
void emitStringTable(MCObjectStreamer &OS)
Emits the string table substream.
Definition: MCCodeView.cpp:171
void encodeDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &F)
Definition: MCCodeView.cpp:622
bool isValidFileNumber(unsigned FileNumber) const
This is a valid number for use with .cv_loc if we've already seen a .cv_file for it.
Definition: MCCodeView.cpp:40
MCFragment * emitDefRange(MCObjectStreamer &OS, ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > Ranges, StringRef FixedSizePortion)
Definition: MCCodeView.cpp:458
std::pair< StringRef, unsigned > addToStringTable(StringRef S)
Add something to the string table.
Definition: MCCodeView.cpp:148
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
MCAssembler & getAssembler() const
Get the assembler object this is a layout for.
Definition: MCAsmLayout.h:50
MCContext & getContext() const
Definition: MCAssembler.h:326
Binary assembler expressions.
Definition: MCExpr.h:492
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:536
static const MCBinaryExpr * create(Opcode Op, const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.cpp:183
@ Sub
Subtraction.
Definition: MCExpr.h:517
Fragment representing the .cv_def_range directive.
Definition: MCFragment.h:550
ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > getRanges() const
Definition: MCFragment.h:566
StringRef getFixedSizePortion() const
Definition: MCFragment.h:570
Fragment representing the binary annotations produced by the .cv_inline_linetable directive.
Definition: MCFragment.h:517
const MCSymbol * getFnStartSym() const
Definition: MCFragment.h:538
const MCSymbol * getFnEndSym() const
Definition: MCFragment.h:539
SmallString< 8 > & getContents()
Definition: MCFragment.h:541
Instances of this class represent the information from a .cv_loc directive.
Definition: MCCodeView.h:38
void setFileNum(unsigned fileNum)
Set the FileNum of this MCCVLoc.
Definition: MCCodeView.h:79
unsigned getFileNum() const
Get the FileNum of this MCCVLoc.
Definition: MCCodeView.h:63
const MCSymbol * getLabel() const
Definition: MCCodeView.h:58
void setLabel(const MCSymbol *L)
Definition: MCCodeView.h:74
unsigned getColumn() const
Get the Column of this MCCVLoc.
Definition: MCCodeView.h:69
unsigned getFunctionId() const
Definition: MCCodeView.h:60
void setLine(unsigned line)
Set the Line of this MCCVLoc.
Definition: MCCodeView.h:82
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
Context object for machine code objects.
Definition: MCContext.h:76
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:321
Fragment for data and encoded instructions.
Definition: MCFragment.h:242
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:197
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:223
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool evaluateKnownAbsolute(int64_t &Res, const MCAsmLayout &Layout) const
Definition: MCExpr.cpp:572
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
Definition: MCFixup.h:87
Streaming object file generation interface.
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
Streaming machine code generation interface.
Definition: MCStreamer.h:212
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:397
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:269
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:696
void resize(size_type N)
Definition: SmallVector.h:651
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
iterator end()
Definition: StringMap.h:221
iterator find(StringRef Key)
Definition: StringMap.h:234
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:307
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:690
This class represents a function that is read from a sample profile.
Definition: FunctionId.h:36
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
StringRef toStringRef(const std::optional< DWARFFormValue > &V, StringRef Default={})
Take an optional DWARFFormValue and try to extract a string value from it.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
@ Length
Definition: DWP.cpp:456
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1738
@ FK_SecRel_2
A two-byte section relative fixup.
Definition: MCFixup.h:41
@ FK_SecRel_4
A four-byte section relative fixup.
Definition: MCFixup.h:42
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Information describing a function or inlined call site introduced by .cv_func_id or ....
Definition: MCCodeView.h:98
DenseMap< unsigned, LineInfo > InlinedAtMap
Map from inlined call site id to the inlined at location to use for that call site.
Definition: MCCodeView.h:124
Adapter to write values to a stream in a particular byte order.
Definition: EndianStream.h:67
void write(ArrayRef< value_type > Val)
Definition: EndianStream.h:71