CGDebugInfo.h revision 251662
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 CLANG_CODEGEN_CGDEBUGINFO_H 15#define CLANG_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 "llvm/ADT/DenseMap.h" 22#include "llvm/DIBuilder.h" 23#include "llvm/DebugInfo.h" 24#include "llvm/Support/Allocator.h" 25#include "llvm/Support/ValueHandle.h" 26 27namespace llvm { 28 class MDNode; 29} 30 31namespace clang { 32 class CXXMethodDecl; 33 class VarDecl; 34 class ObjCInterfaceDecl; 35 class ObjCIvarDecl; 36 class ClassTemplateSpecializationDecl; 37 class GlobalDecl; 38 39namespace CodeGen { 40 class CodeGenModule; 41 class CodeGenFunction; 42 class CGBlockInfo; 43 44/// CGDebugInfo - This class gathers all debug information during compilation 45/// and is responsible for emitting to llvm globals or pass directly to 46/// the backend. 47class CGDebugInfo { 48 CodeGenModule &CGM; 49 llvm::DIBuilder DBuilder; 50 llvm::DICompileUnit TheCU; 51 SourceLocation CurLoc, PrevLoc; 52 llvm::DIType VTablePtrType; 53 llvm::DIType ClassTy; 54 llvm::DICompositeType ObjTy; 55 llvm::DIType SelTy; 56 llvm::DIType OCLImage1dDITy, OCLImage1dArrayDITy, OCLImage1dBufferDITy; 57 llvm::DIType OCLImage2dDITy, OCLImage2dArrayDITy; 58 llvm::DIType OCLImage3dDITy; 59 llvm::DIType OCLEventDITy; 60 61 /// TypeCache - Cache of previously constructed Types. 62 llvm::DenseMap<void *, llvm::WeakVH> TypeCache; 63 64 /// ObjCInterfaceCache - Cache of previously constructed interfaces 65 /// which may change. Storing a pair of DIType and checksum. 66 llvm::DenseMap<void *, std::pair<llvm::WeakVH, unsigned > > 67 ObjCInterfaceCache; 68 69 /// RetainedTypes - list of interfaces we want to keep even if orphaned. 70 std::vector<void *> RetainedTypes; 71 72 /// CompleteTypeCache - Cache of previously constructed complete RecordTypes. 73 llvm::DenseMap<void *, llvm::WeakVH> CompletedTypeCache; 74 75 /// ReplaceMap - Cache of forward declared types to RAUW at the end of 76 /// compilation. 77 std::vector<std::pair<void *, llvm::WeakVH> >ReplaceMap; 78 79 bool BlockLiteralGenericSet; 80 llvm::DIType BlockLiteralGeneric; 81 82 // LexicalBlockStack - Keep track of our current nested lexical block. 83 std::vector<llvm::TrackingVH<llvm::MDNode> > LexicalBlockStack; 84 llvm::DenseMap<const Decl *, llvm::WeakVH> RegionMap; 85 // FnBeginRegionCount - Keep track of LexicalBlockStack counter at the 86 // beginning of a function. This is used to pop unbalanced regions at 87 // the end of a function. 88 std::vector<unsigned> FnBeginRegionCount; 89 90 /// DebugInfoNames - This is a storage for names that are 91 /// constructed on demand. For example, C++ destructors, C++ operators etc.. 92 llvm::BumpPtrAllocator DebugInfoNames; 93 StringRef CWDName; 94 95 llvm::DenseMap<const char *, llvm::WeakVH> DIFileCache; 96 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH> SPCache; 97 llvm::DenseMap<const NamespaceDecl *, llvm::WeakVH> NameSpaceCache; 98 llvm::DenseMap<const Decl *, llvm::WeakVH> StaticDataMemberCache; 99 100 /// Helper functions for getOrCreateType. 101 unsigned Checksum(const ObjCInterfaceDecl *InterfaceDecl); 102 llvm::DIType CreateType(const BuiltinType *Ty); 103 llvm::DIType CreateType(const ComplexType *Ty); 104 llvm::DIType CreateQualifiedType(QualType Ty, llvm::DIFile F); 105 llvm::DIType CreateType(const TypedefType *Ty, llvm::DIFile F); 106 llvm::DIType CreateType(const ObjCObjectPointerType *Ty, 107 llvm::DIFile F); 108 llvm::DIType CreateType(const PointerType *Ty, llvm::DIFile F); 109 llvm::DIType CreateType(const BlockPointerType *Ty, llvm::DIFile F); 110 llvm::DIType CreateType(const FunctionType *Ty, llvm::DIFile F); 111 llvm::DIType CreateType(const RecordType *Ty); 112 llvm::DIType CreateLimitedType(const RecordType *Ty); 113 llvm::DIType CreateType(const ObjCInterfaceType *Ty, llvm::DIFile F); 114 llvm::DIType CreateType(const ObjCObjectType *Ty, llvm::DIFile F); 115 llvm::DIType CreateType(const VectorType *Ty, llvm::DIFile F); 116 llvm::DIType CreateType(const ArrayType *Ty, llvm::DIFile F); 117 llvm::DIType CreateType(const LValueReferenceType *Ty, llvm::DIFile F); 118 llvm::DIType CreateType(const RValueReferenceType *Ty, llvm::DIFile Unit); 119 llvm::DIType CreateType(const MemberPointerType *Ty, llvm::DIFile F); 120 llvm::DIType CreateType(const AtomicType *Ty, llvm::DIFile F); 121 llvm::DIType CreateEnumType(const EnumDecl *ED); 122 llvm::DIType CreateSelfType(const QualType &QualTy, llvm::DIType Ty); 123 llvm::DIType getTypeOrNull(const QualType); 124 llvm::DIType getCompletedTypeOrNull(const QualType); 125 llvm::DIType getOrCreateMethodType(const CXXMethodDecl *Method, 126 llvm::DIFile F); 127 llvm::DIType getOrCreateInstanceMethodType( 128 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile Unit); 129 llvm::DIType getOrCreateFunctionType(const Decl *D, QualType FnType, 130 llvm::DIFile F); 131 llvm::DIType getOrCreateVTablePtrType(llvm::DIFile F); 132 llvm::DINameSpace getOrCreateNameSpace(const NamespaceDecl *N); 133 llvm::DIType CreatePointeeType(QualType PointeeTy, llvm::DIFile F); 134 llvm::DIType CreatePointerLikeType(unsigned Tag, 135 const Type *Ty, QualType PointeeTy, 136 llvm::DIFile F); 137 138 llvm::Value *getCachedInterfaceTypeOrNull(const QualType Ty); 139 llvm::DIType getOrCreateStructPtrType(StringRef Name, llvm::DIType &Cache); 140 141 llvm::DISubprogram CreateCXXMemberFunction(const CXXMethodDecl *Method, 142 llvm::DIFile F, 143 llvm::DIType RecordTy); 144 145 void CollectCXXMemberFunctions(const CXXRecordDecl *Decl, 146 llvm::DIFile F, 147 SmallVectorImpl<llvm::Value *> &E, 148 llvm::DIType T); 149 150 void CollectCXXFriends(const CXXRecordDecl *Decl, 151 llvm::DIFile F, 152 SmallVectorImpl<llvm::Value *> &EltTys, 153 llvm::DIType RecordTy); 154 155 void CollectCXXBases(const CXXRecordDecl *Decl, 156 llvm::DIFile F, 157 SmallVectorImpl<llvm::Value *> &EltTys, 158 llvm::DIType RecordTy); 159 160 llvm::DIArray 161 CollectTemplateParams(const TemplateParameterList *TPList, 162 const TemplateArgumentList &TAList, 163 llvm::DIFile Unit); 164 llvm::DIArray 165 CollectFunctionTemplateParams(const FunctionDecl *FD, llvm::DIFile Unit); 166 llvm::DIArray 167 CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TS, 168 llvm::DIFile F); 169 170 llvm::DIType createFieldType(StringRef name, QualType type, 171 uint64_t sizeInBitsOverride, SourceLocation loc, 172 AccessSpecifier AS, uint64_t offsetInBits, 173 llvm::DIFile tunit, 174 llvm::DIDescriptor scope); 175 176 // Helpers for collecting fields of a record. 177 void CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl, 178 SmallVectorImpl<llvm::Value *> &E, 179 llvm::DIType RecordTy); 180 void CollectRecordStaticField(const VarDecl *Var, 181 SmallVectorImpl<llvm::Value *> &E, 182 llvm::DIType RecordTy); 183 void CollectRecordNormalField(const FieldDecl *Field, uint64_t OffsetInBits, 184 llvm::DIFile F, 185 SmallVectorImpl<llvm::Value *> &E, 186 llvm::DIType RecordTy); 187 void CollectRecordFields(const RecordDecl *Decl, llvm::DIFile F, 188 SmallVectorImpl<llvm::Value *> &E, 189 llvm::DIType RecordTy); 190 191 void CollectVTableInfo(const CXXRecordDecl *Decl, 192 llvm::DIFile F, 193 SmallVectorImpl<llvm::Value *> &EltTys); 194 195 // CreateLexicalBlock - Create a new lexical block node and push it on 196 // the stack. 197 void CreateLexicalBlock(SourceLocation Loc); 198 199public: 200 CGDebugInfo(CodeGenModule &CGM); 201 ~CGDebugInfo(); 202 203 void finalize(); 204 205 /// setLocation - Update the current source location. If \arg loc is 206 /// invalid it is ignored. 207 void setLocation(SourceLocation Loc); 208 209 /// EmitLocation - Emit metadata to indicate a change in line/column 210 /// information in the source file. 211 /// \param ForceColumnInfo Assume DebugColumnInfo option is true. 212 void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc, 213 bool ForceColumnInfo = false); 214 215 /// EmitFunctionStart - Emit a call to llvm.dbg.function.start to indicate 216 /// start of a new function. 217 void EmitFunctionStart(GlobalDecl GD, QualType FnType, 218 llvm::Function *Fn, CGBuilderTy &Builder); 219 220 /// EmitFunctionEnd - Constructs the debug code for exiting a function. 221 void EmitFunctionEnd(CGBuilderTy &Builder); 222 223 /// EmitLexicalBlockStart - Emit metadata to indicate the beginning of a 224 /// new lexical block and push the block onto the stack. 225 void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc); 226 227 /// EmitLexicalBlockEnd - Emit metadata to indicate the end of a new lexical 228 /// block and pop the current block. 229 void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc); 230 231 /// EmitDeclareOfAutoVariable - Emit call to llvm.dbg.declare for an automatic 232 /// variable declaration. 233 void EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI, 234 CGBuilderTy &Builder); 235 236 /// EmitDeclareOfBlockDeclRefVariable - Emit call to llvm.dbg.declare for an 237 /// imported variable declaration in a block. 238 void EmitDeclareOfBlockDeclRefVariable(const VarDecl *variable, 239 llvm::Value *storage, 240 CGBuilderTy &Builder, 241 const CGBlockInfo &blockInfo); 242 243 /// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument 244 /// variable declaration. 245 void EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI, 246 unsigned ArgNo, CGBuilderTy &Builder); 247 248 /// EmitDeclareOfBlockLiteralArgVariable - Emit call to 249 /// llvm.dbg.declare for the block-literal argument to a block 250 /// invocation function. 251 void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block, 252 llvm::Value *Arg, 253 llvm::Value *LocalAddr, 254 CGBuilderTy &Builder); 255 256 /// EmitGlobalVariable - Emit information about a global variable. 257 void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl); 258 259 /// EmitGlobalVariable - Emit information about an objective-c interface. 260 void EmitGlobalVariable(llvm::GlobalVariable *GV, ObjCInterfaceDecl *Decl); 261 262 /// EmitGlobalVariable - Emit global variable's debug info. 263 void EmitGlobalVariable(const ValueDecl *VD, llvm::Constant *Init); 264 265 /// \brief - Emit C++ using directive. 266 void EmitUsingDirective(const UsingDirectiveDecl &UD); 267 268 /// getOrCreateRecordType - Emit record type's standalone debug info. 269 llvm::DIType getOrCreateRecordType(QualType Ty, SourceLocation L); 270 271 /// getOrCreateInterfaceType - Emit an objective c interface type standalone 272 /// debug info. 273 llvm::DIType getOrCreateInterfaceType(QualType Ty, 274 SourceLocation Loc); 275 276private: 277 /// EmitDeclare - Emit call to llvm.dbg.declare for a variable declaration. 278 void EmitDeclare(const VarDecl *decl, unsigned Tag, llvm::Value *AI, 279 unsigned ArgNo, CGBuilderTy &Builder); 280 281 // EmitTypeForVarWithBlocksAttr - Build up structure info for the byref. 282 // See BuildByRefType. 283 llvm::DIType EmitTypeForVarWithBlocksAttr(const VarDecl *VD, 284 uint64_t *OffSet); 285 286 /// getContextDescriptor - Get context info for the decl. 287 llvm::DIScope getContextDescriptor(const Decl *Decl); 288 289 /// createRecordFwdDecl - Create a forward decl for a RecordType in a given 290 /// context. 291 llvm::DIType createRecordFwdDecl(const RecordDecl *, llvm::DIDescriptor); 292 293 /// createContextChain - Create a set of decls for the context chain. 294 llvm::DIDescriptor createContextChain(const Decl *Decl); 295 296 /// getCurrentDirname - Return current directory name. 297 StringRef getCurrentDirname(); 298 299 /// CreateCompileUnit - Create new compile unit. 300 void CreateCompileUnit(); 301 302 /// getOrCreateFile - Get the file debug info descriptor for the input 303 /// location. 304 llvm::DIFile getOrCreateFile(SourceLocation Loc); 305 306 /// getOrCreateMainFile - Get the file info for main compile unit. 307 llvm::DIFile getOrCreateMainFile(); 308 309 /// getOrCreateType - Get the type from the cache or create a new type if 310 /// necessary. 311 llvm::DIType getOrCreateType(QualType Ty, llvm::DIFile F); 312 313 /// getOrCreateLimitedType - Get the type from the cache or create a new 314 /// partial type if necessary. 315 llvm::DIType getOrCreateLimitedType(QualType Ty, llvm::DIFile F); 316 317 /// CreateTypeNode - Create type metadata for a source language type. 318 llvm::DIType CreateTypeNode(QualType Ty, llvm::DIFile F); 319 320 /// getObjCInterfaceDecl - return the underlying ObjCInterfaceDecl 321 /// if Ty is an ObjCInterface or a pointer to one. 322 ObjCInterfaceDecl* getObjCInterfaceDecl(QualType Ty); 323 324 /// CreateLimitedTypeNode - Create type metadata for a source language 325 /// type, but only partial types for records. 326 llvm::DIType CreateLimitedTypeNode(QualType Ty, llvm::DIFile F); 327 328 /// CreateMemberType - Create new member and increase Offset by FType's size. 329 llvm::DIType CreateMemberType(llvm::DIFile Unit, QualType FType, 330 StringRef Name, uint64_t *Offset); 331 332 /// getFunctionDeclaration - Return debug info descriptor to describe method 333 /// declaration for the given method definition. 334 llvm::DISubprogram getFunctionDeclaration(const Decl *D); 335 336 /// getStaticDataMemberDeclaration - Return debug info descriptor to 337 /// describe in-class static data member declaration for the given 338 /// out-of-class definition. 339 llvm::DIDerivedType getStaticDataMemberDeclaration(const Decl *D); 340 341 /// getFunctionName - Get function name for the given FunctionDecl. If the 342 /// name is constructred on demand (e.g. C++ destructor) then the name 343 /// is stored on the side. 344 StringRef getFunctionName(const FunctionDecl *FD); 345 346 /// getObjCMethodName - Returns the unmangled name of an Objective-C method. 347 /// This is the display name for the debugging info. 348 StringRef getObjCMethodName(const ObjCMethodDecl *FD); 349 350 /// getSelectorName - Return selector name. This is used for debugging 351 /// info. 352 StringRef getSelectorName(Selector S); 353 354 /// getClassName - Get class name including template argument list. 355 StringRef getClassName(const RecordDecl *RD); 356 357 /// getVTableName - Get vtable name for the given Class. 358 StringRef getVTableName(const CXXRecordDecl *Decl); 359 360 /// getLineNumber - Get line number for the location. If location is invalid 361 /// then use current location. 362 unsigned getLineNumber(SourceLocation Loc); 363 364 /// getColumnNumber - Get column number for the location. If location is 365 /// invalid then use current location. 366 /// \param Force Assume DebugColumnInfo option is true. 367 unsigned getColumnNumber(SourceLocation Loc, bool Force=false); 368}; 369} // namespace CodeGen 370} // namespace clang 371 372 373#endif 374