blob: 35902302c2152340d65f80f0cd83f58257485846 [file] [log] [blame]
Eugene Zelenkofb69e662017-06-06 22:22:41 +00001//===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h --------------*- C++ -*-===//
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +00002//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// 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
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +00006//
7//===----------------------------------------------------------------------===//
8//
Reid Kleckner70f5bc92016-01-14 19:25:04 +00009// This file contains support for writing Microsoft CodeView debug info.
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +000010//
11//===----------------------------------------------------------------------===//
12
Reid Kleckner70f5bc92016-01-14 19:25:04 +000013#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
14#define LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +000015
Eugene Zelenkofb69e662017-06-06 22:22:41 +000016#include "llvm/ADT/ArrayRef.h"
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +000017#include "llvm/ADT/DenseMap.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000018#include "llvm/ADT/DenseSet.h"
19#include "llvm/ADT/MapVector.h"
20#include "llvm/ADT/SetVector.h"
21#include "llvm/ADT/SmallVector.h"
Yonghong Song61b189e2018-12-18 23:10:17 +000022#include "llvm/CodeGen/DbgEntityHistoryCalculator.h"
23#include "llvm/CodeGen/DebugHandlerBase.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000024#include "llvm/DebugInfo/CodeView/CodeView.h"
Zachary Turner048f8f92017-12-13 22:33:58 +000025#include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
Reid Klecknerf3b9ba42016-01-29 18:16:43 +000026#include "llvm/DebugInfo/CodeView/TypeIndex.h"
Chandler Carruth92051402014-03-05 10:30:38 +000027#include "llvm/IR/DebugLoc.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000028#include "llvm/Support/Allocator.h"
29#include "llvm/Support/Compiler.h"
30#include <cstdint>
31#include <map>
32#include <string>
33#include <tuple>
34#include <unordered_map>
35#include <utility>
36#include <vector>
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +000037
38namespace llvm {
Reid Klecknerf9c275f2016-02-10 20:55:49 +000039
Amjad Aboud76c9eb92016-06-18 10:25:07 +000040struct ClassInfo;
Eugene Zelenkofb69e662017-06-06 22:22:41 +000041class StringRef;
42class AsmPrinter;
43class Function;
44class GlobalVariable;
45class MCSectionCOFF;
46class MCStreamer;
47class MCSymbol;
48class MachineFunction;
Reid Klecknerf9c275f2016-02-10 20:55:49 +000049
Adrian Prantl5f8f34e42018-05-01 15:54:18 +000050/// Collects and handles line tables information in a CodeView format.
Reid Klecknerf9c275f2016-02-10 20:55:49 +000051class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
Reid Klecknerdac21b42016-02-03 21:15:48 +000052 MCStreamer &OS;
Eugene Zelenkofb69e662017-06-06 22:22:41 +000053 BumpPtrAllocator Allocator;
Zachary Turner048f8f92017-12-13 22:33:58 +000054 codeview::GlobalTypeTableBuilder TypeTable;
Reid Klecknerf9c275f2016-02-10 20:55:49 +000055
Reid Kleckner75557712018-11-16 18:47:41 +000056 /// Whether to emit type record hashes into .debug$H.
57 bool EmitDebugGlobalHashes = false;
58
Reid Kleckner9ea2c012018-10-01 21:59:45 +000059 /// The codeview CPU type used by the translation unit.
60 codeview::CPUType TheCPU;
61
Reid Kleckner876330d2016-02-12 21:48:30 +000062 /// Represents the most general definition range.
63 struct LocalVarDefRange {
64 /// Indicates that variable data is stored in memory relative to the
65 /// specified register.
66 int InMemory : 1;
67
68 /// Offset of variable data in memory.
69 int DataOffset : 31;
70
Reid Kleckner2b3e6422016-10-05 21:21:33 +000071 /// Non-zero if this is a piece of an aggregate.
72 uint16_t IsSubfield : 1;
73
74 /// Offset into aggregate.
75 uint16_t StructOffset : 15;
Reid Kleckner876330d2016-02-12 21:48:30 +000076
77 /// Register containing the data or the register base of the memory
78 /// location containing the data.
79 uint16_t CVRegister;
80
81 /// Compares all location fields. This includes all fields except the label
82 /// ranges.
83 bool isDifferentLocation(LocalVarDefRange &O) {
84 return InMemory != O.InMemory || DataOffset != O.DataOffset ||
Reid Kleckner2b3e6422016-10-05 21:21:33 +000085 IsSubfield != O.IsSubfield || StructOffset != O.StructOffset ||
86 CVRegister != O.CVRegister;
Reid Kleckner876330d2016-02-12 21:48:30 +000087 }
88
89 SmallVector<std::pair<const MCSymbol *, const MCSymbol *>, 1> Ranges;
90 };
91
92 static LocalVarDefRange createDefRangeMem(uint16_t CVRegister, int Offset);
Reid Kleckner876330d2016-02-12 21:48:30 +000093
Reid Klecknerf9c275f2016-02-10 20:55:49 +000094 /// Similar to DbgVariable in DwarfDebug, but not dwarf-specific.
95 struct LocalVariable {
96 const DILocalVariable *DIVar = nullptr;
Reid Kleckner876330d2016-02-12 21:48:30 +000097 SmallVector<LocalVarDefRange, 1> DefRanges;
Reid Kleckner08f5fd52017-08-31 15:56:49 +000098 bool UseReferenceType = false;
Reid Klecknerf9c275f2016-02-10 20:55:49 +000099 };
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000100
Brock Wymab17464e2018-12-20 17:33:45 +0000101 struct CVGlobalVariable {
102 const DIGlobalVariable *DIGV;
103 const GlobalVariable *GV;
104 };
105
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000106 struct InlineSite {
Reid Klecknerf9c275f2016-02-10 20:55:49 +0000107 SmallVector<LocalVariable, 1> InlinedLocals;
108 SmallVector<const DILocation *, 1> ChildSites;
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000109 const DISubprogram *Inlinee = nullptr;
Reid Klecknerc29b4f02016-07-14 23:47:15 +0000110
111 /// The ID of the inline site or function used with .cv_loc. Not a type
112 /// index.
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000113 unsigned SiteFuncId = 0;
114 };
115
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000116 // Combines information from DILexicalBlock and LexicalScope.
117 struct LexicalBlock {
118 SmallVector<LocalVariable, 1> Locals;
Brock Wymab17464e2018-12-20 17:33:45 +0000119 SmallVector<CVGlobalVariable, 1> Globals;
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000120 SmallVector<LexicalBlock *, 1> Children;
121 const MCSymbol *Begin;
122 const MCSymbol *End;
123 StringRef Name;
124 };
125
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000126 // For each function, store a vector of labels to its instructions, as well as
127 // to the end of the function.
128 struct FunctionInfo {
Reid Kleckner55baeef2018-03-15 21:12:21 +0000129 FunctionInfo() = default;
130
131 // Uncopyable.
132 FunctionInfo(const FunctionInfo &FI) = delete;
133
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000134 /// Map from inlined call site to inlined instructions and child inlined
135 /// call sites. Listed in program order.
Reid Klecknerf9c275f2016-02-10 20:55:49 +0000136 std::unordered_map<const DILocation *, InlineSite> InlineSites;
137
138 /// Ordered list of top-level inlined call sites.
139 SmallVector<const DILocation *, 1> ChildSites;
140
141 SmallVector<LocalVariable, 1> Locals;
Brock Wymab17464e2018-12-20 17:33:45 +0000142 SmallVector<CVGlobalVariable, 1> Globals;
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000143
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000144 std::unordered_map<const DILexicalBlockBase*, LexicalBlock> LexicalBlocks;
145
146 // Lexical blocks containing local variables.
147 SmallVector<LexicalBlock *, 1> ChildBlocks;
148
Reid Klecknere33c94f2017-09-05 20:14:58 +0000149 std::vector<std::pair<MCSymbol *, MDNode *>> Annotations;
150
Reid Kleckner1fcd6102016-02-02 17:41:18 +0000151 const MCSymbol *Begin = nullptr;
152 const MCSymbol *End = nullptr;
Reid Kleckner2214ed82016-01-29 00:49:42 +0000153 unsigned FuncId = 0;
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000154 unsigned LastFileId = 0;
Reid Kleckner9ea2c012018-10-01 21:59:45 +0000155
156 /// Number of bytes allocated in the prologue for all local stack objects.
157 unsigned FrameSize = 0;
158
159 /// Number of bytes of parameters on the stack.
160 unsigned ParamSize = 0;
161
162 /// Number of bytes pushed to save CSRs.
163 unsigned CSRSize = 0;
164
Reid Kleckner2bcb2882018-11-03 00:41:52 +0000165 /// Adjustment to apply on x86 when using the VFRAME frame pointer.
166 int OffsetAdjustment = 0;
167
Reid Kleckner9ea2c012018-10-01 21:59:45 +0000168 /// Two-bit value indicating which register is the designated frame pointer
169 /// register for local variables. Included in S_FRAMEPROC.
170 codeview::EncodedFramePtrReg EncodedLocalFramePtrReg =
171 codeview::EncodedFramePtrReg::None;
172
173 /// Two-bit value indicating which register is the designated frame pointer
174 /// register for stack parameters. Included in S_FRAMEPROC.
175 codeview::EncodedFramePtrReg EncodedParamFramePtrReg =
176 codeview::EncodedFramePtrReg::None;
177
178 codeview::FrameProcedureOptions FrameProcOpts;
179
Reid Klecknerd5e4ec72018-10-02 16:43:52 +0000180 bool HasStackRealignment = false;
181
Reid Kleckner2214ed82016-01-29 00:49:42 +0000182 bool HaveLineInfo = false;
Reid Kleckner9533af42016-01-16 00:09:09 +0000183 };
Eugene Zelenkofb69e662017-06-06 22:22:41 +0000184 FunctionInfo *CurFn = nullptr;
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000185
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000186 // Map used to seperate variables according to the lexical scope they belong
187 // in. This is populated by recordLocalVariable() before
188 // collectLexicalBlocks() separates the variables between the FunctionInfo
189 // and LexicalBlocks.
190 DenseMap<const LexicalScope *, SmallVector<LocalVariable, 1>> ScopeVariables;
191
Brock Wymab17464e2018-12-20 17:33:45 +0000192 // Map to separate global variables according to the lexical scope they
193 // belong in. A null local scope represents the global scope.
194 typedef SmallVector<CVGlobalVariable, 1> GlobalVariableList;
195 DenseMap<const DIScope*, std::unique_ptr<GlobalVariableList> > ScopeGlobals;
196
197 // Array of global variables which need to be emitted into a COMDAT section.
198 SmallVector<CVGlobalVariable, 1> ComdatVariables;
199
200 // Array of non-COMDAT global variables.
201 SmallVector<CVGlobalVariable, 1> GlobalVariables;
202
Reid Kleckner5d122f82016-05-25 23:16:12 +0000203 /// The set of comdat .debug$S sections that we've seen so far. Each section
204 /// must start with a magic version number that must only be emitted once.
205 /// This set tracks which sections we've already opened.
206 DenseSet<MCSectionCOFF *> ComdatDebugSections;
207
208 /// Switch to the appropriate .debug$S section for GVSym. If GVSym, the symbol
209 /// of an emitted global value, is in a comdat COFF section, this will switch
210 /// to a new .debug$S section in that comdat. This method ensures that the
211 /// section starts with the magic version number on first use. If GVSym is
212 /// null, uses the main .debug$S section.
213 void switchToDebugSectionForSymbol(const MCSymbol *GVSym);
214
Reid Klecknerfbd77872016-03-18 18:54:32 +0000215 /// The next available function index for use with our .cv_* directives. Not
216 /// to be confused with type indices for LF_FUNC_ID records.
Reid Kleckner2214ed82016-01-29 00:49:42 +0000217 unsigned NextFuncId = 0;
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000218
Reid Kleckner876330d2016-02-12 21:48:30 +0000219 InlineSite &getInlineSite(const DILocation *InlinedAt,
220 const DISubprogram *Inlinee);
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000221
David Majnemer75c3ebf2016-06-02 17:13:53 +0000222 codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP);
Reid Kleckner2280f932016-05-23 20:23:46 +0000223
Bob Haarman223303c2017-08-29 20:59:25 +0000224 void calculateRanges(LocalVariable &Var,
David Stenberg6feef562019-04-10 09:07:43 +0000225 const DbgValueHistoryMap::Entries &Entries);
Bob Haarman223303c2017-08-29 20:59:25 +0000226
Reid Kleckner1fcd6102016-02-02 17:41:18 +0000227 static void collectInlineSiteChildren(SmallVectorImpl<unsigned> &Children,
228 const FunctionInfo &FI,
229 const InlineSite &Site);
230
Reid Kleckner2214ed82016-01-29 00:49:42 +0000231 /// Remember some debug info about each function. Keep it in a stable order to
232 /// emit at the end of the TU.
Reid Kleckner55baeef2018-03-15 21:12:21 +0000233 MapVector<const Function *, std::unique_ptr<FunctionInfo>> FnDebugInfo;
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000234
Reid Klecknerbc6f52d2017-10-31 21:52:15 +0000235 /// Map from full file path to .cv_file id. Full paths are built from DIFiles
236 /// and are stored in FileToFilepathMap;
237 DenseMap<StringRef, unsigned> FileIdMap;
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000238
Reid Klecknerfbd77872016-03-18 18:54:32 +0000239 /// All inlined subprograms in the order they should be emitted.
Reid Kleckner2280f932016-05-23 20:23:46 +0000240 SmallSetVector<const DISubprogram *, 4> InlinedSubprograms;
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000241
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000242 /// Map from a pair of DI metadata nodes and its DI type (or scope) that can
243 /// be nullptr, to CodeView type indices. Primarily indexed by
244 /// {DIType*, DIType*} and {DISubprogram*, DIType*}.
245 ///
246 /// The second entry in the key is needed for methods as DISubroutineType
247 /// representing static method type are shared with non-method function type.
248 DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex>
249 TypeIndices;
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000250
Reid Klecknera8d57402016-06-03 15:58:20 +0000251 /// Map from DICompositeType* to complete type index. Non-record types are
252 /// always looked up in the normal TypeIndices map.
253 DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices;
254
Reid Kleckner643dd832016-06-22 17:15:28 +0000255 /// Complete record types to emit after all active type lowerings are
256 /// finished.
257 SmallVector<const DICompositeType *, 4> DeferredCompleteTypes;
258
259 /// Number of type lowering frames active on the stack.
260 unsigned TypeEmissionLevel = 0;
261
Reid Kleckner9f7f3e12016-06-24 16:24:24 +0000262 codeview::TypeIndex VBPType;
263
David Majnemer3128b102016-06-15 18:00:01 +0000264 const DISubprogram *CurrentSubprogram = nullptr;
265
266 // The UDTs we have seen while processing types; each entry is a pair of type
267 // index and type name.
Zachary Turnera7b04172017-08-28 18:49:04 +0000268 std::vector<std::pair<std::string, const DIType *>> LocalUDTs;
269 std::vector<std::pair<std::string, const DIType *>> GlobalUDTs;
David Majnemer3128b102016-06-15 18:00:01 +0000270
Eugene Zelenkofb69e662017-06-06 22:22:41 +0000271 using FileToFilepathMapTy = std::map<const DIFile *, std::string>;
Reid Kleckner9533af42016-01-16 00:09:09 +0000272 FileToFilepathMapTy FileToFilepathMap;
Eugene Zelenkofb69e662017-06-06 22:22:41 +0000273
Fangrui Songcb0bab82018-07-16 18:51:40 +0000274 StringRef getFullFilepath(const DIFile *File);
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000275
Reid Kleckner2214ed82016-01-29 00:49:42 +0000276 unsigned maybeRecordFile(const DIFile *F);
277
Benjamin Kramerbdc49562016-06-12 15:39:02 +0000278 void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF);
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000279
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000280 void clear();
David Majnemer3128b102016-06-15 18:00:01 +0000281
282 void setCurrentSubprogram(const DISubprogram *SP) {
283 CurrentSubprogram = SP;
284 LocalUDTs.clear();
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000285 }
286
Reid Kleckner5d122f82016-05-25 23:16:12 +0000287 /// Emit the magic version number at the start of a CodeView type or symbol
Alexandre Ganead9e96742018-04-09 20:17:56 +0000288 /// section. Appears at the front of every .debug$S or .debug$T or .debug$P
289 /// section.
Reid Kleckner5d122f82016-05-25 23:16:12 +0000290 void emitCodeViewMagicVersion();
291
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000292 void emitTypeInformation();
293
Zachary Turner048f8f92017-12-13 22:33:58 +0000294 void emitTypeGlobalHashes();
295
Adrian McCarthyc64acfd2016-09-20 17:20:51 +0000296 void emitCompilerInformation();
297
Reid Kleckner810687c2018-10-12 18:19:06 +0000298 void emitBuildInfo();
299
Reid Kleckner5d122f82016-05-25 23:16:12 +0000300 void emitInlineeLinesSubsection();
Reid Kleckner1fcd6102016-02-02 17:41:18 +0000301
Brock Wyma94ece8f2018-04-16 16:53:57 +0000302 void emitDebugInfoForThunk(const Function *GV,
303 FunctionInfo &FI,
304 const MCSymbol *Fn);
305
Reid Kleckner2214ed82016-01-29 00:49:42 +0000306 void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000307
Hans Wennborgb510b452016-06-23 16:33:53 +0000308 void emitDebugInfoForRetainedTypes();
309
Zachary Turnera7b04172017-08-28 18:49:04 +0000310 void
311 emitDebugInfoForUDTs(ArrayRef<std::pair<std::string, const DIType *>> UDTs);
David Majnemer3128b102016-06-15 18:00:01 +0000312
Brock Wymab17464e2018-12-20 17:33:45 +0000313 void emitDebugInfoForGlobals();
314 void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals);
Peter Collingbourned4135bb2016-09-13 01:12:59 +0000315 void emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
316 const GlobalVariable *GV, MCSymbol *GVSym);
Reid Kleckner6f3406d2016-06-07 00:02:03 +0000317
318 /// Opens a subsection of the given kind in a .debug$S codeview section.
319 /// Returns an end label for use with endCVSubsection when the subsection is
320 /// finished.
Zachary Turner8c099fe2017-05-30 16:36:15 +0000321 MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
Reid Kleckner6f3406d2016-06-07 00:02:03 +0000322 void endCVSubsection(MCSymbol *EndLabel);
323
Reid Kleckner5bf71d12018-12-14 22:40:28 +0000324 /// Opens a symbol record of the given kind. Returns an end label for use with
325 /// endSymbolRecord.
326 MCSymbol *beginSymbolRecord(codeview::SymbolKind Kind);
327 void endSymbolRecord(MCSymbol *SymEnd);
328
329 /// Emits an S_END, S_INLINESITE_END, or S_PROC_ID_END record. These records
330 /// are empty, so we emit them with a simpler assembly sequence that doesn't
331 /// involve labels.
332 void emitEndSymbolRecord(codeview::SymbolKind EndKind);
333
Reid Klecknerf3b9ba42016-01-29 18:16:43 +0000334 void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
335 const InlineSite &Site);
336
Hsiangkai Wang760c1ab2018-09-06 02:22:06 +0000337 using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
Reid Kleckner876330d2016-02-12 21:48:30 +0000338
Brock Wymab17464e2018-12-20 17:33:45 +0000339 void collectGlobalVariableInfo();
Reid Kleckner876330d2016-02-12 21:48:30 +0000340 void collectVariableInfo(const DISubprogram *SP);
341
Hsiangkai Wang760c1ab2018-09-06 02:22:06 +0000342 void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed);
Reid Kleckner876330d2016-02-12 21:48:30 +0000343
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000344 // Construct the lexical block tree for a routine, pruning emptpy lexical
345 // scopes, and populate it with local variables.
346 void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
347 SmallVectorImpl<LexicalBlock *> &Blocks,
Brock Wymab17464e2018-12-20 17:33:45 +0000348 SmallVectorImpl<LocalVariable> &Locals,
349 SmallVectorImpl<CVGlobalVariable> &Globals);
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000350 void collectLexicalBlockInfo(LexicalScope &Scope,
351 SmallVectorImpl<LexicalBlock *> &ParentBlocks,
Brock Wymab17464e2018-12-20 17:33:45 +0000352 SmallVectorImpl<LocalVariable> &ParentLocals,
353 SmallVectorImpl<CVGlobalVariable> &ParentGlobals);
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000354
Reid Kleckner876330d2016-02-12 21:48:30 +0000355 /// Records information about a local variable in the appropriate scope. In
356 /// particular, locals from inlined code live inside the inlining site.
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000357 void recordLocalVariable(LocalVariable &&Var, const LexicalScope *LS);
Reid Klecknerf9c275f2016-02-10 20:55:49 +0000358
Reid Kleckner10dd55c2016-06-24 17:55:40 +0000359 /// Emits local variables in the appropriate order.
Reid Kleckner9ea2c012018-10-01 21:59:45 +0000360 void emitLocalVariableList(const FunctionInfo &FI,
361 ArrayRef<LocalVariable> Locals);
Reid Kleckner10dd55c2016-06-24 17:55:40 +0000362
363 /// Emits an S_LOCAL record and its associated defined ranges.
Reid Kleckner9ea2c012018-10-01 21:59:45 +0000364 void emitLocalVariable(const FunctionInfo &FI, const LocalVariable &Var);
Reid Klecknerf9c275f2016-02-10 20:55:49 +0000365
Reid Kleckner5a791ee2018-03-15 21:24:04 +0000366 /// Emits a sequence of lexical block scopes and their children.
367 void emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
368 const FunctionInfo& FI);
369
370 /// Emit a lexical block scope and its children.
371 void emitLexicalBlock(const LexicalBlock &Block, const FunctionInfo& FI);
372
Reid Kleckner5acacbb2016-06-01 17:05:51 +0000373 /// Translates the DIType to codeview if necessary and returns a type index
374 /// for it.
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000375 codeview::TypeIndex getTypeIndex(DITypeRef TypeRef,
376 DITypeRef ClassTyRef = DITypeRef());
Reid Kleckner5acacbb2016-06-01 17:05:51 +0000377
Zachary Turnerc68f8952018-11-20 22:13:43 +0000378 codeview::TypeIndex
Reid Klecknerc168c6f2018-12-26 21:52:17 +0000379 getTypeIndexForThisPtr(const DIDerivedType *PtrTy,
Zachary Turnerc68f8952018-11-20 22:13:43 +0000380 const DISubroutineType *SubroutineTy);
381
Bob Haarman223303c2017-08-29 20:59:25 +0000382 codeview::TypeIndex getTypeIndexForReferenceTo(DITypeRef TypeRef);
383
Reid Kleckner0c5d8742016-06-22 01:32:56 +0000384 codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
385 const DICompositeType *Class);
386
387 codeview::TypeIndex getScopeIndex(const DIScope *Scope);
388
Reid Kleckner9f7f3e12016-06-24 16:24:24 +0000389 codeview::TypeIndex getVBPTypeIndex();
390
Zachary Turnera7b04172017-08-28 18:49:04 +0000391 void addToUDTs(const DIType *Ty);
Hans Wennborg4b63a982016-06-23 22:57:25 +0000392
Aaron Smith122d9e72018-03-06 18:20:22 +0000393 void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
394
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000395 codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
David Majnemerd065e232016-06-02 06:21:37 +0000396 codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
Adrian McCarthyf3c3c132016-06-08 18:22:59 +0000397 codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
Reid Kleckner5acacbb2016-06-01 17:05:51 +0000398 codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
Reid Kleckner3acdc672018-02-27 22:08:15 +0000399 codeview::TypeIndex lowerTypePointer(
400 const DIDerivedType *Ty,
401 codeview::PointerOptions PO = codeview::PointerOptions::None);
402 codeview::TypeIndex lowerTypeMemberPointer(
403 const DIDerivedType *Ty,
404 codeview::PointerOptions PO = codeview::PointerOptions::None);
Reid Kleckner5acacbb2016-06-01 17:05:51 +0000405 codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
David Majnemer75c3ebf2016-06-02 17:13:53 +0000406 codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
Reid Kleckner9dac4732016-08-31 15:59:30 +0000407 codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty);
Aaron Smith802b0332018-10-02 20:21:05 +0000408 codeview::TypeIndex lowerTypeMemberFunction(
409 const DISubroutineType *Ty, const DIType *ClassTy, int ThisAdjustment,
410 bool IsStaticMethod,
411 codeview::FunctionOptions FO = codeview::FunctionOptions::None);
David Majnemer979cb882016-06-16 21:32:16 +0000412 codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
Reid Klecknera8d57402016-06-03 15:58:20 +0000413 codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
414 codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
415
416 /// Symbol records should point to complete types, but type records should
417 /// always point to incomplete types to avoid cycles in the type graph. Only
418 /// use this entry point when generating symbol records. The complete and
419 /// incomplete type indices only differ for record types. All other types use
420 /// the same index.
421 codeview::TypeIndex getCompleteTypeIndex(DITypeRef TypeRef);
422
423 codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
424 codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
425
Reid Kleckner643dd832016-06-22 17:15:28 +0000426 struct TypeLoweringScope;
427
428 void emitDeferredCompleteTypes();
429
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000430 void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy);
Reid Kleckner1ab7eac2016-06-22 16:06:42 +0000431 ClassInfo collectClassInfo(const DICompositeType *Ty);
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000432
Reid Klecknera8d57402016-06-03 15:58:20 +0000433 /// Common record member lowering functionality for record types, which are
434 /// structs, classes, and unions. Returns the field list index and the member
435 /// count.
Adrian McCarthy820ca542016-07-06 19:49:51 +0000436 std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
Reid Klecknera8d57402016-06-03 15:58:20 +0000437 lowerRecordFieldList(const DICompositeType *Ty);
438
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000439 /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates.
Reid Kleckner0c5d8742016-06-22 01:32:56 +0000440 codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
441 codeview::TypeIndex TI,
442 const DIType *ClassTy = nullptr);
Amjad Aboud76c9eb92016-06-18 10:25:07 +0000443
444 unsigned getPointerSizeInBytes();
Reid Kleckner5acacbb2016-06-01 17:05:51 +0000445
David Blaikieb2fbb4b2017-02-16 18:48:33 +0000446protected:
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000447 /// Gather pre-function debug information.
David Blaikieb2fbb4b2017-02-16 18:48:33 +0000448 void beginFunctionImpl(const MachineFunction *MF) override;
449
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000450 /// Gather post-function debug information.
David Blaikieb2fbb4b2017-02-16 18:48:33 +0000451 void endFunctionImpl(const MachineFunction *) override;
452
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000453public:
Fangrui Songcb0bab82018-07-16 18:51:40 +0000454 CodeViewDebug(AsmPrinter *AP);
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000455
Eugene Zelenkofb69e662017-06-06 22:22:41 +0000456 void setSymbolSize(const MCSymbol *, uint64_t) override {}
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000457
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000458 /// Emit the COFF section that holds the line table information.
Craig Topper7b883b32014-03-08 06:31:39 +0000459 void endModule() override;
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000460
Adrian Prantl5f8f34e42018-05-01 15:54:18 +0000461 /// Process beginning of an instruction.
Craig Topper7b883b32014-03-08 06:31:39 +0000462 void beginInstruction(const MachineInstr *MI) override;
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000463};
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +0000464
Eugene Zelenkofb69e662017-06-06 22:22:41 +0000465} // end namespace llvm
466
467#endif // LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H