1 //===- MCCodeView.h - Machine Code CodeView support -------------*- 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 // Holds state from .cv_file and .cv_loc directives for later emission.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/MC/MCCodeView.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/StringExtras.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/MCAsmLayout.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCObjectStreamer.h"
23 #include "llvm/MC/MCValue.h"
24 #include "llvm/Support/EndianStream.h"
25
26 using namespace llvm;
27 using namespace llvm::codeview;
28
CodeViewContext()29 CodeViewContext::CodeViewContext() {}
30
~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;
36 }
37
38 /// This is a valid number for use with .cv_loc if we've already seen a .cv_file
39 /// for it.
isValidFileNumber(unsigned FileNumber) const40 bool 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
addFile(MCStreamer & OS,unsigned FileNumber,StringRef Filename,ArrayRef<uint8_t> ChecksumBytes,uint8_t ChecksumKind)47 bool 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
getCVFunctionInfo(unsigned FuncId)79 MCCVFunctionInfo *CodeViewContext::getCVFunctionInfo(unsigned FuncId) {
80 if (FuncId >= Functions.size())
81 return nullptr;
82 if (Functions[FuncId].isUnallocatedFunctionInfo())
83 return nullptr;
84 return &Functions[FuncId];
85 }
86
recordFunctionId(unsigned FuncId)87 bool CodeViewContext::recordFunctionId(unsigned FuncId) {
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
recordInlinedCallSiteId(unsigned FuncId,unsigned IAFunc,unsigned IAFile,unsigned IALine,unsigned IACol)100 bool CodeViewContext::recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc,
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
110 MCCVFunctionInfo::LineInfo InlinedAt;
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
getStringTableFragment()131 MCDataFragment *CodeViewContext::getStringTableFragment() {
132 if (!StrTabFragment) {
133 StrTabFragment = new MCDataFragment();
134 // Start a new string table out with a null byte.
135 StrTabFragment->getContents().push_back('\0');
136 }
137 return StrTabFragment;
138 }
139
addToStringTable(StringRef S)140 std::pair<StringRef, unsigned> CodeViewContext::addToStringTable(StringRef S) {
141 SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
142 auto Insertion =
143 StringTable.insert(std::make_pair(S, unsigned(Contents.size())));
144 // Return the string from the table, since it is stable.
145 std::pair<StringRef, unsigned> Ret =
146 std::make_pair(Insertion.first->first(), Insertion.first->second);
147 if (Insertion.second) {
148 // The string map key is always null terminated.
149 Contents.append(Ret.first.begin(), Ret.first.end() + 1);
150 }
151 return Ret;
152 }
153
getStringTableOffset(StringRef S)154 unsigned CodeViewContext::getStringTableOffset(StringRef S) {
155 // A string table offset of zero is always the empty string.
156 if (S.empty())
157 return 0;
158 auto I = StringTable.find(S);
159 assert(I != StringTable.end());
160 return I->second;
161 }
162
emitStringTable(MCObjectStreamer & OS)163 void CodeViewContext::emitStringTable(MCObjectStreamer &OS) {
164 MCContext &Ctx = OS.getContext();
165 MCSymbol *StringBegin = Ctx.createTempSymbol("strtab_begin", false),
166 *StringEnd = Ctx.createTempSymbol("strtab_end", false);
167
168 OS.EmitIntValue(unsigned(DebugSubsectionKind::StringTable), 4);
169 OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
170 OS.EmitLabel(StringBegin);
171
172 // Put the string table data fragment here, if we haven't already put it
173 // somewhere else. If somebody wants two string tables in their .s file, one
174 // will just be empty.
175 if (!InsertedStrTabFragment) {
176 OS.insert(getStringTableFragment());
177 InsertedStrTabFragment = true;
178 }
179
180 OS.EmitValueToAlignment(4, 0);
181
182 OS.EmitLabel(StringEnd);
183 }
184
emitFileChecksums(MCObjectStreamer & OS)185 void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) {
186 // Do nothing if there are no file checksums. Microsoft's linker rejects empty
187 // CodeView substreams.
188 if (Files.empty())
189 return;
190
191 MCContext &Ctx = OS.getContext();
192 MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
193 *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
194
195 OS.EmitIntValue(unsigned(DebugSubsectionKind::FileChecksums), 4);
196 OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
197 OS.EmitLabel(FileBegin);
198
199 unsigned CurrentOffset = 0;
200
201 // Emit an array of FileChecksum entries. We index into this table using the
202 // user-provided file number. Each entry may be a variable number of bytes
203 // determined by the checksum kind and size.
204 for (auto File : Files) {
205 OS.EmitAssignment(File.ChecksumTableOffset,
206 MCConstantExpr::create(CurrentOffset, Ctx));
207 CurrentOffset += 4; // String table offset.
208 if (!File.ChecksumKind) {
209 CurrentOffset +=
210 4; // One byte each for checksum size and kind, then align to 4 bytes.
211 } else {
212 CurrentOffset += 2; // One byte each for checksum size and kind.
213 CurrentOffset += File.Checksum.size();
214 CurrentOffset = alignTo(CurrentOffset, 4);
215 }
216
217 OS.EmitIntValue(File.StringTableOffset, 4);
218
219 if (!File.ChecksumKind) {
220 // There is no checksum. Therefore zero the next two fields and align
221 // back to 4 bytes.
222 OS.EmitIntValue(0, 4);
223 continue;
224 }
225 OS.EmitIntValue(static_cast<uint8_t>(File.Checksum.size()), 1);
226 OS.EmitIntValue(File.ChecksumKind, 1);
227 OS.EmitBytes(toStringRef(File.Checksum));
228 OS.EmitValueToAlignment(4);
229 }
230
231 OS.EmitLabel(FileEnd);
232
233 ChecksumOffsetsAssigned = true;
234 }
235
236 // Output checksum table offset of the given file number. It is possible that
237 // not all files have been registered yet, and so the offset cannot be
238 // calculated. In this case a symbol representing the offset is emitted, and
239 // the value of this symbol will be fixed up at a later time.
emitFileChecksumOffset(MCObjectStreamer & OS,unsigned FileNo)240 void CodeViewContext::emitFileChecksumOffset(MCObjectStreamer &OS,
241 unsigned FileNo) {
242 unsigned Idx = FileNo - 1;
243
244 if (Idx >= Files.size())
245 Files.resize(Idx + 1);
246
247 if (ChecksumOffsetsAssigned) {
248 OS.EmitSymbolValue(Files[Idx].ChecksumTableOffset, 4);
249 return;
250 }
251
252 const MCSymbolRefExpr *SRE =
253 MCSymbolRefExpr::create(Files[Idx].ChecksumTableOffset, OS.getContext());
254
255 OS.EmitValueImpl(SRE, 4);
256 }
257
addLineEntry(const MCCVLineEntry & LineEntry)258 void CodeViewContext::addLineEntry(const MCCVLineEntry &LineEntry) {
259 size_t Offset = MCCVLines.size();
260 auto I = MCCVLineStartStop.insert(
261 {LineEntry.getFunctionId(), {Offset, Offset + 1}});
262 if (!I.second)
263 I.first->second.second = Offset + 1;
264 MCCVLines.push_back(LineEntry);
265 }
266
267 std::vector<MCCVLineEntry>
getFunctionLineEntries(unsigned FuncId)268 CodeViewContext::getFunctionLineEntries(unsigned FuncId) {
269 std::vector<MCCVLineEntry> FilteredLines;
270 auto I = MCCVLineStartStop.find(FuncId);
271 if (I != MCCVLineStartStop.end()) {
272 MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(FuncId);
273 for (size_t Idx = I->second.first, End = I->second.second; Idx != End;
274 ++Idx) {
275 unsigned LocationFuncId = MCCVLines[Idx].getFunctionId();
276 if (LocationFuncId == FuncId) {
277 // This was a .cv_loc directly for FuncId, so record it.
278 FilteredLines.push_back(MCCVLines[Idx]);
279 } else {
280 // Check if the current location is inlined in this function. If it is,
281 // synthesize a statement .cv_loc at the original inlined call site.
282 auto I = SiteInfo->InlinedAtMap.find(LocationFuncId);
283 if (I != SiteInfo->InlinedAtMap.end()) {
284 MCCVFunctionInfo::LineInfo &IA = I->second;
285 // Only add the location if it differs from the previous location.
286 // Large inlined calls will have many .cv_loc entries and we only need
287 // one line table entry in the parent function.
288 if (FilteredLines.empty() ||
289 FilteredLines.back().getFileNum() != IA.File ||
290 FilteredLines.back().getLine() != IA.Line ||
291 FilteredLines.back().getColumn() != IA.Col) {
292 FilteredLines.push_back(MCCVLineEntry(
293 MCCVLines[Idx].getLabel(),
294 MCCVLoc(FuncId, IA.File, IA.Line, IA.Col, false, false)));
295 }
296 }
297 }
298 }
299 }
300 return FilteredLines;
301 }
302
getLineExtent(unsigned FuncId)303 std::pair<size_t, size_t> CodeViewContext::getLineExtent(unsigned FuncId) {
304 auto I = MCCVLineStartStop.find(FuncId);
305 // Return an empty extent if there are no cv_locs for this function id.
306 if (I == MCCVLineStartStop.end())
307 return {~0ULL, 0};
308 return I->second;
309 }
310
getLinesForExtent(size_t L,size_t R)311 ArrayRef<MCCVLineEntry> CodeViewContext::getLinesForExtent(size_t L, size_t R) {
312 if (R <= L)
313 return None;
314 if (L >= MCCVLines.size())
315 return None;
316 return makeArrayRef(&MCCVLines[L], R - L);
317 }
318
emitLineTableForFunction(MCObjectStreamer & OS,unsigned FuncId,const MCSymbol * FuncBegin,const MCSymbol * FuncEnd)319 void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
320 unsigned FuncId,
321 const MCSymbol *FuncBegin,
322 const MCSymbol *FuncEnd) {
323 MCContext &Ctx = OS.getContext();
324 MCSymbol *LineBegin = Ctx.createTempSymbol("linetable_begin", false),
325 *LineEnd = Ctx.createTempSymbol("linetable_end", false);
326
327 OS.EmitIntValue(unsigned(DebugSubsectionKind::Lines), 4);
328 OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
329 OS.EmitLabel(LineBegin);
330 OS.EmitCOFFSecRel32(FuncBegin, /*Offset=*/0);
331 OS.EmitCOFFSectionIndex(FuncBegin);
332
333 // Actual line info.
334 std::vector<MCCVLineEntry> Locs = getFunctionLineEntries(FuncId);
335 bool HaveColumns = any_of(Locs, [](const MCCVLineEntry &LineEntry) {
336 return LineEntry.getColumn() != 0;
337 });
338 OS.EmitIntValue(HaveColumns ? int(LF_HaveColumns) : 0, 2);
339 OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
340
341 for (auto I = Locs.begin(), E = Locs.end(); I != E;) {
342 // Emit a file segment for the run of locations that share a file id.
343 unsigned CurFileNum = I->getFileNum();
344 auto FileSegEnd =
345 std::find_if(I, E, [CurFileNum](const MCCVLineEntry &Loc) {
346 return Loc.getFileNum() != CurFileNum;
347 });
348 unsigned EntryCount = FileSegEnd - I;
349 OS.AddComment(
350 "Segment for file '" +
351 Twine(getStringTableFragment()
352 ->getContents()[Files[CurFileNum - 1].StringTableOffset]) +
353 "' begins");
354 OS.EmitCVFileChecksumOffsetDirective(CurFileNum);
355 OS.EmitIntValue(EntryCount, 4);
356 uint32_t SegmentSize = 12;
357 SegmentSize += 8 * EntryCount;
358 if (HaveColumns)
359 SegmentSize += 4 * EntryCount;
360 OS.EmitIntValue(SegmentSize, 4);
361
362 for (auto J = I; J != FileSegEnd; ++J) {
363 OS.emitAbsoluteSymbolDiff(J->getLabel(), FuncBegin, 4);
364 unsigned LineData = J->getLine();
365 if (J->isStmt())
366 LineData |= LineInfo::StatementFlag;
367 OS.EmitIntValue(LineData, 4);
368 }
369 if (HaveColumns) {
370 for (auto J = I; J != FileSegEnd; ++J) {
371 OS.EmitIntValue(J->getColumn(), 2);
372 OS.EmitIntValue(0, 2);
373 }
374 }
375 I = FileSegEnd;
376 }
377 OS.EmitLabel(LineEnd);
378 }
379
compressAnnotation(uint32_t Data,SmallVectorImpl<char> & Buffer)380 static bool compressAnnotation(uint32_t Data, SmallVectorImpl<char> &Buffer) {
381 if (isUInt<7>(Data)) {
382 Buffer.push_back(Data);
383 return true;
384 }
385
386 if (isUInt<14>(Data)) {
387 Buffer.push_back((Data >> 8) | 0x80);
388 Buffer.push_back(Data & 0xff);
389 return true;
390 }
391
392 if (isUInt<29>(Data)) {
393 Buffer.push_back((Data >> 24) | 0xC0);
394 Buffer.push_back((Data >> 16) & 0xff);
395 Buffer.push_back((Data >> 8) & 0xff);
396 Buffer.push_back(Data & 0xff);
397 return true;
398 }
399
400 return false;
401 }
402
compressAnnotation(BinaryAnnotationsOpCode Annotation,SmallVectorImpl<char> & Buffer)403 static bool compressAnnotation(BinaryAnnotationsOpCode Annotation,
404 SmallVectorImpl<char> &Buffer) {
405 return compressAnnotation(static_cast<uint32_t>(Annotation), Buffer);
406 }
407
encodeSignedNumber(uint32_t Data)408 static uint32_t encodeSignedNumber(uint32_t Data) {
409 if (Data >> 31)
410 return ((-Data) << 1) | 1;
411 return Data << 1;
412 }
413
emitInlineLineTableForFunction(MCObjectStreamer & OS,unsigned PrimaryFunctionId,unsigned SourceFileId,unsigned SourceLineNum,const MCSymbol * FnStartSym,const MCSymbol * FnEndSym)414 void CodeViewContext::emitInlineLineTableForFunction(MCObjectStreamer &OS,
415 unsigned PrimaryFunctionId,
416 unsigned SourceFileId,
417 unsigned SourceLineNum,
418 const MCSymbol *FnStartSym,
419 const MCSymbol *FnEndSym) {
420 // Create and insert a fragment into the current section that will be encoded
421 // later.
422 new MCCVInlineLineTableFragment(PrimaryFunctionId, SourceFileId,
423 SourceLineNum, FnStartSym, FnEndSym,
424 OS.getCurrentSectionOnly());
425 }
426
emitDefRange(MCObjectStreamer & OS,ArrayRef<std::pair<const MCSymbol *,const MCSymbol * >> Ranges,StringRef FixedSizePortion)427 void CodeViewContext::emitDefRange(
428 MCObjectStreamer &OS,
429 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
430 StringRef FixedSizePortion) {
431 // Create and insert a fragment into the current section that will be encoded
432 // later.
433 new MCCVDefRangeFragment(Ranges, FixedSizePortion,
434 OS.getCurrentSectionOnly());
435 }
436
computeLabelDiff(MCAsmLayout & Layout,const MCSymbol * Begin,const MCSymbol * End)437 static unsigned computeLabelDiff(MCAsmLayout &Layout, const MCSymbol *Begin,
438 const MCSymbol *End) {
439 MCContext &Ctx = Layout.getAssembler().getContext();
440 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
441 const MCExpr *BeginRef = MCSymbolRefExpr::create(Begin, Variant, Ctx),
442 *EndRef = MCSymbolRefExpr::create(End, Variant, Ctx);
443 const MCExpr *AddrDelta =
444 MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
445 int64_t Result;
446 bool Success = AddrDelta->evaluateKnownAbsolute(Result, Layout);
447 assert(Success && "failed to evaluate label difference as absolute");
448 (void)Success;
449 assert(Result >= 0 && "negative label difference requested");
450 assert(Result < UINT_MAX && "label difference greater than 2GB");
451 return unsigned(Result);
452 }
453
encodeInlineLineTable(MCAsmLayout & Layout,MCCVInlineLineTableFragment & Frag)454 void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
455 MCCVInlineLineTableFragment &Frag) {
456 size_t LocBegin;
457 size_t LocEnd;
458 std::tie(LocBegin, LocEnd) = getLineExtent(Frag.SiteFuncId);
459
460 // Include all child inline call sites in our .cv_loc extent.
461 MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(Frag.SiteFuncId);
462 for (auto &KV : SiteInfo->InlinedAtMap) {
463 unsigned ChildId = KV.first;
464 auto Extent = getLineExtent(ChildId);
465 LocBegin = std::min(LocBegin, Extent.first);
466 LocEnd = std::max(LocEnd, Extent.second);
467 }
468
469 if (LocBegin >= LocEnd)
470 return;
471 ArrayRef<MCCVLineEntry> Locs = getLinesForExtent(LocBegin, LocEnd);
472 if (Locs.empty())
473 return;
474
475 // Check that the locations are all in the same section.
476 #ifndef NDEBUG
477 const MCSection *FirstSec = &Locs.front().getLabel()->getSection();
478 for (const MCCVLineEntry &Loc : Locs) {
479 if (&Loc.getLabel()->getSection() != FirstSec) {
480 errs() << ".cv_loc " << Loc.getFunctionId() << ' ' << Loc.getFileNum()
481 << ' ' << Loc.getLine() << ' ' << Loc.getColumn()
482 << " is in the wrong section\n";
483 llvm_unreachable(".cv_loc crosses sections");
484 }
485 }
486 #endif
487
488 // Make an artificial start location using the function start and the inlinee
489 // lines start location information. All deltas start relative to this
490 // location.
491 MCCVLineEntry StartLoc(Frag.getFnStartSym(), MCCVLoc(Locs.front()));
492 StartLoc.setFileNum(Frag.StartFileId);
493 StartLoc.setLine(Frag.StartLineNum);
494 bool HaveOpenRange = false;
495
496 const MCSymbol *LastLabel = Frag.getFnStartSym();
497 MCCVFunctionInfo::LineInfo LastSourceLoc, CurSourceLoc;
498 LastSourceLoc.File = Frag.StartFileId;
499 LastSourceLoc.Line = Frag.StartLineNum;
500
501 SmallVectorImpl<char> &Buffer = Frag.getContents();
502 Buffer.clear(); // Clear old contents if we went through relaxation.
503 for (const MCCVLineEntry &Loc : Locs) {
504 // Exit early if our line table would produce an oversized InlineSiteSym
505 // record. Account for the ChangeCodeLength annotation emitted after the
506 // loop ends.
507 constexpr uint32_t InlineSiteSize = 12;
508 constexpr uint32_t AnnotationSize = 8;
509 size_t MaxBufferSize = MaxRecordLength - InlineSiteSize - AnnotationSize;
510 if (Buffer.size() >= MaxBufferSize)
511 break;
512
513 if (Loc.getFunctionId() == Frag.SiteFuncId) {
514 CurSourceLoc.File = Loc.getFileNum();
515 CurSourceLoc.Line = Loc.getLine();
516 } else {
517 auto I = SiteInfo->InlinedAtMap.find(Loc.getFunctionId());
518 if (I != SiteInfo->InlinedAtMap.end()) {
519 // This .cv_loc is from a child inline call site. Use the source
520 // location of the inlined call site instead of the .cv_loc directive
521 // source location.
522 CurSourceLoc = I->second;
523 } else {
524 // We've hit a cv_loc not attributed to this inline call site. Use this
525 // label to end the PC range.
526 if (HaveOpenRange) {
527 unsigned Length = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
528 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
529 compressAnnotation(Length, Buffer);
530 LastLabel = Loc.getLabel();
531 }
532 HaveOpenRange = false;
533 continue;
534 }
535 }
536
537 // Skip this .cv_loc if we have an open range and this isn't a meaningful
538 // source location update. The current table format does not support column
539 // info, so we can skip updates for those.
540 if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
541 CurSourceLoc.Line == LastSourceLoc.Line)
542 continue;
543
544 HaveOpenRange = true;
545
546 if (CurSourceLoc.File != LastSourceLoc.File) {
547 unsigned FileOffset = static_cast<const MCConstantExpr *>(
548 Files[CurSourceLoc.File - 1]
549 .ChecksumTableOffset->getVariableValue())
550 ->getValue();
551 compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
552 compressAnnotation(FileOffset, Buffer);
553 }
554
555 int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
556 unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
557 unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
558 if (CodeDelta == 0 && LineDelta != 0) {
559 compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
560 compressAnnotation(EncodedLineDelta, Buffer);
561 } else if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) {
562 // The ChangeCodeOffsetAndLineOffset combination opcode is used when the
563 // encoded line delta uses 3 or fewer set bits and the code offset fits
564 // in one nibble.
565 unsigned Operand = (EncodedLineDelta << 4) | CodeDelta;
566 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset,
567 Buffer);
568 compressAnnotation(Operand, Buffer);
569 } else {
570 // Otherwise use the separate line and code deltas.
571 if (LineDelta != 0) {
572 compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
573 compressAnnotation(EncodedLineDelta, Buffer);
574 }
575 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffset, Buffer);
576 compressAnnotation(CodeDelta, Buffer);
577 }
578
579 LastLabel = Loc.getLabel();
580 LastSourceLoc = CurSourceLoc;
581 }
582
583 assert(HaveOpenRange);
584
585 unsigned EndSymLength =
586 computeLabelDiff(Layout, LastLabel, Frag.getFnEndSym());
587 unsigned LocAfterLength = ~0U;
588 ArrayRef<MCCVLineEntry> LocAfter = getLinesForExtent(LocEnd, LocEnd + 1);
589 if (!LocAfter.empty()) {
590 // Only try to compute this difference if we're in the same section.
591 const MCCVLineEntry &Loc = LocAfter[0];
592 if (&Loc.getLabel()->getSection() == &LastLabel->getSection())
593 LocAfterLength = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
594 }
595
596 compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
597 compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
598 }
599
encodeDefRange(MCAsmLayout & Layout,MCCVDefRangeFragment & Frag)600 void CodeViewContext::encodeDefRange(MCAsmLayout &Layout,
601 MCCVDefRangeFragment &Frag) {
602 MCContext &Ctx = Layout.getAssembler().getContext();
603 SmallVectorImpl<char> &Contents = Frag.getContents();
604 Contents.clear();
605 SmallVectorImpl<MCFixup> &Fixups = Frag.getFixups();
606 Fixups.clear();
607 raw_svector_ostream OS(Contents);
608
609 // Compute all the sizes up front.
610 SmallVector<std::pair<unsigned, unsigned>, 4> GapAndRangeSizes;
611 const MCSymbol *LastLabel = nullptr;
612 for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
613 unsigned GapSize =
614 LastLabel ? computeLabelDiff(Layout, LastLabel, Range.first) : 0;
615 unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
616 GapAndRangeSizes.push_back({GapSize, RangeSize});
617 LastLabel = Range.second;
618 }
619
620 // Write down each range where the variable is defined.
621 for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {
622 // If the range size of multiple consecutive ranges is under the max,
623 // combine the ranges and emit some gaps.
624 const MCSymbol *RangeBegin = Frag.getRanges()[I].first;
625 unsigned RangeSize = GapAndRangeSizes[I].second;
626 size_t J = I + 1;
627 for (; J != E; ++J) {
628 unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
629 if (RangeSize + GapAndRangeSize > MaxDefRange)
630 break;
631 RangeSize += GapAndRangeSize;
632 }
633 unsigned NumGaps = J - I - 1;
634
635 support::endian::Writer LEWriter(OS, support::little);
636
637 unsigned Bias = 0;
638 // We must split the range into chunks of MaxDefRange, this is a fundamental
639 // limitation of the file format.
640 do {
641 uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
642
643 const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);
644 const MCBinaryExpr *BE =
645 MCBinaryExpr::createAdd(SRE, MCConstantExpr::create(Bias, Ctx), Ctx);
646 MCValue Res;
647 BE->evaluateAsRelocatable(Res, &Layout, /*Fixup=*/nullptr);
648
649 // Each record begins with a 2-byte number indicating how large the record
650 // is.
651 StringRef FixedSizePortion = Frag.getFixedSizePortion();
652 // Our record is a fixed sized prefix and a LocalVariableAddrRange that we
653 // are artificially constructing.
654 size_t RecordSize = FixedSizePortion.size() +
655 sizeof(LocalVariableAddrRange) + 4 * NumGaps;
656 // Write out the record size.
657 LEWriter.write<uint16_t>(RecordSize);
658 // Write out the fixed size prefix.
659 OS << FixedSizePortion;
660 // Make space for a fixup that will eventually have a section relative
661 // relocation pointing at the offset where the variable becomes live.
662 Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_4));
663 LEWriter.write<uint32_t>(0); // Fixup for code start.
664 // Make space for a fixup that will record the section index for the code.
665 Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_2));
666 LEWriter.write<uint16_t>(0); // Fixup for section index.
667 // Write down the range's extent.
668 LEWriter.write<uint16_t>(Chunk);
669
670 // Move on to the next range.
671 Bias += Chunk;
672 RangeSize -= Chunk;
673 } while (RangeSize > 0);
674
675 // Emit the gaps afterwards.
676 assert((NumGaps == 0 || Bias <= MaxDefRange) &&
677 "large ranges should not have gaps");
678 unsigned GapStartOffset = GapAndRangeSizes[I].second;
679 for (++I; I != J; ++I) {
680 unsigned GapSize, RangeSize;
681 assert(I < GapAndRangeSizes.size());
682 std::tie(GapSize, RangeSize) = GapAndRangeSizes[I];
683 LEWriter.write<uint16_t>(GapStartOffset);
684 LEWriter.write<uint16_t>(GapSize);
685 GapStartOffset += GapSize + RangeSize;
686 }
687 }
688 }
689
690 //
691 // This is called when an instruction is assembled into the specified section
692 // and if there is information from the last .cv_loc directive that has yet to have
693 // a line entry made for it is made.
694 //
Make(MCObjectStreamer * MCOS)695 void MCCVLineEntry::Make(MCObjectStreamer *MCOS) {
696 CodeViewContext &CVC = MCOS->getContext().getCVContext();
697 if (!CVC.getCVLocSeen())
698 return;
699
700 // Create a symbol at in the current section for use in the line entry.
701 MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
702 // Set the value of the symbol to use for the MCCVLineEntry.
703 MCOS->EmitLabel(LineSym);
704
705 // Get the current .loc info saved in the context.
706 const MCCVLoc &CVLoc = CVC.getCurrentCVLoc();
707
708 // Create a (local) line entry with the symbol and the current .loc info.
709 MCCVLineEntry LineEntry(LineSym, CVLoc);
710
711 // clear CVLocSeen saying the current .loc info is now used.
712 CVC.clearCVLocSeen();
713
714 // Add the line entry to this section's entries.
715 CVC.addLineEntry(LineEntry);
716 }
717