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/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"
25 
26 using namespace llvm;
27 using namespace llvm::codeview;
28 
29 CodeViewContext::CodeViewContext() {}
30 
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.
40 bool CodeViewContext::isValidFileNumber(unsigned FileNumber) const {
41   unsigned Idx = FileNumber - 1;
42   if (Idx < Filenames.size())
43     return !Filenames[Idx].empty();
44   return false;
45 }
46 
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);
53 
54   if (Filename.empty())
55     Filename = "<stdin>";
56 
57   if (!Filenames[Idx].empty())
58     return false;
59 
60   // FIXME: We should store the string table offset of the filename, rather than
61   // the filename itself for efficiency.
62   Filename = addToStringTable(Filename);
63 
64   Filenames[Idx] = Filename;
65   return true;
66 }
67 
68 bool CodeViewContext::recordFunctionId(unsigned FuncId) {
69   if (FuncId >= Functions.size())
70     Functions.resize(FuncId + 1);
71 
72   // Return false if this function info was already allocated.
73   if (!Functions[FuncId].isUnallocatedFunctionInfo())
74     return false;
75 
76   // Mark this as an allocated normal function, and leave the rest alone.
77   Functions[FuncId].ParentFuncIdPlusOne = MCCVFunctionInfo::FunctionSentinel;
78   return true;
79 }
80 
81 bool CodeViewContext::recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc,
82                                               unsigned IAFile, unsigned IALine,
83                                               unsigned IACol) {
84   if (FuncId >= Functions.size())
85     Functions.resize(FuncId + 1);
86 
87   // Return false if this function info was already allocated.
88   if (!Functions[FuncId].isUnallocatedFunctionInfo())
89     return false;
90 
91   MCCVFunctionInfo::LineInfo InlinedAt;
92   InlinedAt.File = IAFile;
93   InlinedAt.Line = IALine;
94   InlinedAt.Col = IACol;
95 
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;
100 
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;
107   }
108 
109   return true;
110 }
111 
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');
117   }
118   return StrTabFragment;
119 }
120 
121 StringRef CodeViewContext::addToStringTable(StringRef S) {
122   SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
123   auto Insertion =
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);
130   }
131   return S;
132 }
133 
134 unsigned CodeViewContext::getStringTableOffset(StringRef S) {
135   // A string table offset of zero is always the empty string.
136   if (S.empty())
137     return 0;
138   auto I = StringTable.find(S);
139   assert(I != StringTable.end());
140   return I->second;
141 }
142 
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);
147 
148   OS.EmitIntValue(unsigned(ModuleSubstreamKind::StringTable), 4);
149   OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
150   OS.EmitLabel(StringBegin);
151 
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;
158   }
159 
160   OS.EmitValueToAlignment(4, 0);
161 
162   OS.EmitLabel(StringEnd);
163 }
164 
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())
169     return;
170 
171   MCContext &Ctx = OS.getContext();
172   MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
173            *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
174 
175   OS.EmitIntValue(unsigned(ModuleSubstreamKind::FileChecksums), 4);
176   OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
177   OS.EmitLabel(FileBegin);
178 
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
181   // emit checksums.
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);
187   }
188 
189   OS.EmitLabel(FileEnd);
190 }
191 
192 void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
193                                                unsigned FuncId,
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);
199 
200   OS.EmitIntValue(unsigned(ModuleSubstreamKind::Lines), 4);
201   OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
202   OS.EmitLabel(LineBegin);
203   OS.EmitCOFFSecRel32(FuncBegin);
204   OS.EmitCOFFSectionIndex(FuncBegin);
205 
206   // Actual line info.
207   std::vector<MCCVLineEntry> Locs = getFunctionLineEntries(FuncId);
208   bool HaveColumns = any_of(Locs, [](const MCCVLineEntry &LineEntry) {
209     return LineEntry.getColumn() != 0;
210   });
211   OS.EmitIntValue(HaveColumns ? int(LineFlags::HaveColumns) : 0, 2);
212   OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
213 
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();
217     auto FileSegEnd =
218         std::find_if(I, E, [CurFileNum](const MCCVLineEntry &Loc) {
219           return Loc.getFileNum() != CurFileNum;
220         });
221     unsigned EntryCount = FileSegEnd - I;
222     OS.AddComment("Segment for file '" + Twine(Filenames[CurFileNum - 1]) +
223                   "' begins");
224     OS.EmitIntValue(8 * (CurFileNum - 1), 4);
225     OS.EmitIntValue(EntryCount, 4);
226     uint32_t SegmentSize = 12;
227     SegmentSize += 8 * EntryCount;
228     if (HaveColumns)
229       SegmentSize += 4 * EntryCount;
230     OS.EmitIntValue(SegmentSize, 4);
231 
232     for (auto J = I; J != FileSegEnd; ++J) {
233       OS.emitAbsoluteSymbolDiff(J->getLabel(), FuncBegin, 4);
234       unsigned LineData = J->getLine();
235       if (J->isStmt())
236         LineData |= LineInfo::StatementFlag;
237       OS.EmitIntValue(LineData, 4);
238     }
239     if (HaveColumns) {
240       for (auto J = I; J != FileSegEnd; ++J) {
241         OS.EmitIntValue(J->getColumn(), 2);
242         OS.EmitIntValue(0, 2);
243       }
244     }
245     I = FileSegEnd;
246   }
247   OS.EmitLabel(LineEnd);
248 }
249 
250 static bool compressAnnotation(uint32_t Data, SmallVectorImpl<char> &Buffer) {
251   if (isUInt<7>(Data)) {
252     Buffer.push_back(Data);
253     return true;
254   }
255 
256   if (isUInt<14>(Data)) {
257     Buffer.push_back((Data >> 8) | 0x80);
258     Buffer.push_back(Data & 0xff);
259     return true;
260   }
261 
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);
267     return true;
268   }
269 
270   return false;
271 }
272 
273 static bool compressAnnotation(BinaryAnnotationsOpCode Annotation,
274                                SmallVectorImpl<char> &Buffer) {
275   return compressAnnotation(static_cast<uint32_t>(Annotation), Buffer);
276 }
277 
278 static uint32_t encodeSignedNumber(uint32_t Data) {
279   if (Data >> 31)
280     return ((-Data) << 1) | 1;
281   return Data << 1;
282 }
283 
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
291   // later.
292   new MCCVInlineLineTableFragment(PrimaryFunctionId, SourceFileId,
293                                   SourceLineNum, FnStartSym, FnEndSym,
294                                   OS.getCurrentSectionOnly());
295 }
296 
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
302   // later.
303   new MCCVDefRangeFragment(Ranges, FixedSizePortion,
304                            OS.getCurrentSectionOnly());
305 }
306 
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);
315   int64_t Result;
316   bool Success = AddrDelta->evaluateKnownAbsolute(Result, Layout);
317   assert(Success && "failed to evaluate label difference as absolute");
318   (void)Success;
319   assert(Result >= 0 && "negative label difference requested");
320   assert(Result < UINT_MAX && "label difference greater than 2GB");
321   return unsigned(Result);
322 }
323 
324 void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
325                                             MCCVInlineLineTableFragment &Frag) {
326   size_t LocBegin;
327   size_t LocEnd;
328   std::tie(LocBegin, LocEnd) = getLineExtent(Frag.SiteFuncId);
329 
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);
337   }
338 
339   if (LocBegin >= LocEnd)
340     return;
341   ArrayRef<MCCVLineEntry> Locs = getLinesForExtent(LocBegin, LocEnd);
342   if (Locs.empty())
343     return;
344 
345   // Make an artificial start location using the function start and the inlinee
346   // lines start location information. All deltas start relative to this
347   // location.
348   MCCVLineEntry StartLoc(Frag.getFnStartSym(), MCCVLoc(Locs.front()));
349   StartLoc.setFileNum(Frag.StartFileId);
350   StartLoc.setLine(Frag.StartLineNum);
351   bool HaveOpenRange = false;
352 
353   const MCSymbol *LastLabel = Frag.getFnStartSym();
354   MCCVFunctionInfo::LineInfo LastSourceLoc, CurSourceLoc;
355   LastSourceLoc.File = Frag.StartFileId;
356   LastSourceLoc.Line = Frag.StartLineNum;
357 
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
363     // loop ends.
364     size_t MaxBufferSize = MaxRecordLength - sizeof(InlineSiteSym::Hdr) - 8;
365     if (Buffer.size() >= MaxBufferSize)
366       break;
367 
368     if (Loc.getFunctionId() == Frag.SiteFuncId) {
369       CurSourceLoc.File = Loc.getFileNum();
370       CurSourceLoc.Line = Loc.getLine();
371     } else {
372       auto I = SiteInfo->InlinedAtMap.find(Loc.getFunctionId());
373       if (I != SiteInfo->InlinedAtMap.end()) {
374         // This .cv_loc is from a child inline call site. Use the source
375         // location of the inlined call site instead of the .cv_loc directive
376         // source location.
377         CurSourceLoc = I->second;
378       } else {
379         // We've hit a cv_loc not attributed to this inline call site. Use this
380         // label to end the PC range.
381         if (HaveOpenRange) {
382           unsigned Length = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
383           compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
384           compressAnnotation(Length, Buffer);
385           LastLabel = Loc.getLabel();
386         }
387         HaveOpenRange = false;
388         continue;
389       }
390     }
391 
392     // Skip this .cv_loc if we have an open range and this isn't a meaningful
393     // source location update. The current table format does not support column
394     // info, so we can skip updates for those.
395     if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
396         CurSourceLoc.Line == LastSourceLoc.Line)
397       continue;
398 
399     HaveOpenRange = true;
400 
401     if (CurSourceLoc.File != LastSourceLoc.File) {
402       // File ids are 1 based, and each file checksum table entry is 8 bytes
403       // long. See emitFileChecksums above.
404       unsigned FileOffset = 8 * (CurSourceLoc.File - 1);
405       compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
406       compressAnnotation(FileOffset, Buffer);
407     }
408 
409     int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
410     unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
411     unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
412     if (CodeDelta == 0 && LineDelta != 0) {
413       compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
414       compressAnnotation(EncodedLineDelta, Buffer);
415     } else if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) {
416       // The ChangeCodeOffsetAndLineOffset combination opcode is used when the
417       // encoded line delta uses 3 or fewer set bits and the code offset fits
418       // in one nibble.
419       unsigned Operand = (EncodedLineDelta << 4) | CodeDelta;
420       compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset,
421                          Buffer);
422       compressAnnotation(Operand, Buffer);
423     } else {
424       // Otherwise use the separate line and code deltas.
425       if (LineDelta != 0) {
426         compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
427         compressAnnotation(EncodedLineDelta, Buffer);
428       }
429       compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffset, Buffer);
430       compressAnnotation(CodeDelta, Buffer);
431     }
432 
433     LastLabel = Loc.getLabel();
434     LastSourceLoc = CurSourceLoc;
435   }
436 
437   assert(HaveOpenRange);
438 
439   unsigned EndSymLength =
440       computeLabelDiff(Layout, LastLabel, Frag.getFnEndSym());
441   unsigned LocAfterLength = ~0U;
442   ArrayRef<MCCVLineEntry> LocAfter = getLinesForExtent(LocEnd, LocEnd + 1);
443   if (!LocAfter.empty()) {
444     // Only try to compute this difference if we're in the same section.
445     const MCCVLineEntry &Loc = LocAfter[0];
446     if (&Loc.getLabel()->getSection(false) == &LastLabel->getSection(false))
447       LocAfterLength = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
448   }
449 
450   compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
451   compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
452 }
453 
454 void CodeViewContext::encodeDefRange(MCAsmLayout &Layout,
455                                      MCCVDefRangeFragment &Frag) {
456   MCContext &Ctx = Layout.getAssembler().getContext();
457   SmallVectorImpl<char> &Contents = Frag.getContents();
458   Contents.clear();
459   SmallVectorImpl<MCFixup> &Fixups = Frag.getFixups();
460   Fixups.clear();
461   raw_svector_ostream OS(Contents);
462 
463   // Compute all the sizes up front.
464   SmallVector<std::pair<unsigned, unsigned>, 4> GapAndRangeSizes;
465   const MCSymbol *LastLabel = nullptr;
466   for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
467     unsigned GapSize =
468         LastLabel ? computeLabelDiff(Layout, LastLabel, Range.first) : 0;
469     unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
470     GapAndRangeSizes.push_back({GapSize, RangeSize});
471     LastLabel = Range.second;
472   }
473 
474   // Write down each range where the variable is defined.
475   for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {
476     // If the range size of multiple consecutive ranges is under the max,
477     // combine the ranges and emit some gaps.
478     const MCSymbol *RangeBegin = Frag.getRanges()[I].first;
479     unsigned RangeSize = GapAndRangeSizes[I].second;
480     size_t J = I + 1;
481     for (; J != E; ++J) {
482       unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
483       if (RangeSize + GapAndRangeSize > MaxDefRange)
484         break;
485       RangeSize += GapAndRangeSize;
486     }
487     unsigned NumGaps = J - I - 1;
488 
489     support::endian::Writer<support::little> LEWriter(OS);
490 
491     unsigned Bias = 0;
492     // We must split the range into chunks of MaxDefRange, this is a fundamental
493     // limitation of the file format.
494     do {
495       uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
496 
497       const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);
498       const MCBinaryExpr *BE =
499           MCBinaryExpr::createAdd(SRE, MCConstantExpr::create(Bias, Ctx), Ctx);
500       MCValue Res;
501       BE->evaluateAsRelocatable(Res, &Layout, /*Fixup=*/nullptr);
502 
503       // Each record begins with a 2-byte number indicating how large the record
504       // is.
505       StringRef FixedSizePortion = Frag.getFixedSizePortion();
506       // Our record is a fixed sized prefix and a LocalVariableAddrRange that we
507       // are artificially constructing.
508       size_t RecordSize = FixedSizePortion.size() +
509                           sizeof(LocalVariableAddrRange) + 4 * NumGaps;
510       // Write out the recrod size.
511       support::endian::Writer<support::little>(OS).write<uint16_t>(RecordSize);
512       // Write out the fixed size prefix.
513       OS << FixedSizePortion;
514       // Make space for a fixup that will eventually have a section relative
515       // relocation pointing at the offset where the variable becomes live.
516       Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_4));
517       Contents.resize(Contents.size() + 4); // Fixup for code start.
518       // Make space for a fixup that will record the section index for the code.
519       Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_2));
520       Contents.resize(Contents.size() + 2); // Fixup for section index.
521       // Write down the range's extent.
522       LEWriter.write<uint16_t>(Chunk);
523 
524       // Move on to the next range.
525       Bias += Chunk;
526       RangeSize -= Chunk;
527     } while (RangeSize > 0);
528 
529     // Emit the gaps afterwards.
530     assert((NumGaps == 0 || Bias < MaxDefRange) &&
531            "large ranges should not have gaps");
532     unsigned GapStartOffset = GapAndRangeSizes[I].second;
533     for (++I; I != J; ++I) {
534       unsigned GapSize, RangeSize;
535       assert(I < GapAndRangeSizes.size());
536       std::tie(GapSize, RangeSize) = GapAndRangeSizes[I];
537       LEWriter.write<uint16_t>(GapStartOffset);
538       LEWriter.write<uint16_t>(RangeSize);
539       GapStartOffset += GapSize + RangeSize;
540     }
541   }
542 }
543 
544 //
545 // This is called when an instruction is assembled into the specified section
546 // and if there is information from the last .cv_loc directive that has yet to have
547 // a line entry made for it is made.
548 //
549 void MCCVLineEntry::Make(MCObjectStreamer *MCOS) {
550   CodeViewContext &CVC = MCOS->getContext().getCVContext();
551   if (!CVC.getCVLocSeen())
552     return;
553 
554   // Create a symbol at in the current section for use in the line entry.
555   MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
556   // Set the value of the symbol to use for the MCCVLineEntry.
557   MCOS->EmitLabel(LineSym);
558 
559   // Get the current .loc info saved in the context.
560   const MCCVLoc &CVLoc = CVC.getCurrentCVLoc();
561 
562   // Create a (local) line entry with the symbol and the current .loc info.
563   MCCVLineEntry LineEntry(LineSym, CVLoc);
564 
565   // clear CVLocSeen saying the current .loc info is now used.
566   CVC.clearCVLocSeen();
567 
568   // Add the line entry to this section's entries.
569   CVC.addLineEntry(LineEntry);
570 }
571