1 //===--- CGDebugInfo.h - DebugInfo for LLVM CodeGen -------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This is the source-level debug info generator for llvm translation.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGDEBUGINFO_H
15 #define LLVM_CLANG_LIB_CODEGEN_CGDEBUGINFO_H
16 
17 #include "CGBuilder.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/SourceLocation.h"
21 #include "clang/Frontend/CodeGenOptions.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/IR/DIBuilder.h"
24 #include "llvm/IR/DebugInfo.h"
25 #include "llvm/IR/ValueHandle.h"
26 #include "llvm/Support/Allocator.h"
27 
28 namespace llvm {
29   class MDNode;
30 }
31 
32 namespace clang {
33   class CXXMethodDecl;
34   class VarDecl;
35   class ObjCInterfaceDecl;
36   class ObjCIvarDecl;
37   class ClassTemplateSpecializationDecl;
38   class GlobalDecl;
39   class UsingDecl;
40 
41 namespace CodeGen {
42   class CodeGenModule;
43   class CodeGenFunction;
44   class CGBlockInfo;
45 
46 /// \brief This class gathers all debug information during compilation
47 /// and is responsible for emitting to llvm globals or pass directly to
48 /// the backend.
49 class CGDebugInfo {
50   friend class ApplyDebugLocation;
51   friend class SaveAndRestoreLocation;
52   CodeGenModule &CGM;
53   const CodeGenOptions::DebugInfoKind DebugKind;
54   llvm::DIBuilder DBuilder;
55   llvm::DICompileUnit *TheCU = nullptr;
56   SourceLocation CurLoc;
57   llvm::DIType *VTablePtrType = nullptr;
58   llvm::DIType *ClassTy = nullptr;
59   llvm::DICompositeType *ObjTy = nullptr;
60   llvm::DIType *SelTy = nullptr;
61   llvm::DIType *OCLImage1dDITy = nullptr;
62   llvm::DIType *OCLImage1dArrayDITy = nullptr;
63   llvm::DIType *OCLImage1dBufferDITy = nullptr;
64   llvm::DIType *OCLImage2dDITy = nullptr;
65   llvm::DIType *OCLImage2dArrayDITy = nullptr;
66   llvm::DIType *OCLImage3dDITy = nullptr;
67   llvm::DIType *OCLEventDITy = nullptr;
68   llvm::DIType *BlockLiteralGeneric = nullptr;
69 
70   /// \brief Cache of previously constructed Types.
71   llvm::DenseMap<const void *, llvm::TrackingMDRef> TypeCache;
72 
73   struct ObjCInterfaceCacheEntry {
74     const ObjCInterfaceType *Type;
75     llvm::DIType *Decl;
76     llvm::DIFile *Unit;
77     ObjCInterfaceCacheEntry(const ObjCInterfaceType *Type, llvm::DIType *Decl,
78                             llvm::DIFile *Unit)
79         : Type(Type), Decl(Decl), Unit(Unit) {}
80   };
81 
82   /// \brief Cache of previously constructed interfaces
83   /// which may change.
84   llvm::SmallVector<ObjCInterfaceCacheEntry, 32> ObjCInterfaceCache;
85 
86   /// \brief list of interfaces we want to keep even if orphaned.
87   std::vector<void *> RetainedTypes;
88 
89   /// \brief Cache of forward declared types to RAUW at the end of
90   /// compilation.
91   std::vector<std::pair<const TagType *, llvm::TrackingMDRef>> ReplaceMap;
92 
93   /// \brief Cache of replaceable forward declarartions (functions and
94   /// variables) to RAUW at the end of compilation.
95   std::vector<std::pair<const DeclaratorDecl *, llvm::TrackingMDRef>>
96       FwdDeclReplaceMap;
97 
98   // LexicalBlockStack - Keep track of our current nested lexical block.
99   std::vector<llvm::TypedTrackingMDRef<llvm::DIScope>> LexicalBlockStack;
100   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> RegionMap;
101   // FnBeginRegionCount - Keep track of LexicalBlockStack counter at the
102   // beginning of a function. This is used to pop unbalanced regions at
103   // the end of a function.
104   std::vector<unsigned> FnBeginRegionCount;
105 
106   /// \brief This is a storage for names that are
107   /// constructed on demand. For example, C++ destructors, C++ operators etc..
108   llvm::BumpPtrAllocator DebugInfoNames;
109   StringRef CWDName;
110 
111   llvm::DenseMap<const char *, llvm::TrackingMDRef> DIFileCache;
112   llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> SPCache;
113   /// \brief Cache declarations relevant to DW_TAG_imported_declarations (C++
114   /// using declarations) that aren't covered by other more specific caches.
115   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> DeclCache;
116   llvm::DenseMap<const NamespaceDecl *, llvm::TrackingMDRef> NameSpaceCache;
117   llvm::DenseMap<const NamespaceAliasDecl *, llvm::TrackingMDRef>
118       NamespaceAliasCache;
119   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> StaticDataMemberCache;
120 
121   /// Helper functions for getOrCreateType.
122   unsigned Checksum(const ObjCInterfaceDecl *InterfaceDecl);
123   llvm::DIType *CreateType(const BuiltinType *Ty);
124   llvm::DIType *CreateType(const ComplexType *Ty);
125   llvm::DIType *CreateQualifiedType(QualType Ty, llvm::DIFile *Fg);
126   llvm::DIType *CreateType(const TypedefType *Ty, llvm::DIFile *Fg);
127   llvm::DIType *CreateType(const TemplateSpecializationType *Ty,
128                            llvm::DIFile *Fg);
129   llvm::DIType *CreateType(const ObjCObjectPointerType *Ty, llvm::DIFile *F);
130   llvm::DIType *CreateType(const PointerType *Ty, llvm::DIFile *F);
131   llvm::DIType *CreateType(const BlockPointerType *Ty, llvm::DIFile *F);
132   llvm::DIType *CreateType(const FunctionType *Ty, llvm::DIFile *F);
133   llvm::DIType *CreateType(const RecordType *Tyg);
134   llvm::DIType *CreateTypeDefinition(const RecordType *Ty);
135   llvm::DICompositeType *CreateLimitedType(const RecordType *Ty);
136   void CollectContainingType(const CXXRecordDecl *RD,
137                              llvm::DICompositeType *CT);
138   llvm::DIType *CreateType(const ObjCInterfaceType *Ty, llvm::DIFile *F);
139   llvm::DIType *CreateTypeDefinition(const ObjCInterfaceType *Ty,
140                                      llvm::DIFile *F);
141   llvm::DIType *CreateType(const ObjCObjectType *Ty, llvm::DIFile *F);
142   llvm::DIType *CreateType(const VectorType *Ty, llvm::DIFile *F);
143   llvm::DIType *CreateType(const ArrayType *Ty, llvm::DIFile *F);
144   llvm::DIType *CreateType(const LValueReferenceType *Ty, llvm::DIFile *F);
145   llvm::DIType *CreateType(const RValueReferenceType *Ty, llvm::DIFile *Unit);
146   llvm::DIType *CreateType(const MemberPointerType *Ty, llvm::DIFile *F);
147   llvm::DIType *CreateType(const AtomicType *Ty, llvm::DIFile *F);
148   llvm::DIType *CreateEnumType(const EnumType *Ty);
149   llvm::DIType *CreateTypeDefinition(const EnumType *Ty);
150   llvm::DIType *CreateSelfType(const QualType &QualTy, llvm::DIType *Ty);
151   llvm::DIType *getTypeOrNull(const QualType);
152   llvm::DISubroutineType *getOrCreateMethodType(const CXXMethodDecl *Method,
153                                                 llvm::DIFile *F);
154   llvm::DISubroutineType *
155   getOrCreateInstanceMethodType(QualType ThisPtr, const FunctionProtoType *Func,
156                                 llvm::DIFile *Unit);
157   llvm::DISubroutineType *
158   getOrCreateFunctionType(const Decl *D, QualType FnType, llvm::DIFile *F);
159   llvm::DIType *getOrCreateVTablePtrType(llvm::DIFile *F);
160   llvm::DINamespace *getOrCreateNameSpace(const NamespaceDecl *N);
161   llvm::DIType *getOrCreateTypeDeclaration(QualType PointeeTy, llvm::DIFile *F);
162   llvm::DIType *CreatePointerLikeType(llvm::dwarf::Tag Tag, const Type *Ty,
163                                       QualType PointeeTy, llvm::DIFile *F);
164 
165   llvm::Value *getCachedInterfaceTypeOrNull(const QualType Ty);
166   llvm::DIType *getOrCreateStructPtrType(StringRef Name, llvm::DIType *&Cache);
167 
168   llvm::DISubprogram *CreateCXXMemberFunction(const CXXMethodDecl *Method,
169                                               llvm::DIFile *F,
170                                               llvm::DIType *RecordTy);
171 
172   void CollectCXXMemberFunctions(const CXXRecordDecl *Decl, llvm::DIFile *F,
173                                  SmallVectorImpl<llvm::Metadata *> &E,
174                                  llvm::DIType *T);
175 
176   void CollectCXXBases(const CXXRecordDecl *Decl, llvm::DIFile *F,
177                        SmallVectorImpl<llvm::Metadata *> &EltTys,
178                        llvm::DIType *RecordTy);
179 
180   llvm::DINodeArray CollectTemplateParams(const TemplateParameterList *TPList,
181                                           ArrayRef<TemplateArgument> TAList,
182                                           llvm::DIFile *Unit);
183   llvm::DINodeArray CollectFunctionTemplateParams(const FunctionDecl *FD,
184                                                   llvm::DIFile *Unit);
185   llvm::DINodeArray
186   CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TS,
187                            llvm::DIFile *F);
188 
189   llvm::DIType *createFieldType(StringRef name, QualType type,
190                                 uint64_t sizeInBitsOverride, SourceLocation loc,
191                                 AccessSpecifier AS, uint64_t offsetInBits,
192                                 llvm::DIFile *tunit, llvm::DIScope *scope,
193                                 const RecordDecl *RD = nullptr);
194 
195   // Helpers for collecting fields of a record.
196   void CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl,
197                                  SmallVectorImpl<llvm::Metadata *> &E,
198                                  llvm::DIType *RecordTy);
199   llvm::DIDerivedType *CreateRecordStaticField(const VarDecl *Var,
200                                                llvm::DIType *RecordTy,
201                                                const RecordDecl *RD);
202   void CollectRecordNormalField(const FieldDecl *Field, uint64_t OffsetInBits,
203                                 llvm::DIFile *F,
204                                 SmallVectorImpl<llvm::Metadata *> &E,
205                                 llvm::DIType *RecordTy, const RecordDecl *RD);
206   void CollectRecordFields(const RecordDecl *Decl, llvm::DIFile *F,
207                            SmallVectorImpl<llvm::Metadata *> &E,
208                            llvm::DICompositeType *RecordTy);
209 
210   void CollectVTableInfo(const CXXRecordDecl *Decl, llvm::DIFile *F,
211                          SmallVectorImpl<llvm::Metadata *> &EltTys);
212 
213   // CreateLexicalBlock - Create a new lexical block node and push it on
214   // the stack.
215   void CreateLexicalBlock(SourceLocation Loc);
216 
217 public:
218   CGDebugInfo(CodeGenModule &CGM);
219   ~CGDebugInfo();
220 
221   void finalize();
222 
223   /// \brief Update the current source location. If \arg loc is
224   /// invalid it is ignored.
225   void setLocation(SourceLocation Loc);
226 
227   /// \brief Emit metadata to indicate a change in line/column
228   /// information in the source file.
229   void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc);
230 
231   /// \brief Emit a call to llvm.dbg.function.start to indicate
232   /// start of a new function.
233   /// \param Loc       The location of the function header.
234   /// \param ScopeLoc  The location of the function body.
235   void EmitFunctionStart(GlobalDecl GD,
236                          SourceLocation Loc, SourceLocation ScopeLoc,
237                          QualType FnType, llvm::Function *Fn,
238                          CGBuilderTy &Builder);
239 
240   /// \brief Constructs the debug code for exiting a function.
241   void EmitFunctionEnd(CGBuilderTy &Builder);
242 
243   /// \brief Emit metadata to indicate the beginning of a
244   /// new lexical block and push the block onto the stack.
245   void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc);
246 
247   /// \brief Emit metadata to indicate the end of a new lexical
248   /// block and pop the current block.
249   void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc);
250 
251   /// \brief Emit call to llvm.dbg.declare for an automatic
252   /// variable declaration.
253   void EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI,
254                                  CGBuilderTy &Builder);
255 
256   /// \brief Emit call to llvm.dbg.declare for an
257   /// imported variable declaration in a block.
258   void EmitDeclareOfBlockDeclRefVariable(const VarDecl *variable,
259                                          llvm::Value *storage,
260                                          CGBuilderTy &Builder,
261                                          const CGBlockInfo &blockInfo,
262                                          llvm::Instruction *InsertPoint = 0);
263 
264   /// \brief Emit call to llvm.dbg.declare for an argument
265   /// variable declaration.
266   void EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI,
267                                 unsigned ArgNo, CGBuilderTy &Builder);
268 
269   /// \brief Emit call to
270   /// llvm.dbg.declare for the block-literal argument to a block
271   /// invocation function.
272   void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
273                                             llvm::Value *Arg, unsigned ArgNo,
274                                             llvm::Value *LocalAddr,
275                                             CGBuilderTy &Builder);
276 
277   /// \brief Emit information about a global variable.
278   void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl);
279 
280   /// \brief Emit global variable's debug info.
281   void EmitGlobalVariable(const ValueDecl *VD, llvm::Constant *Init);
282 
283   /// \brief Emit C++ using directive.
284   void EmitUsingDirective(const UsingDirectiveDecl &UD);
285 
286   /// \brief Emit the type explicitly casted to.
287   void EmitExplicitCastType(QualType Ty);
288 
289   /// \brief Emit C++ using declaration.
290   void EmitUsingDecl(const UsingDecl &UD);
291 
292   /// \brief Emit C++ namespace alias.
293   llvm::DIImportedEntity *EmitNamespaceAlias(const NamespaceAliasDecl &NA);
294 
295   /// \brief Emit record type's standalone debug info.
296   llvm::DIType *getOrCreateRecordType(QualType Ty, SourceLocation L);
297 
298   /// \brief Emit an objective c interface type standalone
299   /// debug info.
300   llvm::DIType *getOrCreateInterfaceType(QualType Ty, SourceLocation Loc);
301 
302   void completeType(const EnumDecl *ED);
303   void completeType(const RecordDecl *RD);
304   void completeRequiredType(const RecordDecl *RD);
305   void completeClassData(const RecordDecl *RD);
306 
307   void completeTemplateDefinition(const ClassTemplateSpecializationDecl &SD);
308 
309 private:
310   /// \brief Emit call to llvm.dbg.declare for a variable declaration.
311   /// Tag accepts custom types DW_TAG_arg_variable and DW_TAG_auto_variable,
312   /// otherwise would be of type llvm::dwarf::Tag.
313   void EmitDeclare(const VarDecl *decl, llvm::dwarf::Tag Tag, llvm::Value *AI,
314                    unsigned ArgNo, CGBuilderTy &Builder);
315 
316   // EmitTypeForVarWithBlocksAttr - Build up structure info for the byref.
317   // See BuildByRefType.
318   llvm::DIType *EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
319                                              uint64_t *OffSet);
320 
321   /// \brief Get context info for the decl.
322   llvm::DIScope *getContextDescriptor(const Decl *Decl);
323 
324   llvm::DIScope *getCurrentContextDescriptor(const Decl *Decl);
325 
326   /// \brief Create a forward decl for a RecordType in a given context.
327   llvm::DICompositeType *getOrCreateRecordFwdDecl(const RecordType *,
328                                                   llvm::DIScope *);
329 
330   /// \brief Return current directory name.
331   StringRef getCurrentDirname();
332 
333   /// \brief Create new compile unit.
334   void CreateCompileUnit();
335 
336   /// \brief Get the file debug info descriptor for the input
337   /// location.
338   llvm::DIFile *getOrCreateFile(SourceLocation Loc);
339 
340   /// \brief Get the file info for main compile unit.
341   llvm::DIFile *getOrCreateMainFile();
342 
343   /// \brief Get the type from the cache or create a new type if
344   /// necessary.
345   llvm::DIType *getOrCreateType(QualType Ty, llvm::DIFile *Fg);
346 
347   /// \brief Get the type from the cache or create a new
348   /// partial type if necessary.
349   llvm::DIType *getOrCreateLimitedType(const RecordType *Ty, llvm::DIFile *F);
350 
351   /// \brief Create type metadata for a source language type.
352   llvm::DIType *CreateTypeNode(QualType Ty, llvm::DIFile *Fg);
353 
354   /// \brief return the underlying ObjCInterfaceDecl
355   /// if Ty is an ObjCInterface or a pointer to one.
356   ObjCInterfaceDecl* getObjCInterfaceDecl(QualType Ty);
357 
358   /// \brief Create new member and increase Offset by FType's size.
359   llvm::DIType *CreateMemberType(llvm::DIFile *Unit, QualType FType,
360                                  StringRef Name, uint64_t *Offset);
361 
362   /// \brief Retrieve the DIDescriptor, if any, for the canonical form of this
363   /// declaration.
364   llvm::DINode *getDeclarationOrDefinition(const Decl *D);
365 
366   /// \brief Return debug info descriptor to describe method
367   /// declaration for the given method definition.
368   llvm::DISubprogram *getFunctionDeclaration(const Decl *D);
369 
370   /// Return debug info descriptor to describe in-class static data member
371   /// declaration for the given out-of-class definition.
372   llvm::DIDerivedType *
373   getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D);
374 
375   /// \brief Create a subprogram describing the forward
376   /// decalration represented in the given FunctionDecl.
377   llvm::DISubprogram *getFunctionForwardDeclaration(const FunctionDecl *FD);
378 
379   /// \brief Create a global variable describing the forward decalration
380   /// represented in the given VarDecl.
381   llvm::DIGlobalVariable *
382   getGlobalVariableForwardDeclaration(const VarDecl *VD);
383 
384   /// Return a global variable that represents one of the collection of
385   /// global variables created for an anonmyous union.
386   llvm::DIGlobalVariable *
387   CollectAnonRecordDecls(const RecordDecl *RD, llvm::DIFile *Unit,
388                          unsigned LineNo, StringRef LinkageName,
389                          llvm::GlobalVariable *Var, llvm::DIScope *DContext);
390 
391   /// \brief Get function name for the given FunctionDecl. If the
392   /// name is constructed on demand (e.g. C++ destructor) then the name
393   /// is stored on the side.
394   StringRef getFunctionName(const FunctionDecl *FD);
395 
396   /// \brief Returns the unmangled name of an Objective-C method.
397   /// This is the display name for the debugging info.
398   StringRef getObjCMethodName(const ObjCMethodDecl *FD);
399 
400   /// \brief Return selector name. This is used for debugging
401   /// info.
402   StringRef getSelectorName(Selector S);
403 
404   /// \brief Get class name including template argument list.
405   StringRef getClassName(const RecordDecl *RD);
406 
407   /// \brief Get vtable name for the given Class.
408   StringRef getVTableName(const CXXRecordDecl *Decl);
409 
410   /// \brief Get line number for the location. If location is invalid
411   /// then use current location.
412   unsigned getLineNumber(SourceLocation Loc);
413 
414   /// \brief Get column number for the location. If location is
415   /// invalid then use current location.
416   /// \param Force  Assume DebugColumnInfo option is true.
417   unsigned getColumnNumber(SourceLocation Loc, bool Force=false);
418 
419   /// \brief Collect various properties of a FunctionDecl.
420   /// \param GD  A GlobalDecl whose getDecl() must return a FunctionDecl.
421   void collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
422                                 StringRef &Name, StringRef &LinkageName,
423                                 llvm::DIScope *&FDContext,
424                                 llvm::DINodeArray &TParamsArray,
425                                 unsigned &Flags);
426 
427   /// \brief Collect various properties of a VarDecl.
428   void collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
429                            unsigned &LineNo, QualType &T, StringRef &Name,
430                            StringRef &LinkageName, llvm::DIScope *&VDContext);
431 
432   /// \brief Allocate a copy of \p A using the DebugInfoNames allocator
433   /// and return a reference to it. If multiple arguments are given the strings
434   /// are concatenated.
435   StringRef internString(StringRef A, StringRef B = StringRef()) {
436     char *Data = DebugInfoNames.Allocate<char>(A.size() + B.size());
437     std::memcpy(Data, A.data(), A.size());
438     std::memcpy(Data + A.size(), B.data(), B.size());
439     return StringRef(Data, A.size() + B.size());
440   }
441 };
442 
443 /// \brief A scoped helper to set the current debug location to the specified
444 /// location or preferred location of the specified Expr.
445 class ApplyDebugLocation {
446 private:
447   void init(SourceLocation TemporaryLocation, bool DefaultToEmpty = false);
448   ApplyDebugLocation(CodeGenFunction &CGF, bool DefaultToEmpty,
449                      SourceLocation TemporaryLocation);
450 
451   llvm::DebugLoc OriginalLocation;
452   CodeGenFunction &CGF;
453 public:
454 
455   /// \brief Set the location to the (valid) TemporaryLocation.
456   ApplyDebugLocation(CodeGenFunction &CGF, SourceLocation TemporaryLocation);
457   ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E);
458   ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc);
459 
460   ~ApplyDebugLocation();
461 
462   /// \brief Apply TemporaryLocation if it is valid. Otherwise switch to an
463   /// artificial debug location that has a valid scope, but no line information.
464   ///
465   /// Artificial locations are useful when emitting compiler-generated helper
466   /// functions that have no source location associated with them. The DWARF
467   /// specification allows the compiler to use the special line number 0 to
468   /// indicate code that can not be attributed to any source location. Note that
469   /// passing an empty SourceLocation to CGDebugInfo::setLocation() will result
470   /// in the last valid location being reused.
471   static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF) {
472     return ApplyDebugLocation(CGF, false, SourceLocation());
473   }
474   /// \brief Apply TemporaryLocation if it is valid. Otherwise switch to an
475   /// artificial debug location that has a valid scope, but no line information.
476   static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF,
477                                              SourceLocation TemporaryLocation) {
478     return ApplyDebugLocation(CGF, false, TemporaryLocation);
479   }
480 
481   /// \brief Set the IRBuilder to not attach debug locations.  Note that passing
482   /// an empty SourceLocation to CGDebugInfo::setLocation() will result in the
483   /// last valid location being reused.  Note that all instructions that do not
484   /// have a location at the beginning of a function are counted towards to
485   /// funciton prologue.
486   static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF) {
487     return ApplyDebugLocation(CGF, true, SourceLocation());
488   }
489 
490   /// \brief Apply TemporaryLocation if it is valid. Otherwise set the IRBuilder
491   /// to not attach debug locations.
492   static ApplyDebugLocation CreateDefaultEmpty(CodeGenFunction &CGF,
493                                              SourceLocation TemporaryLocation) {
494     return ApplyDebugLocation(CGF, true, TemporaryLocation);
495   }
496 
497 };
498 
499 
500 } // namespace CodeGen
501 } // namespace clang
502 
503 
504 #endif
505