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