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