LCOV - code coverage report
Current view: top level - include/llvm/MC - MCCodeView.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 7 16 43.8 %
Date: 2018-10-20 13:21:21 Functions: 0 10 0.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             : #ifndef LLVM_MC_MCCODEVIEW_H
      15             : #define LLVM_MC_MCCODEVIEW_H
      16             : 
      17             : #include "llvm/ADT/StringMap.h"
      18             : #include "llvm/ADT/StringRef.h"
      19             : #include "llvm/MC/MCFragment.h"
      20             : #include "llvm/MC/MCObjectStreamer.h"
      21             : #include <map>
      22             : #include <vector>
      23             : 
      24             : namespace llvm {
      25             : class MCContext;
      26             : class MCObjectStreamer;
      27             : class MCStreamer;
      28             : class CodeViewContext;
      29             : 
      30             : /// Instances of this class represent the information from a
      31             : /// .cv_loc directive.
      32             : class MCCVLoc {
      33             :   const MCSymbol *Label = nullptr;
      34             :   uint32_t FunctionId;
      35             :   uint32_t FileNum;
      36             :   uint32_t Line;
      37             :   uint16_t Column;
      38             :   uint16_t PrologueEnd : 1;
      39             :   uint16_t IsStmt : 1;
      40             : 
      41             : private: // CodeViewContext manages these
      42             :   friend class CodeViewContext;
      43             :   MCCVLoc(const MCSymbol *Label, unsigned functionid, unsigned fileNum,
      44             :           unsigned line, unsigned column, bool prologueend, bool isstmt)
      45         554 :       : Label(Label), FunctionId(functionid), FileNum(fileNum), Line(line),
      46         554 :         Column(column), PrologueEnd(prologueend), IsStmt(isstmt) {}
      47             : 
      48             :   // Allow the default copy constructor and assignment operator to be used
      49             :   // for an MCCVLoc object.
      50             : 
      51             : public:
      52           0 :   const MCSymbol *getLabel() const { return Label; }
      53             : 
      54           0 :   unsigned getFunctionId() const { return FunctionId; }
      55             : 
      56             :   /// Get the FileNum of this MCCVLoc.
      57           0 :   unsigned getFileNum() const { return FileNum; }
      58             : 
      59             :   /// Get the Line of this MCCVLoc.
      60           0 :   unsigned getLine() const { return Line; }
      61             : 
      62             :   /// Get the Column of this MCCVLoc.
      63          18 :   unsigned getColumn() const { return Column; }
      64             : 
      65             :   bool isPrologueEnd() const { return PrologueEnd; }
      66         501 :   bool isStmt() const { return IsStmt; }
      67             : 
      68           0 :   void setLabel(const MCSymbol *L) { Label = L; }
      69             : 
      70             :   void setFunctionId(unsigned FID) { FunctionId = FID; }
      71             : 
      72             :   /// Set the FileNum of this MCCVLoc.
      73           0 :   void setFileNum(unsigned fileNum) { FileNum = fileNum; }
      74             : 
      75             :   /// Set the Line of this MCCVLoc.
      76           0 :   void setLine(unsigned line) { Line = line; }
      77             : 
      78             :   /// Set the Column of this MCCVLoc.
      79             :   void setColumn(unsigned column) {
      80             :     assert(column <= UINT16_MAX);
      81             :     Column = column;
      82             :   }
      83             : 
      84             :   void setPrologueEnd(bool PE) { PrologueEnd = PE; }
      85             :   void setIsStmt(bool IS) { IsStmt = IS; }
      86             : };
      87             : 
      88             : /// Information describing a function or inlined call site introduced by
      89             : /// .cv_func_id or .cv_inline_site_id. Accumulates information from .cv_loc
      90             : /// directives used with this function's id or the id of an inlined call site
      91             : /// within this function or inlined call site.
      92        1087 : struct MCCVFunctionInfo {
      93             :   /// If this represents an inlined call site, then ParentFuncIdPlusOne will be
      94             :   /// the parent function id plus one. If this represents a normal function,
      95             :   /// then there is no parent, and ParentFuncIdPlusOne will be FunctionSentinel.
      96             :   /// If this struct is an unallocated slot in the function info vector, then
      97             :   /// ParentFuncIdPlusOne will be zero.
      98             :   unsigned ParentFuncIdPlusOne = 0;
      99             : 
     100             :   enum : unsigned { FunctionSentinel = ~0U };
     101             : 
     102             :   struct LineInfo {
     103             :     unsigned File;
     104             :     unsigned Line;
     105             :     unsigned Col;
     106             :   };
     107             : 
     108             :   LineInfo InlinedAt;
     109             : 
     110             :   /// The section of the first .cv_loc directive used for this function, or null
     111             :   /// if none has been seen yet.
     112             :   MCSection *Section = nullptr;
     113             : 
     114             :   /// Map from inlined call site id to the inlined at location to use for that
     115             :   /// call site. Call chains are collapsed, so for the call chain 'f -> g -> h',
     116             :   /// the InlinedAtMap of 'f' will contain entries for 'g' and 'h' that both
     117             :   /// list the line info for the 'g' call site.
     118             :   DenseMap<unsigned, LineInfo> InlinedAtMap;
     119             : 
     120             :   /// Returns true if this is function info has not yet been used in a
     121             :   /// .cv_func_id or .cv_inline_site_id directive.
     122           0 :   bool isUnallocatedFunctionInfo() const { return ParentFuncIdPlusOne == 0; }
     123             : 
     124             :   /// Returns true if this represents an inlined call site, meaning
     125             :   /// ParentFuncIdPlusOne is neither zero nor ~0U.
     126             :   bool isInlinedCallSite() const {
     127          72 :     return !isUnallocatedFunctionInfo() &&
     128             :            ParentFuncIdPlusOne != FunctionSentinel;
     129             :   }
     130             : 
     131           0 :   unsigned getParentFuncId() const {
     132             :     assert(isInlinedCallSite());
     133          40 :     return ParentFuncIdPlusOne - 1;
     134             :   }
     135             : };
     136             : 
     137             : /// Holds state from .cv_file and .cv_loc directives for later emission.
     138             : class CodeViewContext {
     139             : public:
     140             :   CodeViewContext();
     141             :   ~CodeViewContext();
     142             : 
     143             :   bool isValidFileNumber(unsigned FileNumber) const;
     144             :   bool addFile(MCStreamer &OS, unsigned FileNumber, StringRef Filename,
     145             :                ArrayRef<uint8_t> ChecksumBytes, uint8_t ChecksumKind);
     146             : 
     147             :   /// Records the function id of a normal function. Returns false if the
     148             :   /// function id has already been used, and true otherwise.
     149             :   bool recordFunctionId(unsigned FuncId);
     150             : 
     151             :   /// Records the function id of an inlined call site. Records the "inlined at"
     152             :   /// location info of the call site, including what function or inlined call
     153             :   /// site it was inlined into. Returns false if the function id has already
     154             :   /// been used, and true otherwise.
     155             :   bool recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc,
     156             :                                unsigned IAFile, unsigned IALine,
     157             :                                unsigned IACol);
     158             : 
     159             :   /// Retreive the function info if this is a valid function id, or nullptr.
     160             :   MCCVFunctionInfo *getCVFunctionInfo(unsigned FuncId);
     161             : 
     162             :   /// Saves the information from the currently parsed .cv_loc directive
     163             :   /// and sets CVLocSeen.  When the next instruction is assembled an entry
     164             :   /// in the line number table with this information and the address of the
     165             :   /// instruction will be created.
     166             :   void recordCVLoc(MCContext &Ctx, const MCSymbol *Label, unsigned FunctionId,
     167             :                    unsigned FileNo, unsigned Line, unsigned Column,
     168             :                    bool PrologueEnd, bool IsStmt);
     169             : 
     170             :   bool isValidCVFileNumber(unsigned FileNumber);
     171             : 
     172             :   /// Add a line entry.
     173             :   void addLineEntry(const MCCVLoc &LineEntry);
     174             : 
     175             :   std::vector<MCCVLoc> getFunctionLineEntries(unsigned FuncId);
     176             : 
     177             :   std::pair<size_t, size_t> getLineExtent(unsigned FuncId);
     178             : 
     179             :   ArrayRef<MCCVLoc> getLinesForExtent(size_t L, size_t R);
     180             : 
     181             :   /// Emits a line table substream.
     182             :   void emitLineTableForFunction(MCObjectStreamer &OS, unsigned FuncId,
     183             :                                 const MCSymbol *FuncBegin,
     184             :                                 const MCSymbol *FuncEnd);
     185             : 
     186             :   void emitInlineLineTableForFunction(MCObjectStreamer &OS,
     187             :                                       unsigned PrimaryFunctionId,
     188             :                                       unsigned SourceFileId,
     189             :                                       unsigned SourceLineNum,
     190             :                                       const MCSymbol *FnStartSym,
     191             :                                       const MCSymbol *FnEndSym);
     192             : 
     193             :   /// Encodes the binary annotations once we have a layout.
     194             :   void encodeInlineLineTable(MCAsmLayout &Layout,
     195             :                              MCCVInlineLineTableFragment &F);
     196             : 
     197             :   void
     198             :   emitDefRange(MCObjectStreamer &OS,
     199             :                ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     200             :                StringRef FixedSizePortion);
     201             : 
     202             :   void encodeDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &F);
     203             : 
     204             :   /// Emits the string table substream.
     205             :   void emitStringTable(MCObjectStreamer &OS);
     206             : 
     207             :   /// Emits the file checksum substream.
     208             :   void emitFileChecksums(MCObjectStreamer &OS);
     209             : 
     210             :   /// Emits the offset into the checksum table of the given file number.
     211             :   void emitFileChecksumOffset(MCObjectStreamer &OS, unsigned FileNo);
     212             : 
     213             :   /// Add something to the string table.  Returns the final string as well as
     214             :   /// offset into the string table.
     215             :   std::pair<StringRef, unsigned> addToStringTable(StringRef S);
     216             : 
     217             : private:
     218             :   /// Map from string to string table offset.
     219             :   StringMap<unsigned> StringTable;
     220             : 
     221             :   /// The fragment that ultimately holds our strings.
     222             :   MCDataFragment *StrTabFragment = nullptr;
     223             :   bool InsertedStrTabFragment = false;
     224             : 
     225             :   MCDataFragment *getStringTableFragment();
     226             : 
     227             :   /// Get a string table offset.
     228             :   unsigned getStringTableOffset(StringRef S);
     229             : 
     230             :   struct FileInfo {
     231             :     unsigned StringTableOffset;
     232             : 
     233             :     // Indicates if this FileInfo corresponds to an actual file, or hasn't been
     234             :     // set yet.
     235             :     bool Assigned = false;
     236             : 
     237             :     uint8_t ChecksumKind;
     238             : 
     239             :     ArrayRef<uint8_t> Checksum;
     240             : 
     241             :     // Checksum offset stored as a symbol because it might be requested
     242             :     // before it has been calculated, so a fixup may be needed.
     243             :     MCSymbol *ChecksumTableOffset;
     244             :   };
     245             : 
     246             :   /// Array storing added file information.
     247             :   SmallVector<FileInfo, 4> Files;
     248             : 
     249             :   /// The offset of the first and last .cv_loc directive for a given function
     250             :   /// id.
     251             :   std::map<unsigned, std::pair<size_t, size_t>> MCCVLineStartStop;
     252             : 
     253             :   /// A collection of MCCVLoc for each section.
     254             :   std::vector<MCCVLoc> MCCVLines;
     255             : 
     256             :   /// All known functions and inlined call sites, indexed by function id.
     257             :   std::vector<MCCVFunctionInfo> Functions;
     258             : 
     259             :   /// Indicate whether we have already laid out the checksum table addresses or
     260             :   /// not.
     261             :   bool ChecksumOffsetsAssigned = false;
     262             : };
     263             : 
     264             : } // end namespace llvm
     265             : #endif

Generated by: LCOV version 1.13