LCOV - code coverage report
Current view: top level - lib/MC - MCCodeView.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 295 313 94.2 %
Date: 2018-07-13 00:08:38 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       27420 : CodeViewContext::CodeViewContext() {}
      30             : 
      31       20493 : CodeViewContext::~CodeViewContext() {
      32             :   // If someone inserted strings into the string table but never actually
      33             :   // emitted them somewhere, clean up the fragment.
      34        6831 :   if (!InsertedStrTabFragment)
      35        6806 :     delete StrTabFragment;
      36        6831 : }
      37             : 
      38             : /// This is a valid number for use with .cv_loc if we've already seen a .cv_file
      39             : /// for it.
      40         106 : bool CodeViewContext::isValidFileNumber(unsigned FileNumber) const {
      41         106 :   unsigned Idx = FileNumber - 1;
      42         212 :   if (Idx < Files.size())
      43         105 :     return Files[Idx].Assigned;
      44             :   return false;
      45             : }
      46             : 
      47         144 : bool CodeViewContext::addFile(MCStreamer &OS, unsigned FileNumber,
      48             :                               StringRef Filename,
      49             :                               ArrayRef<uint8_t> ChecksumBytes,
      50             :                               uint8_t ChecksumKind) {
      51             :   assert(FileNumber > 0);
      52         144 :   auto FilenameOffset = addToStringTable(Filename);
      53         144 :   Filename = FilenameOffset.first;
      54         144 :   unsigned Idx = FileNumber - 1;
      55         288 :   if (Idx >= Files.size())
      56         144 :     Files.resize(Idx + 1);
      57             : 
      58         144 :   if (Filename.empty())
      59           0 :     Filename = "<stdin>";
      60             : 
      61         144 :   if (Files[Idx].Assigned)
      62             :     return false;
      63             : 
      64         288 :   FilenameOffset = addToStringTable(Filename);
      65             :   Filename = FilenameOffset.first;
      66             :   unsigned Offset = FilenameOffset.second;
      67             : 
      68             :   auto ChecksumOffsetSymbol =
      69         288 :       OS.getContext().createTempSymbol("checksum_offset", false);
      70         144 :   Files[Idx].StringTableOffset = Offset;
      71         144 :   Files[Idx].ChecksumTableOffset = ChecksumOffsetSymbol;
      72         144 :   Files[Idx].Assigned = true;
      73         144 :   Files[Idx].Checksum = ChecksumBytes;
      74         144 :   Files[Idx].ChecksumKind = ChecksumKind;
      75             : 
      76         144 :   return true;
      77             : }
      78             : 
      79        1167 : MCCVFunctionInfo *CodeViewContext::getCVFunctionInfo(unsigned FuncId) {
      80        2334 :   if (FuncId >= Functions.size())
      81             :     return nullptr;
      82        1167 :   if (Functions[FuncId].isUnallocatedFunctionInfo())
      83             :     return nullptr;
      84        1167 :   return &Functions[FuncId];
      85             : }
      86             : 
      87         239 : bool CodeViewContext::recordFunctionId(unsigned FuncId) {
      88         478 :   if (FuncId >= Functions.size())
      89         239 :     Functions.resize(FuncId + 1);
      90             : 
      91             :   // Return false if this function info was already allocated.
      92         478 :   if (!Functions[FuncId].isUnallocatedFunctionInfo())
      93             :     return false;
      94             : 
      95             :   // Mark this as an allocated normal function, and leave the rest alone.
      96         239 :   Functions[FuncId].ParentFuncIdPlusOne = MCCVFunctionInfo::FunctionSentinel;
      97         239 :   return true;
      98             : }
      99             : 
     100          32 : bool CodeViewContext::recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc,
     101             :                                               unsigned IAFile, unsigned IALine,
     102             :                                               unsigned IACol) {
     103          64 :   if (FuncId >= Functions.size())
     104          31 :     Functions.resize(FuncId + 1);
     105             : 
     106             :   // Return false if this function info was already allocated.
     107          64 :   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          31 :   Info->ParentFuncIdPlusOne = IAFunc + 1;
     118          31 :   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          39 :   while (Info->isInlinedCallSite()) {
     123          39 :     InlinedAt = Info->InlinedAt;
     124          39 :     Info = getCVFunctionInfo(Info->getParentFuncId());
     125          78 :     Info->InlinedAtMap[FuncId] = InlinedAt;
     126             :   }
     127             : 
     128             :   return true;
     129             : }
     130             : 
     131         641 : MCDataFragment *CodeViewContext::getStringTableFragment() {
     132         641 :   if (!StrTabFragment) {
     133         292 :     StrTabFragment = new MCDataFragment();
     134             :     // Start a new string table out with a null byte.
     135         146 :     StrTabFragment->getContents().push_back('\0');
     136             :   }
     137         641 :   return StrTabFragment;
     138             : }
     139             : 
     140         419 : std::pair<StringRef, unsigned> CodeViewContext::addToStringTable(StringRef S) {
     141         419 :   SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
     142             :   auto Insertion =
     143         838 :       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         419 :       std::make_pair(Insertion.first->first(), Insertion.first->second);
     147         419 :   if (Insertion.second) {
     148             :     // The string map key is always null terminated.
     149         213 :     Contents.append(Ret.first.begin(), Ret.first.end() + 1);
     150             :   }
     151         419 :   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          85 : void CodeViewContext::emitStringTable(MCObjectStreamer &OS) {
     164          85 :   MCContext &Ctx = OS.getContext();
     165          85 :   MCSymbol *StringBegin = Ctx.createTempSymbol("strtab_begin", false),
     166          85 :            *StringEnd = Ctx.createTempSymbol("strtab_end", false);
     167             : 
     168          85 :   OS.EmitIntValue(unsigned(DebugSubsectionKind::StringTable), 4);
     169          85 :   OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
     170          85 :   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          85 :   if (!InsertedStrTabFragment) {
     176          85 :     OS.insert(getStringTableFragment());
     177          85 :     InsertedStrTabFragment = true;
     178             :   }
     179             : 
     180          85 :   OS.EmitValueToAlignment(4, 0);
     181             : 
     182          85 :   OS.EmitLabel(StringEnd);
     183          85 : }
     184             : 
     185          83 : void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) {
     186             :   // Do nothing if there are no file checksums. Microsoft's linker rejects empty
     187             :   // CodeView substreams.
     188          83 :   if (Files.empty())
     189             :     return;
     190             : 
     191          68 :   MCContext &Ctx = OS.getContext();
     192          68 :   MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
     193          68 :            *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
     194             : 
     195          68 :   OS.EmitIntValue(unsigned(DebugSubsectionKind::FileChecksums), 4);
     196          68 :   OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
     197          68 :   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         220 :   for (auto File : Files) {
     205          76 :     OS.EmitAssignment(File.ChecksumTableOffset,
     206          76 :                       MCConstantExpr::create(CurrentOffset, Ctx));
     207             :     CurrentOffset += 4; // String table offset.
     208          76 :     if (!File.ChecksumKind) {
     209          45 :       CurrentOffset +=
     210             :           4; // One byte each for checksum size and kind, then align to 4 bytes.
     211             :     } else {
     212          31 :       CurrentOffset += 2; // One byte each for checksum size and kind.
     213          31 :       CurrentOffset += File.Checksum.size();
     214          62 :       CurrentOffset = alignTo(CurrentOffset, 4);
     215             :     }
     216             : 
     217          76 :     OS.EmitIntValue(File.StringTableOffset, 4);
     218             : 
     219         121 :     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          31 :     OS.EmitIntValue(static_cast<uint8_t>(File.Checksum.size()), 1);
     226          31 :     OS.EmitIntValue(File.ChecksumKind, 1);
     227          31 :     OS.EmitBytes(toStringRef(File.Checksum));
     228          31 :     OS.EmitValueToAlignment(4);
     229             :   }
     230             : 
     231          68 :   OS.EmitLabel(FileEnd);
     232             : 
     233          68 :   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         154 : void CodeViewContext::emitFileChecksumOffset(MCObjectStreamer &OS,
     241             :                                              unsigned FileNo) {
     242         154 :   unsigned Idx = FileNo - 1;
     243             : 
     244         308 :   if (Idx >= Files.size())
     245           0 :     Files.resize(Idx + 1);
     246             : 
     247         154 :   if (ChecksumOffsetsAssigned) {
     248           6 :     OS.EmitSymbolValue(Files[Idx].ChecksumTableOffset, 4);
     249           3 :     return;
     250             :   }
     251             : 
     252             :   const MCSymbolRefExpr *SRE =
     253         302 :       MCSymbolRefExpr::create(Files[Idx].ChecksumTableOffset, OS.getContext());
     254             : 
     255         151 :   OS.EmitValueImpl(SRE, 4);
     256             : }
     257             : 
     258         482 : void CodeViewContext::addLineEntry(const MCCVLineEntry &LineEntry) {
     259         482 :   size_t Offset = MCCVLines.size();
     260             :   auto I = MCCVLineStartStop.insert(
     261         964 :       {LineEntry.getFunctionId(), {Offset, Offset + 1}});
     262         482 :   if (!I.second)
     263         329 :     I.first->second.second = Offset + 1;
     264         482 :   MCCVLines.push_back(LineEntry);
     265         482 : }
     266             : 
     267             : std::vector<MCCVLineEntry>
     268         131 : CodeViewContext::getFunctionLineEntries(unsigned FuncId) {
     269             :   std::vector<MCCVLineEntry> FilteredLines;
     270             :   auto I = MCCVLineStartStop.find(FuncId);
     271         131 :   if (I != MCCVLineStartStop.end()) {
     272         128 :     MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(FuncId);
     273         591 :     for (size_t Idx = I->second.first, End = I->second.second; Idx != End;
     274             :          ++Idx) {
     275         926 :       unsigned LocationFuncId = MCCVLines[Idx].getFunctionId();
     276         463 :       if (LocationFuncId == FuncId) {
     277             :         // This was a .cv_loc directly for FuncId, so record it.
     278         439 :         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          34 :               FilteredLines.back().getColumn() != IA.Col) {
     292          21 :             FilteredLines.push_back(MCCVLineEntry(
     293           7 :                 MCCVLines[Idx].getLabel(),
     294             :                 MCCVLoc(FuncId, IA.File, IA.Line, IA.Col, false, false)));
     295             :           }
     296             :         }
     297             :       }
     298             :     }
     299             :   }
     300         131 :   return FilteredLines;
     301             : }
     302             : 
     303          87 : 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          87 :   if (I == MCCVLineStartStop.end())
     307           9 :     return {~0ULL, 0};
     308          78 :   return I->second;
     309             : }
     310             : 
     311         138 : ArrayRef<MCCVLineEntry> CodeViewContext::getLinesForExtent(size_t L, size_t R) {
     312         138 :   if (R <= L)
     313           0 :     return None;
     314         276 :   if (L >= MCCVLines.size())
     315          15 :     return None;
     316         123 :   return makeArrayRef(&MCCVLines[L], R - L);
     317             : }
     318             : 
     319         131 : void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
     320             :                                                unsigned FuncId,
     321             :                                                const MCSymbol *FuncBegin,
     322             :                                                const MCSymbol *FuncEnd) {
     323         131 :   MCContext &Ctx = OS.getContext();
     324         131 :   MCSymbol *LineBegin = Ctx.createTempSymbol("linetable_begin", false),
     325         131 :            *LineEnd = Ctx.createTempSymbol("linetable_end", false);
     326             : 
     327         131 :   OS.EmitIntValue(unsigned(DebugSubsectionKind::Lines), 4);
     328         131 :   OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
     329         131 :   OS.EmitLabel(LineBegin);
     330         131 :   OS.EmitCOFFSecRel32(FuncBegin, /*Offset=*/0);
     331         131 :   OS.EmitCOFFSectionIndex(FuncBegin);
     332             : 
     333             :   // Actual line info.
     334         131 :   std::vector<MCCVLineEntry> Locs = getFunctionLineEntries(FuncId);
     335             :   bool HaveColumns = any_of(Locs, [](const MCCVLineEntry &LineEntry) {
     336         251 :     return LineEntry.getColumn() != 0;
     337             :   });
     338         131 :   OS.EmitIntValue(HaveColumns ? int(LF_HaveColumns) : 0, 2);
     339         131 :   OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
     340             : 
     341         268 :   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         137 :     unsigned CurFileNum = I->getFileNum();
     344             :     auto FileSegEnd =
     345             :         std::find_if(I, E, [CurFileNum](const MCCVLineEntry &Loc) {
     346         455 :           return Loc.getFileNum() != CurFileNum;
     347             :         });
     348         137 :     unsigned EntryCount = FileSegEnd - I;
     349         137 :     OS.AddComment(
     350         137 :         "Segment for file '" +
     351         411 :         Twine(getStringTableFragment()
     352         548 :                   ->getContents()[Files[CurFileNum - 1].StringTableOffset]) +
     353         274 :         "' begins");
     354         137 :     OS.EmitCVFileChecksumOffsetDirective(CurFileNum);
     355         137 :     OS.EmitIntValue(EntryCount, 4);
     356             :     uint32_t SegmentSize = 12;
     357         137 :     SegmentSize += 8 * EntryCount;
     358         137 :     if (HaveColumns)
     359          99 :       SegmentSize += 4 * EntryCount;
     360         137 :     OS.EmitIntValue(SegmentSize, 4);
     361             : 
     362         583 :     for (auto J = I; J != FileSegEnd; ++J) {
     363         446 :       OS.emitAbsoluteSymbolDiff(J->getLabel(), FuncBegin, 4);
     364         446 :       unsigned LineData = J->getLine();
     365         446 :       if (J->isStmt())
     366           1 :         LineData |= LineInfo::StatementFlag;
     367         446 :       OS.EmitIntValue(LineData, 4);
     368             :     }
     369         137 :     if (HaveColumns) {
     370         469 :       for (auto J = I; J != FileSegEnd; ++J) {
     371         370 :         OS.EmitIntValue(J->getColumn(), 2);
     372         370 :         OS.EmitIntValue(0, 2);
     373             :       }
     374             :     }
     375             :     I = FileSegEnd;
     376             :   }
     377         131 :   OS.EmitLabel(LineEnd);
     378         131 : }
     379             : 
     380         450 : static bool compressAnnotation(uint32_t Data, SmallVectorImpl<char> &Buffer) {
     381         450 :   if (isUInt<7>(Data)) {
     382         450 :     Buffer.push_back(Data);
     383         450 :     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         225 :   return compressAnnotation(static_cast<uint32_t>(Annotation), Buffer);
     406             : }
     407             : 
     408             : static uint32_t encodeSignedNumber(uint32_t Data) {
     409         129 :   if (Data >> 31)
     410           3 :     return ((-Data) << 1) | 1;
     411         126 :   return Data << 1;
     412             : }
     413             : 
     414          23 : 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          23 :                                   OS.getCurrentSectionOnly());
     425          23 : }
     426             : 
     427         181 : 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         362 :   new MCCVDefRangeFragment(Ranges, FixedSizePortion,
     434         181 :                            OS.getCurrentSectionOnly());
     435         181 : }
     436             : 
     437         840 : static unsigned computeLabelDiff(MCAsmLayout &Layout, const MCSymbol *Begin,
     438             :                                  const MCSymbol *End) {
     439         840 :   MCContext &Ctx = Layout.getAssembler().getContext();
     440             :   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
     441         840 :   const MCExpr *BeginRef = MCSymbolRefExpr::create(Begin, Variant, Ctx),
     442         840 :                *EndRef = MCSymbolRefExpr::create(End, Variant, Ctx);
     443             :   const MCExpr *AddrDelta =
     444         840 :       MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
     445             :   int64_t Result;
     446         840 :   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         840 :   return unsigned(Result);
     452             : }
     453             : 
     454          69 : void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
     455             :                                             MCCVInlineLineTableFragment &Frag) {
     456             :   size_t LocBegin;
     457             :   size_t LocEnd;
     458         138 :   std::tie(LocBegin, LocEnd) = getLineExtent(Frag.SiteFuncId);
     459             : 
     460             :   // Include all child inline call sites in our .cv_loc extent.
     461          69 :   MCCVFunctionInfo *SiteInfo = getCVFunctionInfo(Frag.SiteFuncId);
     462         156 :   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          69 :   if (LocBegin >= LocEnd)
     470           0 :     return;
     471          69 :   ArrayRef<MCCVLineEntry> Locs = getLinesForExtent(LocBegin, LocEnd);
     472          69 :   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          69 :   MCCVLineEntry StartLoc(Frag.getFnStartSym(), MCCVLoc(Locs.front()));
     492          69 :   StartLoc.setFileNum(Frag.StartFileId);
     493          69 :   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          69 :   SmallVectorImpl<char> &Buffer = Frag.getContents();
     502             :   Buffer.clear(); // Clear old contents if we went through relaxation.
     503         381 :   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         156 :     if (Buffer.size() >= MaxBufferSize)
     511             :       break;
     512             : 
     513         156 :     if (Loc.getFunctionId() == Frag.SiteFuncId) {
     514         114 :       CurSourceLoc.File = Loc.getFileNum();
     515         114 :       CurSourceLoc.Line = Loc.getLine();
     516             :     } else {
     517          42 :       auto I = SiteInfo->InlinedAtMap.find(Loc.getFunctionId());
     518          42 :       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          33 :         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           9 :         if (HaveOpenRange) {
     527           6 :           unsigned Length = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     528             :           compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
     529           6 :           compressAnnotation(Length, Buffer);
     530           6 :           LastLabel = Loc.getLabel();
     531             :         }
     532             :         HaveOpenRange = false;
     533           9 :         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         147 :     if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
     541             :         CurSourceLoc.Line == LastSourceLoc.Line)
     542          18 :       continue;
     543             : 
     544             :     HaveOpenRange = true;
     545             : 
     546         129 :     if (CurSourceLoc.File != LastSourceLoc.File) {
     547             :       unsigned FileOffset = static_cast<const MCConstantExpr *>(
     548           6 :                                 Files[CurSourceLoc.File - 1]
     549           6 :                                     .ChecksumTableOffset->getVariableValue())
     550           6 :                                 ->getValue();
     551             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
     552           6 :       compressAnnotation(FileOffset, Buffer);
     553             :     }
     554             : 
     555         129 :     int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
     556             :     unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
     557         129 :     unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     558         129 :     if (CodeDelta == 0 && LineDelta != 0) {
     559             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
     560          15 :       compressAnnotation(EncodedLineDelta, Buffer);
     561         114 :     } 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          93 :       unsigned Operand = (EncodedLineDelta << 4) | CodeDelta;
     566             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset,
     567             :                          Buffer);
     568          93 :       compressAnnotation(Operand, Buffer);
     569             :     } else {
     570             :       // Otherwise use the separate line and code deltas.
     571          21 :       if (LineDelta != 0) {
     572             :         compressAnnotation(BinaryAnnotationsOpCode::ChangeLineOffset, Buffer);
     573          15 :         compressAnnotation(EncodedLineDelta, Buffer);
     574             :       }
     575             :       compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeOffset, Buffer);
     576          21 :       compressAnnotation(CodeDelta, Buffer);
     577             :     }
     578             : 
     579         129 :     LastLabel = Loc.getLabel();
     580             :     LastSourceLoc = CurSourceLoc;
     581             :   }
     582             : 
     583             :   assert(HaveOpenRange);
     584             : 
     585             :   unsigned EndSymLength =
     586          69 :       computeLabelDiff(Layout, LastLabel, Frag.getFnEndSym());
     587          69 :   unsigned LocAfterLength = ~0U;
     588          69 :   ArrayRef<MCCVLineEntry> LocAfter = getLinesForExtent(LocEnd, LocEnd + 1);
     589          69 :   if (!LocAfter.empty()) {
     590             :     // Only try to compute this difference if we're in the same section.
     591          54 :     const MCCVLineEntry &Loc = LocAfter[0];
     592         108 :     if (&Loc.getLabel()->getSection() == &LastLabel->getSection())
     593          51 :       LocAfterLength = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     594             :   }
     595             : 
     596             :   compressAnnotation(BinaryAnnotationsOpCode::ChangeCodeLength, Buffer);
     597          69 :   compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
     598             : }
     599             : 
     600         543 : void CodeViewContext::encodeDefRange(MCAsmLayout &Layout,
     601             :                                      MCCVDefRangeFragment &Frag) {
     602         543 :   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        1671 :   for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
     613             :     unsigned GapSize =
     614         564 :         LastLabel ? computeLabelDiff(Layout, LastLabel, Range.first) : 0;
     615         564 :     unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
     616         564 :     GapAndRangeSizes.push_back({GapSize, RangeSize});
     617             :     LastLabel = Range.second;
     618             :   }
     619             : 
     620             :   // Write down each range where the variable is defined.
     621        1641 :   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         549 :     const MCSymbol *RangeBegin = Frag.getRanges()[I].first;
     625         549 :     unsigned RangeSize = GapAndRangeSizes[I].second;
     626         549 :     size_t J = I + 1;
     627         579 :     for (; J != E; ++J) {
     628          21 :       unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
     629          21 :       if (RangeSize + GapAndRangeSize > MaxDefRange)
     630             :         break;
     631          15 :       RangeSize += GapAndRangeSize;
     632             :     }
     633         549 :     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        1098 :       uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
     642             : 
     643             :       const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);
     644             :       const MCBinaryExpr *BE =
     645         549 :           MCBinaryExpr::createAdd(SRE, MCConstantExpr::create(Bias, Ctx), Ctx);
     646         549 :       MCValue Res;
     647         549 :       BE->evaluateAsRelocatable(Res, &Layout, /*Fixup=*/nullptr);
     648             : 
     649             :       // Each record begins with a 2-byte number indicating how large the record
     650             :       // is.
     651         549 :       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         549 :                           sizeof(LocalVariableAddrRange) + 4 * NumGaps;
     656             :       // Write out the record size.
     657         549 :       LEWriter.write<uint16_t>(RecordSize);
     658             :       // Write out the fixed size prefix.
     659         549 :       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        1647 :       Fixups.push_back(MCFixup::create(Contents.size(), BE, FK_SecRel_4));
     663         549 :       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        1098 :       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         549 :       LEWriter.write<uint16_t>(Chunk);
     669             : 
     670             :       // Move on to the next range.
     671         549 :       Bias += Chunk;
     672         549 :       RangeSize -= Chunk;
     673         549 :     } while (RangeSize > 0);
     674             : 
     675             :     // Emit the gaps afterwards.
     676             :     assert((NumGaps == 0 || Bias <= MaxDefRange) &&
     677             :            "large ranges should not have gaps");
     678         549 :     unsigned GapStartOffset = GapAndRangeSizes[I].second;
     679         579 :     for (++I; I != J; ++I) {
     680             :       unsigned GapSize, RangeSize;
     681             :       assert(I < GapAndRangeSizes.size());
     682             :       std::tie(GapSize, RangeSize) = GapAndRangeSizes[I];
     683          15 :       LEWriter.write<uint16_t>(GapStartOffset);
     684          15 :       LEWriter.write<uint16_t>(GapSize);
     685          15 :       GapStartOffset += GapSize + RangeSize;
     686             :     }
     687             :   }
     688         543 : }
     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             : //
     695    17318529 : void MCCVLineEntry::Make(MCObjectStreamer *MCOS) {
     696    17318529 :   CodeViewContext &CVC = MCOS->getContext().getCVContext();
     697    17318529 :   if (!CVC.getCVLocSeen())
     698    17318047 :     return;
     699             : 
     700             :   // Create a symbol at in the current section for use in the line entry.
     701         482 :   MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
     702             :   // Set the value of the symbol to use for the MCCVLineEntry.
     703         482 :   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         482 :   CVC.addLineEntry(LineEntry);
     716             : }

Generated by: LCOV version 1.13