CGDebugInfo.cpp revision 0ae3d60731abb4c75eb9e993f8492527f4e51c70
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 "clang/Frontend/CompileOptions.h" 23#include "llvm/Constants.h" 24#include "llvm/DerivedTypes.h" 25#include "llvm/Instructions.h" 26#include "llvm/Intrinsics.h" 27#include "llvm/Module.h" 28#include "llvm/ADT/StringExtras.h" 29#include "llvm/ADT/SmallVector.h" 30#include "llvm/Support/Dwarf.h" 31#include "llvm/System/Path.h" 32#include "llvm/Target/TargetMachine.h" 33using namespace clang; 34using namespace clang::CodeGen; 35 36CGDebugInfo::CGDebugInfo(CodeGenModule *m) 37 : M(m), isMainCompileUnitCreated(false), DebugFactory(M->getModule()), 38 BlockLiteralGenericSet(false) { 39} 40 41CGDebugInfo::~CGDebugInfo() { 42 assert(RegionStack.empty() && "Region stack mismatch, stack not empty!"); 43} 44 45void CGDebugInfo::setLocation(SourceLocation Loc) { 46 if (Loc.isValid()) 47 CurLoc = M->getContext().getSourceManager().getInstantiationLoc(Loc); 48} 49 50/// getOrCreateCompileUnit - Get the compile unit from the cache or create a new 51/// one if necessary. This returns null for invalid source locations. 52llvm::DICompileUnit CGDebugInfo::getOrCreateCompileUnit(SourceLocation Loc) { 53 // Get source file information. 54 const char *FileName = "<unknown>"; 55 SourceManager &SM = M->getContext().getSourceManager(); 56 unsigned FID = 0; 57 if (Loc.isValid()) { 58 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 59 FileName = PLoc.getFilename(); 60 FID = PLoc.getIncludeLoc().getRawEncoding(); 61 } 62 63 // See if this compile unit has been used before. 64 llvm::DICompileUnit &Unit = CompileUnitCache[FID]; 65 if (!Unit.isNull()) return Unit; 66 67 // Get absolute path name. 68 llvm::sys::Path AbsFileName(FileName); 69 if (!AbsFileName.isAbsolute()) { 70 llvm::sys::Path tmp = llvm::sys::Path::GetCurrentDirectory(); 71 tmp.appendComponent(FileName); 72 AbsFileName = tmp; 73 } 74 75 // See if thie compile unit is representing main source file. Each source 76 // file has corresponding compile unit. There is only one main source 77 // file at a time. 78 bool isMain = false; 79 const LangOptions &LO = M->getLangOptions(); 80 const char *MainFileName = LO.getMainFileName(); 81 if (isMainCompileUnitCreated == false) { 82 if (MainFileName) { 83 if (!strcmp(AbsFileName.getLast().c_str(), MainFileName)) 84 isMain = true; 85 } else { 86 if (Loc.isValid() && SM.isFromMainFile(Loc)) 87 isMain = true; 88 } 89 if (isMain) 90 isMainCompileUnitCreated = true; 91 } 92 93 unsigned LangTag; 94 if (LO.CPlusPlus) { 95 if (LO.ObjC1) 96 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus; 97 else 98 LangTag = llvm::dwarf::DW_LANG_C_plus_plus; 99 } else if (LO.ObjC1) { 100 LangTag = llvm::dwarf::DW_LANG_ObjC; 101 } else if (LO.C99) { 102 LangTag = llvm::dwarf::DW_LANG_C99; 103 } else { 104 LangTag = llvm::dwarf::DW_LANG_C89; 105 } 106 107 std::string Producer = "clang 1.0";// FIXME: clang version. 108 bool isOptimized = LO.Optimize; 109 const char *Flags = ""; // FIXME: Encode command line options. 110 111 // Figure out which version of the ObjC runtime we have. 112 unsigned RuntimeVers = 0; 113 if (LO.ObjC1) 114 RuntimeVers = LO.ObjCNonFragileABI ? 2 : 1; 115 116 // Create new compile unit. 117 return Unit = DebugFactory.CreateCompileUnit(LangTag, AbsFileName.getLast(), 118 AbsFileName.getDirname(), 119 Producer, isMain, isOptimized, 120 Flags, RuntimeVers); 121} 122 123/// CreateType - Get the Basic type from the cache or create a new 124/// one if necessary. 125llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT, 126 llvm::DICompileUnit Unit) { 127 unsigned Encoding = 0; 128 switch (BT->getKind()) { 129 default: 130 case BuiltinType::Void: 131 return llvm::DIType(); 132 case BuiltinType::UChar: 133 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break; 134 case BuiltinType::Char_S: 135 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break; 136 case BuiltinType::UShort: 137 case BuiltinType::UInt: 138 case BuiltinType::ULong: 139 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break; 140 case BuiltinType::Short: 141 case BuiltinType::Int: 142 case BuiltinType::Long: 143 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break; 144 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break; 145 case BuiltinType::Float: 146 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break; 147 } 148 // Bit size, align and offset of the type. 149 uint64_t Size = M->getContext().getTypeSize(BT); 150 uint64_t Align = M->getContext().getTypeAlign(BT); 151 uint64_t Offset = 0; 152 153 return DebugFactory.CreateBasicType(Unit, 154 BT->getName(M->getContext().getLangOptions()), 155 Unit, 0, Size, Align, 156 Offset, /*flags*/ 0, Encoding); 157} 158 159llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty, 160 llvm::DICompileUnit Unit) { 161 // Bit size, align and offset of the type. 162 unsigned Encoding = llvm::dwarf::DW_ATE_complex_float; 163 if (Ty->isComplexIntegerType()) 164 Encoding = llvm::dwarf::DW_ATE_lo_user; 165 166 uint64_t Size = M->getContext().getTypeSize(Ty); 167 uint64_t Align = M->getContext().getTypeAlign(Ty); 168 uint64_t Offset = 0; 169 170 return DebugFactory.CreateBasicType(Unit, "complex", 171 Unit, 0, Size, Align, 172 Offset, /*flags*/ 0, Encoding); 173} 174 175/// getOrCreateCVRType - Get the CVR qualified type from the cache or create 176/// a new one if necessary. 177llvm::DIType CGDebugInfo::CreateCVRType(QualType Ty, llvm::DICompileUnit Unit) { 178 // We will create one Derived type for one qualifier and recurse to handle any 179 // additional ones. 180 llvm::DIType FromTy; 181 unsigned Tag; 182 if (Ty.isConstQualified()) { 183 Tag = llvm::dwarf::DW_TAG_const_type; 184 Ty.removeConst(); 185 FromTy = getOrCreateType(Ty, Unit); 186 } else if (Ty.isVolatileQualified()) { 187 Tag = llvm::dwarf::DW_TAG_volatile_type; 188 Ty.removeVolatile(); 189 FromTy = getOrCreateType(Ty, Unit); 190 } else { 191 assert(Ty.isRestrictQualified() && "Unknown type qualifier for debug info"); 192 Tag = llvm::dwarf::DW_TAG_restrict_type; 193 Ty.removeRestrict(); 194 FromTy = getOrCreateType(Ty, Unit); 195 } 196 197 // No need to fill in the Name, Line, Size, Alignment, Offset in case of 198 // CVR derived types. 199 return DebugFactory.CreateDerivedType(Tag, Unit, "", llvm::DICompileUnit(), 200 0, 0, 0, 0, 0, FromTy); 201} 202 203llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty, 204 llvm::DICompileUnit Unit) { 205 llvm::DIType EltTy = getOrCreateType(Ty->getPointeeType(), Unit); 206 207 // Bit size, align and offset of the type. 208 uint64_t Size = M->getContext().getTypeSize(Ty); 209 uint64_t Align = M->getContext().getTypeAlign(Ty); 210 211 return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, Unit, 212 "", llvm::DICompileUnit(), 213 0, Size, Align, 0, 0, EltTy); 214} 215 216llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty, 217 llvm::DICompileUnit Unit) { 218 if (BlockLiteralGenericSet) 219 return BlockLiteralGeneric; 220 221 llvm::DICompileUnit DefUnit; 222 unsigned Tag = llvm::dwarf::DW_TAG_structure_type; 223 224 llvm::SmallVector<llvm::DIDescriptor, 5> EltTys; 225 226 llvm::DIType FieldTy; 227 228 QualType FType; 229 uint64_t FieldSize, FieldOffset; 230 unsigned FieldAlign; 231 232 llvm::DIArray Elements; 233 llvm::DIType EltTy, DescTy; 234 235 FieldOffset = 0; 236 FType = M->getContext().UnsignedLongTy; 237 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 238 FieldSize = M->getContext().getTypeSize(FType); 239 FieldAlign = M->getContext().getTypeAlign(FType); 240 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 241 "reserved", DefUnit, 242 0, FieldSize, FieldAlign, 243 FieldOffset, 0, FieldTy); 244 EltTys.push_back(FieldTy); 245 246 FieldOffset += FieldSize; 247 FType = M->getContext().UnsignedLongTy; 248 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 249 FieldSize = M->getContext().getTypeSize(FType); 250 FieldAlign = M->getContext().getTypeAlign(FType); 251 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 252 "Size", DefUnit, 253 0, FieldSize, FieldAlign, 254 FieldOffset, 0, FieldTy); 255 EltTys.push_back(FieldTy); 256 257 FieldOffset += FieldSize; 258 Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size()); 259 EltTys.clear(); 260 261 EltTy = DebugFactory.CreateCompositeType(Tag, Unit, "__block_descriptor", 262 DefUnit, 0, FieldOffset, 0, 0, 0, 263 llvm::DIType(), Elements); 264 265 // Bit size, align and offset of the type. 266 uint64_t Size = M->getContext().getTypeSize(Ty); 267 uint64_t Align = M->getContext().getTypeAlign(Ty); 268 269 DescTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, 270 Unit, "", llvm::DICompileUnit(), 271 0, Size, Align, 0, 0, EltTy); 272 273 FieldOffset = 0; 274 FType = M->getContext().getPointerType(M->getContext().VoidTy); 275 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 276 FieldSize = M->getContext().getTypeSize(FType); 277 FieldAlign = M->getContext().getTypeAlign(FType); 278 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 279 "__isa", DefUnit, 280 0, FieldSize, FieldAlign, 281 FieldOffset, 0, FieldTy); 282 EltTys.push_back(FieldTy); 283 284 FieldOffset += FieldSize; 285 FType = M->getContext().IntTy; 286 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 287 FieldSize = M->getContext().getTypeSize(FType); 288 FieldAlign = M->getContext().getTypeAlign(FType); 289 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 290 "__flags", DefUnit, 291 0, FieldSize, FieldAlign, 292 FieldOffset, 0, FieldTy); 293 EltTys.push_back(FieldTy); 294 295 FieldOffset += FieldSize; 296 FType = M->getContext().IntTy; 297 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 298 FieldSize = M->getContext().getTypeSize(FType); 299 FieldAlign = M->getContext().getTypeAlign(FType); 300 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 301 "__reserved", DefUnit, 302 0, FieldSize, FieldAlign, 303 FieldOffset, 0, FieldTy); 304 EltTys.push_back(FieldTy); 305 306 FieldOffset += FieldSize; 307 FType = M->getContext().getPointerType(M->getContext().VoidTy); 308 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 309 FieldSize = M->getContext().getTypeSize(FType); 310 FieldAlign = M->getContext().getTypeAlign(FType); 311 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 312 "__FuncPtr", DefUnit, 313 0, FieldSize, FieldAlign, 314 FieldOffset, 0, FieldTy); 315 EltTys.push_back(FieldTy); 316 317 FieldOffset += FieldSize; 318 FType = M->getContext().getPointerType(M->getContext().VoidTy); 319 FieldTy = DescTy; 320 FieldSize = M->getContext().getTypeSize(Ty); 321 FieldAlign = M->getContext().getTypeAlign(Ty); 322 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 323 "__descriptor", DefUnit, 324 0, FieldSize, FieldAlign, 325 FieldOffset, 0, FieldTy); 326 EltTys.push_back(FieldTy); 327 328 FieldOffset += FieldSize; 329 Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size()); 330 331 EltTy = DebugFactory.CreateCompositeType(Tag, Unit, "__block_literal_generic", 332 DefUnit, 0, FieldOffset, 0, 0, 0, 333 llvm::DIType(), Elements); 334 335 BlockLiteralGenericSet = true; 336 BlockLiteralGeneric 337 = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, Unit, 338 "", llvm::DICompileUnit(), 339 0, Size, Align, 0, 0, EltTy); 340 return BlockLiteralGeneric; 341} 342 343llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty, 344 llvm::DICompileUnit Unit) { 345 // Typedefs are derived from some other type. If we have a typedef of a 346 // typedef, make sure to emit the whole chain. 347 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit); 348 349 // We don't set size information, but do specify where the typedef was 350 // declared. 351 std::string TyName = Ty->getDecl()->getNameAsString(); 352 SourceLocation DefLoc = Ty->getDecl()->getLocation(); 353 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc); 354 355 SourceManager &SM = M->getContext().getSourceManager(); 356 PresumedLoc PLoc = SM.getPresumedLoc(DefLoc); 357 unsigned Line = PLoc.isInvalid() ? 0 : PLoc.getLine(); 358 359 return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_typedef, Unit, 360 TyName, DefUnit, Line, 0, 0, 0, 0, Src); 361} 362 363llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty, 364 llvm::DICompileUnit Unit) { 365 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys; 366 367 // Add the result type at least. 368 EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit)); 369 370 // Set up remainder of arguments if there is a prototype. 371 // FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'! 372 if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) { 373 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) 374 EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit)); 375 } else { 376 // FIXME: Handle () case in C. llvm-gcc doesn't do it either. 377 } 378 379 llvm::DIArray EltTypeArray = 380 DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size()); 381 382 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type, 383 Unit, "", llvm::DICompileUnit(), 384 0, 0, 0, 0, 0, 385 llvm::DIType(), EltTypeArray); 386} 387 388/// CreateType - get structure or union type. 389llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty, 390 llvm::DICompileUnit Unit) { 391 RecordDecl *Decl = Ty->getDecl(); 392 393 unsigned Tag; 394 if (Decl->isStruct()) 395 Tag = llvm::dwarf::DW_TAG_structure_type; 396 else if (Decl->isUnion()) 397 Tag = llvm::dwarf::DW_TAG_union_type; 398 else { 399 assert(Decl->isClass() && "Unknown RecordType!"); 400 Tag = llvm::dwarf::DW_TAG_class_type; 401 } 402 403 SourceManager &SM = M->getContext().getSourceManager(); 404 405 // Get overall information about the record type for the debug info. 406 std::string Name = Decl->getNameAsString(); 407 408 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation()); 409 llvm::DICompileUnit DefUnit; 410 unsigned Line = 0; 411 if (!PLoc.isInvalid()) { 412 DefUnit = getOrCreateCompileUnit(Decl->getLocation()); 413 Line = PLoc.getLine(); 414 } 415 416 // Records and classes and unions can all be recursive. To handle them, we 417 // first generate a debug descriptor for the struct as a forward declaration. 418 // Then (if it is a definition) we go through and get debug info for all of 419 // its members. Finally, we create a descriptor for the complete type (which 420 // may refer to the forward decl if the struct is recursive) and replace all 421 // uses of the forward declaration with the final definition. 422 llvm::DIType FwdDecl = 423 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0, 424 llvm::DIType(), llvm::DIArray()); 425 426 // If this is just a forward declaration, return it. 427 if (!Decl->getDefinition(M->getContext())) 428 return FwdDecl; 429 430 // Otherwise, insert it into the TypeCache so that recursive uses will find 431 // it. 432 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl; 433 434 // Convert all the elements. 435 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys; 436 437 const ASTRecordLayout &RL = M->getContext().getASTRecordLayout(Decl); 438 439 unsigned FieldNo = 0; 440 for (RecordDecl::field_iterator I = Decl->field_begin(), 441 E = Decl->field_end(); 442 I != E; ++I, ++FieldNo) { 443 FieldDecl *Field = *I; 444 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit); 445 446 std::string FieldName = Field->getNameAsString(); 447 448 // Ignore unnamed fields. 449 if (FieldName.empty()) 450 continue; 451 452 // Get the location for the field. 453 SourceLocation FieldDefLoc = Field->getLocation(); 454 PresumedLoc PLoc = SM.getPresumedLoc(FieldDefLoc); 455 llvm::DICompileUnit FieldDefUnit; 456 unsigned FieldLine = 0; 457 458 if (!PLoc.isInvalid()) { 459 FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc); 460 FieldLine = PLoc.getLine(); 461 } 462 463 QualType FType = Field->getType(); 464 uint64_t FieldSize = 0; 465 unsigned FieldAlign = 0; 466 if (!FType->isIncompleteArrayType()) { 467 468 // Bit size, align and offset of the type. 469 FieldSize = M->getContext().getTypeSize(FType); 470 Expr *BitWidth = Field->getBitWidth(); 471 if (BitWidth) 472 FieldSize = BitWidth->EvaluateAsInt(M->getContext()).getZExtValue(); 473 474 FieldAlign = M->getContext().getTypeAlign(FType); 475 } 476 477 uint64_t FieldOffset = RL.getFieldOffset(FieldNo); 478 479 // Create a DW_TAG_member node to remember the offset of this field in the 480 // struct. FIXME: This is an absolutely insane way to capture this 481 // information. When we gut debug info, this should be fixed. 482 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 483 FieldName, FieldDefUnit, 484 FieldLine, FieldSize, FieldAlign, 485 FieldOffset, 0, FieldTy); 486 EltTys.push_back(FieldTy); 487 } 488 489 llvm::DIArray Elements = 490 DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size()); 491 492 // Bit size, align and offset of the type. 493 uint64_t Size = M->getContext().getTypeSize(Ty); 494 uint64_t Align = M->getContext().getTypeAlign(Ty); 495 496 llvm::DIType RealDecl = 497 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size, 498 Align, 0, 0, llvm::DIType(), Elements); 499 500 // Now that we have a real decl for the struct, replace anything using the 501 // old decl with the new one. This will recursively update the debug info. 502 FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV()); 503 FwdDecl.getGV()->eraseFromParent(); 504 505 return RealDecl; 506} 507 508/// CreateType - get objective-c interface type. 509llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, 510 llvm::DICompileUnit Unit) { 511 ObjCInterfaceDecl *Decl = Ty->getDecl(); 512 513 unsigned Tag = llvm::dwarf::DW_TAG_structure_type; 514 SourceManager &SM = M->getContext().getSourceManager(); 515 516 // Get overall information about the record type for the debug info. 517 std::string Name = Decl->getNameAsString(); 518 519 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation()); 520 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation()); 521 unsigned Line = PLoc.isInvalid() ? 0 : PLoc.getLine(); 522 523 524 unsigned RuntimeLang = DefUnit.getLanguage(); 525 526 // To handle recursive interface, we 527 // first generate a debug descriptor for the struct as a forward declaration. 528 // Then (if it is a definition) we go through and get debug info for all of 529 // its members. Finally, we create a descriptor for the complete type (which 530 // may refer to the forward decl if the struct is recursive) and replace all 531 // uses of the forward declaration with the final definition. 532 llvm::DIType FwdDecl = 533 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0, 534 llvm::DIType(), llvm::DIArray(), 535 RuntimeLang); 536 537 // If this is just a forward declaration, return it. 538 if (Decl->isForwardDecl()) 539 return FwdDecl; 540 541 // Otherwise, insert it into the TypeCache so that recursive uses will find 542 // it. 543 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl; 544 545 // Convert all the elements. 546 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys; 547 548 ObjCInterfaceDecl *SClass = Decl->getSuperClass(); 549 if (SClass) { 550 llvm::DIType SClassTy = 551 getOrCreateType(M->getContext().getObjCInterfaceType(SClass), Unit); 552 llvm::DIType InhTag = 553 DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_inheritance, 554 Unit, "", llvm::DICompileUnit(), 0, 0, 0, 555 0 /* offset */, 0, SClassTy); 556 EltTys.push_back(InhTag); 557 } 558 559 const ASTRecordLayout &RL = M->getContext().getASTObjCInterfaceLayout(Decl); 560 561 unsigned FieldNo = 0; 562 for (ObjCInterfaceDecl::ivar_iterator I = Decl->ivar_begin(), 563 E = Decl->ivar_end(); I != E; ++I, ++FieldNo) { 564 ObjCIvarDecl *Field = *I; 565 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit); 566 567 std::string FieldName = Field->getNameAsString(); 568 569 // Ignore unnamed fields. 570 if (FieldName.empty()) 571 continue; 572 573 // Get the location for the field. 574 SourceLocation FieldDefLoc = Field->getLocation(); 575 llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc); 576 PresumedLoc PLoc = SM.getPresumedLoc(FieldDefLoc); 577 unsigned FieldLine = PLoc.isInvalid() ? 0 : PLoc.getLine(); 578 579 580 QualType FType = Field->getType(); 581 uint64_t FieldSize = 0; 582 unsigned FieldAlign = 0; 583 584 if (!FType->isIncompleteArrayType()) { 585 586 // Bit size, align and offset of the type. 587 FieldSize = M->getContext().getTypeSize(FType); 588 Expr *BitWidth = Field->getBitWidth(); 589 if (BitWidth) 590 FieldSize = BitWidth->EvaluateAsInt(M->getContext()).getZExtValue(); 591 592 FieldAlign = M->getContext().getTypeAlign(FType); 593 } 594 595 uint64_t FieldOffset = RL.getFieldOffset(FieldNo); 596 597 unsigned Flags = 0; 598 if (Field->getAccessControl() == ObjCIvarDecl::Protected) 599 Flags = llvm::DIType::FlagProtected; 600 else if (Field->getAccessControl() == ObjCIvarDecl::Private) 601 Flags = llvm::DIType::FlagPrivate; 602 603 // Create a DW_TAG_member node to remember the offset of this field in the 604 // struct. FIXME: This is an absolutely insane way to capture this 605 // information. When we gut debug info, this should be fixed. 606 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit, 607 FieldName, FieldDefUnit, 608 FieldLine, FieldSize, FieldAlign, 609 FieldOffset, Flags, FieldTy); 610 EltTys.push_back(FieldTy); 611 } 612 613 llvm::DIArray Elements = 614 DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size()); 615 616 // Bit size, align and offset of the type. 617 uint64_t Size = M->getContext().getTypeSize(Ty); 618 uint64_t Align = M->getContext().getTypeAlign(Ty); 619 620 llvm::DIType RealDecl = 621 DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size, 622 Align, 0, 0, llvm::DIType(), Elements, 623 RuntimeLang); 624 625 // Now that we have a real decl for the struct, replace anything using the 626 // old decl with the new one. This will recursively update the debug info. 627 FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV()); 628 FwdDecl.getGV()->eraseFromParent(); 629 630 return RealDecl; 631} 632 633llvm::DIType CGDebugInfo::CreateType(const EnumType *Ty, 634 llvm::DICompileUnit Unit) { 635 EnumDecl *Decl = Ty->getDecl(); 636 637 llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators; 638 639 // Create DIEnumerator elements for each enumerator. 640 for (EnumDecl::enumerator_iterator 641 Enum = Decl->enumerator_begin(), EnumEnd = Decl->enumerator_end(); 642 Enum != EnumEnd; ++Enum) { 643 Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getNameAsString(), 644 Enum->getInitVal().getZExtValue())); 645 } 646 647 // Return a CompositeType for the enum itself. 648 llvm::DIArray EltArray = 649 DebugFactory.GetOrCreateArray(Enumerators.data(), Enumerators.size()); 650 651 std::string EnumName = Decl->getNameAsString(); 652 SourceLocation DefLoc = Decl->getLocation(); 653 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc); 654 SourceManager &SM = M->getContext().getSourceManager(); 655 PresumedLoc PLoc = SM.getPresumedLoc(DefLoc); 656 unsigned Line = PLoc.isInvalid() ? 0 : PLoc.getLine(); 657 658 659 // Size and align of the type. 660 uint64_t Size = 0; 661 unsigned Align = 0; 662 if (!Ty->isIncompleteType()) { 663 Size = M->getContext().getTypeSize(Ty); 664 Align = M->getContext().getTypeAlign(Ty); 665 } 666 667 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_enumeration_type, 668 Unit, EnumName, DefUnit, Line, 669 Size, Align, 0, 0, 670 llvm::DIType(), EltArray); 671} 672 673llvm::DIType CGDebugInfo::CreateType(const TagType *Ty, 674 llvm::DICompileUnit Unit) { 675 if (const RecordType *RT = dyn_cast<RecordType>(Ty)) 676 return CreateType(RT, Unit); 677 else if (const EnumType *ET = dyn_cast<EnumType>(Ty)) 678 return CreateType(ET, Unit); 679 680 return llvm::DIType(); 681} 682 683llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty, 684 llvm::DICompileUnit Unit) { 685 uint64_t Size; 686 uint64_t Align; 687 688 689 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types 690 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) { 691 Size = 0; 692 Align = 693 M->getContext().getTypeAlign(M->getContext().getBaseElementType(VAT)); 694 } else if (Ty->isIncompleteArrayType()) { 695 Size = 0; 696 Align = M->getContext().getTypeAlign(Ty->getElementType()); 697 } else { 698 // Size and align of the whole array, not the element type. 699 Size = M->getContext().getTypeSize(Ty); 700 Align = M->getContext().getTypeAlign(Ty); 701 } 702 703 // Add the dimensions of the array. FIXME: This loses CV qualifiers from 704 // interior arrays, do we care? Why aren't nested arrays represented the 705 // obvious/recursive way? 706 llvm::SmallVector<llvm::DIDescriptor, 8> Subscripts; 707 QualType EltTy(Ty, 0); 708 while ((Ty = dyn_cast<ArrayType>(EltTy))) { 709 uint64_t Upper = 0; 710 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty)) 711 Upper = CAT->getSize().getZExtValue() - 1; 712 // FIXME: Verify this is right for VLAs. 713 Subscripts.push_back(DebugFactory.GetOrCreateSubrange(0, Upper)); 714 EltTy = Ty->getElementType(); 715 } 716 717 llvm::DIArray SubscriptArray = 718 DebugFactory.GetOrCreateArray(Subscripts.data(), Subscripts.size()); 719 720 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_array_type, 721 Unit, "", llvm::DICompileUnit(), 722 0, Size, Align, 0, 0, 723 getOrCreateType(EltTy, Unit), 724 SubscriptArray); 725} 726 727 728/// getOrCreateType - Get the type from the cache or create a new 729/// one if necessary. 730llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, 731 llvm::DICompileUnit Unit) { 732 if (Ty.isNull()) 733 return llvm::DIType(); 734 735 // Check TypeCache first. 736 llvm::DIType &Slot = TypeCache[Ty.getAsOpaquePtr()]; 737 if (!Slot.isNull()) return Slot; 738 739 // Handle CVR qualifiers, which recursively handles what they refer to. 740 if (Ty.getCVRQualifiers()) 741 return Slot = CreateCVRType(Ty, Unit); 742 743 // Work out details of type. 744 switch (Ty->getTypeClass()) { 745#define TYPE(Class, Base) 746#define ABSTRACT_TYPE(Class, Base) 747#define NON_CANONICAL_TYPE(Class, Base) 748#define DEPENDENT_TYPE(Class, Base) case Type::Class: 749#include "clang/AST/TypeNodes.def" 750 assert(false && "Dependent types cannot show up in debug information"); 751 752 case Type::LValueReference: 753 case Type::RValueReference: 754 case Type::Vector: 755 case Type::ExtVector: 756 case Type::ExtQual: 757 case Type::FixedWidthInt: 758 case Type::MemberPointer: 759 case Type::TemplateSpecialization: 760 case Type::QualifiedName: 761 // Unsupported types 762 return llvm::DIType(); 763 case Type::ObjCObjectPointer: // Encode id<p> in debug info just like id. 764 { 765 ObjCObjectPointerType *OPT = cast<ObjCObjectPointerType>(Ty); 766 return Slot = CreateType(OPT->getInterfaceType(), Unit); 767 } 768 case Type::ObjCQualifiedInterface: // Drop protocols from interface. 769 case Type::ObjCInterface: 770 return Slot = CreateType(cast<ObjCInterfaceType>(Ty), Unit); 771 case Type::Builtin: return Slot = CreateType(cast<BuiltinType>(Ty), Unit); 772 case Type::Complex: return Slot = CreateType(cast<ComplexType>(Ty), Unit); 773 case Type::Pointer: return Slot = CreateType(cast<PointerType>(Ty), Unit); 774 case Type::BlockPointer: 775 return Slot = CreateType(cast<BlockPointerType>(Ty), Unit); 776 case Type::Typedef: return Slot = CreateType(cast<TypedefType>(Ty), Unit); 777 case Type::Record: 778 case Type::Enum: 779 return Slot = CreateType(cast<TagType>(Ty), Unit); 780 case Type::FunctionProto: 781 case Type::FunctionNoProto: 782 return Slot = CreateType(cast<FunctionType>(Ty), Unit); 783 784 case Type::ConstantArray: 785 case Type::ConstantArrayWithExpr: 786 case Type::ConstantArrayWithoutExpr: 787 case Type::VariableArray: 788 case Type::IncompleteArray: 789 return Slot = CreateType(cast<ArrayType>(Ty), Unit); 790 case Type::TypeOfExpr: 791 return Slot = getOrCreateType(cast<TypeOfExprType>(Ty)->getUnderlyingExpr() 792 ->getType(), Unit); 793 case Type::TypeOf: 794 return Slot = getOrCreateType(cast<TypeOfType>(Ty)->getUnderlyingType(), 795 Unit); 796 case Type::Decltype: 797 return Slot = getOrCreateType(cast<DecltypeType>(Ty)->getUnderlyingType(), 798 Unit); 799 } 800 801 return Slot; 802} 803 804/// EmitFunctionStart - Constructs the debug code for entering a function - 805/// "llvm.dbg.func.start.". 806void CGDebugInfo::EmitFunctionStart(const char *Name, QualType ReturnType, 807 llvm::Function *Fn, 808 CGBuilderTy &Builder) { 809 const char *LinkageName = Name; 810 811 // Skip the asm prefix if it exists. 812 // 813 // FIXME: This should probably be the unmangled name? 814 if (Name[0] == '\01') 815 ++Name; 816 817 // FIXME: Why is this using CurLoc??? 818 llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc); 819 SourceManager &SM = M->getContext().getSourceManager(); 820 unsigned LineNo = SM.getPresumedLoc(CurLoc).getLine(); 821 822 llvm::DISubprogram SP = 823 DebugFactory.CreateSubprogram(Unit, Name, Name, LinkageName, Unit, LineNo, 824 getOrCreateType(ReturnType, Unit), 825 Fn->hasInternalLinkage(), true/*definition*/); 826 827 DebugFactory.InsertSubprogramStart(SP, Builder.GetInsertBlock()); 828 829 // Push function on region stack. 830 RegionStack.push_back(SP); 831} 832 833 834void CGDebugInfo::EmitStopPoint(llvm::Function *Fn, CGBuilderTy &Builder) { 835 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return; 836 837 // Don't bother if things are the same as last time. 838 SourceManager &SM = M->getContext().getSourceManager(); 839 if (CurLoc == PrevLoc 840 || (SM.getInstantiationLineNumber(CurLoc) == 841 SM.getInstantiationLineNumber(PrevLoc) 842 && SM.isFromSameFile(CurLoc, PrevLoc))) 843 return; 844 845 // Update last state. 846 PrevLoc = CurLoc; 847 848 // Get the appropriate compile unit. 849 llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc); 850 PresumedLoc PLoc = SM.getPresumedLoc(CurLoc); 851 DebugFactory.InsertStopPoint(Unit, PLoc.getLine(), PLoc.getColumn(), 852 Builder.GetInsertBlock()); 853} 854 855/// EmitRegionStart- Constructs the debug code for entering a declarative 856/// region - "llvm.dbg.region.start.". 857void CGDebugInfo::EmitRegionStart(llvm::Function *Fn, CGBuilderTy &Builder) { 858 llvm::DIDescriptor D; 859 if (!RegionStack.empty()) 860 D = RegionStack.back(); 861 D = DebugFactory.CreateBlock(D); 862 RegionStack.push_back(D); 863 DebugFactory.InsertRegionStart(D, Builder.GetInsertBlock()); 864} 865 866/// EmitRegionEnd - Constructs the debug code for exiting a declarative 867/// region - "llvm.dbg.region.end." 868void CGDebugInfo::EmitRegionEnd(llvm::Function *Fn, CGBuilderTy &Builder) { 869 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!"); 870 871 // Provide an region stop point. 872 EmitStopPoint(Fn, Builder); 873 874 DebugFactory.InsertRegionEnd(RegionStack.back(), Builder.GetInsertBlock()); 875 RegionStack.pop_back(); 876} 877 878/// EmitDeclare - Emit local variable declaration debug info. 879void CGDebugInfo::EmitDeclare(const VarDecl *Decl, unsigned Tag, 880 llvm::Value *Storage, CGBuilderTy &Builder) { 881 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!"); 882 883 // Do not emit variable debug information while generating optimized code. 884 // The llvm optimizer and code generator are not yet ready to support 885 // optimized code debugging. 886 const CompileOptions &CO = M->getCompileOpts(); 887 if (CO.OptimizationLevel) 888 return; 889 890 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation()); 891 llvm::DIType Ty = getOrCreateType(Decl->getType(), Unit); 892 893 // Get location information. 894 SourceManager &SM = M->getContext().getSourceManager(); 895 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation()); 896 unsigned Line = 0; 897 if (!PLoc.isInvalid()) 898 Line = PLoc.getLine(); 899 else 900 Unit = llvm::DICompileUnit(); 901 902 903 // Create the descriptor for the variable. 904 llvm::DIVariable D = 905 DebugFactory.CreateVariable(Tag, RegionStack.back(),Decl->getNameAsString(), 906 Unit, Line, Ty); 907 // Insert an llvm.dbg.declare into the current block. 908 DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock()); 909} 910 911void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *Decl, 912 llvm::Value *Storage, 913 CGBuilderTy &Builder) { 914 EmitDeclare(Decl, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder); 915} 916 917/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument 918/// variable declaration. 919void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI, 920 CGBuilderTy &Builder) { 921 EmitDeclare(Decl, llvm::dwarf::DW_TAG_arg_variable, AI, Builder); 922} 923 924 925 926/// EmitGlobalVariable - Emit information about a global variable. 927void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, 928 const VarDecl *Decl) { 929 930 // Do not emit variable debug information while generating optimized code. 931 // The llvm optimizer and code generator are not yet ready to support 932 // optimized code debugging. 933 const CompileOptions &CO = M->getCompileOpts(); 934 if (CO.OptimizationLevel) 935 return; 936 937 // Create global variable debug descriptor. 938 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation()); 939 SourceManager &SM = M->getContext().getSourceManager(); 940 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation()); 941 unsigned LineNo = PLoc.isInvalid() ? 0 : PLoc.getLine(); 942 943 std::string Name = Decl->getNameAsString(); 944 945 QualType T = Decl->getType(); 946 if (T->isIncompleteArrayType()) { 947 948 // CodeGen turns int[] into int[1] so we'll do the same here. 949 llvm::APSInt ConstVal(32); 950 951 ConstVal = 1; 952 QualType ET = M->getContext().getAsArrayType(T)->getElementType(); 953 954 T = M->getContext().getConstantArrayType(ET, ConstVal, 955 ArrayType::Normal, 0); 956 } 957 958 DebugFactory.CreateGlobalVariable(Unit, Name, Name, "", Unit, LineNo, 959 getOrCreateType(T, Unit), 960 Var->hasInternalLinkage(), 961 true/*definition*/, Var); 962} 963 964/// EmitGlobalVariable - Emit information about an objective-c interface. 965void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, 966 ObjCInterfaceDecl *Decl) { 967 // Create global variable debug descriptor. 968 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation()); 969 SourceManager &SM = M->getContext().getSourceManager(); 970 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation()); 971 unsigned LineNo = PLoc.isInvalid() ? 0 : PLoc.getLine(); 972 973 std::string Name = Decl->getNameAsString(); 974 975 QualType T = M->getContext().getObjCInterfaceType(Decl); 976 if (T->isIncompleteArrayType()) { 977 978 // CodeGen turns int[] into int[1] so we'll do the same here. 979 llvm::APSInt ConstVal(32); 980 981 ConstVal = 1; 982 QualType ET = M->getContext().getAsArrayType(T)->getElementType(); 983 984 T = M->getContext().getConstantArrayType(ET, ConstVal, 985 ArrayType::Normal, 0); 986 } 987 988 DebugFactory.CreateGlobalVariable(Unit, Name, Name, "", Unit, LineNo, 989 getOrCreateType(T, Unit), 990 Var->hasInternalLinkage(), 991 true/*definition*/, Var); 992} 993 994