LCOV - code coverage report
Current view: top level - lib/MC - MCCodeView.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 275 293 93.9 %
Date: 2018-02-18 16:14:26 Functions: 24 25 96.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      29       25692 : CodeViewContext::CodeViewContext() {}
      30             : 
      31       19210 : CodeViewContext::~CodeViewContext() {
      32             :   // If someone inserted strings into the string table but never actually
      33             :   // emitted them somewhere, clean up the fragment.
      34        6403 :   if (!InsertedStrTabFragment)
      35        6384 :     delete StrTabFragment;
      36        6404 : }
      37             : 
      38             : /// This is a valid number for use with .cv_loc if we've already seen a .cv_file
      39             : /// for it.
      40          91 : bool CodeViewContext::isValidFileNumber(unsigned FileNumber) const {
      41          91 :   unsigned Idx = FileNumber - 1;
      42         182 :   if (Idx < Files.size())
      43          90 :     return Files[Idx].Assigned;
      44             :   return false;
      45             : }
      46             : 
      47         127 : bool CodeViewContext::addFile(MCStreamer &OS, unsigned FileNumber,
      48             :                               StringRef Filename,
      49             :                               ArrayRef<uint8_t> ChecksumBytes,
      50             :                               uint8_t ChecksumKind) {
      51             :   assert(FileNumber > 0);
      52         127 :   auto FilenameOffset = addToStringTable(Filename);
      53         127 :   Filename = FilenameOffset.first;
      54         127 :   unsigned Idx = FileNumber - 1;
      55         254 :   if (Idx >= Files.size())
      56         127 :     Files.resize(Idx + 1);
      57             : 
      58         127 :   if (Filename.empty())
      59           0 :     Filename = "<stdin>";
      60             : 
      61         127 :   if (Files[Idx].Assigned)
      62             :     return false;
      63             : 
      64         254 :   FilenameOffset = addToStringTable(Filename);
      65             :   Filename = FilenameOffset.first;
      66             :   unsigned Offset = FilenameOffset.second;
      67             : 
      68             :   auto ChecksumOffsetSymbol =
      69         127 :       OS.getContext().createTempSymbol("checksum_offset", false);
      70         127 :   Files[Idx].StringTableOffset = Offset;
      71         127 :   Files[Idx].ChecksumTableOffset = ChecksumOffsetSymbol;
      72         127 :   Files[Idx].Assigned = true;
      73         127 :   Files[Idx].Checksum = ChecksumBytes;
      74         127 :   Files[Idx].ChecksumKind = ChecksumKind;
      75             : 
      76         127 :   return true;
      77             : }
      78             : 
      79        1006 : MCCVFunctionInfo *CodeViewContext::getCVFunctionInfo(unsigned FuncId) {
      80        2012 :   if (FuncId >= Functions.size())
      81             :     return nullptr;
      82        1006 :   if (Functions[FuncId].isUnallocatedFunctionInfo())
      83             :     return nullptr;
      84        1006 :   return &Functions[FuncId];
      85             : }
      86             : 
      87         200 : bool CodeViewContext::recordFunctionId(unsigned FuncId) {
      88         400 :   if (FuncId >= Functions.size())
      89         200 :     Functions.resize(FuncId + 1);
      90             : 
      91             :   // Return false if this function info was already allocated.
      92         200 :   if (!Functions[FuncId].isUnallocatedFunctionInfo())
      93             :     return false;
      94             : 
      95             :   // Mark this as an allocated normal function, and leave the rest alone.
      96         200 :   Functions[FuncId].ParentFuncIdPlusOne = MCCVFunctionInfo::FunctionSentinel;
      97         200 :   return true;
      98             : }
      99             : 
     100          31 : bool CodeViewContext::recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc,
     101             :                                               unsigned IAFile, unsigned IALine,
     102             :                                               unsigned IACol) {
     103          62 :   if (FuncId >= Functions.size())
     104          30 :     Functions.resize(FuncId + 1);
     105             : 
     106             :   // Return false if this function info was already allocated.
     107          62 :   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          30 :   Info->ParentFuncIdPlusOne = IAFunc + 1;
     118          30 :   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          38 :   while (Info->isInlinedCallSite()) {
     123          38 :     InlinedAt = Info->InlinedAt;
     124          38 :     Info = getCVFunctionInfo(Info->getParentFuncId());
     125          76 :     Info->InlinedAtMap[FuncId] = InlinedAt;
     126             :   }
     127             : 
     128             :   return true;
     129             : }
     130             : 
     131         540 : MCDataFragment *CodeViewContext::getStringTableFragment() {
     132         540 :   if (!StrTabFragment) {
     133         260 :     StrTabFragment = new MCDataFragment();
     134             :     // Start a new string table out with a null byte.
     135         130 :     StrTabFragment->getContents().push_back('\0');
     136             :   }
     137         540 :   return StrTabFragment;
     138             : }
     139             : 
     140         352 : std::pair<StringRef, unsigned> CodeViewContext::addToStringTable(StringRef S) {
     141         352 :   SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
     142             :   auto Insertion =
     143         704 :       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         352 :   if (Insertion.second) {
     148             :     // The string map key is always null terminated.
     149         186 :     Contents.append(Ret.first.begin(), Ret.first.end() + 1);
     150             :   }
     151         352 :   return Ret;
     152             : }
     153             : 
     154           0 : unsigned CodeViewContext::getStringTableOffset(StringRef S) {
     155             :   // A string table offset of zero is always the empty string.
     156           0 :   if (S.empty())
     157             :     return 0;
     158           0 :   auto I = StringTable.find(S);
     159             :   assert(I != StringTable.end());
     160           0 :   return I->second;
     161             : }
     162             : 
     163          75 : void CodeViewContext::emitStringTable(MCObjectStreamer &OS) {
     164             :   MCContext &Ctx = OS.getContext();
     165          75 :   MCSymbol *StringBegin = Ctx.createTempSymbol("strtab_begin", false),
     166          75 :            *StringEnd = Ctx.createTempSymbol("strtab_end", false);
     167             : 
     168          75 :   OS.EmitIntValue(unsigned(DebugSubsectionKind::StringTable), 4);
     169          75 :   OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
     170          75 :   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          75 :   if (!InsertedStrTabFragment) {
     176          75 :     OS.insert(getStringTableFragment());
     177          75 :     InsertedStrTabFragment = true;
     178             :   }
     179             : 
     180          75 :   OS.EmitValueToAlignment(4, 0);
     181             : 
     182          75 :   OS.EmitLabel(StringEnd);
     183          75 : }
     184             : 
     185          73 : void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) {
     186             :   // Do nothing if there are no file checksums. Microsoft's linker rejects empty
     187             :   // CodeView substreams.
     188          73 :   if (Files.empty())
     189             :     return;
     190             : 
     191             :   MCContext &Ctx = OS.getContext();
     192          58 :   MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
     193          58 :            *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
     194             : 
     195          58 :   OS.EmitIntValue(unsigned(DebugSubsectionKind::FileChecksums), 4);
     196          58 :   OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
     197          58 :   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         188 :   for (auto File : Files) {
     205          65 :     OS.EmitAssignment(File.ChecksumTableOffset,
     206          65 :                       MCConstantExpr::create(CurrentOffset, Ctx));
     207             :     CurrentOffset += 4; // String table offset.
     208          65 :     if (!File.ChecksumKind) {
     209          45 :       CurrentOffset +=
     210             :           4; // One byte each for checksum size and kind, then align to 4 bytes.
     211             :     } else {
     212          20 :       CurrentOffset += 2; // One byte each for checksum size and kind.
     213          20 :       CurrentOffset += File.Checksum.size();
     214          40 :       CurrentOffset = alignTo(CurrentOffset, 4);
     215             :     }
     216             : 
     217          65 :     OS.EmitIntValue(File.StringTableOffset, 4);
     218             : 
     219         110 :     if (!File.ChecksumKind) {
     220             :       // There is no checksum.  Therefore zero the next two fields and align
     221             :       // back to 4 bytes.
     222          45 :       OS.EmitIntValue(0, 4);
     223          45 :       continue;
     224             :     }
     225          20 :     OS.EmitIntValue(static_cast<uint8_t>(File.Checksum.size()), 1);
     226          20 :     OS.EmitIntValue(File.ChecksumKind, 1);
     227          20 :     OS.EmitBytes(toStringRef(File.Checksum));
     228          20 :     OS.EmitValueToAlignment(4);
     229             :   }
     230             : 
     231          58 :   OS.EmitLabel(FileEnd);
     232             : 
     233          58 :   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.
     240         129 : void CodeViewContext::emitFileChecksumOffset(MCObjectStreamer &OS,
     241             :                                              unsigned FileNo) {
     242         129 :   unsigned Idx = FileNo - 1;
     243             : 
     244         258 :   if (Idx >= Files.size())
     245           0 :     Files.resize(Idx + 1);
     246             : 
     247         129 :   if (ChecksumOffsetsAssigned) {
     248           6 :     OS.EmitSymbolValue(Files[Idx].ChecksumTableOffset, 4);
     249           3 :     return;
     250             :   }
     251             : 
     252             :   const MCSymbolRefExpr *SRE =
     253         126 :       MCSymbolRefExpr::create(Files[Idx].ChecksumTableOffset, OS.getContext());
     254             : 
     255         126 :   OS.EmitValueImpl(SRE, 4);
     256             : }
     257             : 
     258         393 : void CodeViewContext::addLineEntry(const MCCVLineEntry &LineEntry) {
     259             :   size_t Offset = MCCVLines.size();
     260             :   auto I = MCCVLineStartStop.insert(
     261         786 :       {LineEntry.getFunctionId(), {Offset, Offset + 1}});
     262         393 :   if (!I.second)
     263         266 :     I.first->second.second = Offset + 1;
     264         393 :   MCCVLines.push_back(LineEntry);
     265         393 : }
     266             : 
     267             : std::vector<MCCVLineEntry>
     268         108 : CodeViewContext::getFunctionLineEntries(unsigned FuncId) {
     269             :   std::vector<MCCVLineEntry> FilteredLines;
     270             :   auto I = MCCVLineStartStop.find(FuncId);
     271         108 :   if (I != MCCVLineStartStop.end()) {
     272         105 :     MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(FuncId);
     273         484 :     for (size_t Idx = I->second.first, End = I->second.second; Idx != End;
     274             :          ++Idx) {
     275         379 :       unsigned LocationFuncId = MCCVLines[Idx].getFunctionId();
     276         379 :       if (LocationFuncId == FuncId) {
     277             :         // This was a .cv_loc directly for FuncId, so record it.
     278         355 :         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          24 :         auto I = SiteInfo->InlinedAtMap.find(LocationFuncId);
     283          24 :         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          24 :           if (FilteredLines.empty() ||
     289          48 :               FilteredLines.back().getFileNum() != IA.File ||
     290          65 :               FilteredLines.back().getLine() != IA.Line ||
     291          17 :               FilteredLines.back().getColumn() != IA.Col) {
     292          14 :             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         108 :   return FilteredLines;
     301             : }
     302             : 
     303          84 : 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          84 :   if (I == MCCVLineStartStop.end())
     307           9 :     return {~0ULL, 0};
     308          75 :   return I->second;
     309             : }
     310             : 
     311         132 : ArrayRef<MCCVLineEntry> CodeViewContext::getLinesForExtent(size_t L, size_t R) {
     312         132 :   if (R <= L)
     313           0 :     return None;
     314         132 :   if (L >= MCCVLines.size())
     315          12 :     return None;
     316         120 :   return makeArrayRef(&MCCVLines[L], R - L);
     317             : }
     318             : 
     319         108 : void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
     320             :                                                unsigned FuncId,
     321             :                                                const MCSymbol *FuncBegin,
     322             :                                                const MCSymbol *FuncEnd) {
     323             :   MCContext &Ctx = OS.getContext();
     324         108 :   MCSymbol *LineBegin = Ctx.createTempSymbol("linetable_begin", false),
     325         108 :            *LineEnd = Ctx.createTempSymbol("linetable_end", false);
     326             : 
     327         108 :   OS.EmitIntValue(unsigned(DebugSubsectionKind::Lines), 4);
     328         108 :   OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
     329         108 :   OS.EmitLabel(LineBegin);
     330         108 :   OS.EmitCOFFSecRel32(FuncBegin, /*Offset=*/0);
     331         108 :   OS.EmitCOFFSectionIndex(FuncBegin);
     332             : 
     333             :   // Actual line info.
     334         108 :   std::vector<MCCVLineEntry> Locs = getFunctionLineEntries(FuncId);
     335             :   bool HaveColumns = any_of(Locs, [](const MCCVLineEntry &LineEntry) {
     336             :     return LineEntry.getColumn() != 0;
     337             :   });
     338         108 :   OS.EmitIntValue(HaveColumns ? int(LF_HaveColumns) : 0, 2);
     339         108 :   OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
     340             : 
     341         221 :   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         113 :     unsigned EntryCount = FileSegEnd - I;
     349         113 :     OS.AddComment(
     350         113 :         "Segment for file '" +
     351         339 :         Twine(getStringTableFragment()
     352         452 :                   ->getContents()[Files[CurFileNum - 1].StringTableOffset]) +
     353         226 :         "' begins");
     354         113 :     OS.EmitCVFileChecksumOffsetDirective(CurFileNum);
     355         113 :     OS.EmitIntValue(EntryCount, 4);
     356             :     uint32_t SegmentSize = 12;
     357         113 :     SegmentSize += 8 * EntryCount;
     358         113 :     if (HaveColumns)
     359          85 :       SegmentSize += 4 * EntryCount;
     360         113 :     OS.EmitIntValue(SegmentSize, 4);
     361             : 
     362         475 :     for (auto J = I; J != FileSegEnd; ++J) {
     363         362 :       OS.emitAbsoluteSymbolDiff(J->getLabel(), FuncBegin, 4);
     364             :       unsigned LineData = J->getLine();
     365         362 :       if (J->isStmt())
     366           1 :         LineData |= LineInfo::StatementFlag;
     367         362 :       OS.EmitIntValue(LineData, 4);
     368             :     }
     369         113 :     if (HaveColumns) {
     370         400 :       for (auto J = I; J != FileSegEnd; ++J) {
     371         315 :         OS.EmitIntValue(J->getColumn(), 2);
     372         315 :         OS.EmitIntValue(0, 2);
     373             :       }
     374             :     }
     375             :     I = FileSegEnd;
     376             :   }
     377         108 :   OS.EmitLabel(LineEnd);
     378         108 : }
     379             : 
     380         426 : static bool compressAnnotation(uint32_t Data, SmallVectorImpl<char> &Buffer) {
     381         426 :   if (isUInt<7>(Data)) {
     382         426 :     Buffer.push_back(Data);
     383         426 :     return true;
     384             :   }
     385             : 
     386           0 :   if (isUInt<14>(Data)) {
     387           0 :     Buffer.push_back((Data >> 8) | 0x80);
     388           0 :     Buffer.push_back(Data & 0xff);
     389           0 :     return true;
     390             :   }
     391             : 
     392           0 :   if (isUInt<29>(Data)) {
     393           0 :     Buffer.push_back((Data >> 24) | 0xC0);
     394           0 :     Buffer.push_back((Data >> 16) & 0xff);
     395           0 :     Buffer.push_back((Data >> 8) & 0xff);
     396           0 :     Buffer.push_back(Data & 0xff);
     397           0 :     return true;
     398             :   }
     399             : 
     400             :   return false;
     401             : }
     402             : 
     403             : static bool compressAnnotation(BinaryAnnotationsOpCode Annotation,
     404             :                                SmallVectorImpl<char> &Buffer) {
     405         213 :   return compressAnnotation(static_cast<uint32_t>(Annotation), Buffer);
     406             : }
     407             : 
     408             : static uint32_t encodeSignedNumber(uint32_t Data) {
     409         123 :   if (Data >> 31)
     410           3 :     return ((-Data) << 1) | 1;
     411         120 :   return Data << 1;
     412             : }
     413             : 
     414          22 : 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          22 :                                   OS.getCurrentSectionOnly());
     425          22 : }
     426             : 
     427         137 : 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         274 :   new MCCVDefRangeFragment(Ranges, FixedSizePortion,
     434         137 :                            OS.getCurrentSectionOnly());
     435         137 : }
     436             : 
     437         690 : 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         690 :   const MCExpr *BeginRef = MCSymbolRefExpr::create(Begin, Variant, Ctx),
     442         690 :                *EndRef = MCSymbolRefExpr::create(End, Variant, Ctx);
     443             :   const MCExpr *AddrDelta =
     444         690 :       MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
     445             :   int64_t Result;
     446         690 :   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         690 :   return unsigned(Result);
     452             : }
     453             : 
     454          66 : void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
     455             :                                             MCCVInlineLineTableFragment &Frag) {
     456             :   size_t LocBegin;
     457             :   size_t LocEnd;
     458         132 :   std::tie(LocBegin, LocEnd) = getLineExtent(Frag.SiteFuncId);
     459             : 
     460             :   // Include all child inline call sites in our .cv_loc extent.
     461          66 :   MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(Frag.SiteFuncId);
     462         150 :   for (auto &KV : SiteInfo->InlinedAtMap) {
     463          18 :     unsigned ChildId = KV.first;
     464          18 :     auto Extent = getLineExtent(ChildId);
     465          18 :     LocBegin = std::min(LocBegin, Extent.first);
     466          18 :     LocEnd = std::max(LocEnd, Extent.second);
     467             :   }
     468             : 
     469          66 :   if (LocBegin >= LocEnd)
     470           0 :     return;
     471          66 :   ArrayRef<MCCVLineEntry> Locs = getLinesForExtent(LocBegin, LocEnd);
     472          66 :   if (Locs.empty())
     473             :     return;
     474             : 
     475             :   // Make an artificial start location using the function start and the inlinee
     476             :   // lines start location information. All deltas start relative to this
     477             :   // location.
     478             :   MCCVLineEntry StartLoc(Frag.getFnStartSym(), MCCVLoc(Locs.front()));
     479          66 :   StartLoc.setFileNum(Frag.StartFileId);
     480          66 :   StartLoc.setLine(Frag.StartLineNum);
     481             :   bool HaveOpenRange = false;
     482             : 
     483             :   const MCSymbol *LastLabel = Frag.getFnStartSym();
     484             :   MCCVFunctionInfo::LineInfo LastSourceLoc, CurSourceLoc;
     485             :   LastSourceLoc.File = Frag.StartFileId;
     486             :   LastSourceLoc.Line = Frag.StartLineNum;
     487             : 
     488          66 :   SmallVectorImpl<char> &Buffer = Frag.getContents();
     489             :   Buffer.clear(); // Clear old contents if we went through relaxation.
     490         360 :   for (const MCCVLineEntry &Loc : Locs) {
     491             :     // Exit early if our line table would produce an oversized InlineSiteSym
     492             :     // record. Account for the ChangeCodeLength annotation emitted after the
     493             :     // loop ends.
     494             :     constexpr uint32_t InlineSiteSize = 12;
     495             :     constexpr uint32_t AnnotationSize = 8;
     496             :     size_t MaxBufferSize = MaxRecordLength - InlineSiteSize - AnnotationSize;
     497         147 :     if (Buffer.size() >= MaxBufferSize)
     498             :       break;
     499             : 
     500         147 :     if (Loc.getFunctionId() == Frag.SiteFuncId) {
     501             :       CurSourceLoc.File = Loc.getFileNum();
     502             :       CurSourceLoc.Line = Loc.getLine();
     503             :     } else {
     504          39 :       auto I = SiteInfo->InlinedAtMap.find(Loc.getFunctionId());
     505          39 :       if (I != SiteInfo->InlinedAtMap.end()) {
     506             :         // This .cv_loc is from a child inline call site. Use the source
     507             :         // location of the inlined call site instead of the .cv_loc directive
     508             :         // source location.
     509          33 :         CurSourceLoc = I->second;
     510             :       } else {
     511             :         // We've hit a cv_loc not attributed to this inline call site. Use this
     512             :         // label to end the PC range.
     513           6 :         if (HaveOpenRange) {
     514           3 :           unsigned Length = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     515             :           compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
     516           3 :           compressAnnotation(Length, Buffer);
     517             :           LastLabel = Loc.getLabel();
     518             :         }
     519             :         HaveOpenRange = false;
     520           6 :         continue;
     521             :       }
     522             :     }
     523             : 
     524             :     // Skip this .cv_loc if we have an open range and this isn't a meaningful
     525             :     // source location update. The current table format does not support column
     526             :     // info, so we can skip updates for those.
     527         141 :     if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
     528             :         CurSourceLoc.Line == LastSourceLoc.Line)
     529          18 :       continue;
     530             : 
     531             :     HaveOpenRange = true;
     532             : 
     533         123 :     if (CurSourceLoc.File != LastSourceLoc.File) {
     534             :       unsigned FileOffset = static_cast<const MCConstantExpr *>(
     535           6 :                                 Files[CurSourceLoc.File - 1]
     536           6 :                                     .ChecksumTableOffset->getVariableValue())
     537           6 :                                 ->getValue();
     538             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
     539           6 :       compressAnnotation(FileOffset, Buffer);
     540             :     }
     541             : 
     542         123 :     int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
     543             :     unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
     544         123 :     unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     545         123 :     if (CodeDelta == 0 && LineDelta != 0) {
     546             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
     547          12 :       compressAnnotation(EncodedLineDelta, Buffer);
     548         111 :     } else if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) {
     549             :       // The ChangeCodeOffsetAndLineOffset combination opcode is used when the
     550             :       // encoded line delta uses 3 or fewer set bits and the code offset fits
     551             :       // in one nibble.
     552          90 :       unsigned Operand = (EncodedLineDelta << 4) | CodeDelta;
     553             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset,
     554             :                          Buffer);
     555          90 :       compressAnnotation(Operand, Buffer);
     556             :     } else {
     557             :       // Otherwise use the separate line and code deltas.
     558          21 :       if (LineDelta != 0) {
     559             :         compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
     560          15 :         compressAnnotation(EncodedLineDelta, Buffer);
     561             :       }
     562             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffset, Buffer);
     563          21 :       compressAnnotation(CodeDelta, Buffer);
     564             :     }
     565             : 
     566             :     LastLabel = Loc.getLabel();
     567             :     LastSourceLoc = CurSourceLoc;
     568             :   }
     569             : 
     570             :   assert(HaveOpenRange);
     571             : 
     572             :   unsigned EndSymLength =
     573          66 :       computeLabelDiff(Layout, LastLabel, Frag.getFnEndSym());
     574          66 :   unsigned LocAfterLength = ~0U;
     575          66 :   ArrayRef<MCCVLineEntry> LocAfter = getLinesForExtent(LocEnd, LocEnd + 1);
     576          66 :   if (!LocAfter.empty()) {
     577             :     // Only try to compute this difference if we're in the same section.
     578             :     const MCCVLineEntry &Loc = LocAfter[0];
     579          54 :     if (&Loc.getLabel()->getSection() == &LastLabel->getSection())
     580          51 :       LocAfterLength = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     581             :   }
     582             : 
     583             :   compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
     584          66 :   compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
     585             : }
     586             : 
     587         411 : void CodeViewContext::encodeDefRange(MCAsmLayout &Layout,
     588             :                                      MCCVDefRangeFragment &Frag) {
     589             :   MCContext &Ctx = Layout.getAssembler().getContext();
     590             :   SmallVectorImpl<char> &Contents = Frag.getContents();
     591             :   Contents.clear();
     592             :   SmallVectorImpl<MCFixup> &Fixups = Frag.getFixups();
     593             :   Fixups.clear();
     594             :   raw_svector_ostream OS(Contents);
     595             : 
     596             :   // Compute all the sizes up front.
     597             :   SmallVector<std::pair<unsigned, unsigned>, 4> GapAndRangeSizes;
     598             :   const MCSymbol *LastLabel = nullptr;
     599        1269 :   for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
     600             :     unsigned GapSize =
     601         429 :         LastLabel ? computeLabelDiff(Layout, LastLabel, Range.first) : 0;
     602         429 :     unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
     603         429 :     GapAndRangeSizes.push_back({GapSize, RangeSize});
     604             :     LastLabel = Range.second;
     605             :   }
     606             : 
     607             :   // Write down each range where the variable is defined.
     608        1245 :   for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {
     609             :     // If the range size of multiple consecutive ranges is under the max,
     610             :     // combine the ranges and emit some gaps.
     611         417 :     const MCSymbol *RangeBegin = Frag.getRanges()[I].first;
     612         417 :     unsigned RangeSize = GapAndRangeSizes[I].second;
     613         417 :     size_t J = I + 1;
     614         441 :     for (; J != E; ++J) {
     615          18 :       unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
     616          18 :       if (RangeSize + GapAndRangeSize > MaxDefRange)
     617             :         break;
     618          12 :       RangeSize += GapAndRangeSize;
     619             :     }
     620         417 :     unsigned NumGaps = J - I - 1;
     621             : 
     622             :     support::endian::Writer<support::little> LEWriter(OS);
     623             : 
     624             :     unsigned Bias = 0;
     625             :     // We must split the range into chunks of MaxDefRange, this is a fundamental
     626             :     // limitation of the file format.
     627             :     do {
     628         834 :       uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
     629             : 
     630             :       const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);
     631             :       const MCBinaryExpr *BE =
     632         417 :           MCBinaryExpr::createAdd(SRE, MCConstantExpr::create(Bias, Ctx), Ctx);
     633         417 :       MCValue Res;
     634         417 :       BE->evaluateAsRelocatable(Res, &Layout, /*Fixup=*/nullptr);
     635             : 
     636             :       // Each record begins with a 2-byte number indicating how large the record
     637             :       // is.
     638         417 :       StringRef FixedSizePortion = Frag.getFixedSizePortion();
     639             :       // Our record is a fixed sized prefix and a LocalVariableAddrRange that we
     640             :       // are artificially constructing.
     641             :       size_t RecordSize = FixedSizePortion.size() +
     642         417 :                           sizeof(LocalVariableAddrRange) + 4 * NumGaps;
     643             :       // Write out the record size.
     644         417 :       LEWriter.write<uint16_t>(RecordSize);
     645             :       // Write out the fixed size prefix.
     646         417 :       OS << FixedSizePortion;
     647             :       // Make space for a fixup that will eventually have a section relative
     648             :       // relocation pointing at the offset where the variable becomes live.
     649        1251 :       Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_4));
     650             :       LEWriter.write<uint32_t>(0); // Fixup for code start.
     651             :       // Make space for a fixup that will record the section index for the code.
     652         834 :       Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_2));
     653             :       LEWriter.write<uint16_t>(0); // Fixup for section index.
     654             :       // Write down the range's extent.
     655             :       LEWriter.write<uint16_t>(Chunk);
     656             : 
     657             :       // Move on to the next range.
     658         417 :       Bias += Chunk;
     659         417 :       RangeSize -= Chunk;
     660         417 :     } while (RangeSize > 0);
     661             : 
     662             :     // Emit the gaps afterwards.
     663             :     assert((NumGaps == 0 || Bias <= MaxDefRange) &&
     664             :            "large ranges should not have gaps");
     665         417 :     unsigned GapStartOffset = GapAndRangeSizes[I].second;
     666         441 :     for (++I; I != J; ++I) {
     667             :       unsigned GapSize, RangeSize;
     668             :       assert(I < GapAndRangeSizes.size());
     669             :       std::tie(GapSize, RangeSize) = GapAndRangeSizes[I];
     670          12 :       LEWriter.write<uint16_t>(GapStartOffset);
     671          12 :       LEWriter.write<uint16_t>(GapSize);
     672          12 :       GapStartOffset += GapSize + RangeSize;
     673             :     }
     674             :   }
     675         411 : }
     676             : 
     677             : //
     678             : // This is called when an instruction is assembled into the specified section
     679             : // and if there is information from the last .cv_loc directive that has yet to have
     680             : // a line entry made for it is made.
     681             : //
     682    18583835 : void MCCVLineEntry::Make(MCObjectStreamer *MCOS) {
     683    18583835 :   CodeViewContext &CVC = MCOS->getContext().getCVContext();
     684    18583835 :   if (!CVC.getCVLocSeen())
     685    18583442 :     return;
     686             : 
     687             :   // Create a symbol at in the current section for use in the line entry.
     688         393 :   MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
     689             :   // Set the value of the symbol to use for the MCCVLineEntry.
     690         393 :   MCOS->EmitLabel(LineSym);
     691             : 
     692             :   // Get the current .loc info saved in the context.
     693             :   const MCCVLoc &CVLoc = CVC.getCurrentCVLoc();
     694             : 
     695             :   // Create a (local) line entry with the symbol and the current .loc info.
     696             :   MCCVLineEntry LineEntry(LineSym, CVLoc);
     697             : 
     698             :   // clear CVLocSeen saying the current .loc info is now used.
     699             :   CVC.clearCVLocSeen();
     700             : 
     701             :   // Add the line entry to this section's entries.
     702         393 :   CVC.addLineEntry(LineEntry);
     703             : }

Generated by: LCOV version 1.13