LLVM  13.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  // 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.
194 
195  // Map to separate global variables according to the lexical scope they
196  // belong in. A null local scope represents the global scope.
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  /// List of static const data members to be emitted as S_CONSTANTs.
207  SmallVector<const DIDerivedType *, 4> StaticConstMembers;
208 
209  /// The set of comdat .debug$S sections that we've seen so far. Each section
210  /// must start with a magic version number that must only be emitted once.
211  /// This set tracks which sections we've already opened.
212  DenseSet<MCSectionCOFF *> ComdatDebugSections;
213 
214  /// Switch to the appropriate .debug$S section for GVSym. If GVSym, the symbol
215  /// of an emitted global value, is in a comdat COFF section, this will switch
216  /// to a new .debug$S section in that comdat. This method ensures that the
217  /// section starts with the magic version number on first use. If GVSym is
218  /// null, uses the main .debug$S section.
219  void switchToDebugSectionForSymbol(const MCSymbol *GVSym);
220 
221  /// The next available function index for use with our .cv_* directives. Not
222  /// to be confused with type indices for LF_FUNC_ID records.
223  unsigned NextFuncId = 0;
224 
225  InlineSite &getInlineSite(const DILocation *InlinedAt,
226  const DISubprogram *Inlinee);
227 
228  codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP);
229 
230  void calculateRanges(LocalVariable &Var,
231  const DbgValueHistoryMap::Entries &Entries);
232 
233  /// Remember some debug info about each function. Keep it in a stable order to
234  /// emit at the end of the TU.
236 
237  /// Map from full file path to .cv_file id. Full paths are built from DIFiles
238  /// and are stored in FileToFilepathMap;
240 
241  /// All inlined subprograms in the order they should be emitted.
242  SmallSetVector<const DISubprogram *, 4> InlinedSubprograms;
243 
244  /// Map from a pair of DI metadata nodes and its DI type (or scope) that can
245  /// be nullptr, to CodeView type indices. Primarily indexed by
246  /// {DIType*, DIType*} and {DISubprogram*, DIType*}.
247  ///
248  /// The second entry in the key is needed for methods as DISubroutineType
249  /// representing static method type are shared with non-method function type.
251  TypeIndices;
252 
253  /// Map from DICompositeType* to complete type index. Non-record types are
254  /// always looked up in the normal TypeIndices map.
256 
257  /// Complete record types to emit after all active type lowerings are
258  /// finished.
259  SmallVector<const DICompositeType *, 4> DeferredCompleteTypes;
260 
261  /// Number of type lowering frames active on the stack.
262  unsigned TypeEmissionLevel = 0;
263 
264  codeview::TypeIndex VBPType;
265 
266  const DISubprogram *CurrentSubprogram = nullptr;
267 
268  // The UDTs we have seen while processing types; each entry is a pair of type
269  // index and type name.
270  std::vector<std::pair<std::string, const DIType *>> LocalUDTs;
271  std::vector<std::pair<std::string, const DIType *>> GlobalUDTs;
272 
273  using FileToFilepathMapTy = std::map<const DIFile *, std::string>;
274  FileToFilepathMapTy FileToFilepathMap;
275 
276  StringRef getFullFilepath(const DIFile *File);
277 
278  unsigned maybeRecordFile(const DIFile *F);
279 
280  void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF);
281 
282  void clear();
283 
284  void setCurrentSubprogram(const DISubprogram *SP) {
285  CurrentSubprogram = SP;
286  LocalUDTs.clear();
287  }
288 
289  /// Emit the magic version number at the start of a CodeView type or symbol
290  /// section. Appears at the front of every .debug$S or .debug$T or .debug$P
291  /// section.
292  void emitCodeViewMagicVersion();
293 
294  void emitTypeInformation();
295 
296  void emitTypeGlobalHashes();
297 
298  void emitCompilerInformation();
299 
300  void emitBuildInfo();
301 
302  void emitInlineeLinesSubsection();
303 
304  void emitDebugInfoForThunk(const Function *GV,
305  FunctionInfo &FI,
306  const MCSymbol *Fn);
307 
308  void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
309 
310  void emitDebugInfoForRetainedTypes();
311 
312  void emitDebugInfoForUDTs(
313  const std::vector<std::pair<std::string, const DIType *>> &UDTs);
314 
315  void collectDebugInfoForGlobals();
316  void emitDebugInfoForGlobals();
317  void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals);
318  void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV);
319  void emitStaticConstMemberList();
320 
321  /// Opens a subsection of the given kind in a .debug$S codeview section.
322  /// Returns an end label for use with endCVSubsection when the subsection is
323  /// finished.
324  MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
325  void endCVSubsection(MCSymbol *EndLabel);
326 
327  /// Opens a symbol record of the given kind. Returns an end label for use with
328  /// endSymbolRecord.
329  MCSymbol *beginSymbolRecord(codeview::SymbolKind Kind);
330  void endSymbolRecord(MCSymbol *SymEnd);
331 
332  /// Emits an S_END, S_INLINESITE_END, or S_PROC_ID_END record. These records
333  /// are empty, so we emit them with a simpler assembly sequence that doesn't
334  /// involve labels.
335  void emitEndSymbolRecord(codeview::SymbolKind EndKind);
336 
337  void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
338  const InlineSite &Site);
339 
340  using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
341 
342  void collectGlobalVariableInfo();
343  void collectVariableInfo(const DISubprogram *SP);
344 
345  void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed);
346 
347  // Construct the lexical block tree for a routine, pruning emptpy lexical
348  // scopes, and populate it with local variables.
349  void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
353  void collectLexicalBlockInfo(LexicalScope &Scope,
354  SmallVectorImpl<LexicalBlock *> &ParentBlocks,
355  SmallVectorImpl<LocalVariable> &ParentLocals,
356  SmallVectorImpl<CVGlobalVariable> &ParentGlobals);
357 
358  /// Records information about a local variable in the appropriate scope. In
359  /// particular, locals from inlined code live inside the inlining site.
360  void recordLocalVariable(LocalVariable &&Var, const LexicalScope *LS);
361 
362  /// Emits local variables in the appropriate order.
363  void emitLocalVariableList(const FunctionInfo &FI,
364  ArrayRef<LocalVariable> Locals);
365 
366  /// Emits an S_LOCAL record and its associated defined ranges.
367  void emitLocalVariable(const FunctionInfo &FI, const LocalVariable &Var);
368 
369  /// Emits a sequence of lexical block scopes and their children.
370  void emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
371  const FunctionInfo& FI);
372 
373  /// Emit a lexical block scope and its children.
374  void emitLexicalBlock(const LexicalBlock &Block, const FunctionInfo& FI);
375 
376  /// Translates the DIType to codeview if necessary and returns a type index
377  /// for it.
378  codeview::TypeIndex getTypeIndex(const DIType *Ty,
379  const DIType *ClassTy = nullptr);
380 
382  getTypeIndexForThisPtr(const DIDerivedType *PtrTy,
383  const DISubroutineType *SubroutineTy);
384 
385  codeview::TypeIndex getTypeIndexForReferenceTo(const DIType *Ty);
386 
387  codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
388  const DICompositeType *Class);
389 
390  codeview::TypeIndex getScopeIndex(const DIScope *Scope);
391 
392  codeview::TypeIndex getVBPTypeIndex();
393 
394  void addToUDTs(const DIType *Ty);
395 
396  void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
397 
398  codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
399  codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
400  codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
401  codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
402  codeview::TypeIndex lowerTypePointer(
403  const DIDerivedType *Ty,
405  codeview::TypeIndex lowerTypeMemberPointer(
406  const DIDerivedType *Ty,
408  codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
409  codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
410  codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty);
411  codeview::TypeIndex lowerTypeMemberFunction(
412  const DISubroutineType *Ty, const DIType *ClassTy, int ThisAdjustment,
413  bool IsStaticMethod,
415  codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
416  codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
417  codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
418 
419  /// Symbol records should point to complete types, but type records should
420  /// always point to incomplete types to avoid cycles in the type graph. Only
421  /// use this entry point when generating symbol records. The complete and
422  /// incomplete type indices only differ for record types. All other types use
423  /// the same index.
424  codeview::TypeIndex getCompleteTypeIndex(const DIType *Ty);
425 
426  codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
427  codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
428 
429  struct TypeLoweringScope;
430 
431  void emitDeferredCompleteTypes();
432 
433  void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy);
434  ClassInfo collectClassInfo(const DICompositeType *Ty);
435 
436  /// Common record member lowering functionality for record types, which are
437  /// structs, classes, and unions. Returns the field list index and the member
438  /// count.
439  std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
440  lowerRecordFieldList(const DICompositeType *Ty);
441 
442  /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates.
443  codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
445  const DIType *ClassTy = nullptr);
446 
447  /// Collect the names of parent scopes, innermost to outermost. Return the
448  /// innermost subprogram scope if present. Ensure that parent type scopes are
449  /// inserted into the type table.
450  const DISubprogram *
451  collectParentScopeNames(const DIScope *Scope,
452  SmallVectorImpl<StringRef> &ParentScopeNames);
453  std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name);
454  std::string getFullyQualifiedName(const DIScope *Scope);
455 
456  unsigned getPointerSizeInBytes();
457 
458 protected:
459  /// Gather pre-function debug information.
460  void beginFunctionImpl(const MachineFunction *MF) override;
461 
462  /// Gather post-function debug information.
463  void endFunctionImpl(const MachineFunction *) override;
464 
465 public:
467 
468  void beginModule(Module *M) override;
469 
470  void setSymbolSize(const MCSymbol *, uint64_t) override {}
471 
472  /// Emit the COFF section that holds the line table information.
473  void endModule() override;
474 
475  /// Process beginning of an instruction.
476  void beginInstruction(const MachineInstr *MI) override;
477 };
478 
479 } // end namespace llvm
480 
481 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
GlobalTypeTableBuilder.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:102
llvm
Definition: AllocatorList.h:23
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:662
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:100
llvm::Function
Definition: Function.h:61
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:244
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1167
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:1562
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
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::Annotations
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:46
clear
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:233
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:197
llvm::codeview::EncodedFramePtrReg
EncodedFramePtrReg
Two-bit value indicating which register is the designated frame pointer register.
Definition: CodeView.h:536
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3050
llvm::codeview::PointerOptions
PointerOptions
Equivalent to misc lfPointerAttr bitfields.
Definition: CodeView.h:357
DebugHandlerBase.h
DbgEntityHistoryCalculator.h
DenseSet.h
llvm::DbgValueHistoryMap::InlinedEntity
std::pair< const DINode *, const DILocation * > InlinedEntity
Definition: DbgEntityHistoryCalculator.h:97
llvm::CodeViewDebug::TypeLoweringScope
Definition: CodeViewDebug.cpp:314
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:218
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::codeview::GlobalTypeTableBuilder
Definition: GlobalTypeTableBuilder.h:29
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:179
llvm::ClassInfo
Definition: CodeViewDebug.cpp:2144
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:67
llvm::CodeViewDebug::setSymbolSize
void setSymbolSize(const MCSymbol *, uint64_t) override
For symbols that have a size designated (e.g.
Definition: CodeViewDebug.h:470
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2908
llvm::DenseMap
Definition: DenseMap.h:714
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:67
llvm::DIBasicType
Basic type, like 'int' or 'float'.
Definition: DebugInfoMetadata.h:769
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1263
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1051
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:127
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:131
Node
Definition: ItaniumDemangle.h:114
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:149
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:476
uint16_t
llvm::AArch64CC::LS
@ LS
Definition: AArch64BaseInfo.h:245
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:82
TypeIndex.h
llvm::codeview::FunctionOptions::None
@ None
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:917
llvm::codeview::DebugSubsectionKind
DebugSubsectionKind
Definition: CodeView.h:310
SmallVector.h
Allocator
Basic Register Allocator
Definition: RegAllocBasic.cpp:146
llvm::DebugHandlerBase
Base class for debug information backends.
Definition: DebugHandlerBase.h:53
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1800
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::codeview::TypeIndex
A 32-bit type reference.
Definition: TypeIndex.h:95
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
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:206
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:165
SetVector.h
llvm::DIFile
File.
Definition: DebugInfoMetadata.h:530