clang  15.0.0git
CGDebugInfo.h
Go to the documentation of this file.
1 //===--- CGDebugInfo.h - DebugInfo for LLVM CodeGen -------------*- 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 is the source-level debug info generator for llvm translation.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGDEBUGINFO_H
14 #define LLVM_CLANG_LIB_CODEGEN_CGDEBUGINFO_H
15 
16 #include "CGBuilder.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/Expr.h"
21 #include "clang/AST/Type.h"
22 #include "clang/AST/TypeOrdering.h"
24 #include "clang/Basic/Module.h"
26 #include "llvm/ADT/DenseMap.h"
27 #include "llvm/ADT/DenseSet.h"
28 #include "llvm/ADT/Optional.h"
29 #include "llvm/IR/DIBuilder.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/Support/Allocator.h"
33 
34 namespace llvm {
35 class MDNode;
36 }
37 
38 namespace clang {
39 class ClassTemplateSpecializationDecl;
40 class GlobalDecl;
41 class ModuleMap;
42 class ObjCInterfaceDecl;
43 class UsingDecl;
44 class VarDecl;
45 enum class DynamicInitKind : unsigned;
46 
47 namespace CodeGen {
48 class CodeGenModule;
49 class CodeGenFunction;
50 class CGBlockInfo;
51 
52 /// This class gathers all debug information during compilation and is
53 /// responsible for emitting to llvm globals or pass directly to the
54 /// backend.
55 class CGDebugInfo {
56  friend class ApplyDebugLocation;
57  friend class SaveAndRestoreLocation;
58  CodeGenModule &CGM;
59  const codegenoptions::DebugInfoKind DebugKind;
60  bool DebugTypeExtRefs;
61  llvm::DIBuilder DBuilder;
62  llvm::DICompileUnit *TheCU = nullptr;
63  ModuleMap *ClangModuleMap = nullptr;
64  ASTSourceDescriptor PCHDescriptor;
65  SourceLocation CurLoc;
66  llvm::MDNode *CurInlinedAt = nullptr;
67  llvm::DIType *VTablePtrType = nullptr;
68  llvm::DIType *ClassTy = nullptr;
69  llvm::DICompositeType *ObjTy = nullptr;
70  llvm::DIType *SelTy = nullptr;
71 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
72  llvm::DIType *SingletonId = nullptr;
73 #include "clang/Basic/OpenCLImageTypes.def"
74  llvm::DIType *OCLSamplerDITy = nullptr;
75  llvm::DIType *OCLEventDITy = nullptr;
76  llvm::DIType *OCLClkEventDITy = nullptr;
77  llvm::DIType *OCLQueueDITy = nullptr;
78  llvm::DIType *OCLNDRangeDITy = nullptr;
79  llvm::DIType *OCLReserveIDDITy = nullptr;
80 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
81  llvm::DIType *Id##Ty = nullptr;
82 #include "clang/Basic/OpenCLExtensionTypes.def"
83 
84  /// Cache of previously constructed Types.
85  llvm::DenseMap<const void *, llvm::TrackingMDRef> TypeCache;
86 
87  std::map<llvm::StringRef, llvm::StringRef, std::greater<llvm::StringRef>>
88  DebugPrefixMap;
89 
90  /// Cache that maps VLA types to size expressions for that type,
91  /// represented by instantiated Metadata nodes.
92  llvm::SmallDenseMap<QualType, llvm::Metadata *> SizeExprCache;
93 
94  /// Callbacks to use when printing names and types.
95  class PrintingCallbacks final : public clang::PrintingCallbacks {
96  const CGDebugInfo &Self;
97 
98  public:
99  PrintingCallbacks(const CGDebugInfo &Self) : Self(Self) {}
100  std::string remapPath(StringRef Path) const override {
101  return Self.remapDIPath(Path);
102  }
103  };
104  PrintingCallbacks PrintCB = {*this};
105 
106  struct ObjCInterfaceCacheEntry {
107  const ObjCInterfaceType *Type;
108  llvm::DIType *Decl;
109  llvm::DIFile *Unit;
110  ObjCInterfaceCacheEntry(const ObjCInterfaceType *Type, llvm::DIType *Decl,
111  llvm::DIFile *Unit)
112  : Type(Type), Decl(Decl), Unit(Unit) {}
113  };
114 
115  /// Cache of previously constructed interfaces which may change.
117 
118  /// Cache of forward declarations for methods belonging to the interface.
119  /// The extra bit on the DISubprogram specifies whether a method is
120  /// "objc_direct".
121  llvm::DenseMap<const ObjCInterfaceDecl *,
122  std::vector<llvm::PointerIntPair<llvm::DISubprogram *, 1>>>
123  ObjCMethodCache;
124 
125  /// Cache of references to clang modules and precompiled headers.
126  llvm::DenseMap<const Module *, llvm::TrackingMDRef> ModuleCache;
127 
128  /// List of interfaces we want to keep even if orphaned.
129  std::vector<void *> RetainedTypes;
130 
131  /// Cache of forward declared types to RAUW at the end of compilation.
132  std::vector<std::pair<const TagType *, llvm::TrackingMDRef>> ReplaceMap;
133 
134  /// Cache of replaceable forward declarations (functions and
135  /// variables) to RAUW at the end of compilation.
136  std::vector<std::pair<const DeclaratorDecl *, llvm::TrackingMDRef>>
137  FwdDeclReplaceMap;
138 
139  /// Keep track of our current nested lexical block.
140  std::vector<llvm::TypedTrackingMDRef<llvm::DIScope>> LexicalBlockStack;
141  llvm::DenseMap<const Decl *, llvm::TrackingMDRef> RegionMap;
142  /// Keep track of LexicalBlockStack counter at the beginning of a
143  /// function. This is used to pop unbalanced regions at the end of a
144  /// function.
145  std::vector<unsigned> FnBeginRegionCount;
146 
147  /// This is a storage for names that are constructed on demand. For
148  /// example, C++ destructors, C++ operators etc..
149  llvm::BumpPtrAllocator DebugInfoNames;
150  StringRef CWDName;
151 
152  llvm::DenseMap<const char *, llvm::TrackingMDRef> DIFileCache;
153  llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> SPCache;
154  /// Cache declarations relevant to DW_TAG_imported_declarations (C++
155  /// using declarations and global alias variables) that aren't covered
156  /// by other more specific caches.
157  llvm::DenseMap<const Decl *, llvm::TrackingMDRef> DeclCache;
158  llvm::DenseMap<const Decl *, llvm::TrackingMDRef> ImportedDeclCache;
159  llvm::DenseMap<const NamespaceDecl *, llvm::TrackingMDRef> NamespaceCache;
160  llvm::DenseMap<const NamespaceAliasDecl *, llvm::TrackingMDRef>
161  NamespaceAliasCache;
162  llvm::DenseMap<const Decl *, llvm::TypedTrackingMDRef<llvm::DIDerivedType>>
163  StaticDataMemberCache;
164 
165  using ParamDecl2StmtTy = llvm::DenseMap<const ParmVarDecl *, const Stmt *>;
166  using Param2DILocTy =
167  llvm::DenseMap<const ParmVarDecl *, llvm::DILocalVariable *>;
168 
169  /// The key is coroutine real parameters, value is coroutine move parameters.
170  ParamDecl2StmtTy CoroutineParameterMappings;
171  /// The key is coroutine real parameters, value is DIVariable in LLVM IR.
172  Param2DILocTy ParamDbgMappings;
173 
174  /// Helper functions for getOrCreateType.
175  /// @{
176  /// Currently the checksum of an interface includes the number of
177  /// ivars and property accessors.
178  llvm::DIType *CreateType(const BuiltinType *Ty);
179  llvm::DIType *CreateType(const ComplexType *Ty);
180  llvm::DIType *CreateType(const AutoType *Ty);
181  llvm::DIType *CreateType(const BitIntType *Ty);
182  llvm::DIType *CreateQualifiedType(QualType Ty, llvm::DIFile *Fg);
183  llvm::DIType *CreateQualifiedType(const FunctionProtoType *Ty,
184  llvm::DIFile *Fg);
185  llvm::DIType *CreateType(const TypedefType *Ty, llvm::DIFile *Fg);
186  llvm::DIType *CreateType(const TemplateSpecializationType *Ty,
187  llvm::DIFile *Fg);
188  llvm::DIType *CreateType(const ObjCObjectPointerType *Ty, llvm::DIFile *F);
189  llvm::DIType *CreateType(const PointerType *Ty, llvm::DIFile *F);
190  llvm::DIType *CreateType(const BlockPointerType *Ty, llvm::DIFile *F);
191  llvm::DIType *CreateType(const FunctionType *Ty, llvm::DIFile *F);
192  /// Get structure or union type.
193  llvm::DIType *CreateType(const RecordType *Tyg);
194  llvm::DIType *CreateTypeDefinition(const RecordType *Ty);
195  llvm::DICompositeType *CreateLimitedType(const RecordType *Ty);
196  void CollectContainingType(const CXXRecordDecl *RD,
197  llvm::DICompositeType *CT);
198  /// Get Objective-C interface type.
199  llvm::DIType *CreateType(const ObjCInterfaceType *Ty, llvm::DIFile *F);
200  llvm::DIType *CreateTypeDefinition(const ObjCInterfaceType *Ty,
201  llvm::DIFile *F);
202  /// Get Objective-C object type.
203  llvm::DIType *CreateType(const ObjCObjectType *Ty, llvm::DIFile *F);
204  llvm::DIType *CreateType(const ObjCTypeParamType *Ty, llvm::DIFile *Unit);
205 
206  llvm::DIType *CreateType(const VectorType *Ty, llvm::DIFile *F);
207  llvm::DIType *CreateType(const ConstantMatrixType *Ty, llvm::DIFile *F);
208  llvm::DIType *CreateType(const ArrayType *Ty, llvm::DIFile *F);
209  llvm::DIType *CreateType(const LValueReferenceType *Ty, llvm::DIFile *F);
210  llvm::DIType *CreateType(const RValueReferenceType *Ty, llvm::DIFile *Unit);
211  llvm::DIType *CreateType(const MemberPointerType *Ty, llvm::DIFile *F);
212  llvm::DIType *CreateType(const AtomicType *Ty, llvm::DIFile *F);
213  llvm::DIType *CreateType(const PipeType *Ty, llvm::DIFile *F);
214  /// Get enumeration type.
215  llvm::DIType *CreateEnumType(const EnumType *Ty);
216  llvm::DIType *CreateTypeDefinition(const EnumType *Ty);
217  /// Look up the completed type for a self pointer in the TypeCache and
218  /// create a copy of it with the ObjectPointer and Artificial flags
219  /// set. If the type is not cached, a new one is created. This should
220  /// never happen though, since creating a type for the implicit self
221  /// argument implies that we already parsed the interface definition
222  /// and the ivar declarations in the implementation.
223  llvm::DIType *CreateSelfType(const QualType &QualTy, llvm::DIType *Ty);
224  /// @}
225 
226  /// Get the type from the cache or return null type if it doesn't
227  /// exist.
228  llvm::DIType *getTypeOrNull(const QualType);
229  /// Return the debug type for a C++ method.
230  /// \arg CXXMethodDecl is of FunctionType. This function type is
231  /// not updated to include implicit \c this pointer. Use this routine
232  /// to get a method type which includes \c this pointer.
233  llvm::DISubroutineType *getOrCreateMethodType(const CXXMethodDecl *Method,
234  llvm::DIFile *F, bool decl);
235  llvm::DISubroutineType *
236  getOrCreateInstanceMethodType(QualType ThisPtr, const FunctionProtoType *Func,
237  llvm::DIFile *Unit, bool decl);
238  llvm::DISubroutineType *
239  getOrCreateFunctionType(const Decl *D, QualType FnType, llvm::DIFile *F);
240  /// \return debug info descriptor for vtable.
241  llvm::DIType *getOrCreateVTablePtrType(llvm::DIFile *F);
242 
243  /// \return namespace descriptor for the given namespace decl.
244  llvm::DINamespace *getOrCreateNamespace(const NamespaceDecl *N);
245  llvm::DIType *CreatePointerLikeType(llvm::dwarf::Tag Tag, const Type *Ty,
246  QualType PointeeTy, llvm::DIFile *F);
247  llvm::DIType *getOrCreateStructPtrType(StringRef Name, llvm::DIType *&Cache);
248 
249  /// A helper function to create a subprogram for a single member
250  /// function GlobalDecl.
251  llvm::DISubprogram *CreateCXXMemberFunction(const CXXMethodDecl *Method,
252  llvm::DIFile *F,
253  llvm::DIType *RecordTy);
254 
255  /// A helper function to collect debug info for C++ member
256  /// functions. This is used while creating debug info entry for a
257  /// Record.
258  void CollectCXXMemberFunctions(const CXXRecordDecl *Decl, llvm::DIFile *F,
259  SmallVectorImpl<llvm::Metadata *> &E,
260  llvm::DIType *T);
261 
262  /// A helper function to collect debug info for C++ base
263  /// classes. This is used while creating debug info entry for a
264  /// Record.
265  void CollectCXXBases(const CXXRecordDecl *Decl, llvm::DIFile *F,
266  SmallVectorImpl<llvm::Metadata *> &EltTys,
267  llvm::DIType *RecordTy);
268 
269  /// Helper function for CollectCXXBases.
270  /// Adds debug info entries for types in Bases that are not in SeenTypes.
271  void CollectCXXBasesAux(
272  const CXXRecordDecl *RD, llvm::DIFile *Unit,
273  SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
275  llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes,
276  llvm::DINode::DIFlags StartingFlags);
277 
278  struct TemplateArgs {
279  const TemplateParameterList *TList;
281  };
282  /// A helper function to collect template parameters.
283  llvm::DINodeArray CollectTemplateParams(Optional<TemplateArgs> Args,
284  llvm::DIFile *Unit);
285  /// A helper function to collect debug info for function template
286  /// parameters.
287  llvm::DINodeArray CollectFunctionTemplateParams(const FunctionDecl *FD,
288  llvm::DIFile *Unit);
289 
290  /// A helper function to collect debug info for function template
291  /// parameters.
292  llvm::DINodeArray CollectVarTemplateParams(const VarDecl *VD,
293  llvm::DIFile *Unit);
294 
295  Optional<TemplateArgs> GetTemplateArgs(const VarDecl *) const;
296  Optional<TemplateArgs> GetTemplateArgs(const RecordDecl *) const;
297  Optional<TemplateArgs> GetTemplateArgs(const FunctionDecl *) const;
298 
299  /// A helper function to collect debug info for template
300  /// parameters.
301  llvm::DINodeArray CollectCXXTemplateParams(const RecordDecl *TS,
302  llvm::DIFile *F);
303 
304  /// A helper function to collect debug info for btf_decl_tag annotations.
305  llvm::DINodeArray CollectBTFDeclTagAnnotations(const Decl *D);
306 
307  llvm::DIType *createFieldType(StringRef name, QualType type,
308  SourceLocation loc, AccessSpecifier AS,
309  uint64_t offsetInBits, uint32_t AlignInBits,
310  llvm::DIFile *tunit, llvm::DIScope *scope,
311  const RecordDecl *RD = nullptr,
312  llvm::DINodeArray Annotations = nullptr);
313 
314  llvm::DIType *createFieldType(StringRef name, QualType type,
315  SourceLocation loc, AccessSpecifier AS,
316  uint64_t offsetInBits, llvm::DIFile *tunit,
317  llvm::DIScope *scope,
318  const RecordDecl *RD = nullptr) {
319  return createFieldType(name, type, loc, AS, offsetInBits, 0, tunit, scope,
320  RD);
321  }
322 
323  /// Create new bit field member.
324  llvm::DIType *createBitFieldType(const FieldDecl *BitFieldDecl,
325  llvm::DIScope *RecordTy,
326  const RecordDecl *RD);
327 
328  /// Helpers for collecting fields of a record.
329  /// @{
330  void CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl,
331  SmallVectorImpl<llvm::Metadata *> &E,
332  llvm::DIType *RecordTy);
333  llvm::DIDerivedType *CreateRecordStaticField(const VarDecl *Var,
334  llvm::DIType *RecordTy,
335  const RecordDecl *RD);
336  void CollectRecordNormalField(const FieldDecl *Field, uint64_t OffsetInBits,
337  llvm::DIFile *F,
338  SmallVectorImpl<llvm::Metadata *> &E,
339  llvm::DIType *RecordTy, const RecordDecl *RD);
340  void CollectRecordNestedType(const TypeDecl *RD,
341  SmallVectorImpl<llvm::Metadata *> &E);
342  void CollectRecordFields(const RecordDecl *Decl, llvm::DIFile *F,
343  SmallVectorImpl<llvm::Metadata *> &E,
344  llvm::DICompositeType *RecordTy);
345 
346  /// If the C++ class has vtable info then insert appropriate debug
347  /// info entry in EltTys vector.
348  void CollectVTableInfo(const CXXRecordDecl *Decl, llvm::DIFile *F,
349  SmallVectorImpl<llvm::Metadata *> &EltTys);
350  /// @}
351 
352  /// Create a new lexical block node and push it on the stack.
353  void CreateLexicalBlock(SourceLocation Loc);
354 
355  /// If target-specific LLVM \p AddressSpace directly maps to target-specific
356  /// DWARF address space, appends extended dereferencing mechanism to complex
357  /// expression \p Expr. Otherwise, does nothing.
358  ///
359  /// Extended dereferencing mechanism is has the following format:
360  /// DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef
361  void AppendAddressSpaceXDeref(unsigned AddressSpace,
362  SmallVectorImpl<uint64_t> &Expr) const;
363 
364  /// A helper function to collect debug info for the default elements of a
365  /// block.
366  ///
367  /// \returns The next available field offset after the default elements.
368  uint64_t collectDefaultElementTypesForBlockPointer(
369  const BlockPointerType *Ty, llvm::DIFile *Unit,
370  llvm::DIDerivedType *DescTy, unsigned LineNo,
371  SmallVectorImpl<llvm::Metadata *> &EltTys);
372 
373  /// A helper function to collect debug info for the default fields of a
374  /// block.
375  void collectDefaultFieldsForBlockLiteralDeclare(
376  const CGBlockInfo &Block, const ASTContext &Context, SourceLocation Loc,
377  const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
378  SmallVectorImpl<llvm::Metadata *> &Fields);
379 
380 public:
381  CGDebugInfo(CodeGenModule &CGM);
382  ~CGDebugInfo();
383 
384  void finalize();
385 
386  /// Remap a given path with the current debug prefix map
387  std::string remapDIPath(StringRef) const;
388 
389  /// Register VLA size expression debug node with the qualified type.
390  void registerVLASizeExpression(QualType Ty, llvm::Metadata *SizeExpr) {
391  SizeExprCache[Ty] = SizeExpr;
392  }
393 
394  /// Module debugging: Support for building PCMs.
395  /// @{
396  /// Set the main CU's DwoId field to \p Signature.
397  void setDwoId(uint64_t Signature);
398 
399  /// When generating debug information for a clang module or
400  /// precompiled header, this module map will be used to determine
401  /// the module of origin of each Decl.
402  void setModuleMap(ModuleMap &MMap) { ClangModuleMap = &MMap; }
403 
404  /// When generating debug information for a clang module or
405  /// precompiled header, this module map will be used to determine
406  /// the module of origin of each Decl.
407  void setPCHDescriptor(ASTSourceDescriptor PCH) { PCHDescriptor = PCH; }
408  /// @}
409 
410  /// Update the current source location. If \arg loc is invalid it is
411  /// ignored.
412  void setLocation(SourceLocation Loc);
413 
414  /// Return the current source location. This does not necessarily correspond
415  /// to the IRBuilder's current DebugLoc.
416  SourceLocation getLocation() const { return CurLoc; }
417 
418  /// Update the current inline scope. All subsequent calls to \p EmitLocation
419  /// will create a location with this inlinedAt field.
420  void setInlinedAt(llvm::MDNode *InlinedAt) { CurInlinedAt = InlinedAt; }
421 
422  /// \return the current inline scope.
423  llvm::MDNode *getInlinedAt() const { return CurInlinedAt; }
424 
425  // Converts a SourceLocation to a DebugLoc
426  llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Loc);
427 
428  /// Emit metadata to indicate a change in line/column information in
429  /// the source file. If the location is invalid, the previous
430  /// location will be reused.
431  void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc);
432 
433  QualType getFunctionType(const FunctionDecl *FD, QualType RetTy,
435 
436  /// Emit a call to llvm.dbg.function.start to indicate
437  /// start of a new function.
438  /// \param Loc The location of the function header.
439  /// \param ScopeLoc The location of the function body.
440  void emitFunctionStart(GlobalDecl GD, SourceLocation Loc,
441  SourceLocation ScopeLoc, QualType FnType,
442  llvm::Function *Fn, bool CurFnIsThunk);
443 
444  /// Start a new scope for an inlined function.
445  void EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD);
446  /// End an inlined function scope.
447  void EmitInlineFunctionEnd(CGBuilderTy &Builder);
448 
449  /// Emit debug info for a function declaration.
450  /// \p Fn is set only when a declaration for a debug call site gets created.
451  void EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
452  QualType FnType, llvm::Function *Fn = nullptr);
453 
454  /// Emit debug info for an extern function being called.
455  /// This is needed for call site debug info.
456  void EmitFuncDeclForCallSite(llvm::CallBase *CallOrInvoke,
457  QualType CalleeType,
458  const FunctionDecl *CalleeDecl);
459 
460  /// Constructs the debug code for exiting a function.
461  void EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn);
462 
463  /// Emit metadata to indicate the beginning of a new lexical block
464  /// and push the block onto the stack.
465  void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc);
466 
467  /// Emit metadata to indicate the end of a new lexical block and pop
468  /// the current block.
469  void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc);
470 
471  /// Emit call to \c llvm.dbg.declare for an automatic variable
472  /// declaration.
473  /// Returns a pointer to the DILocalVariable associated with the
474  /// llvm.dbg.declare, or nullptr otherwise.
475  llvm::DILocalVariable *
476  EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI,
477  CGBuilderTy &Builder,
478  const bool UsePointerValue = false);
479 
480  /// Emit call to \c llvm.dbg.label for an label.
481  void EmitLabel(const LabelDecl *D, CGBuilderTy &Builder);
482 
483  /// Emit call to \c llvm.dbg.declare for an imported variable
484  /// declaration in a block.
485  void EmitDeclareOfBlockDeclRefVariable(
486  const VarDecl *variable, llvm::Value *storage, CGBuilderTy &Builder,
487  const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint = nullptr);
488 
489  /// Emit call to \c llvm.dbg.declare for an argument variable
490  /// declaration.
491  llvm::DILocalVariable *EmitDeclareOfArgVariable(const VarDecl *Decl,
492  llvm::Value *AI,
493  unsigned ArgNo,
494  CGBuilderTy &Builder);
495 
496  /// Emit call to \c llvm.dbg.declare for the block-literal argument
497  /// to a block invocation function.
498  void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
499  StringRef Name, unsigned ArgNo,
500  llvm::AllocaInst *LocalAddr,
501  CGBuilderTy &Builder);
502 
503  /// Emit information about a global variable.
504  void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl);
505 
506  /// Emit a constant global variable's debug info.
507  void EmitGlobalVariable(const ValueDecl *VD, const APValue &Init);
508 
509  /// Emit information about an external variable.
510  void EmitExternalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl);
511 
512  /// Emit information about global variable alias.
513  void EmitGlobalAlias(const llvm::GlobalValue *GV, const GlobalDecl Decl);
514 
515  /// Emit C++ using directive.
516  void EmitUsingDirective(const UsingDirectiveDecl &UD);
517 
518  /// Emit the type explicitly casted to.
519  void EmitExplicitCastType(QualType Ty);
520 
521  /// Emit the type even if it might not be used.
522  void EmitAndRetainType(QualType Ty);
523 
524  /// Emit a shadow decl brought in by a using or using-enum
525  void EmitUsingShadowDecl(const UsingShadowDecl &USD);
526 
527  /// Emit C++ using declaration.
528  void EmitUsingDecl(const UsingDecl &UD);
529 
530  /// Emit C++ using-enum declaration.
531  void EmitUsingEnumDecl(const UsingEnumDecl &UD);
532 
533  /// Emit an @import declaration.
534  void EmitImportDecl(const ImportDecl &ID);
535 
536  /// DebugInfo isn't attached to string literals by default. While certain
537  /// aspects of debuginfo aren't useful for string literals (like a name), it's
538  /// nice to be able to symbolize the line and column information. This is
539  /// especially useful for sanitizers, as it allows symbolization of
540  /// heap-buffer-overflows on constant strings.
541  void AddStringLiteralDebugInfo(llvm::GlobalVariable *GV,
542  const StringLiteral *S);
543 
544  /// Emit C++ namespace alias.
545  llvm::DIImportedEntity *EmitNamespaceAlias(const NamespaceAliasDecl &NA);
546 
547  /// Emit record type's standalone debug info.
548  llvm::DIType *getOrCreateRecordType(QualType Ty, SourceLocation L);
549 
550  /// Emit an Objective-C interface type standalone debug info.
551  llvm::DIType *getOrCreateInterfaceType(QualType Ty, SourceLocation Loc);
552 
553  /// Emit standalone debug info for a type.
554  llvm::DIType *getOrCreateStandaloneType(QualType Ty, SourceLocation Loc);
555 
556  /// Add heapallocsite metadata for MSAllocator calls.
557  void addHeapAllocSiteMetadata(llvm::CallBase *CallSite, QualType AllocatedTy,
558  SourceLocation Loc);
559 
560  void completeType(const EnumDecl *ED);
561  void completeType(const RecordDecl *RD);
562  void completeRequiredType(const RecordDecl *RD);
563  void completeClassData(const RecordDecl *RD);
564  void completeClass(const RecordDecl *RD);
565 
566  void completeTemplateDefinition(const ClassTemplateSpecializationDecl &SD);
567  void completeUnusedClass(const CXXRecordDecl &D);
568 
569  /// Create debug info for a macro defined by a #define directive or a macro
570  /// undefined by a #undef directive.
571  llvm::DIMacro *CreateMacro(llvm::DIMacroFile *Parent, unsigned MType,
572  SourceLocation LineLoc, StringRef Name,
573  StringRef Value);
574 
575  /// Create debug info for a file referenced by an #include directive.
576  llvm::DIMacroFile *CreateTempMacroFile(llvm::DIMacroFile *Parent,
577  SourceLocation LineLoc,
578  SourceLocation FileLoc);
579 
580  Param2DILocTy &getParamDbgMappings() { return ParamDbgMappings; }
581  ParamDecl2StmtTy &getCoroutineParameterMappings() {
582  return CoroutineParameterMappings;
583  }
584 
585 private:
586  /// Emit call to llvm.dbg.declare for a variable declaration.
587  /// Returns a pointer to the DILocalVariable associated with the
588  /// llvm.dbg.declare, or nullptr otherwise.
589  llvm::DILocalVariable *EmitDeclare(const VarDecl *decl, llvm::Value *AI,
591  CGBuilderTy &Builder,
592  const bool UsePointerValue = false);
593 
594  /// Emit call to llvm.dbg.declare for a binding declaration.
595  /// Returns a pointer to the DILocalVariable associated with the
596  /// llvm.dbg.declare, or nullptr otherwise.
597  llvm::DILocalVariable *EmitDeclare(const BindingDecl *decl, llvm::Value *AI,
599  CGBuilderTy &Builder,
600  const bool UsePointerValue = false);
601 
602  struct BlockByRefType {
603  /// The wrapper struct used inside the __block_literal struct.
604  llvm::DIType *BlockByRefWrapper;
605  /// The type as it appears in the source code.
606  llvm::DIType *WrappedType;
607  };
608 
609  std::string GetName(const Decl*, bool Qualified = false) const;
610 
611  /// Build up structure info for the byref. See \a BuildByRefType.
612  BlockByRefType EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
613  uint64_t *OffSet);
614 
615  /// Get context info for the DeclContext of \p Decl.
616  llvm::DIScope *getDeclContextDescriptor(const Decl *D);
617  /// Get context info for a given DeclContext \p Decl.
618  llvm::DIScope *getContextDescriptor(const Decl *Context,
619  llvm::DIScope *Default);
620 
621  llvm::DIScope *getCurrentContextDescriptor(const Decl *Decl);
622 
623  /// Create a forward decl for a RecordType in a given context.
624  llvm::DICompositeType *getOrCreateRecordFwdDecl(const RecordType *,
625  llvm::DIScope *);
626 
627  /// Return current directory name.
628  StringRef getCurrentDirname();
629 
630  /// Create new compile unit.
631  void CreateCompileUnit();
632 
633  /// Compute the file checksum debug info for input file ID.
635  computeChecksum(FileID FID, SmallString<32> &Checksum) const;
636 
637  /// Get the source of the given file ID.
638  Optional<StringRef> getSource(const SourceManager &SM, FileID FID);
639 
640  /// Convenience function to get the file debug info descriptor for the input
641  /// location.
642  llvm::DIFile *getOrCreateFile(SourceLocation Loc);
643 
644  /// Create a file debug info descriptor for a source file.
645  llvm::DIFile *
646  createFile(StringRef FileName,
647  Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
648  Optional<StringRef> Source);
649 
650  /// Get the type from the cache or create a new type if necessary.
651  llvm::DIType *getOrCreateType(QualType Ty, llvm::DIFile *Fg);
652 
653  /// Get a reference to a clang module. If \p CreateSkeletonCU is true,
654  /// this also creates a split dwarf skeleton compile unit.
655  llvm::DIModule *getOrCreateModuleRef(ASTSourceDescriptor Mod,
656  bool CreateSkeletonCU);
657 
658  /// DebugTypeExtRefs: If \p D originated in a clang module, return it.
659  llvm::DIModule *getParentModuleOrNull(const Decl *D);
660 
661  /// Get the type from the cache or create a new partial type if
662  /// necessary.
663  llvm::DICompositeType *getOrCreateLimitedType(const RecordType *Ty);
664 
665  /// Create type metadata for a source language type.
666  llvm::DIType *CreateTypeNode(QualType Ty, llvm::DIFile *Fg);
667 
668  /// Create new member and increase Offset by FType's size.
669  llvm::DIType *CreateMemberType(llvm::DIFile *Unit, QualType FType,
670  StringRef Name, uint64_t *Offset);
671 
672  /// Retrieve the DIDescriptor, if any, for the canonical form of this
673  /// declaration.
674  llvm::DINode *getDeclarationOrDefinition(const Decl *D);
675 
676  /// \return debug info descriptor to describe method
677  /// declaration for the given method definition.
678  llvm::DISubprogram *getFunctionDeclaration(const Decl *D);
679 
680  /// \return debug info descriptor to the describe method declaration
681  /// for the given method definition.
682  /// \param FnType For Objective-C methods, their type.
683  /// \param LineNo The declaration's line number.
684  /// \param Flags The DIFlags for the method declaration.
685  /// \param SPFlags The subprogram-spcific flags for the method declaration.
686  llvm::DISubprogram *
687  getObjCMethodDeclaration(const Decl *D, llvm::DISubroutineType *FnType,
688  unsigned LineNo, llvm::DINode::DIFlags Flags,
689  llvm::DISubprogram::DISPFlags SPFlags);
690 
691  /// \return debug info descriptor to describe in-class static data
692  /// member declaration for the given out-of-class definition. If D
693  /// is an out-of-class definition of a static data member of a
694  /// class, find its corresponding in-class declaration.
695  llvm::DIDerivedType *
696  getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D);
697 
698  /// Helper that either creates a forward declaration or a stub.
699  llvm::DISubprogram *getFunctionFwdDeclOrStub(GlobalDecl GD, bool Stub);
700 
701  /// Create a subprogram describing the forward declaration
702  /// represented in the given FunctionDecl wrapped in a GlobalDecl.
703  llvm::DISubprogram *getFunctionForwardDeclaration(GlobalDecl GD);
704 
705  /// Create a DISubprogram describing the function
706  /// represented in the given FunctionDecl wrapped in a GlobalDecl.
707  llvm::DISubprogram *getFunctionStub(GlobalDecl GD);
708 
709  /// Create a global variable describing the forward declaration
710  /// represented in the given VarDecl.
711  llvm::DIGlobalVariable *
712  getGlobalVariableForwardDeclaration(const VarDecl *VD);
713 
714  /// Return a global variable that represents one of the collection of global
715  /// variables created for an anonmyous union.
716  ///
717  /// Recursively collect all of the member fields of a global
718  /// anonymous decl and create static variables for them. The first
719  /// time this is called it needs to be on a union and then from
720  /// there we can have additional unnamed fields.
721  llvm::DIGlobalVariableExpression *
722  CollectAnonRecordDecls(const RecordDecl *RD, llvm::DIFile *Unit,
723  unsigned LineNo, StringRef LinkageName,
724  llvm::GlobalVariable *Var, llvm::DIScope *DContext);
725 
726 
727  /// Return flags which enable debug info emission for call sites, provided
728  /// that it is supported and enabled.
729  llvm::DINode::DIFlags getCallSiteRelatedAttrs() const;
730 
731  /// Get the printing policy for producing names for debug info.
732  PrintingPolicy getPrintingPolicy() const;
733 
734  /// Get function name for the given FunctionDecl. If the name is
735  /// constructed on demand (e.g., C++ destructor) then the name is
736  /// stored on the side.
737  StringRef getFunctionName(const FunctionDecl *FD);
738 
739  /// Returns the unmangled name of an Objective-C method.
740  /// This is the display name for the debugging info.
741  StringRef getObjCMethodName(const ObjCMethodDecl *FD);
742 
743  /// Return selector name. This is used for debugging
744  /// info.
745  StringRef getSelectorName(Selector S);
746 
747  /// Get class name including template argument list.
748  StringRef getClassName(const RecordDecl *RD);
749 
750  /// Get the vtable name for the given class.
751  StringRef getVTableName(const CXXRecordDecl *Decl);
752 
753  /// Get the name to use in the debug info for a dynamic initializer or atexit
754  /// stub function.
755  StringRef getDynamicInitializerName(const VarDecl *VD,
756  DynamicInitKind StubKind,
757  llvm::Function *InitFn);
758 
759  /// Get line number for the location. If location is invalid
760  /// then use current location.
761  unsigned getLineNumber(SourceLocation Loc);
762 
763  /// Get column number for the location. If location is
764  /// invalid then use current location.
765  /// \param Force Assume DebugColumnInfo option is true.
766  unsigned getColumnNumber(SourceLocation Loc, bool Force = false);
767 
768  /// Collect various properties of a FunctionDecl.
769  /// \param GD A GlobalDecl whose getDecl() must return a FunctionDecl.
770  void collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
771  StringRef &Name, StringRef &LinkageName,
772  llvm::DIScope *&FDContext,
773  llvm::DINodeArray &TParamsArray,
774  llvm::DINode::DIFlags &Flags);
775 
776  /// Collect various properties of a VarDecl.
777  void collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
778  unsigned &LineNo, QualType &T, StringRef &Name,
779  StringRef &LinkageName,
780  llvm::MDTuple *&TemplateParameters,
781  llvm::DIScope *&VDContext);
782 
783  /// Allocate a copy of \p A using the DebugInfoNames allocator
784  /// and return a reference to it. If multiple arguments are given the strings
785  /// are concatenated.
786  StringRef internString(StringRef A, StringRef B = StringRef()) {
787  char *Data = DebugInfoNames.Allocate<char>(A.size() + B.size());
788  if (!A.empty())
789  std::memcpy(Data, A.data(), A.size());
790  if (!B.empty())
791  std::memcpy(Data + A.size(), B.data(), B.size());
792  return StringRef(Data, A.size() + B.size());
793  }
794 };
795 
796 /// A scoped helper to set the current debug location to the specified
797 /// location or preferred location of the specified Expr.
799 private:
800  void init(SourceLocation TemporaryLocation, bool DefaultToEmpty = false);
801  ApplyDebugLocation(CodeGenFunction &CGF, bool DefaultToEmpty,
802  SourceLocation TemporaryLocation);
803 
804  llvm::DebugLoc OriginalLocation;
805  CodeGenFunction *CGF;
806 
807 public:
808  /// Set the location to the (valid) TemporaryLocation.
809  ApplyDebugLocation(CodeGenFunction &CGF, SourceLocation TemporaryLocation);
810  ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E);
811  ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc);
812  ApplyDebugLocation(ApplyDebugLocation &&Other) : CGF(Other.CGF) {
813  Other.CGF = nullptr;
814  }
815  ApplyDebugLocation &operator=(ApplyDebugLocation &&) = default;
816 
818 
819  /// Apply TemporaryLocation if it is valid. Otherwise switch
820  /// to an artificial debug location that has a valid scope, but no
821  /// line information.
822  ///
823  /// Artificial locations are useful when emitting compiler-generated
824  /// helper functions that have no source location associated with
825  /// them. The DWARF specification allows the compiler to use the
826  /// special line number 0 to indicate code that can not be
827  /// attributed to any source location. Note that passing an empty
828  /// SourceLocation to CGDebugInfo::setLocation() will result in the
829  /// last valid location being reused.
831  return ApplyDebugLocation(CGF, false, SourceLocation());
832  }
833  /// Apply TemporaryLocation if it is valid. Otherwise switch
834  /// to an artificial debug location that has a valid scope, but no
835  /// line information.
836  static ApplyDebugLocation
838  SourceLocation TemporaryLocation) {
839  return ApplyDebugLocation(CGF, false, TemporaryLocation);
840  }
841 
842  /// Set the IRBuilder to not attach debug locations. Note that
843  /// passing an empty SourceLocation to \a CGDebugInfo::setLocation()
844  /// will result in the last valid location being reused. Note that
845  /// all instructions that do not have a location at the beginning of
846  /// a function are counted towards to function prologue.
848  return ApplyDebugLocation(CGF, true, SourceLocation());
849  }
850 };
851 
852 /// A scoped helper to set the current debug location to an inlined location.
854  SourceLocation SavedLocation;
855  CodeGenFunction *CGF;
856 
857 public:
858  /// Set up the CodeGenFunction's DebugInfo to produce inline locations for the
859  /// function \p InlinedFn. The current debug location becomes the inlined call
860  /// site of the inlined function.
862  /// Restore everything back to the original state.
864 };
865 
866 } // namespace CodeGen
867 } // namespace clang
868 
869 #endif // LLVM_CLANG_LIB_CODEGEN_CGDEBUGINFO_H
llvm
YAML serialization mapping.
Definition: Dominators.h:30
type
clang::CodeGen::CGDebugInfo::getCoroutineParameterMappings
ParamDecl2StmtTy & getCoroutineParameterMappings()
Definition: CGDebugInfo.h:581
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::NamespaceAliasDecl
Represents a C++ namespace alias.
Definition: DeclCXX.h:3006
clang::CodeGen::CGDebugInfo::getLocation
SourceLocation getLocation() const
Return the current source location.
Definition: CGDebugInfo.h:416
clang::UsingDirectiveDecl
Represents C++ using-directive.
Definition: DeclCXX.h:2902
clang::BindingDecl
A binding in a decomposition declaration.
Definition: DeclCXX.h:3979
llvm::SmallVector< ObjCInterfaceCacheEntry, 32 >
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:675
clang::CodeGen::CGBlockInfo
CGBlockInfo - Information to generate a block literal.
Definition: CGBlocks.h:156
DeclCXX.h
memcpy
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Definition: __clang_cuda_device_functions.h:1549
Module.h
clang::UsingShadowDecl
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3207
llvm::Optional
Definition: LLVM.h:40
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
clang::CodeGen::CGBuilderTy
Definition: CGBuilder.h:44
clang::detail::Qualified
std::conditional_t< Const, const T, T > Qualified
Definition: HeaderSearch.h:158
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:627
clang::EnumDecl
Represents an enum.
Definition: Decl.h:3628
Offset
unsigned Offset
Definition: Format.cpp:2553
clang::GlobalDecl
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
clang::CodeGen::AlignmentSource::Decl
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
clang::DynamicInitKind
DynamicInitKind
Definition: GlobalDecl.h:32
CodeGenOptions.h
PrettyPrinter.h
clang::CXXRecordDecl::base_class_const_range
llvm::iterator_range< base_class_const_iterator > base_class_const_range
Definition: DeclCXX.h:594
clang::CodeGen::CGDebugInfo::setPCHDescriptor
void setPCHDescriptor(ASTSourceDescriptor PCH)
When generating debug information for a clang module or precompiled header, this module map will be u...
Definition: CGDebugInfo.h:407
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4647
clang::ImportDecl
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4505
clang::markup::EmitLocation
void EmitLocation(raw_ostream &o, const SourceManager &SM, SourceLocation L, const FIDMap &FM, unsigned indent)
Definition: PlistSupport.h:107
clang::LabelDecl
Represents the declaration of a label.
Definition: Decl.h:494
clang::CodeGen::CGDebugInfo
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:55
Type.h
clang::CodeGen::CGDebugInfo::setModuleMap
void setModuleMap(ModuleMap &MMap)
When generating debug information for a clang module or precompiled header, this module map will be u...
Definition: CGDebugInfo.h:402
Expr.h
llvm::SmallString< 32 >
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1767
llvm::DenseSet
Definition: Sema.h:77
clang::CodeGen::ApplyDebugLocation::ApplyDebugLocation
ApplyDebugLocation(ApplyDebugLocation &&Other)
Definition: CGDebugInfo.h:812
clang::ModuleMap
Definition: ModuleMap.h:75
clang::DisableValidationForModuleKind::PCH
@ PCH
Disable validation for a precompiled header and the modules it depends on.
ExternalASTSource.h
clang::UsingDecl
Represents a C++ using-declaration.
Definition: DeclCXX.h:3399
clang::CodeGen::ApplyDebugLocation
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:798
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:108
clang::CodeGen::CGDebugInfo::setInlinedAt
void setInlinedAt(llvm::MDNode *InlinedAt)
Update the current inline scope.
Definition: CGDebugInfo.h:420
clang::UsingEnumDecl
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3599
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
SourceLocation.h
clang::ast_matchers::decl
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchersInternal.cpp:734
clang::CodeGen::CGDebugInfo::getInlinedAt
llvm::MDNode * getInlinedAt() const
Definition: CGDebugInfo.h:423
clang::PrintingCallbacks
Callbacks to use to customize the behavior of the pretty-printer.
Definition: PrettyPrinter.h:32
Cache
TypePropertyCache< Private > Cache
Definition: Type.cpp:3879
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition: CodeGenFunction.h:231
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::CodeGen::CodeGenModule
This class organizes the cross-function state that is used while generating LLVM code.
Definition: CodeGenModule.h:275
TypeOrdering.h
llvm::ArrayRef
Definition: LLVM.h:34
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
CGBuilder.h
clang::CodeGen::ApplyDebugLocation::CreateDefaultArtificial
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:837
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::Builtin::ID
ID
Definition: Builtins.h:51
clang
Definition: CalledOnceCheck.h:17
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:752
clang::CodeGen::ApplyDebugLocation::CreateArtificial
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:830
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
unsigned
clang::CodeGen::ApplyDebugLocation::CreateEmpty
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
Definition: CGDebugInfo.h:847
clang::CodeGen::CGDebugInfo::registerVLASizeExpression
void registerVLASizeExpression(QualType Ty, llvm::Metadata *SizeExpr)
Register VLA size expression debug node with the qualified type.
Definition: CGDebugInfo.h:390
clang::codegenoptions::DebugInfoKind
DebugInfoKind
Definition: DebugInfoOptions.h:20
clang::CodeGen::CGDebugInfo::getParamDbgMappings
Param2DILocTy & getParamDbgMappings()
Definition: CGDebugInfo.h:580
Parent
NodeId Parent
Definition: ASTDiff.cpp:192
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::Expr
This represents one expression.
Definition: Expr.h:109
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::transformer::name
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...
Definition: RangeSelector.cpp:200
clang::ClassTemplateSpecializationDecl
Represents a class template specialization, which refers to a class template with a given set of temp...
Definition: DeclTemplate.h:1820
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1872
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3901
clang::finalize
void finalize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
Definition: TemplateInstCallback.h:52
clang::ASTSourceDescriptor
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
Definition: Module.h:776
clang::CodeGen::ApplyInlineDebugLocation
A scoped helper to set the current debug location to an inlined location.
Definition: CGDebugInfo.h:853
Type
MatchType Type
Definition: ASTMatchFinder.cpp:71