/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h
Line | Count | Source |
1 | | //===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h --------------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This file contains support for writing Microsoft CodeView debug info. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H |
14 | | #define LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H |
15 | | |
16 | | #include "llvm/ADT/ArrayRef.h" |
17 | | #include "llvm/ADT/DenseMap.h" |
18 | | #include "llvm/ADT/DenseSet.h" |
19 | | #include "llvm/ADT/MapVector.h" |
20 | | #include "llvm/ADT/PointerUnion.h" |
21 | | #include "llvm/ADT/SetVector.h" |
22 | | #include "llvm/ADT/SmallVector.h" |
23 | | #include "llvm/CodeGen/DbgEntityHistoryCalculator.h" |
24 | | #include "llvm/CodeGen/DebugHandlerBase.h" |
25 | | #include "llvm/DebugInfo/CodeView/CodeView.h" |
26 | | #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h" |
27 | | #include "llvm/DebugInfo/CodeView/TypeIndex.h" |
28 | | #include "llvm/IR/DebugLoc.h" |
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> |
38 | | |
39 | | namespace llvm { |
40 | | |
41 | | struct ClassInfo; |
42 | | class StringRef; |
43 | | class AsmPrinter; |
44 | | class Function; |
45 | | class GlobalVariable; |
46 | | class MCSectionCOFF; |
47 | | class MCStreamer; |
48 | | class MCSymbol; |
49 | | class MachineFunction; |
50 | | |
51 | | /// Collects and handles line tables information in a CodeView format. |
52 | | class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase { |
53 | | MCStreamer &OS; |
54 | | BumpPtrAllocator Allocator; |
55 | | codeview::GlobalTypeTableBuilder TypeTable; |
56 | | |
57 | | /// Whether to emit type record hashes into .debug$H. |
58 | | bool EmitDebugGlobalHashes = false; |
59 | | |
60 | | /// The codeview CPU type used by the translation unit. |
61 | | codeview::CPUType TheCPU; |
62 | | |
63 | | /// Represents the most general definition range. |
64 | | struct LocalVarDefRange { |
65 | | /// Indicates that variable data is stored in memory relative to the |
66 | | /// specified register. |
67 | | int InMemory : 1; |
68 | | |
69 | | /// Offset of variable data in memory. |
70 | | int DataOffset : 31; |
71 | | |
72 | | /// Non-zero if this is a piece of an aggregate. |
73 | | uint16_t IsSubfield : 1; |
74 | | |
75 | | /// Offset into aggregate. |
76 | | uint16_t StructOffset : 15; |
77 | | |
78 | | /// Register containing the data or the register base of the memory |
79 | | /// location containing the data. |
80 | | uint16_t CVRegister; |
81 | | |
82 | | /// Compares all location fields. This includes all fields except the label |
83 | | /// ranges. |
84 | 40 | bool isDifferentLocation(LocalVarDefRange &O) { |
85 | 40 | return InMemory != O.InMemory || DataOffset != O.DataOffset36 || |
86 | 40 | IsSubfield != O.IsSubfield36 || StructOffset != O.StructOffset36 || |
87 | 40 | CVRegister != O.CVRegister30 ; |
88 | 40 | } |
89 | | |
90 | | SmallVector<std::pair<const MCSymbol *, const MCSymbol *>, 1> Ranges; |
91 | | }; |
92 | | |
93 | | static LocalVarDefRange createDefRangeMem(uint16_t CVRegister, int Offset); |
94 | | |
95 | | /// Similar to DbgVariable in DwarfDebug, but not dwarf-specific. |
96 | | struct LocalVariable { |
97 | | const DILocalVariable *DIVar = nullptr; |
98 | | SmallVector<LocalVarDefRange, 1> DefRanges; |
99 | | bool UseReferenceType = false; |
100 | | }; |
101 | | |
102 | | struct CVGlobalVariable { |
103 | | const DIGlobalVariable *DIGV; |
104 | | PointerUnion<const GlobalVariable *, const DIExpression *> GVInfo; |
105 | | }; |
106 | | |
107 | | struct InlineSite { |
108 | | SmallVector<LocalVariable, 1> InlinedLocals; |
109 | | SmallVector<const DILocation *, 1> ChildSites; |
110 | | const DISubprogram *Inlinee = nullptr; |
111 | | |
112 | | /// The ID of the inline site or function used with .cv_loc. Not a type |
113 | | /// index. |
114 | | unsigned SiteFuncId = 0; |
115 | | }; |
116 | | |
117 | | // Combines information from DILexicalBlock and LexicalScope. |
118 | | struct LexicalBlock { |
119 | | SmallVector<LocalVariable, 1> Locals; |
120 | | SmallVector<CVGlobalVariable, 1> Globals; |
121 | | SmallVector<LexicalBlock *, 1> Children; |
122 | | const MCSymbol *Begin; |
123 | | const MCSymbol *End; |
124 | | StringRef Name; |
125 | | }; |
126 | | |
127 | | // For each function, store a vector of labels to its instructions, as well as |
128 | | // to the end of the function. |
129 | | struct FunctionInfo { |
130 | 368 | FunctionInfo() = default; |
131 | | |
132 | | // Uncopyable. |
133 | | FunctionInfo(const FunctionInfo &FI) = delete; |
134 | | |
135 | | /// Map from inlined call site to inlined instructions and child inlined |
136 | | /// call sites. Listed in program order. |
137 | | std::unordered_map<const DILocation *, InlineSite> InlineSites; |
138 | | |
139 | | /// Ordered list of top-level inlined call sites. |
140 | | SmallVector<const DILocation *, 1> ChildSites; |
141 | | |
142 | | SmallVector<LocalVariable, 1> Locals; |
143 | | SmallVector<CVGlobalVariable, 1> Globals; |
144 | | |
145 | | std::unordered_map<const DILexicalBlockBase*, LexicalBlock> LexicalBlocks; |
146 | | |
147 | | // Lexical blocks containing local variables. |
148 | | SmallVector<LexicalBlock *, 1> ChildBlocks; |
149 | | |
150 | | std::vector<std::pair<MCSymbol *, MDNode *>> Annotations; |
151 | | std::vector<std::tuple<MCSymbol *, MCSymbol *, const DIType *>> |
152 | | HeapAllocSites; |
153 | | |
154 | | const MCSymbol *Begin = nullptr; |
155 | | const MCSymbol *End = nullptr; |
156 | | unsigned FuncId = 0; |
157 | | unsigned LastFileId = 0; |
158 | | |
159 | | /// Number of bytes allocated in the prologue for all local stack objects. |
160 | | unsigned FrameSize = 0; |
161 | | |
162 | | /// Number of bytes of parameters on the stack. |
163 | | unsigned ParamSize = 0; |
164 | | |
165 | | /// Number of bytes pushed to save CSRs. |
166 | | unsigned CSRSize = 0; |
167 | | |
168 | | /// Adjustment to apply on x86 when using the VFRAME frame pointer. |
169 | | int OffsetAdjustment = 0; |
170 | | |
171 | | /// Two-bit value indicating which register is the designated frame pointer |
172 | | /// register for local variables. Included in S_FRAMEPROC. |
173 | | codeview::EncodedFramePtrReg EncodedLocalFramePtrReg = |
174 | | codeview::EncodedFramePtrReg::None; |
175 | | |
176 | | /// Two-bit value indicating which register is the designated frame pointer |
177 | | /// register for stack parameters. Included in S_FRAMEPROC. |
178 | | codeview::EncodedFramePtrReg EncodedParamFramePtrReg = |
179 | | codeview::EncodedFramePtrReg::None; |
180 | | |
181 | | codeview::FrameProcedureOptions FrameProcOpts; |
182 | | |
183 | | bool HasStackRealignment = false; |
184 | | |
185 | | bool HaveLineInfo = false; |
186 | | }; |
187 | | FunctionInfo *CurFn = nullptr; |
188 | | |
189 | | // Map used to seperate variables according to the lexical scope they belong |
190 | | // in. This is populated by recordLocalVariable() before |
191 | | // collectLexicalBlocks() separates the variables between the FunctionInfo |
192 | | // and LexicalBlocks. |
193 | | DenseMap<const LexicalScope *, SmallVector<LocalVariable, 1>> ScopeVariables; |
194 | | |
195 | | // Map to separate global variables according to the lexical scope they |
196 | | // belong in. A null local scope represents the global scope. |
197 | | typedef SmallVector<CVGlobalVariable, 1> GlobalVariableList; |
198 | | DenseMap<const DIScope*, std::unique_ptr<GlobalVariableList> > ScopeGlobals; |
199 | | |
200 | | // Array of global variables which need to be emitted into a COMDAT section. |
201 | | SmallVector<CVGlobalVariable, 1> ComdatVariables; |
202 | | |
203 | | // Array of non-COMDAT global variables. |
204 | | SmallVector<CVGlobalVariable, 1> GlobalVariables; |
205 | | |
206 | | /// The set of comdat .debug$S sections that we've seen so far. Each section |
207 | | /// must start with a magic version number that must only be emitted once. |
208 | | /// This set tracks which sections we've already opened. |
209 | | DenseSet<MCSectionCOFF *> ComdatDebugSections; |
210 | | |
211 | | /// Switch to the appropriate .debug$S section for GVSym. If GVSym, the symbol |
212 | | /// of an emitted global value, is in a comdat COFF section, this will switch |
213 | | /// to a new .debug$S section in that comdat. This method ensures that the |
214 | | /// section starts with the magic version number on first use. If GVSym is |
215 | | /// null, uses the main .debug$S section. |
216 | | void switchToDebugSectionForSymbol(const MCSymbol *GVSym); |
217 | | |
218 | | /// The next available function index for use with our .cv_* directives. Not |
219 | | /// to be confused with type indices for LF_FUNC_ID records. |
220 | | unsigned NextFuncId = 0; |
221 | | |
222 | | InlineSite &getInlineSite(const DILocation *InlinedAt, |
223 | | const DISubprogram *Inlinee); |
224 | | |
225 | | codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP); |
226 | | |
227 | | void calculateRanges(LocalVariable &Var, |
228 | | const DbgValueHistoryMap::Entries &Entries); |
229 | | |
230 | | static void collectInlineSiteChildren(SmallVectorImpl<unsigned> &Children, |
231 | | const FunctionInfo &FI, |
232 | | const InlineSite &Site); |
233 | | |
234 | | /// Remember some debug info about each function. Keep it in a stable order to |
235 | | /// emit at the end of the TU. |
236 | | MapVector<const Function *, std::unique_ptr<FunctionInfo>> FnDebugInfo; |
237 | | |
238 | | /// Map from full file path to .cv_file id. Full paths are built from DIFiles |
239 | | /// and are stored in FileToFilepathMap; |
240 | | DenseMap<StringRef, unsigned> FileIdMap; |
241 | | |
242 | | /// All inlined subprograms in the order they should be emitted. |
243 | | SmallSetVector<const DISubprogram *, 4> InlinedSubprograms; |
244 | | |
245 | | /// Map from a pair of DI metadata nodes and its DI type (or scope) that can |
246 | | /// be nullptr, to CodeView type indices. Primarily indexed by |
247 | | /// {DIType*, DIType*} and {DISubprogram*, DIType*}. |
248 | | /// |
249 | | /// The second entry in the key is needed for methods as DISubroutineType |
250 | | /// representing static method type are shared with non-method function type. |
251 | | DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex> |
252 | | TypeIndices; |
253 | | |
254 | | /// Map from DICompositeType* to complete type index. Non-record types are |
255 | | /// always looked up in the normal TypeIndices map. |
256 | | DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices; |
257 | | |
258 | | /// Complete record types to emit after all active type lowerings are |
259 | | /// finished. |
260 | | SmallVector<const DICompositeType *, 4> DeferredCompleteTypes; |
261 | | |
262 | | /// Number of type lowering frames active on the stack. |
263 | | unsigned TypeEmissionLevel = 0; |
264 | | |
265 | | codeview::TypeIndex VBPType; |
266 | | |
267 | | const DISubprogram *CurrentSubprogram = nullptr; |
268 | | |
269 | | // The UDTs we have seen while processing types; each entry is a pair of type |
270 | | // index and type name. |
271 | | std::vector<std::pair<std::string, const DIType *>> LocalUDTs; |
272 | | std::vector<std::pair<std::string, const DIType *>> GlobalUDTs; |
273 | | |
274 | | using FileToFilepathMapTy = std::map<const DIFile *, std::string>; |
275 | | FileToFilepathMapTy FileToFilepathMap; |
276 | | |
277 | | StringRef getFullFilepath(const DIFile *File); |
278 | | |
279 | | unsigned maybeRecordFile(const DIFile *F); |
280 | | |
281 | | void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF); |
282 | | |
283 | | void clear(); |
284 | | |
285 | 558 | void setCurrentSubprogram(const DISubprogram *SP) { |
286 | 558 | CurrentSubprogram = SP; |
287 | 558 | LocalUDTs.clear(); |
288 | 558 | } |
289 | | |
290 | | /// Emit the magic version number at the start of a CodeView type or symbol |
291 | | /// section. Appears at the front of every .debug$S or .debug$T or .debug$P |
292 | | /// section. |
293 | | void emitCodeViewMagicVersion(); |
294 | | |
295 | | void emitTypeInformation(); |
296 | | |
297 | | void emitTypeGlobalHashes(); |
298 | | |
299 | | void emitCompilerInformation(); |
300 | | |
301 | | void emitBuildInfo(); |
302 | | |
303 | | void emitInlineeLinesSubsection(); |
304 | | |
305 | | void emitDebugInfoForThunk(const Function *GV, |
306 | | FunctionInfo &FI, |
307 | | const MCSymbol *Fn); |
308 | | |
309 | | void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI); |
310 | | |
311 | | void emitDebugInfoForRetainedTypes(); |
312 | | |
313 | | void |
314 | | emitDebugInfoForUDTs(ArrayRef<std::pair<std::string, const DIType *>> UDTs); |
315 | | |
316 | | void emitDebugInfoForGlobals(); |
317 | | void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals); |
318 | | void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV); |
319 | | |
320 | | /// Opens a subsection of the given kind in a .debug$S codeview section. |
321 | | /// Returns an end label for use with endCVSubsection when the subsection is |
322 | | /// finished. |
323 | | MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind); |
324 | | void endCVSubsection(MCSymbol *EndLabel); |
325 | | |
326 | | /// Opens a symbol record of the given kind. Returns an end label for use with |
327 | | /// endSymbolRecord. |
328 | | MCSymbol *beginSymbolRecord(codeview::SymbolKind Kind); |
329 | | void endSymbolRecord(MCSymbol *SymEnd); |
330 | | |
331 | | /// Emits an S_END, S_INLINESITE_END, or S_PROC_ID_END record. These records |
332 | | /// are empty, so we emit them with a simpler assembly sequence that doesn't |
333 | | /// involve labels. |
334 | | void emitEndSymbolRecord(codeview::SymbolKind EndKind); |
335 | | |
336 | | void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt, |
337 | | const InlineSite &Site); |
338 | | |
339 | | using InlinedEntity = DbgValueHistoryMap::InlinedEntity; |
340 | | |
341 | | void collectGlobalVariableInfo(); |
342 | | void collectVariableInfo(const DISubprogram *SP); |
343 | | |
344 | | void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed); |
345 | | |
346 | | // Construct the lexical block tree for a routine, pruning emptpy lexical |
347 | | // scopes, and populate it with local variables. |
348 | | void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes, |
349 | | SmallVectorImpl<LexicalBlock *> &Blocks, |
350 | | SmallVectorImpl<LocalVariable> &Locals, |
351 | | SmallVectorImpl<CVGlobalVariable> &Globals); |
352 | | void collectLexicalBlockInfo(LexicalScope &Scope, |
353 | | SmallVectorImpl<LexicalBlock *> &ParentBlocks, |
354 | | SmallVectorImpl<LocalVariable> &ParentLocals, |
355 | | SmallVectorImpl<CVGlobalVariable> &ParentGlobals); |
356 | | |
357 | | /// Records information about a local variable in the appropriate scope. In |
358 | | /// particular, locals from inlined code live inside the inlining site. |
359 | | void recordLocalVariable(LocalVariable &&Var, const LexicalScope *LS); |
360 | | |
361 | | /// Emits local variables in the appropriate order. |
362 | | void emitLocalVariableList(const FunctionInfo &FI, |
363 | | ArrayRef<LocalVariable> Locals); |
364 | | |
365 | | /// Emits an S_LOCAL record and its associated defined ranges. |
366 | | void emitLocalVariable(const FunctionInfo &FI, const LocalVariable &Var); |
367 | | |
368 | | /// Emits a sequence of lexical block scopes and their children. |
369 | | void emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks, |
370 | | const FunctionInfo& FI); |
371 | | |
372 | | /// Emit a lexical block scope and its children. |
373 | | void emitLexicalBlock(const LexicalBlock &Block, const FunctionInfo& FI); |
374 | | |
375 | | /// Translates the DIType to codeview if necessary and returns a type index |
376 | | /// for it. |
377 | | codeview::TypeIndex getTypeIndex(const DIType *Ty, |
378 | | const DIType *ClassTy = nullptr); |
379 | | |
380 | | codeview::TypeIndex |
381 | | getTypeIndexForThisPtr(const DIDerivedType *PtrTy, |
382 | | const DISubroutineType *SubroutineTy); |
383 | | |
384 | | codeview::TypeIndex getTypeIndexForReferenceTo(const DIType *Ty); |
385 | | |
386 | | codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP, |
387 | | const DICompositeType *Class); |
388 | | |
389 | | codeview::TypeIndex getScopeIndex(const DIScope *Scope); |
390 | | |
391 | | codeview::TypeIndex getVBPTypeIndex(); |
392 | | |
393 | | void addToUDTs(const DIType *Ty); |
394 | | |
395 | | void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI); |
396 | | |
397 | | codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy); |
398 | | codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty); |
399 | | codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty); |
400 | | codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty); |
401 | | codeview::TypeIndex lowerTypePointer( |
402 | | const DIDerivedType *Ty, |
403 | | codeview::PointerOptions PO = codeview::PointerOptions::None); |
404 | | codeview::TypeIndex lowerTypeMemberPointer( |
405 | | const DIDerivedType *Ty, |
406 | | codeview::PointerOptions PO = codeview::PointerOptions::None); |
407 | | codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty); |
408 | | codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty); |
409 | | codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty); |
410 | | codeview::TypeIndex lowerTypeMemberFunction( |
411 | | const DISubroutineType *Ty, const DIType *ClassTy, int ThisAdjustment, |
412 | | bool IsStaticMethod, |
413 | | codeview::FunctionOptions FO = codeview::FunctionOptions::None); |
414 | | codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty); |
415 | | codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty); |
416 | | codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty); |
417 | | |
418 | | /// Symbol records should point to complete types, but type records should |
419 | | /// always point to incomplete types to avoid cycles in the type graph. Only |
420 | | /// use this entry point when generating symbol records. The complete and |
421 | | /// incomplete type indices only differ for record types. All other types use |
422 | | /// the same index. |
423 | | codeview::TypeIndex getCompleteTypeIndex(const DIType *Ty); |
424 | | |
425 | | codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty); |
426 | | codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty); |
427 | | |
428 | | struct TypeLoweringScope; |
429 | | |
430 | | void emitDeferredCompleteTypes(); |
431 | | |
432 | | void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy); |
433 | | ClassInfo collectClassInfo(const DICompositeType *Ty); |
434 | | |
435 | | /// Common record member lowering functionality for record types, which are |
436 | | /// structs, classes, and unions. Returns the field list index and the member |
437 | | /// count. |
438 | | std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool> |
439 | | lowerRecordFieldList(const DICompositeType *Ty); |
440 | | |
441 | | /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates. |
442 | | codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node, |
443 | | codeview::TypeIndex TI, |
444 | | const DIType *ClassTy = nullptr); |
445 | | |
446 | | unsigned getPointerSizeInBytes(); |
447 | | |
448 | | protected: |
449 | | /// Gather pre-function debug information. |
450 | | void beginFunctionImpl(const MachineFunction *MF) override; |
451 | | |
452 | | /// Gather post-function debug information. |
453 | | void endFunctionImpl(const MachineFunction *) override; |
454 | | |
455 | | public: |
456 | | CodeViewDebug(AsmPrinter *AP); |
457 | | |
458 | 286 | void setSymbolSize(const MCSymbol *, uint64_t) override {} |
459 | | |
460 | | /// Emit the COFF section that holds the line table information. |
461 | | void endModule() override; |
462 | | |
463 | | /// Process beginning of an instruction. |
464 | | void beginInstruction(const MachineInstr *MI) override; |
465 | | }; |
466 | | |
467 | | } // end namespace llvm |
468 | | |
469 | | #endif // LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H |