LLVM  15.0.0git
CodeViewDebug.h
Go to the documentation of this file.
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"
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.
53  MCStreamer &OS;
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  bool isDifferentLocation(LocalVarDefRange &O) {
85  return InMemory != O.InMemory || DataOffset != O.DataOffset ||
86  IsSubfield != O.IsSubfield || StructOffset != O.StructOffset ||
87  CVRegister != O.CVRegister;
88  }
89 
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;
99  bool UseReferenceType = false;
100  };
101 
102  struct CVGlobalVariable {
103  const DIGlobalVariable *DIGV;
105  };
106 
107  struct InlineSite {
108  SmallVector<LocalVariable, 1> InlinedLocals;
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 {
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  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.
141 
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<const MCSymbol *, const 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 =
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 =
180 
181  codeview::FrameProcedureOptions FrameProcOpts;
182 
183  bool HasStackRealignment = false;
184 
185  bool HaveLineInfo = false;
186  };
187  FunctionInfo *CurFn = nullptr;
188 
189  codeview::SourceLanguage CurrentSourceLanguage =
191 
192  // This map records the constant offset in DIExpression of the
193  // DIGlobalVariableExpression referencing the DIGlobalVariable.
194  DenseMap<const DIGlobalVariable *, uint64_t> CVGlobalVariableOffsets;
195 
196  // Map used to seperate variables according to the lexical scope they belong
197  // in. This is populated by recordLocalVariable() before
198  // collectLexicalBlocks() separates the variables between the FunctionInfo
199  // and LexicalBlocks.
201 
202  // Map to separate global variables according to the lexical scope they
203  // belong in. A null local scope represents the global scope.
206 
207  // Array of global variables which need to be emitted into a COMDAT section.
208  SmallVector<CVGlobalVariable, 1> ComdatVariables;
209 
210  // Array of non-COMDAT global variables.
211  SmallVector<CVGlobalVariable, 1> GlobalVariables;
212 
213  /// List of static const data members to be emitted as S_CONSTANTs.
214  SmallVector<const DIDerivedType *, 4> StaticConstMembers;
215 
216  /// The set of comdat .debug$S sections that we've seen so far. Each section
217  /// must start with a magic version number that must only be emitted once.
218  /// This set tracks which sections we've already opened.
219  DenseSet<MCSectionCOFF *> ComdatDebugSections;
220 
221  /// Switch to the appropriate .debug$S section for GVSym. If GVSym, the symbol
222  /// of an emitted global value, is in a comdat COFF section, this will switch
223  /// to a new .debug$S section in that comdat. This method ensures that the
224  /// section starts with the magic version number on first use. If GVSym is
225  /// null, uses the main .debug$S section.
226  void switchToDebugSectionForSymbol(const MCSymbol *GVSym);
227 
228  /// The next available function index for use with our .cv_* directives. Not
229  /// to be confused with type indices for LF_FUNC_ID records.
230  unsigned NextFuncId = 0;
231 
232  InlineSite &getInlineSite(const DILocation *InlinedAt,
233  const DISubprogram *Inlinee);
234 
235  codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP);
236 
237  void calculateRanges(LocalVariable &Var,
238  const DbgValueHistoryMap::Entries &Entries);
239 
240  /// Remember some debug info about each function. Keep it in a stable order to
241  /// emit at the end of the TU.
243 
244  /// Map from full file path to .cv_file id. Full paths are built from DIFiles
245  /// and are stored in FileToFilepathMap;
247 
248  /// All inlined subprograms in the order they should be emitted.
249  SmallSetVector<const DISubprogram *, 4> InlinedSubprograms;
250 
251  /// Map from a pair of DI metadata nodes and its DI type (or scope) that can
252  /// be nullptr, to CodeView type indices. Primarily indexed by
253  /// {DIType*, DIType*} and {DISubprogram*, DIType*}.
254  ///
255  /// The second entry in the key is needed for methods as DISubroutineType
256  /// representing static method type are shared with non-method function type.
258  TypeIndices;
259 
260  /// Map from DICompositeType* to complete type index. Non-record types are
261  /// always looked up in the normal TypeIndices map.
263 
264  /// Complete record types to emit after all active type lowerings are
265  /// finished.
266  SmallVector<const DICompositeType *, 4> DeferredCompleteTypes;
267 
268  /// Number of type lowering frames active on the stack.
269  unsigned TypeEmissionLevel = 0;
270 
271  codeview::TypeIndex VBPType;
272 
273  const DISubprogram *CurrentSubprogram = nullptr;
274 
275  // The UDTs we have seen while processing types; each entry is a pair of type
276  // index and type name.
277  std::vector<std::pair<std::string, const DIType *>> LocalUDTs;
278  std::vector<std::pair<std::string, const DIType *>> GlobalUDTs;
279 
280  using FileToFilepathMapTy = std::map<const DIFile *, std::string>;
281  FileToFilepathMapTy FileToFilepathMap;
282 
283  StringRef getFullFilepath(const DIFile *File);
284 
285  unsigned maybeRecordFile(const DIFile *F);
286 
287  void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF);
288 
289  void clear();
290 
291  void setCurrentSubprogram(const DISubprogram *SP) {
292  CurrentSubprogram = SP;
293  LocalUDTs.clear();
294  }
295 
296  /// Emit the magic version number at the start of a CodeView type or symbol
297  /// section. Appears at the front of every .debug$S or .debug$T or .debug$P
298  /// section.
299  void emitCodeViewMagicVersion();
300 
301  void emitTypeInformation();
302 
303  void emitTypeGlobalHashes();
304 
305  void emitObjName();
306 
307  void emitCompilerInformation();
308 
309  void emitBuildInfo();
310 
311  void emitInlineeLinesSubsection();
312 
313  void emitDebugInfoForThunk(const Function *GV,
314  FunctionInfo &FI,
315  const MCSymbol *Fn);
316 
317  void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
318 
319  void emitDebugInfoForRetainedTypes();
320 
321  void emitDebugInfoForUDTs(
322  const std::vector<std::pair<std::string, const DIType *>> &UDTs);
323 
324  void collectDebugInfoForGlobals();
325  void emitDebugInfoForGlobals();
326  void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals);
327  void emitConstantSymbolRecord(const DIType *DTy, APSInt &Value,
328  const std::string &QualifiedName);
329  void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV);
330  void emitStaticConstMemberList();
331 
332  /// Opens a subsection of the given kind in a .debug$S codeview section.
333  /// Returns an end label for use with endCVSubsection when the subsection is
334  /// finished.
335  MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
336  void endCVSubsection(MCSymbol *EndLabel);
337 
338  /// Opens a symbol record of the given kind. Returns an end label for use with
339  /// endSymbolRecord.
340  MCSymbol *beginSymbolRecord(codeview::SymbolKind Kind);
341  void endSymbolRecord(MCSymbol *SymEnd);
342 
343  /// Emits an S_END, S_INLINESITE_END, or S_PROC_ID_END record. These records
344  /// are empty, so we emit them with a simpler assembly sequence that doesn't
345  /// involve labels.
346  void emitEndSymbolRecord(codeview::SymbolKind EndKind);
347 
348  void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
349  const InlineSite &Site);
350 
351  using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
352 
353  void collectGlobalVariableInfo();
354  void collectVariableInfo(const DISubprogram *SP);
355 
356  void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed);
357 
358  // Construct the lexical block tree for a routine, pruning emptpy lexical
359  // scopes, and populate it with local variables.
360  void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
364  void collectLexicalBlockInfo(LexicalScope &Scope,
365  SmallVectorImpl<LexicalBlock *> &ParentBlocks,
366  SmallVectorImpl<LocalVariable> &ParentLocals,
367  SmallVectorImpl<CVGlobalVariable> &ParentGlobals);
368 
369  /// Records information about a local variable in the appropriate scope. In
370  /// particular, locals from inlined code live inside the inlining site.
371  void recordLocalVariable(LocalVariable &&Var, const LexicalScope *LS);
372 
373  /// Emits local variables in the appropriate order.
374  void emitLocalVariableList(const FunctionInfo &FI,
375  ArrayRef<LocalVariable> Locals);
376 
377  /// Emits an S_LOCAL record and its associated defined ranges.
378  void emitLocalVariable(const FunctionInfo &FI, const LocalVariable &Var);
379 
380  /// Emits a sequence of lexical block scopes and their children.
381  void emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
382  const FunctionInfo& FI);
383 
384  /// Emit a lexical block scope and its children.
385  void emitLexicalBlock(const LexicalBlock &Block, const FunctionInfo& FI);
386 
387  /// Translates the DIType to codeview if necessary and returns a type index
388  /// for it.
389  codeview::TypeIndex getTypeIndex(const DIType *Ty,
390  const DIType *ClassTy = nullptr);
391 
393  getTypeIndexForThisPtr(const DIDerivedType *PtrTy,
394  const DISubroutineType *SubroutineTy);
395 
396  codeview::TypeIndex getTypeIndexForReferenceTo(const DIType *Ty);
397 
398  codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
399  const DICompositeType *Class);
400 
401  codeview::TypeIndex getScopeIndex(const DIScope *Scope);
402 
403  codeview::TypeIndex getVBPTypeIndex();
404 
405  void addToUDTs(const DIType *Ty);
406 
407  void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
408 
409  codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
410  codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
411  codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
412  codeview::TypeIndex lowerTypeString(const DIStringType *Ty);
413  codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
414  codeview::TypeIndex lowerTypePointer(
415  const DIDerivedType *Ty,
417  codeview::TypeIndex lowerTypeMemberPointer(
418  const DIDerivedType *Ty,
420  codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
421  codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
422  codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty);
423  codeview::TypeIndex lowerTypeMemberFunction(
424  const DISubroutineType *Ty, const DIType *ClassTy, int ThisAdjustment,
425  bool IsStaticMethod,
427  codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
428  codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
429  codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
430 
431  /// Symbol records should point to complete types, but type records should
432  /// always point to incomplete types to avoid cycles in the type graph. Only
433  /// use this entry point when generating symbol records. The complete and
434  /// incomplete type indices only differ for record types. All other types use
435  /// the same index.
436  codeview::TypeIndex getCompleteTypeIndex(const DIType *Ty);
437 
438  codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
439  codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
440 
441  struct TypeLoweringScope;
442 
443  void emitDeferredCompleteTypes();
444 
445  void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy);
446  ClassInfo collectClassInfo(const DICompositeType *Ty);
447 
448  /// Common record member lowering functionality for record types, which are
449  /// structs, classes, and unions. Returns the field list index and the member
450  /// count.
451  std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
452  lowerRecordFieldList(const DICompositeType *Ty);
453 
454  /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates.
455  codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
457  const DIType *ClassTy = nullptr);
458 
459  /// Collect the names of parent scopes, innermost to outermost. Return the
460  /// innermost subprogram scope if present. Ensure that parent type scopes are
461  /// inserted into the type table.
462  const DISubprogram *
463  collectParentScopeNames(const DIScope *Scope,
464  SmallVectorImpl<StringRef> &ParentScopeNames);
465  std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name);
466  std::string getFullyQualifiedName(const DIScope *Scope);
467 
468  unsigned getPointerSizeInBytes();
469 
470 protected:
471  /// Gather pre-function debug information.
472  void beginFunctionImpl(const MachineFunction *MF) override;
473 
474  /// Gather post-function debug information.
475  void endFunctionImpl(const MachineFunction *) override;
476 
477  /// Check if the current module is in Fortran.
479  return CurrentSourceLanguage == codeview::SourceLanguage::Fortran;
480  }
481 
482 public:
484 
485  void beginModule(Module *M) override;
486 
487  void setSymbolSize(const MCSymbol *, uint64_t) override {}
488 
489  /// Emit the COFF section that holds the line table information.
490  void endModule() override;
491 
492  /// Process beginning of an instruction.
493  void beginInstruction(const MachineInstr *MI) override;
494 };
495 
496 } // end namespace llvm
497 
498 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
GlobalTypeTableBuilder.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:104
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:658
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::InlineSite
std::tuple< uint64_t, uint32_t > InlineSite
Definition: MCPseudoProbe.h:89
llvm::Function
Definition: Function.h:60
llvm::codeview::SymbolKind
SymbolKind
Duplicate copy of the above enum, but using the official CV names.
Definition: CodeView.h:47
llvm::codeview::FunctionOptions
FunctionOptions
Definition: CodeView.h:249
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::DIStringType
String type, Fortran CHARACTER(n)
Definition: DebugInfoMetadata.h:832
llvm::LexicalScope
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:44
MapVector.h
Allocator.h
llvm::codeview::PointerOptions::None
@ None
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1551
DenseMap.h
llvm::codeview::EncodedFramePtrReg::None
@ None
llvm::MapVector
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:37
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::Annotations
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:48
clear
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:149
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:201
llvm::codeview::EncodedFramePtrReg
EncodedFramePtrReg
Two-bit value indicating which register is the designated frame pointer register.
Definition: CodeView.h:541
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3048
llvm::CodeViewDebug::moduleIsInFortran
bool moduleIsInFortran()
Check if the current module is in Fortran.
Definition: CodeViewDebug.h:478
llvm::codeview::Masm
@ Masm
Definition: CodeView.h:150
llvm::codeview::PointerOptions
PointerOptions
Equivalent to misc lfPointerAttr bitfields.
Definition: CodeView.h:362
DebugHandlerBase.h
DbgEntityHistoryCalculator.h
DenseSet.h
llvm::DbgValueHistoryMap::InlinedEntity
std::pair< const DINode *, const DILocation * > InlinedEntity
Definition: DbgEntityHistoryCalculator.h:96
llvm::APSInt
An arbitrary precision integer that knows its signedness.
Definition: APSInt.h:23
llvm::CodeViewDebug::TypeLoweringScope
Definition: CodeViewDebug.cpp:309
DebugLoc.h
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
CodeView.h
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::CodeViewDebug
Collects and handles line tables information in a CodeView format.
Definition: CodeViewDebug.h:52
llvm::codeview::FrameProcedureOptions
FrameProcedureOptions
Definition: CodeView.h:223
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::codeview::Fortran
@ Fortran
Definition: CodeView.h:149
llvm::codeview::GlobalTypeTableBuilder
Definition: GlobalTypeTableBuilder.h:29
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::ClassInfo
Definition: CodeViewDebug.cpp:2258
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
uint64_t
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:63
llvm::CodeViewDebug::setSymbolSize
void setSymbolSize(const MCSymbol *, uint64_t) override
For symbols that have a size designated (e.g.
Definition: CodeViewDebug.h:487
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2904
QualifiedName
Definition: ItaniumDemangle.h:1045
llvm::DenseMap
Definition: DenseMap.h:716
FuncId
Profile::FuncID FuncId
Definition: Profile.cpp:321
ArrayRef.h
PointerUnion.h
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::DIBasicType
Basic type, like 'int' or 'float'.
Definition: DebugInfoMetadata.h:764
llvm::MachineFunction
Definition: MachineFunction.h:241
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1265
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1042
llvm::codeview::SourceLanguage
SourceLanguage
These values correspond to the CV_CFL_LANG enumeration, and are documented here: https://msdn....
Definition: CodeView.h:146
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::DINode
Tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:129
Compiler.h
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
LLVM_LIBRARY_VISIBILITY
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library,...
Definition: Compiler.h:125
Node
Definition: ItaniumDemangle.h:155
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:112
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:471
uint16_t
llvm::AArch64CC::LS
@ LS
Definition: AArch64BaseInfo.h:264
llvm::codeview::CPUType
CPUType
These values correspond to the CV_CPU_TYPE_e enumeration, and are documented here: https://msdn....
Definition: CodeView.h:78
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:81
TypeIndex.h
llvm::codeview::FunctionOptions::None
@ None
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:924
llvm::codeview::DebugSubsectionKind
DebugSubsectionKind
Definition: CodeView.h:315
SmallVector.h
Allocator
Basic Register Allocator
Definition: RegAllocBasic.cpp:142
llvm::DebugHandlerBase
Base class for debug information backends.
Definition: DebugHandlerBase.h:53
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1797
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::codeview::TypeIndex
A 32-bit type reference.
Definition: TypeIndex.h:96
llvm::SmallSetVector
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:307
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:172
SetVector.h
llvm::DIFile
File.
Definition: DebugInfoMetadata.h:525