Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 1 | //===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h --------------*- C++ -*-===// |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 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 | // |
Reid Kleckner | 70f5bc9 | 2016-01-14 19:25:04 +0000 | [diff] [blame] | 10 | // This file contains support for writing Microsoft CodeView debug info. |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Reid Kleckner | 70f5bc9 | 2016-01-14 19:25:04 +0000 | [diff] [blame] | 14 | #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H |
| 15 | #define LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 16 | |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 17 | #include "DbgValueHistoryCalculator.h" |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 18 | #include "DebugHandlerBase.h" |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/ArrayRef.h" |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/DenseMap.h" |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/DenseSet.h" |
| 22 | #include "llvm/ADT/MapVector.h" |
| 23 | #include "llvm/ADT/SetVector.h" |
| 24 | #include "llvm/ADT/SmallVector.h" |
| 25 | #include "llvm/DebugInfo/CodeView/CodeView.h" |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 26 | #include "llvm/DebugInfo/CodeView/TypeIndex.h" |
Zachary Turner | 4efa0a4 | 2016-11-08 22:24:53 +0000 | [diff] [blame] | 27 | #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h" |
Chandler Carruth | 9205140 | 2014-03-05 10:30:38 +0000 | [diff] [blame] | 28 | #include "llvm/IR/DebugLoc.h" |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 29 | #include "llvm/Support/Allocator.h" |
| 30 | #include "llvm/Support/Compiler.h" |
| 31 | #include <cstdint> |
| 32 | #include <map> |
| 33 | #include <string> |
| 34 | #include <tuple> |
| 35 | #include <unordered_map> |
| 36 | #include <utility> |
| 37 | #include <vector> |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 38 | |
| 39 | namespace llvm { |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 40 | |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 41 | struct ClassInfo; |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 42 | class StringRef; |
| 43 | class AsmPrinter; |
| 44 | class Function; |
| 45 | class GlobalVariable; |
| 46 | class MCSectionCOFF; |
| 47 | class MCStreamer; |
| 48 | class MCSymbol; |
| 49 | class MachineFunction; |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 50 | |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 51 | /// \brief Collects and handles line tables information in a CodeView format. |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 52 | class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase { |
Reid Kleckner | dac21b4 | 2016-02-03 21:15:48 +0000 | [diff] [blame] | 53 | MCStreamer &OS; |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 54 | BumpPtrAllocator Allocator; |
Zachary Turner | 4efa0a4 | 2016-11-08 22:24:53 +0000 | [diff] [blame] | 55 | codeview::TypeTableBuilder TypeTable; |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 56 | |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 57 | /// Represents the most general definition range. |
| 58 | struct LocalVarDefRange { |
| 59 | /// Indicates that variable data is stored in memory relative to the |
| 60 | /// specified register. |
| 61 | int InMemory : 1; |
| 62 | |
| 63 | /// Offset of variable data in memory. |
| 64 | int DataOffset : 31; |
| 65 | |
Reid Kleckner | 2b3e642 | 2016-10-05 21:21:33 +0000 | [diff] [blame] | 66 | /// Non-zero if this is a piece of an aggregate. |
| 67 | uint16_t IsSubfield : 1; |
| 68 | |
| 69 | /// Offset into aggregate. |
| 70 | uint16_t StructOffset : 15; |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 71 | |
| 72 | /// Register containing the data or the register base of the memory |
| 73 | /// location containing the data. |
| 74 | uint16_t CVRegister; |
| 75 | |
| 76 | /// Compares all location fields. This includes all fields except the label |
| 77 | /// ranges. |
| 78 | bool isDifferentLocation(LocalVarDefRange &O) { |
| 79 | return InMemory != O.InMemory || DataOffset != O.DataOffset || |
Reid Kleckner | 2b3e642 | 2016-10-05 21:21:33 +0000 | [diff] [blame] | 80 | IsSubfield != O.IsSubfield || StructOffset != O.StructOffset || |
| 81 | CVRegister != O.CVRegister; |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | SmallVector<std::pair<const MCSymbol *, const MCSymbol *>, 1> Ranges; |
| 85 | }; |
| 86 | |
| 87 | static LocalVarDefRange createDefRangeMem(uint16_t CVRegister, int Offset); |
Reid Kleckner | 2b3e642 | 2016-10-05 21:21:33 +0000 | [diff] [blame] | 88 | static LocalVarDefRange createDefRangeGeneral(uint16_t CVRegister, |
| 89 | bool InMemory, int Offset, |
| 90 | bool IsSubfield, |
| 91 | uint16_t StructOffset); |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 92 | |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 93 | /// Similar to DbgVariable in DwarfDebug, but not dwarf-specific. |
| 94 | struct LocalVariable { |
| 95 | const DILocalVariable *DIVar = nullptr; |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 96 | SmallVector<LocalVarDefRange, 1> DefRanges; |
Reid Kleckner | 08f5fd5 | 2017-08-31 15:56:49 +0000 | [diff] [blame] | 97 | bool UseReferenceType = false; |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 98 | }; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 99 | |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 100 | struct InlineSite { |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 101 | SmallVector<LocalVariable, 1> InlinedLocals; |
| 102 | SmallVector<const DILocation *, 1> ChildSites; |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 103 | const DISubprogram *Inlinee = nullptr; |
Reid Kleckner | c29b4f0 | 2016-07-14 23:47:15 +0000 | [diff] [blame] | 104 | |
| 105 | /// The ID of the inline site or function used with .cv_loc. Not a type |
| 106 | /// index. |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 107 | unsigned SiteFuncId = 0; |
| 108 | }; |
| 109 | |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 110 | // For each function, store a vector of labels to its instructions, as well as |
| 111 | // to the end of the function. |
| 112 | struct FunctionInfo { |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 113 | /// Map from inlined call site to inlined instructions and child inlined |
| 114 | /// call sites. Listed in program order. |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 115 | std::unordered_map<const DILocation *, InlineSite> InlineSites; |
| 116 | |
| 117 | /// Ordered list of top-level inlined call sites. |
| 118 | SmallVector<const DILocation *, 1> ChildSites; |
| 119 | |
| 120 | SmallVector<LocalVariable, 1> Locals; |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 121 | |
Reid Kleckner | e33c94f | 2017-09-05 20:14:58 +0000 | [diff] [blame] | 122 | std::vector<std::pair<MCSymbol *, MDNode *>> Annotations; |
| 123 | |
Reid Kleckner | 1fcd610 | 2016-02-02 17:41:18 +0000 | [diff] [blame] | 124 | const MCSymbol *Begin = nullptr; |
| 125 | const MCSymbol *End = nullptr; |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 126 | unsigned FuncId = 0; |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 127 | unsigned LastFileId = 0; |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 128 | bool HaveLineInfo = false; |
Reid Kleckner | 9533af4 | 2016-01-16 00:09:09 +0000 | [diff] [blame] | 129 | }; |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 130 | FunctionInfo *CurFn = nullptr; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 131 | |
Reid Kleckner | 5d122f8 | 2016-05-25 23:16:12 +0000 | [diff] [blame] | 132 | /// The set of comdat .debug$S sections that we've seen so far. Each section |
| 133 | /// must start with a magic version number that must only be emitted once. |
| 134 | /// This set tracks which sections we've already opened. |
| 135 | DenseSet<MCSectionCOFF *> ComdatDebugSections; |
| 136 | |
| 137 | /// Switch to the appropriate .debug$S section for GVSym. If GVSym, the symbol |
| 138 | /// of an emitted global value, is in a comdat COFF section, this will switch |
| 139 | /// to a new .debug$S section in that comdat. This method ensures that the |
| 140 | /// section starts with the magic version number on first use. If GVSym is |
| 141 | /// null, uses the main .debug$S section. |
| 142 | void switchToDebugSectionForSymbol(const MCSymbol *GVSym); |
| 143 | |
Reid Kleckner | fbd7787 | 2016-03-18 18:54:32 +0000 | [diff] [blame] | 144 | /// The next available function index for use with our .cv_* directives. Not |
| 145 | /// to be confused with type indices for LF_FUNC_ID records. |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 146 | unsigned NextFuncId = 0; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 147 | |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 148 | InlineSite &getInlineSite(const DILocation *InlinedAt, |
| 149 | const DISubprogram *Inlinee); |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 150 | |
David Majnemer | 75c3ebf | 2016-06-02 17:13:53 +0000 | [diff] [blame] | 151 | codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP); |
Reid Kleckner | 2280f93 | 2016-05-23 20:23:46 +0000 | [diff] [blame] | 152 | |
Bob Haarman | 223303c | 2017-08-29 20:59:25 +0000 | [diff] [blame] | 153 | void calculateRanges(LocalVariable &Var, |
| 154 | const DbgValueHistoryMap::InstrRanges &Ranges); |
| 155 | |
Reid Kleckner | 1fcd610 | 2016-02-02 17:41:18 +0000 | [diff] [blame] | 156 | static void collectInlineSiteChildren(SmallVectorImpl<unsigned> &Children, |
| 157 | const FunctionInfo &FI, |
| 158 | const InlineSite &Site); |
| 159 | |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 160 | /// Remember some debug info about each function. Keep it in a stable order to |
| 161 | /// emit at the end of the TU. |
| 162 | MapVector<const Function *, FunctionInfo> FnDebugInfo; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 163 | |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 164 | /// Map from DIFile to .cv_file id. |
| 165 | DenseMap<const DIFile *, unsigned> FileIdMap; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 166 | |
Reid Kleckner | fbd7787 | 2016-03-18 18:54:32 +0000 | [diff] [blame] | 167 | /// All inlined subprograms in the order they should be emitted. |
Reid Kleckner | 2280f93 | 2016-05-23 20:23:46 +0000 | [diff] [blame] | 168 | SmallSetVector<const DISubprogram *, 4> InlinedSubprograms; |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 169 | |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 170 | /// Map from a pair of DI metadata nodes and its DI type (or scope) that can |
| 171 | /// be nullptr, to CodeView type indices. Primarily indexed by |
| 172 | /// {DIType*, DIType*} and {DISubprogram*, DIType*}. |
| 173 | /// |
| 174 | /// The second entry in the key is needed for methods as DISubroutineType |
| 175 | /// representing static method type are shared with non-method function type. |
| 176 | DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex> |
| 177 | TypeIndices; |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 178 | |
Reid Kleckner | a8d5740 | 2016-06-03 15:58:20 +0000 | [diff] [blame] | 179 | /// Map from DICompositeType* to complete type index. Non-record types are |
| 180 | /// always looked up in the normal TypeIndices map. |
| 181 | DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices; |
| 182 | |
Reid Kleckner | 643dd83 | 2016-06-22 17:15:28 +0000 | [diff] [blame] | 183 | /// Complete record types to emit after all active type lowerings are |
| 184 | /// finished. |
| 185 | SmallVector<const DICompositeType *, 4> DeferredCompleteTypes; |
| 186 | |
| 187 | /// Number of type lowering frames active on the stack. |
| 188 | unsigned TypeEmissionLevel = 0; |
| 189 | |
Reid Kleckner | 9f7f3e1 | 2016-06-24 16:24:24 +0000 | [diff] [blame] | 190 | codeview::TypeIndex VBPType; |
| 191 | |
David Majnemer | 3128b10 | 2016-06-15 18:00:01 +0000 | [diff] [blame] | 192 | const DISubprogram *CurrentSubprogram = nullptr; |
| 193 | |
| 194 | // The UDTs we have seen while processing types; each entry is a pair of type |
| 195 | // index and type name. |
Zachary Turner | a7b0417 | 2017-08-28 18:49:04 +0000 | [diff] [blame] | 196 | std::vector<std::pair<std::string, const DIType *>> LocalUDTs; |
| 197 | std::vector<std::pair<std::string, const DIType *>> GlobalUDTs; |
David Majnemer | 3128b10 | 2016-06-15 18:00:01 +0000 | [diff] [blame] | 198 | |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 199 | using FileToFilepathMapTy = std::map<const DIFile *, std::string>; |
Reid Kleckner | 9533af4 | 2016-01-16 00:09:09 +0000 | [diff] [blame] | 200 | FileToFilepathMapTy FileToFilepathMap; |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 201 | |
Reid Kleckner | 9533af4 | 2016-01-16 00:09:09 +0000 | [diff] [blame] | 202 | StringRef getFullFilepath(const DIFile *S); |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 203 | |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 204 | unsigned maybeRecordFile(const DIFile *F); |
| 205 | |
Benjamin Kramer | bdc4956 | 2016-06-12 15:39:02 +0000 | [diff] [blame] | 206 | void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF); |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 207 | |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 208 | void clear(); |
David Majnemer | 3128b10 | 2016-06-15 18:00:01 +0000 | [diff] [blame] | 209 | |
| 210 | void setCurrentSubprogram(const DISubprogram *SP) { |
| 211 | CurrentSubprogram = SP; |
| 212 | LocalUDTs.clear(); |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Reid Kleckner | 5d122f8 | 2016-05-25 23:16:12 +0000 | [diff] [blame] | 215 | /// Emit the magic version number at the start of a CodeView type or symbol |
| 216 | /// section. Appears at the front of every .debug$S or .debug$T section. |
| 217 | void emitCodeViewMagicVersion(); |
| 218 | |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 219 | void emitTypeInformation(); |
| 220 | |
Adrian McCarthy | c64acfd | 2016-09-20 17:20:51 +0000 | [diff] [blame] | 221 | void emitCompilerInformation(); |
| 222 | |
Reid Kleckner | 5d122f8 | 2016-05-25 23:16:12 +0000 | [diff] [blame] | 223 | void emitInlineeLinesSubsection(); |
Reid Kleckner | 1fcd610 | 2016-02-02 17:41:18 +0000 | [diff] [blame] | 224 | |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 225 | void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI); |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 226 | |
Reid Kleckner | 6f3406d | 2016-06-07 00:02:03 +0000 | [diff] [blame] | 227 | void emitDebugInfoForGlobals(); |
| 228 | |
Hans Wennborg | b510b45 | 2016-06-23 16:33:53 +0000 | [diff] [blame] | 229 | void emitDebugInfoForRetainedTypes(); |
| 230 | |
Zachary Turner | a7b0417 | 2017-08-28 18:49:04 +0000 | [diff] [blame] | 231 | void |
| 232 | emitDebugInfoForUDTs(ArrayRef<std::pair<std::string, const DIType *>> UDTs); |
David Majnemer | 3128b10 | 2016-06-15 18:00:01 +0000 | [diff] [blame] | 233 | |
Peter Collingbourne | d4135bb | 2016-09-13 01:12:59 +0000 | [diff] [blame] | 234 | void emitDebugInfoForGlobal(const DIGlobalVariable *DIGV, |
| 235 | const GlobalVariable *GV, MCSymbol *GVSym); |
Reid Kleckner | 6f3406d | 2016-06-07 00:02:03 +0000 | [diff] [blame] | 236 | |
| 237 | /// Opens a subsection of the given kind in a .debug$S codeview section. |
| 238 | /// Returns an end label for use with endCVSubsection when the subsection is |
| 239 | /// finished. |
Zachary Turner | 8c099fe | 2017-05-30 16:36:15 +0000 | [diff] [blame] | 240 | MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind); |
Reid Kleckner | 6f3406d | 2016-06-07 00:02:03 +0000 | [diff] [blame] | 241 | |
| 242 | void endCVSubsection(MCSymbol *EndLabel); |
| 243 | |
Reid Kleckner | f3b9ba4 | 2016-01-29 18:16:43 +0000 | [diff] [blame] | 244 | void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt, |
| 245 | const InlineSite &Site); |
| 246 | |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 247 | using InlinedVariable = DbgValueHistoryMap::InlinedVariable; |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 248 | |
| 249 | void collectVariableInfo(const DISubprogram *SP); |
| 250 | |
Matthias Braun | ef331ef | 2016-11-30 23:48:50 +0000 | [diff] [blame] | 251 | void collectVariableInfoFromMFTable(DenseSet<InlinedVariable> &Processed); |
Reid Kleckner | 876330d | 2016-02-12 21:48:30 +0000 | [diff] [blame] | 252 | |
| 253 | /// Records information about a local variable in the appropriate scope. In |
| 254 | /// particular, locals from inlined code live inside the inlining site. |
| 255 | void recordLocalVariable(LocalVariable &&Var, const DILocation *Loc); |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 256 | |
Reid Kleckner | 10dd55c | 2016-06-24 17:55:40 +0000 | [diff] [blame] | 257 | /// Emits local variables in the appropriate order. |
| 258 | void emitLocalVariableList(ArrayRef<LocalVariable> Locals); |
| 259 | |
| 260 | /// Emits an S_LOCAL record and its associated defined ranges. |
Reid Kleckner | f9c275f | 2016-02-10 20:55:49 +0000 | [diff] [blame] | 261 | void emitLocalVariable(const LocalVariable &Var); |
| 262 | |
Reid Kleckner | 5acacbb | 2016-06-01 17:05:51 +0000 | [diff] [blame] | 263 | /// Translates the DIType to codeview if necessary and returns a type index |
| 264 | /// for it. |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 265 | codeview::TypeIndex getTypeIndex(DITypeRef TypeRef, |
| 266 | DITypeRef ClassTyRef = DITypeRef()); |
Reid Kleckner | 5acacbb | 2016-06-01 17:05:51 +0000 | [diff] [blame] | 267 | |
Bob Haarman | 223303c | 2017-08-29 20:59:25 +0000 | [diff] [blame] | 268 | codeview::TypeIndex getTypeIndexForReferenceTo(DITypeRef TypeRef); |
| 269 | |
Reid Kleckner | 0c5d874 | 2016-06-22 01:32:56 +0000 | [diff] [blame] | 270 | codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP, |
| 271 | const DICompositeType *Class); |
| 272 | |
| 273 | codeview::TypeIndex getScopeIndex(const DIScope *Scope); |
| 274 | |
Reid Kleckner | 9f7f3e1 | 2016-06-24 16:24:24 +0000 | [diff] [blame] | 275 | codeview::TypeIndex getVBPTypeIndex(); |
| 276 | |
Zachary Turner | a7b0417 | 2017-08-28 18:49:04 +0000 | [diff] [blame] | 277 | void addToUDTs(const DIType *Ty); |
Hans Wennborg | 4b63a98 | 2016-06-23 22:57:25 +0000 | [diff] [blame] | 278 | |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 279 | codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy); |
David Majnemer | d065e23 | 2016-06-02 06:21:37 +0000 | [diff] [blame] | 280 | codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty); |
Adrian McCarthy | f3c3c13 | 2016-06-08 18:22:59 +0000 | [diff] [blame] | 281 | codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty); |
Reid Kleckner | 5acacbb | 2016-06-01 17:05:51 +0000 | [diff] [blame] | 282 | codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty); |
| 283 | codeview::TypeIndex lowerTypePointer(const DIDerivedType *Ty); |
| 284 | codeview::TypeIndex lowerTypeMemberPointer(const DIDerivedType *Ty); |
| 285 | codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty); |
David Majnemer | 75c3ebf | 2016-06-02 17:13:53 +0000 | [diff] [blame] | 286 | codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty); |
Reid Kleckner | 9dac473 | 2016-08-31 15:59:30 +0000 | [diff] [blame] | 287 | codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty); |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 288 | codeview::TypeIndex lowerTypeMemberFunction(const DISubroutineType *Ty, |
Reid Kleckner | 0c5d874 | 2016-06-22 01:32:56 +0000 | [diff] [blame] | 289 | const DIType *ClassTy, |
Adrian McCarthy | d91bf39 | 2017-09-13 20:53:55 +0000 | [diff] [blame] | 290 | int ThisAdjustment, |
| 291 | bool IsStaticMethod); |
David Majnemer | 979cb88 | 2016-06-16 21:32:16 +0000 | [diff] [blame] | 292 | codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty); |
Reid Kleckner | a8d5740 | 2016-06-03 15:58:20 +0000 | [diff] [blame] | 293 | codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty); |
| 294 | codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty); |
| 295 | |
| 296 | /// Symbol records should point to complete types, but type records should |
| 297 | /// always point to incomplete types to avoid cycles in the type graph. Only |
| 298 | /// use this entry point when generating symbol records. The complete and |
| 299 | /// incomplete type indices only differ for record types. All other types use |
| 300 | /// the same index. |
| 301 | codeview::TypeIndex getCompleteTypeIndex(DITypeRef TypeRef); |
| 302 | |
| 303 | codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty); |
| 304 | codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty); |
| 305 | |
Reid Kleckner | 643dd83 | 2016-06-22 17:15:28 +0000 | [diff] [blame] | 306 | struct TypeLoweringScope; |
| 307 | |
| 308 | void emitDeferredCompleteTypes(); |
| 309 | |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 310 | void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy); |
Reid Kleckner | 1ab7eac | 2016-06-22 16:06:42 +0000 | [diff] [blame] | 311 | ClassInfo collectClassInfo(const DICompositeType *Ty); |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 312 | |
Reid Kleckner | a8d5740 | 2016-06-03 15:58:20 +0000 | [diff] [blame] | 313 | /// Common record member lowering functionality for record types, which are |
| 314 | /// structs, classes, and unions. Returns the field list index and the member |
| 315 | /// count. |
Adrian McCarthy | 820ca54 | 2016-07-06 19:49:51 +0000 | [diff] [blame] | 316 | std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool> |
Reid Kleckner | a8d5740 | 2016-06-03 15:58:20 +0000 | [diff] [blame] | 317 | lowerRecordFieldList(const DICompositeType *Ty); |
| 318 | |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 319 | /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates. |
Reid Kleckner | 0c5d874 | 2016-06-22 01:32:56 +0000 | [diff] [blame] | 320 | codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node, |
| 321 | codeview::TypeIndex TI, |
| 322 | const DIType *ClassTy = nullptr); |
Amjad Aboud | 76c9eb9 | 2016-06-18 10:25:07 +0000 | [diff] [blame] | 323 | |
| 324 | unsigned getPointerSizeInBytes(); |
Reid Kleckner | 5acacbb | 2016-06-01 17:05:51 +0000 | [diff] [blame] | 325 | |
David Blaikie | b2fbb4b | 2017-02-16 18:48:33 +0000 | [diff] [blame] | 326 | protected: |
| 327 | /// \brief Gather pre-function debug information. |
| 328 | void beginFunctionImpl(const MachineFunction *MF) override; |
| 329 | |
| 330 | /// \brief Gather post-function debug information. |
| 331 | void endFunctionImpl(const MachineFunction *) override; |
| 332 | |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 333 | public: |
Reid Kleckner | 70f5bc9 | 2016-01-14 19:25:04 +0000 | [diff] [blame] | 334 | CodeViewDebug(AsmPrinter *Asm); |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 335 | |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 336 | void setSymbolSize(const MCSymbol *, uint64_t) override {} |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 337 | |
| 338 | /// \brief Emit the COFF section that holds the line table information. |
Craig Topper | 7b883b3 | 2014-03-08 06:31:39 +0000 | [diff] [blame] | 339 | void endModule() override; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 340 | |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 341 | /// \brief Process beginning of an instruction. |
Craig Topper | 7b883b3 | 2014-03-08 06:31:39 +0000 | [diff] [blame] | 342 | void beginInstruction(const MachineInstr *MI) override; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 343 | }; |
Timur Iskhodzhanov | f166f6c | 2014-01-30 01:39:17 +0000 | [diff] [blame] | 344 | |
Eugene Zelenko | fb69e66 | 2017-06-06 22:22:41 +0000 | [diff] [blame] | 345 | } // end namespace llvm |
| 346 | |
| 347 | #endif // LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H |