LLVM  14.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 emitConstantSymbolRecord(const DIType *DTy, APSInt &Value,
319  const std::string &QualifiedName);
320  void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV);
321  void emitStaticConstMemberList();
322 
323  /// Opens a subsection of the given kind in a .debug$S codeview section.
324  /// Returns an end label for use with endCVSubsection when the subsection is
325  /// finished.
326  MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
327  void endCVSubsection(MCSymbol *EndLabel);
328 
329  /// Opens a symbol record of the given kind. Returns an end label for use with
330  /// endSymbolRecord.
331  MCSymbol *beginSymbolRecord(codeview::SymbolKind Kind);
332  void endSymbolRecord(MCSymbol *SymEnd);
333 
334  /// Emits an S_END, S_INLINESITE_END, or S_PROC_ID_END record. These records
335  /// are empty, so we emit them with a simpler assembly sequence that doesn't
336  /// involve labels.
337  void emitEndSymbolRecord(codeview::SymbolKind EndKind);
338 
339  void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
340  const InlineSite &Site);
341 
342  using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
343 
344  void collectGlobalVariableInfo();
345  void collectVariableInfo(const DISubprogram *SP);
346 
347  void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed);
348 
349  // Construct the lexical block tree for a routine, pruning emptpy lexical
350  // scopes, and populate it with local variables.
351  void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
355  void collectLexicalBlockInfo(LexicalScope &Scope,
356  SmallVectorImpl<LexicalBlock *> &ParentBlocks,
357  SmallVectorImpl<LocalVariable> &ParentLocals,
358  SmallVectorImpl<CVGlobalVariable> &ParentGlobals);
359 
360  /// Records information about a local variable in the appropriate scope. In
361  /// particular, locals from inlined code live inside the inlining site.
362  void recordLocalVariable(LocalVariable &&Var, const LexicalScope *LS);
363 
364  /// Emits local variables in the appropriate order.
365  void emitLocalVariableList(const FunctionInfo &FI,
366  ArrayRef<LocalVariable> Locals);
367 
368  /// Emits an S_LOCAL record and its associated defined ranges.
369  void emitLocalVariable(const FunctionInfo &FI, const LocalVariable &Var);
370 
371  /// Emits a sequence of lexical block scopes and their children.
372  void emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
373  const FunctionInfo& FI);
374 
375  /// Emit a lexical block scope and its children.
376  void emitLexicalBlock(const LexicalBlock &Block, const FunctionInfo& FI);
377 
378  /// Translates the DIType to codeview if necessary and returns a type index
379  /// for it.
380  codeview::TypeIndex getTypeIndex(const DIType *Ty,
381  const DIType *ClassTy = nullptr);
382 
384  getTypeIndexForThisPtr(const DIDerivedType *PtrTy,
385  const DISubroutineType *SubroutineTy);
386 
387  codeview::TypeIndex getTypeIndexForReferenceTo(const DIType *Ty);
388 
389  codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
390  const DICompositeType *Class);
391 
392  codeview::TypeIndex getScopeIndex(const DIScope *Scope);
393 
394  codeview::TypeIndex getVBPTypeIndex();
395 
396  void addToUDTs(const DIType *Ty);
397 
398  void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
399 
400  codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
401  codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
402  codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
403  codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
404  codeview::TypeIndex lowerTypePointer(
405  const DIDerivedType *Ty,
407  codeview::TypeIndex lowerTypeMemberPointer(
408  const DIDerivedType *Ty,
410  codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
411  codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
412  codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty);
413  codeview::TypeIndex lowerTypeMemberFunction(
414  const DISubroutineType *Ty, const DIType *ClassTy, int ThisAdjustment,
415  bool IsStaticMethod,
417  codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
418  codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
419  codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
420 
421  /// Symbol records should point to complete types, but type records should
422  /// always point to incomplete types to avoid cycles in the type graph. Only
423  /// use this entry point when generating symbol records. The complete and
424  /// incomplete type indices only differ for record types. All other types use
425  /// the same index.
426  codeview::TypeIndex getCompleteTypeIndex(const DIType *Ty);
427 
428  codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
429  codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
430 
431  struct TypeLoweringScope;
432 
433  void emitDeferredCompleteTypes();
434 
435  void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy);
436  ClassInfo collectClassInfo(const DICompositeType *Ty);
437 
438  /// Common record member lowering functionality for record types, which are
439  /// structs, classes, and unions. Returns the field list index and the member
440  /// count.
441  std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
442  lowerRecordFieldList(const DICompositeType *Ty);
443 
444  /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates.
445  codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
447  const DIType *ClassTy = nullptr);
448 
449  /// Collect the names of parent scopes, innermost to outermost. Return the
450  /// innermost subprogram scope if present. Ensure that parent type scopes are
451  /// inserted into the type table.
452  const DISubprogram *
453  collectParentScopeNames(const DIScope *Scope,
454  SmallVectorImpl<StringRef> &ParentScopeNames);
455  std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name);
456  std::string getFullyQualifiedName(const DIScope *Scope);
457 
458  unsigned getPointerSizeInBytes();
459 
460 protected:
461  /// Gather pre-function debug information.
462  void beginFunctionImpl(const MachineFunction *MF) override;
463 
464  /// Gather post-function debug information.
465  void endFunctionImpl(const MachineFunction *) override;
466 
467 public:
469 
470  void beginModule(Module *M) override;
471 
472  void setSymbolSize(const MCSymbol *, uint64_t) override {}
473 
474  /// Emit the COFF section that holds the line table information.
475  void endModule() override;
476 
477  /// Process beginning of an instruction.
478  void beginInstruction(const MachineInstr *MI) override;
479 };
480 
481 } // end namespace llvm
482 
483 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
GlobalTypeTableBuilder.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:103
llvm
---------------------— PointerInfo ------------------------------------—
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:97
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:247
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
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:1580
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:199
llvm::codeview::EncodedFramePtrReg
EncodedFramePtrReg
Two-bit value indicating which register is the designated frame pointer register.
Definition: CodeView.h:539
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3097
llvm::codeview::PointerOptions
PointerOptions
Equivalent to misc lfPointerAttr bitfields.
Definition: CodeView.h:360
DebugHandlerBase.h
DbgEntityHistoryCalculator.h
DenseSet.h
llvm::DbgValueHistoryMap::InlinedEntity
std::pair< const DINode *, const DILocation * > InlinedEntity
Definition: DbgEntityHistoryCalculator.h:97
llvm::APSInt
An arbitrary precision integer that knows its signedness.
Definition: APSInt.h:22
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:221
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:197
llvm::ClassInfo
Definition: CodeViewDebug.cpp:2145
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
uint64_t
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:472
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2946
QualifiedName
Definition: ItaniumDemangle.h:1021
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:1281
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1060
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:235
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:119
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: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:82
TypeIndex.h
llvm::codeview::FunctionOptions::None
@ None
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:917
llvm::codeview::DebugSubsectionKind
DebugSubsectionKind
Definition: CodeView.h:313
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:1820
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
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:172
SetVector.h
llvm::DIFile
File.
Definition: DebugInfoMetadata.h:530