CGDebugInfo.cpp revision e798706bd20e514fcfeba5a7bd7200392d0e6231
1//===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===// 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 coordinates the debug information generation while generating code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CGDebugInfo.h" 15#include "CodeGenModule.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/RecordLayout.h" 20#include "clang/Basic/SourceManager.h" 21#include "clang/Basic/FileManager.h" 22#include "llvm/Constants.h" 23#include "llvm/DerivedTypes.h" 24#include "llvm/Instructions.h" 25#include "llvm/Intrinsics.h" 26#include "llvm/Module.h" 27#include "llvm/ADT/StringExtras.h" 28#include "llvm/ADT/SmallVector.h" 29#include "llvm/Support/Dwarf.h" 30#include "llvm/Target/TargetMachine.h" 31using namespace clang; 32using namespace clang::CodeGen; 33 34CGDebugInfo::CGDebugInfo(CodeGenModule *m) 35 : M(m), DebugFactory(M->getModule()) { 36} 37 38CGDebugInfo::~CGDebugInfo() { 39 assert(RegionStack.empty() && "Region stack mismatch, stack not empty!"); 40} 41 42void CGDebugInfo::setLocation(SourceLocation Loc) { 43 if (Loc.isValid()) 44 CurLoc = M->getContext().getSourceManager().getInstantiationLoc(Loc); 45} 46 47/// getOrCreateCompileUnit - Get the compile unit from the cache or create a new 48/// one if necessary. This returns null for invalid source locations. 49llvm::DICompileUnit CGDebugInfo::getOrCreateCompileUnit(SourceLocation Loc) { 50 // FIXME: Until we do a complete job of emitting debug information, 51 // we need to support making dummy compile units so that we generate 52 // "well formed" debug info. 53 const FileEntry *FE = 0; 54 55 SourceManager &SM = M->getContext().getSourceManager(); 56 if (Loc.isValid()) { 57 Loc = SM.getInstantiationLoc(Loc); 58 FE = SM.getFileEntryForID(SM.getFileID(Loc)); 59 } else { 60 // If Loc is not valid then use main file id. 61 FE = SM.getFileEntryForID(SM.getMainFileID()); 62 } 63 64 // See if this compile unit has been used before. 65 llvm::DICompileUnit &Unit = CompileUnitCache[FE]; 66 if (!Unit.isNull()) return Unit; 67 68 // Get source file information. 69 const char *FileName = FE ? FE->getName() : "<unknown>"; 70 const char *DirName = FE ? FE->getDir()->getName() : "<unknown>"; 71 72 // Create new compile unit. 73 // FIXME: Handle other language IDs as well. 74 // FIXME: Do not know how to get clang version yet. 75 return Unit = DebugFactory.CreateCompileUnit(llvm::dwarf::DW_LANG_C89, 76 FileName, DirName, "clang"); 77} 78 79/// CreateType - Get the Basic type from the cache or create a new 80/// one if necessary. 81llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT, 82 llvm::DICompileUnit Unit) { 83 unsigned Encoding = 0; 84 switch (BT->getKind()) { 85 default: 86 case BuiltinType::Void: 87 return llvm::DIType(); 88 case BuiltinType::UChar: 89 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break; 90 case BuiltinType::Char_S: 91 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break; 92 case BuiltinType::UShort: 93 case BuiltinType::UInt: 94 case BuiltinType::ULong: 95 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break; 96 case BuiltinType::Short: 97 case BuiltinType::Int: 98 case BuiltinType::Long: 99 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break; 100 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break; 101 case BuiltinType::Float: 102 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break; 103 } 104 // Bit size, align and offset of the type. 105 uint64_t Size = M->getContext().getTypeSize(BT); 106 uint64_t Align = M->getContext().getTypeAlign(BT); 107 uint64_t Offset = 0; 108 109 return DebugFactory.CreateBasicType(Unit, BT->getName(), Unit, 0, Size, Align, 110 Offset, /*flags*/ 0, Encoding); 111} 112 113/// getOrCreateCVRType - Get the CVR qualified type from the cache or create 114/// a new one if necessary. 115llvm::DIType CGDebugInfo::CreateCVRType(QualType Ty, llvm::DICompileUnit Unit) { 116 // We will create one Derived type for one qualifier and recurse to handle any 117 // additional ones. 118 llvm::DIType FromTy; 119 unsigned Tag; 120 if (Ty.isConstQualified()) { 121 Tag = llvm::dwarf::DW_TAG_const_type; 122 Ty.removeConst(); 123 FromTy = getOrCreateType(Ty, Unit); 124 } else if (Ty.isVolatileQualified()) { 125 Tag = llvm::dwarf::DW_TAG_volatile_type; 126 Ty.removeVolatile(); 127 FromTy = getOrCreateType(Ty, Unit); 128 } else { 129 assert(Ty.isRestrictQualified() && "Unknown type qualifier for debug info"); 130 Tag = llvm::dwarf::DW_TAG_restrict_type; 131 Ty.removeRestrict(); 132 FromTy = getOrCreateType(Ty, Unit); 133 } 134 135 // No need to fill in the Name, Line, Size, Alignment, Offset in case of 136 // CVR derived types. 137 return DebugFactory.CreateDerivedType(Tag, Unit, "", llvm::DICompileUnit(), 138 0, 0, 0, 0, 0, FromTy); 139} 140 141llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty, 142 llvm::DICompileUnit Unit) { 143 llvm::DIType EltTy = getOrCreateType(Ty->getPointeeType(), Unit); 144 145 // Bit size, align and offset of the type. 146 uint64_t Size = M->getContext().getTypeSize(Ty); 147 uint64_t Align = M->getContext().getTypeAlign(Ty); 148 149 return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, Unit, 150 "", llvm::DICompileUnit(), 151 0, Size, Align, 0, 0, EltTy); 152} 153 154llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty, 155 llvm::DICompileUnit Unit) { 156 // Typedefs are derived from some other type. If we have a typedef of a 157 // typedef, make sure to emit the whole chain. 158 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit); 159 160 // We don't set size information, but do specify where the typedef was 161 // declared. 162 std::string TyName = Ty->getDecl()->getNameAsString(); 163 SourceLocation DefLoc = Ty->getDecl()->getLocation(); 164 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc); 165 166 SourceManager &SM = M->getContext().getSourceManager(); 167 uint64_t Line = SM.getInstantiationLineNumber(DefLoc); 168 169 return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_typedef, Unit, 170 TyName, DefUnit, Line, 0, 0, 0, 0, Src); 171} 172 173llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty, 174 llvm::DICompileUnit Unit) { 175 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys; 176 177 // Add the result type at least. 178 EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit)); 179 180 // Set up remainder of arguments if there is a prototype. 181 // FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'! 182 if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) { 183 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) 184 EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit)); 185 } else { 186 // FIXME: Handle () case in C. llvm-gcc doesn't do it either. 187 } 188 189 llvm::DIArray EltTypeArray = 190 DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size()); 191 192 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type, 193 Unit, "", llvm::DICompileUnit(), 194 0, 0, 0, 0, 0, 195 llvm::DIType(), EltTypeArray); 196} 197 198/// CreateType - get structure or union type. 199llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty, 200 llvm::DICompileUnit Unit) { 201 RecordDecl *Decl = Ty->getDecl(); 202 203 unsigned Tag; 204 if (Decl->isStruct()) 205 Tag = llvm::dwarf::DW_TAG_structure_type; 206 else if (Decl->isUnion()) 207 Tag = llvm::dwarf::DW_TAG_union_type; 208 else { 209 assert(Decl->isClass() && "Unknown RecordType!"); 210 Tag = llvm::dwarf::DW_TAG_class_type; 211 } 212 213 SourceManager &SM = M->getContext().getSourceManager(); 214 215 // Get overall information about the record type for the debug info. 216 std::string Name = Decl->getNameAsString(); 217 218 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation()); 219 unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation()); 220 221 222 // Records and classes and unions can all be recursive. To handle them, we 223 // first generate a debug descriptor for the struct as a forward declaration. 224 // Then (if it is a definition) we go through and get debug info for all of 225 // its members. Finally, we create a descriptor for the complete type (which 226 // may refer to the forward decl if the struct is recursive) and replace all 227 // uses of the forward declaration with the final definition. 228 llvm::DIType FwdDecl = 229 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0, 230 llvm::DIType(), llvm::DIArray()); 231 232 // If this is just a forward declaration, return it. 233 if (!Decl->getDefinition(M->getContext())) 234 return FwdDecl; 235 236 // Otherwise, insert it into the TypeCache so that recursive uses will find 237 // it. 238 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl; 239 240 // Convert all the elements. 241 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys; 242 243 const ASTRecordLayout &RL = M->getContext().getASTRecordLayout(Decl); 244 245 unsigned FieldNo = 0; 246 for (RecordDecl::field_iterator I = Decl->field_begin(), 247 E = Decl->field_end(); 248 I != E; ++I, ++FieldNo) { 249 FieldDecl *Field = *I; 250 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit); 251 252 std::string FieldName = Field->getNameAsString(); 253 254 // Get the location for the field. 255 SourceLocation FieldDefLoc = Field->getLocation(); 256 llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc); 257 unsigned FieldLine = SM.getInstantiationLineNumber(FieldDefLoc); 258 259 // Bit size, align and offset of the type. 260 uint64_t FieldSize = M->getContext().getTypeSize(Ty); 261 unsigned FieldAlign = M->getContext().getTypeAlign(Ty); 262 uint64_t FieldOffset = RL.getFieldOffset(FieldNo); 263 264 // Create a DW_TAG_member node to remember the offset of this field in the 265 // struct. FIXME: This is an absolutely insane way to capture this 266 // information. When we gut debug info, this should be fixed. 267 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 268 FieldName, FieldDefUnit, 269 FieldLine, FieldSize, FieldAlign, 270 FieldOffset, 0, FieldTy); 271 EltTys.push_back(FieldTy); 272 } 273 274 llvm::DIArray Elements = 275 DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size()); 276 277 // Bit size, align and offset of the type. 278 uint64_t Size = M->getContext().getTypeSize(Ty); 279 uint64_t Align = M->getContext().getTypeAlign(Ty); 280 281 llvm::DIType RealDecl = 282 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size, 283 Align, 0, 0, llvm::DIType(), Elements); 284 285 // Now that we have a real decl for the struct, replace anything using the 286 // old decl with the new one. This will recursively update the debug info. 287 FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV()); 288 FwdDecl.getGV()->eraseFromParent(); 289 290 return RealDecl; 291} 292 293/// CreateType - get objective-c interface type. 294llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, 295 llvm::DICompileUnit Unit) { 296 ObjCInterfaceDecl *Decl = Ty->getDecl(); 297 298 unsigned Tag = llvm::dwarf::DW_TAG_structure_type; 299 SourceManager &SM = M->getContext().getSourceManager(); 300 301 // Get overall information about the record type for the debug info. 302 std::string Name = Decl->getNameAsString(); 303 304 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation()); 305 unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation()); 306 307 308 // To handle recursive interface, we 309 // first generate a debug descriptor for the struct as a forward declaration. 310 // Then (if it is a definition) we go through and get debug info for all of 311 // its members. Finally, we create a descriptor for the complete type (which 312 // may refer to the forward decl if the struct is recursive) and replace all 313 // uses of the forward declaration with the final definition. 314 llvm::DIType FwdDecl = 315 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0, 316 llvm::DIType(), llvm::DIArray()); 317 318 // If this is just a forward declaration, return it. 319 if (Decl->isForwardDecl()) 320 return FwdDecl; 321 322 // Otherwise, insert it into the TypeCache so that recursive uses will find 323 // it. 324 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl; 325 326 // Convert all the elements. 327 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys; 328 329 const ASTRecordLayout &RL = M->getContext().getASTObjCInterfaceLayout(Decl); 330 331 unsigned FieldNo = 0; 332 for (ObjCInterfaceDecl::ivar_iterator I = Decl->ivar_begin(), 333 E = Decl->ivar_end(); I != E; ++I, ++FieldNo) { 334 ObjCIvarDecl *Field = *I; 335 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit); 336 337 std::string FieldName = Field->getNameAsString(); 338 339 // Get the location for the field. 340 SourceLocation FieldDefLoc = Field->getLocation(); 341 llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc); 342 unsigned FieldLine = SM.getInstantiationLineNumber(FieldDefLoc); 343 344 // Bit size, align and offset of the type. 345 uint64_t FieldSize = M->getContext().getTypeSize(Ty); 346 unsigned FieldAlign = M->getContext().getTypeAlign(Ty); 347 uint64_t FieldOffset = RL.getFieldOffset(FieldNo); 348 349 // Create a DW_TAG_member node to remember the offset of this field in the 350 // struct. FIXME: This is an absolutely insane way to capture this 351 // information. When we gut debug info, this should be fixed. 352 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 353 FieldName, FieldDefUnit, 354 FieldLine, FieldSize, FieldAlign, 355 FieldOffset, 0, FieldTy); 356 EltTys.push_back(FieldTy); 357 } 358 359 llvm::DIArray Elements = 360 DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size()); 361 362 // Bit size, align and offset of the type. 363 uint64_t Size = M->getContext().getTypeSize(Ty); 364 uint64_t Align = M->getContext().getTypeAlign(Ty); 365 366 llvm::DIType RealDecl = 367 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size, 368 Align, 0, 0, llvm::DIType(), Elements); 369 370 // Now that we have a real decl for the struct, replace anything using the 371 // old decl with the new one. This will recursively update the debug info. 372 FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV()); 373 FwdDecl.getGV()->eraseFromParent(); 374 375 return RealDecl; 376} 377 378llvm::DIType CGDebugInfo::CreateType(const EnumType *Ty, 379 llvm::DICompileUnit Unit) { 380 EnumDecl *Decl = Ty->getDecl(); 381 382 llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators; 383 384 // Create DIEnumerator elements for each enumerator. 385 for (EnumDecl::enumerator_iterator Enum = Decl->enumerator_begin(), 386 EnumEnd = Decl->enumerator_end(); 387 Enum != EnumEnd; ++Enum) { 388 Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getNameAsString(), 389 Enum->getInitVal().getZExtValue())); 390 } 391 392 // Return a CompositeType for the enum itself. 393 llvm::DIArray EltArray = 394 DebugFactory.GetOrCreateArray(&Enumerators[0], Enumerators.size()); 395 396 std::string EnumName = Decl->getNameAsString(); 397 SourceLocation DefLoc = Decl->getLocation(); 398 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc); 399 SourceManager &SM = M->getContext().getSourceManager(); 400 unsigned Line = SM.getInstantiationLineNumber(DefLoc); 401 402 // Size and align of the type. 403 uint64_t Size = M->getContext().getTypeSize(Ty); 404 unsigned Align = M->getContext().getTypeAlign(Ty); 405 406 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_enumeration_type, 407 Unit, EnumName, DefUnit, Line, 408 Size, Align, 0, 0, 409 llvm::DIType(), EltArray); 410} 411 412llvm::DIType CGDebugInfo::CreateType(const TagType *Ty, 413 llvm::DICompileUnit Unit) { 414 if (const RecordType *RT = dyn_cast<RecordType>(Ty)) 415 return CreateType(RT, Unit); 416 else if (const EnumType *ET = dyn_cast<EnumType>(Ty)) 417 return CreateType(ET, Unit); 418 419 return llvm::DIType(); 420} 421 422llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty, 423 llvm::DICompileUnit Unit) { 424 uint64_t Size; 425 uint64_t Align; 426 427 428 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types 429 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) { 430 Size = 0; 431 Align = 432 M->getContext().getTypeAlign(M->getContext().getBaseElementType(VAT)); 433 } else if (Ty->isIncompleteArrayType()) { 434 Size = 0; 435 Align = M->getContext().getTypeAlign(Ty->getElementType()); 436 } else { 437 // Size and align of the whole array, not the element type. 438 Size = M->getContext().getTypeSize(Ty); 439 Align = M->getContext().getTypeAlign(Ty); 440 } 441 442 // Add the dimensions of the array. FIXME: This loses CV qualifiers from 443 // interior arrays, do we care? Why aren't nested arrays represented the 444 // obvious/recursive way? 445 llvm::SmallVector<llvm::DIDescriptor, 8> Subscripts; 446 QualType EltTy(Ty, 0); 447 while ((Ty = dyn_cast<ArrayType>(EltTy))) { 448 uint64_t Upper = 0; 449 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty)) 450 Upper = CAT->getSize().getZExtValue() - 1; 451 // FIXME: Verify this is right for VLAs. 452 Subscripts.push_back(DebugFactory.GetOrCreateSubrange(0, Upper)); 453 EltTy = Ty->getElementType(); 454 } 455 456 llvm::DIArray SubscriptArray = 457 DebugFactory.GetOrCreateArray(&Subscripts[0], Subscripts.size()); 458 459 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_array_type, 460 Unit, "", llvm::DICompileUnit(), 461 0, Size, Align, 0, 0, 462 getOrCreateType(EltTy, Unit), 463 SubscriptArray); 464} 465 466 467/// getOrCreateType - Get the type from the cache or create a new 468/// one if necessary. 469llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, 470 llvm::DICompileUnit Unit) { 471 if (Ty.isNull()) 472 return llvm::DIType(); 473 474 // Check to see if the compile unit already has created this type. 475 llvm::DIType &Slot = TypeCache[Ty.getAsOpaquePtr()]; 476 if (!Slot.isNull()) return Slot; 477 478 // Handle CVR qualifiers, which recursively handles what they refer to. 479 if (Ty.getCVRQualifiers()) 480 return Slot = CreateCVRType(Ty, Unit); 481 482 // Work out details of type. 483 switch (Ty->getTypeClass()) { 484#define TYPE(Class, Base) 485#define ABSTRACT_TYPE(Class, Base) 486#define NON_CANONICAL_TYPE(Class, Base) 487#define DEPENDENT_TYPE(Class, Base) case Type::Class: 488#include "clang/AST/TypeNodes.def" 489 assert(false && "Dependent types cannot show up in debug information"); 490 491 case Type::Complex: 492 case Type::Reference: 493 case Type::Vector: 494 case Type::ExtVector: 495 case Type::ExtQual: 496 case Type::ObjCQualifiedInterface: 497 case Type::ObjCQualifiedId: 498 case Type::FixedWidthInt: 499 case Type::BlockPointer: 500 case Type::MemberPointer: 501 case Type::ClassTemplateSpecialization: 502 case Type::ObjCQualifiedClass: 503 // Unsupported types 504 return llvm::DIType(); 505 506 case Type::ObjCInterface: 507 Slot = CreateType(cast<ObjCInterfaceType>(Ty), Unit); break; 508 case Type::Builtin: Slot = CreateType(cast<BuiltinType>(Ty), Unit); break; 509 case Type::Pointer: Slot = CreateType(cast<PointerType>(Ty), Unit); break; 510 case Type::Typedef: Slot = CreateType(cast<TypedefType>(Ty), Unit); break; 511 case Type::Record: 512 case Type::Enum: 513 Slot = CreateType(cast<TagType>(Ty), Unit); 514 break; 515 case Type::FunctionProto: 516 case Type::FunctionNoProto: 517 return Slot = CreateType(cast<FunctionType>(Ty), Unit); 518 519 case Type::ConstantArray: 520 case Type::VariableArray: 521 case Type::IncompleteArray: 522 return Slot = CreateType(cast<ArrayType>(Ty), Unit); 523 case Type::TypeOfExpr: 524 return Slot = getOrCreateType(cast<TypeOfExprType>(Ty)->getUnderlyingExpr() 525 ->getType(), Unit); 526 case Type::TypeOf: 527 return Slot = getOrCreateType(cast<TypeOfType>(Ty)->getUnderlyingType(), 528 Unit); 529 } 530 531 return Slot; 532} 533 534/// EmitFunctionStart - Constructs the debug code for entering a function - 535/// "llvm.dbg.func.start.". 536void CGDebugInfo::EmitFunctionStart(const char *Name, QualType ReturnType, 537 llvm::Function *Fn, 538 CGBuilderTy &Builder) { 539 // FIXME: Why is this using CurLoc??? 540 llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc); 541 SourceManager &SM = M->getContext().getSourceManager(); 542 unsigned LineNo = SM.getInstantiationLineNumber(CurLoc); 543 544 llvm::DISubprogram SP = 545 DebugFactory.CreateSubprogram(Unit, Name, Name, "", Unit, LineNo, 546 getOrCreateType(ReturnType, Unit), 547 Fn->hasInternalLinkage(), true/*definition*/); 548 549 DebugFactory.InsertSubprogramStart(SP, Builder.GetInsertBlock()); 550 551 // Push function on region stack. 552 RegionStack.push_back(SP); 553} 554 555 556void CGDebugInfo::EmitStopPoint(llvm::Function *Fn, CGBuilderTy &Builder) { 557 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return; 558 559 // Don't bother if things are the same as last time. 560 SourceManager &SM = M->getContext().getSourceManager(); 561 if (CurLoc == PrevLoc 562 || (SM.getInstantiationLineNumber(CurLoc) == 563 SM.getInstantiationLineNumber(PrevLoc) 564 && SM.isFromSameFile(CurLoc, PrevLoc))) 565 return; 566 567 // Update last state. 568 PrevLoc = CurLoc; 569 570 // Get the appropriate compile unit. 571 llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc); 572 DebugFactory.InsertStopPoint(Unit, SM.getInstantiationLineNumber(CurLoc), 573 SM.getInstantiationColumnNumber(CurLoc), 574 Builder.GetInsertBlock()); 575} 576 577/// EmitRegionStart- Constructs the debug code for entering a declarative 578/// region - "llvm.dbg.region.start.". 579void CGDebugInfo::EmitRegionStart(llvm::Function *Fn, CGBuilderTy &Builder) { 580 llvm::DIDescriptor D; 581 if (!RegionStack.empty()) 582 D = RegionStack.back(); 583 D = DebugFactory.CreateBlock(D); 584 RegionStack.push_back(D); 585 DebugFactory.InsertRegionStart(D, Builder.GetInsertBlock()); 586} 587 588/// EmitRegionEnd - Constructs the debug code for exiting a declarative 589/// region - "llvm.dbg.region.end." 590void CGDebugInfo::EmitRegionEnd(llvm::Function *Fn, CGBuilderTy &Builder) { 591 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!"); 592 593 // Provide an region stop point. 594 EmitStopPoint(Fn, Builder); 595 596 DebugFactory.InsertRegionEnd(RegionStack.back(), Builder.GetInsertBlock()); 597 RegionStack.pop_back(); 598} 599 600/// EmitDeclare - Emit local variable declaration debug info. 601void CGDebugInfo::EmitDeclare(const VarDecl *Decl, unsigned Tag, 602 llvm::Value *Storage, CGBuilderTy &Builder) { 603 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!"); 604 605 // Get location information. 606 SourceManager &SM = M->getContext().getSourceManager(); 607 unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation()); 608 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation()); 609 610 // Create the descriptor for the variable. 611 llvm::DIVariable D = 612 DebugFactory.CreateVariable(Tag, RegionStack.back(),Decl->getNameAsString(), 613 Unit, Line, 614 getOrCreateType(Decl->getType(), Unit)); 615 // Insert an llvm.dbg.declare into the current block. 616 DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock()); 617} 618 619void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *Decl, 620 llvm::Value *Storage, 621 CGBuilderTy &Builder) { 622 EmitDeclare(Decl, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder); 623} 624 625/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument 626/// variable declaration. 627void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI, 628 CGBuilderTy &Builder) { 629 EmitDeclare(Decl, llvm::dwarf::DW_TAG_arg_variable, AI, Builder); 630} 631 632 633 634/// EmitGlobalVariable - Emit information about a global variable. 635void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, 636 const VarDecl *Decl) { 637 // Create global variable debug descriptor. 638 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation()); 639 SourceManager &SM = M->getContext().getSourceManager(); 640 unsigned LineNo = SM.getInstantiationLineNumber(Decl->getLocation()); 641 642 std::string Name = Decl->getNameAsString(); 643 644 QualType T = Decl->getType(); 645 if (T->isIncompleteArrayType()) { 646 647 // CodeGen turns int[] into int[1] so we'll do the same here. 648 llvm::APSInt ConstVal(32); 649 650 ConstVal = 1; 651 QualType ET = M->getContext().getAsArrayType(T)->getElementType(); 652 653 T = M->getContext().getConstantArrayType(ET, ConstVal, 654 ArrayType::Normal, 0); 655 } 656 657 DebugFactory.CreateGlobalVariable(Unit, Name, Name, "", Unit, LineNo, 658 getOrCreateType(T, Unit), 659 Var->hasInternalLinkage(), 660 true/*definition*/, Var); 661} 662 663/// EmitGlobalVariable - Emit information about an objective-c interface. 664void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, 665 ObjCInterfaceDecl *Decl) { 666 // Create global variable debug descriptor. 667 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation()); 668 SourceManager &SM = M->getContext().getSourceManager(); 669 unsigned LineNo = SM.getInstantiationLineNumber(Decl->getLocation()); 670 671 std::string Name = Decl->getNameAsString(); 672 673 QualType T = M->getContext().buildObjCInterfaceType(Decl); 674 if (T->isIncompleteArrayType()) { 675 676 // CodeGen turns int[] into int[1] so we'll do the same here. 677 llvm::APSInt ConstVal(32); 678 679 ConstVal = 1; 680 QualType ET = M->getContext().getAsArrayType(T)->getElementType(); 681 682 T = M->getContext().getConstantArrayType(ET, ConstVal, 683 ArrayType::Normal, 0); 684 } 685 686 DebugFactory.CreateGlobalVariable(Unit, Name, Name, "", Unit, LineNo, 687 getOrCreateType(T, Unit), 688 Var->hasInternalLinkage(), 689 true/*definition*/, Var); 690} 691 692