CGDebugInfo.cpp revision 0a0be741f21e75556f649e7e4fcd30e905fc6e2e
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 "CGBlocks.h" 16#include "CGCXXABI.h" 17#include "CGObjCRuntime.h" 18#include "CodeGenFunction.h" 19#include "CodeGenModule.h" 20#include "clang/AST/ASTContext.h" 21#include "clang/AST/DeclFriend.h" 22#include "clang/AST/DeclObjC.h" 23#include "clang/AST/DeclTemplate.h" 24#include "clang/AST/Expr.h" 25#include "clang/AST/RecordLayout.h" 26#include "clang/Basic/FileManager.h" 27#include "clang/Basic/SourceManager.h" 28#include "clang/Basic/Version.h" 29#include "clang/Frontend/CodeGenOptions.h" 30#include "llvm/ADT/SmallVector.h" 31#include "llvm/ADT/StringExtras.h" 32#include "llvm/IR/Constants.h" 33#include "llvm/IR/DataLayout.h" 34#include "llvm/IR/DerivedTypes.h" 35#include "llvm/IR/Instructions.h" 36#include "llvm/IR/Intrinsics.h" 37#include "llvm/IR/Module.h" 38#include "llvm/Support/Dwarf.h" 39#include "llvm/Support/FileSystem.h" 40using namespace clang; 41using namespace clang::CodeGen; 42 43CGDebugInfo::CGDebugInfo(CodeGenModule &CGM) 44 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()), 45 DBuilder(CGM.getModule()) { 46 CreateCompileUnit(); 47} 48 49CGDebugInfo::~CGDebugInfo() { 50 assert(LexicalBlockStack.empty() && 51 "Region stack mismatch, stack not empty!"); 52} 53 54 55NoLocation::NoLocation(CodeGenFunction &CGF, CGBuilderTy &B) 56 : DI(CGF.getDebugInfo()), Builder(B) { 57 if (DI) { 58 SavedLoc = DI->getLocation(); 59 DI->CurLoc = SourceLocation(); 60 Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 61 } 62} 63 64NoLocation::~NoLocation() { 65 if (DI) { 66 assert(Builder.getCurrentDebugLocation().isUnknown()); 67 DI->CurLoc = SavedLoc; 68 } 69} 70 71ArtificialLocation::ArtificialLocation(CodeGenFunction &CGF, CGBuilderTy &B) 72 : DI(CGF.getDebugInfo()), Builder(B) { 73 if (DI) { 74 SavedLoc = DI->getLocation(); 75 DI->CurLoc = SourceLocation(); 76 Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 77 } 78} 79 80void ArtificialLocation::Emit() { 81 if (DI) { 82 // Sync the Builder. 83 DI->EmitLocation(Builder, SavedLoc); 84 DI->CurLoc = SourceLocation(); 85 // Construct a location that has a valid scope, but no line info. 86 assert(!DI->LexicalBlockStack.empty()); 87 llvm::DIDescriptor Scope(DI->LexicalBlockStack.back()); 88 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(0, 0, Scope)); 89 } 90} 91 92ArtificialLocation::~ArtificialLocation() { 93 if (DI) { 94 assert(Builder.getCurrentDebugLocation().getLine() == 0); 95 DI->CurLoc = SavedLoc; 96 } 97} 98 99void CGDebugInfo::setLocation(SourceLocation Loc) { 100 // If the new location isn't valid return. 101 if (Loc.isInvalid()) return; 102 103 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc); 104 105 // If we've changed files in the middle of a lexical scope go ahead 106 // and create a new lexical scope with file node if it's different 107 // from the one in the scope. 108 if (LexicalBlockStack.empty()) return; 109 110 SourceManager &SM = CGM.getContext().getSourceManager(); 111 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc); 112 PresumedLoc PPLoc = SM.getPresumedLoc(PrevLoc); 113 114 if (PCLoc.isInvalid() || PPLoc.isInvalid() || 115 !strcmp(PPLoc.getFilename(), PCLoc.getFilename())) 116 return; 117 118 llvm::MDNode *LB = LexicalBlockStack.back(); 119 llvm::DIScope Scope = llvm::DIScope(LB); 120 if (Scope.isLexicalBlockFile()) { 121 llvm::DILexicalBlockFile LBF = llvm::DILexicalBlockFile(LB); 122 llvm::DIDescriptor D 123 = DBuilder.createLexicalBlockFile(LBF.getScope(), 124 getOrCreateFile(CurLoc)); 125 llvm::MDNode *N = D; 126 LexicalBlockStack.pop_back(); 127 LexicalBlockStack.push_back(N); 128 } else if (Scope.isLexicalBlock() || Scope.isSubprogram()) { 129 llvm::DIDescriptor D 130 = DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)); 131 llvm::MDNode *N = D; 132 LexicalBlockStack.pop_back(); 133 LexicalBlockStack.push_back(N); 134 } 135} 136 137/// getContextDescriptor - Get context info for the decl. 138llvm::DIScope CGDebugInfo::getContextDescriptor(const Decl *Context) { 139 if (!Context) 140 return TheCU; 141 142 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator 143 I = RegionMap.find(Context); 144 if (I != RegionMap.end()) { 145 llvm::Value *V = I->second; 146 return llvm::DIScope(dyn_cast_or_null<llvm::MDNode>(V)); 147 } 148 149 // Check namespace. 150 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context)) 151 return getOrCreateNameSpace(NSDecl); 152 153 if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context)) 154 if (!RDecl->isDependentType()) 155 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl), 156 getOrCreateMainFile()); 157 return TheCU; 158} 159 160/// getFunctionName - Get function name for the given FunctionDecl. If the 161/// name is constructred on demand (e.g. C++ destructor) then the name 162/// is stored on the side. 163StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) { 164 assert (FD && "Invalid FunctionDecl!"); 165 IdentifierInfo *FII = FD->getIdentifier(); 166 FunctionTemplateSpecializationInfo *Info 167 = FD->getTemplateSpecializationInfo(); 168 if (!Info && FII) 169 return FII->getName(); 170 171 // Otherwise construct human readable name for debug info. 172 SmallString<128> NS; 173 llvm::raw_svector_ostream OS(NS); 174 FD->printName(OS); 175 176 // Add any template specialization args. 177 if (Info) { 178 const TemplateArgumentList *TArgs = Info->TemplateArguments; 179 const TemplateArgument *Args = TArgs->data(); 180 unsigned NumArgs = TArgs->size(); 181 PrintingPolicy Policy(CGM.getLangOpts()); 182 TemplateSpecializationType::PrintTemplateArgumentList(OS, Args, NumArgs, 183 Policy); 184 } 185 186 // Copy this name on the side and use its reference. 187 OS.flush(); 188 char *StrPtr = DebugInfoNames.Allocate<char>(NS.size()); 189 memcpy(StrPtr, NS.data(), NS.size()); 190 return StringRef(StrPtr, NS.size()); 191} 192 193StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) { 194 SmallString<256> MethodName; 195 llvm::raw_svector_ostream OS(MethodName); 196 OS << (OMD->isInstanceMethod() ? '-' : '+') << '['; 197 const DeclContext *DC = OMD->getDeclContext(); 198 if (const ObjCImplementationDecl *OID = 199 dyn_cast<const ObjCImplementationDecl>(DC)) { 200 OS << OID->getName(); 201 } else if (const ObjCInterfaceDecl *OID = 202 dyn_cast<const ObjCInterfaceDecl>(DC)) { 203 OS << OID->getName(); 204 } else if (const ObjCCategoryImplDecl *OCD = 205 dyn_cast<const ObjCCategoryImplDecl>(DC)){ 206 OS << ((const NamedDecl *)OCD)->getIdentifier()->getNameStart() << '(' << 207 OCD->getIdentifier()->getNameStart() << ')'; 208 } else if (isa<ObjCProtocolDecl>(DC)) { 209 // We can extract the type of the class from the self pointer. 210 if (ImplicitParamDecl* SelfDecl = OMD->getSelfDecl()) { 211 QualType ClassTy = 212 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType(); 213 ClassTy.print(OS, PrintingPolicy(LangOptions())); 214 } 215 } 216 OS << ' ' << OMD->getSelector().getAsString() << ']'; 217 218 char *StrPtr = DebugInfoNames.Allocate<char>(OS.tell()); 219 memcpy(StrPtr, MethodName.begin(), OS.tell()); 220 return StringRef(StrPtr, OS.tell()); 221} 222 223/// getSelectorName - Return selector name. This is used for debugging 224/// info. 225StringRef CGDebugInfo::getSelectorName(Selector S) { 226 const std::string &SName = S.getAsString(); 227 char *StrPtr = DebugInfoNames.Allocate<char>(SName.size()); 228 memcpy(StrPtr, SName.data(), SName.size()); 229 return StringRef(StrPtr, SName.size()); 230} 231 232/// getClassName - Get class name including template argument list. 233StringRef 234CGDebugInfo::getClassName(const RecordDecl *RD) { 235 const ClassTemplateSpecializationDecl *Spec 236 = dyn_cast<ClassTemplateSpecializationDecl>(RD); 237 if (!Spec) 238 return RD->getName(); 239 240 const TemplateArgument *Args; 241 unsigned NumArgs; 242 if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) { 243 const TemplateSpecializationType *TST = 244 cast<TemplateSpecializationType>(TAW->getType()); 245 Args = TST->getArgs(); 246 NumArgs = TST->getNumArgs(); 247 } else { 248 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 249 Args = TemplateArgs.data(); 250 NumArgs = TemplateArgs.size(); 251 } 252 StringRef Name = RD->getIdentifier()->getName(); 253 PrintingPolicy Policy(CGM.getLangOpts()); 254 SmallString<128> TemplateArgList; 255 { 256 llvm::raw_svector_ostream OS(TemplateArgList); 257 TemplateSpecializationType::PrintTemplateArgumentList(OS, Args, NumArgs, 258 Policy); 259 } 260 261 // Copy this name on the side and use its reference. 262 size_t Length = Name.size() + TemplateArgList.size(); 263 char *StrPtr = DebugInfoNames.Allocate<char>(Length); 264 memcpy(StrPtr, Name.data(), Name.size()); 265 memcpy(StrPtr + Name.size(), TemplateArgList.data(), TemplateArgList.size()); 266 return StringRef(StrPtr, Length); 267} 268 269/// getOrCreateFile - Get the file debug info descriptor for the input location. 270llvm::DIFile CGDebugInfo::getOrCreateFile(SourceLocation Loc) { 271 if (!Loc.isValid()) 272 // If Location is not valid then use main input file. 273 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory()); 274 275 SourceManager &SM = CGM.getContext().getSourceManager(); 276 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 277 278 if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty()) 279 // If the location is not valid then use main input file. 280 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory()); 281 282 // Cache the results. 283 const char *fname = PLoc.getFilename(); 284 llvm::DenseMap<const char *, llvm::WeakVH>::iterator it = 285 DIFileCache.find(fname); 286 287 if (it != DIFileCache.end()) { 288 // Verify that the information still exists. 289 if (llvm::Value *V = it->second) 290 return llvm::DIFile(cast<llvm::MDNode>(V)); 291 } 292 293 llvm::DIFile F = DBuilder.createFile(PLoc.getFilename(), getCurrentDirname()); 294 295 DIFileCache[fname] = F; 296 return F; 297} 298 299/// getOrCreateMainFile - Get the file info for main compile unit. 300llvm::DIFile CGDebugInfo::getOrCreateMainFile() { 301 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory()); 302} 303 304/// getLineNumber - Get line number for the location. If location is invalid 305/// then use current location. 306unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) { 307 if (Loc.isInvalid() && CurLoc.isInvalid()) 308 return 0; 309 SourceManager &SM = CGM.getContext().getSourceManager(); 310 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc); 311 return PLoc.isValid()? PLoc.getLine() : 0; 312} 313 314/// getColumnNumber - Get column number for the location. 315unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) { 316 // We may not want column information at all. 317 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo) 318 return 0; 319 320 // If the location is invalid then use the current column. 321 if (Loc.isInvalid() && CurLoc.isInvalid()) 322 return 0; 323 SourceManager &SM = CGM.getContext().getSourceManager(); 324 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc); 325 return PLoc.isValid()? PLoc.getColumn() : 0; 326} 327 328StringRef CGDebugInfo::getCurrentDirname() { 329 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty()) 330 return CGM.getCodeGenOpts().DebugCompilationDir; 331 332 if (!CWDName.empty()) 333 return CWDName; 334 SmallString<256> CWD; 335 llvm::sys::fs::current_path(CWD); 336 char *CompDirnamePtr = DebugInfoNames.Allocate<char>(CWD.size()); 337 memcpy(CompDirnamePtr, CWD.data(), CWD.size()); 338 return CWDName = StringRef(CompDirnamePtr, CWD.size()); 339} 340 341/// CreateCompileUnit - Create new compile unit. 342void CGDebugInfo::CreateCompileUnit() { 343 344 // Get absolute path name. 345 SourceManager &SM = CGM.getContext().getSourceManager(); 346 std::string MainFileName = CGM.getCodeGenOpts().MainFileName; 347 if (MainFileName.empty()) 348 MainFileName = "<unknown>"; 349 350 // The main file name provided via the "-main-file-name" option contains just 351 // the file name itself with no path information. This file name may have had 352 // a relative path, so we look into the actual file entry for the main 353 // file to determine the real absolute path for the file. 354 std::string MainFileDir; 355 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 356 MainFileDir = MainFile->getDir()->getName(); 357 if (MainFileDir != ".") 358 MainFileName = MainFileDir + "/" + MainFileName; 359 } 360 361 // Save filename string. 362 char *FilenamePtr = DebugInfoNames.Allocate<char>(MainFileName.length()); 363 memcpy(FilenamePtr, MainFileName.c_str(), MainFileName.length()); 364 StringRef Filename(FilenamePtr, MainFileName.length()); 365 366 // Save split dwarf file string. 367 std::string SplitDwarfFile = CGM.getCodeGenOpts().SplitDwarfFile; 368 char *SplitDwarfPtr = DebugInfoNames.Allocate<char>(SplitDwarfFile.length()); 369 memcpy(SplitDwarfPtr, SplitDwarfFile.c_str(), SplitDwarfFile.length()); 370 StringRef SplitDwarfFilename(SplitDwarfPtr, SplitDwarfFile.length()); 371 372 unsigned LangTag; 373 const LangOptions &LO = CGM.getLangOpts(); 374 if (LO.CPlusPlus) { 375 if (LO.ObjC1) 376 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus; 377 else 378 LangTag = llvm::dwarf::DW_LANG_C_plus_plus; 379 } else if (LO.ObjC1) { 380 LangTag = llvm::dwarf::DW_LANG_ObjC; 381 } else if (LO.C99) { 382 LangTag = llvm::dwarf::DW_LANG_C99; 383 } else { 384 LangTag = llvm::dwarf::DW_LANG_C89; 385 } 386 387 std::string Producer = getClangFullVersion(); 388 389 // Figure out which version of the ObjC runtime we have. 390 unsigned RuntimeVers = 0; 391 if (LO.ObjC1) 392 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1; 393 394 // Create new compile unit. 395 // FIXME - Eliminate TheCU. 396 TheCU = DBuilder.createCompileUnit(LangTag, Filename, getCurrentDirname(), 397 Producer, LO.Optimize, 398 CGM.getCodeGenOpts().DwarfDebugFlags, 399 RuntimeVers, SplitDwarfFilename); 400} 401 402/// CreateType - Get the Basic type from the cache or create a new 403/// one if necessary. 404llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT) { 405 unsigned Encoding = 0; 406 StringRef BTName; 407 switch (BT->getKind()) { 408#define BUILTIN_TYPE(Id, SingletonId) 409#define PLACEHOLDER_TYPE(Id, SingletonId) \ 410 case BuiltinType::Id: 411#include "clang/AST/BuiltinTypes.def" 412 case BuiltinType::Dependent: 413 llvm_unreachable("Unexpected builtin type"); 414 case BuiltinType::NullPtr: 415 return DBuilder.createNullPtrType(); 416 case BuiltinType::Void: 417 return llvm::DIType(); 418 case BuiltinType::ObjCClass: 419 if (ClassTy) 420 return ClassTy; 421 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, 422 "objc_class", TheCU, 423 getOrCreateMainFile(), 0); 424 return ClassTy; 425 case BuiltinType::ObjCId: { 426 // typedef struct objc_class *Class; 427 // typedef struct objc_object { 428 // Class isa; 429 // } *id; 430 431 if (ObjTy) 432 return ObjTy; 433 434 if (!ClassTy) 435 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, 436 "objc_class", TheCU, 437 getOrCreateMainFile(), 0); 438 439 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); 440 441 llvm::DIType ISATy = DBuilder.createPointerType(ClassTy, Size); 442 443 ObjTy = 444 DBuilder.createStructType(TheCU, "objc_object", getOrCreateMainFile(), 445 0, 0, 0, 0, llvm::DIType(), llvm::DIArray()); 446 447 ObjTy.setTypeArray(DBuilder.getOrCreateArray(&*DBuilder.createMemberType( 448 ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0, 0, ISATy))); 449 return ObjTy; 450 } 451 case BuiltinType::ObjCSel: { 452 if (SelTy) 453 return SelTy; 454 SelTy = 455 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, 456 "objc_selector", TheCU, getOrCreateMainFile(), 457 0); 458 return SelTy; 459 } 460 461 case BuiltinType::OCLImage1d: 462 return getOrCreateStructPtrType("opencl_image1d_t", 463 OCLImage1dDITy); 464 case BuiltinType::OCLImage1dArray: 465 return getOrCreateStructPtrType("opencl_image1d_array_t", 466 OCLImage1dArrayDITy); 467 case BuiltinType::OCLImage1dBuffer: 468 return getOrCreateStructPtrType("opencl_image1d_buffer_t", 469 OCLImage1dBufferDITy); 470 case BuiltinType::OCLImage2d: 471 return getOrCreateStructPtrType("opencl_image2d_t", 472 OCLImage2dDITy); 473 case BuiltinType::OCLImage2dArray: 474 return getOrCreateStructPtrType("opencl_image2d_array_t", 475 OCLImage2dArrayDITy); 476 case BuiltinType::OCLImage3d: 477 return getOrCreateStructPtrType("opencl_image3d_t", 478 OCLImage3dDITy); 479 case BuiltinType::OCLSampler: 480 return DBuilder.createBasicType("opencl_sampler_t", 481 CGM.getContext().getTypeSize(BT), 482 CGM.getContext().getTypeAlign(BT), 483 llvm::dwarf::DW_ATE_unsigned); 484 case BuiltinType::OCLEvent: 485 return getOrCreateStructPtrType("opencl_event_t", 486 OCLEventDITy); 487 488 case BuiltinType::UChar: 489 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break; 490 case BuiltinType::Char_S: 491 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break; 492 case BuiltinType::Char16: 493 case BuiltinType::Char32: Encoding = llvm::dwarf::DW_ATE_UTF; break; 494 case BuiltinType::UShort: 495 case BuiltinType::UInt: 496 case BuiltinType::UInt128: 497 case BuiltinType::ULong: 498 case BuiltinType::WChar_U: 499 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break; 500 case BuiltinType::Short: 501 case BuiltinType::Int: 502 case BuiltinType::Int128: 503 case BuiltinType::Long: 504 case BuiltinType::WChar_S: 505 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break; 506 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break; 507 case BuiltinType::Half: 508 case BuiltinType::Float: 509 case BuiltinType::LongDouble: 510 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break; 511 } 512 513 switch (BT->getKind()) { 514 case BuiltinType::Long: BTName = "long int"; break; 515 case BuiltinType::LongLong: BTName = "long long int"; break; 516 case BuiltinType::ULong: BTName = "long unsigned int"; break; 517 case BuiltinType::ULongLong: BTName = "long long unsigned int"; break; 518 default: 519 BTName = BT->getName(CGM.getLangOpts()); 520 break; 521 } 522 // Bit size, align and offset of the type. 523 uint64_t Size = CGM.getContext().getTypeSize(BT); 524 uint64_t Align = CGM.getContext().getTypeAlign(BT); 525 llvm::DIType DbgTy = 526 DBuilder.createBasicType(BTName, Size, Align, Encoding); 527 return DbgTy; 528} 529 530llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty) { 531 // Bit size, align and offset of the type. 532 unsigned Encoding = llvm::dwarf::DW_ATE_complex_float; 533 if (Ty->isComplexIntegerType()) 534 Encoding = llvm::dwarf::DW_ATE_lo_user; 535 536 uint64_t Size = CGM.getContext().getTypeSize(Ty); 537 uint64_t Align = CGM.getContext().getTypeAlign(Ty); 538 llvm::DIType DbgTy = 539 DBuilder.createBasicType("complex", Size, Align, Encoding); 540 541 return DbgTy; 542} 543 544/// CreateCVRType - Get the qualified type from the cache or create 545/// a new one if necessary. 546llvm::DIType CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DIFile Unit) { 547 QualifierCollector Qc; 548 const Type *T = Qc.strip(Ty); 549 550 // Ignore these qualifiers for now. 551 Qc.removeObjCGCAttr(); 552 Qc.removeAddressSpace(); 553 Qc.removeObjCLifetime(); 554 555 // We will create one Derived type for one qualifier and recurse to handle any 556 // additional ones. 557 unsigned Tag; 558 if (Qc.hasConst()) { 559 Tag = llvm::dwarf::DW_TAG_const_type; 560 Qc.removeConst(); 561 } else if (Qc.hasVolatile()) { 562 Tag = llvm::dwarf::DW_TAG_volatile_type; 563 Qc.removeVolatile(); 564 } else if (Qc.hasRestrict()) { 565 Tag = llvm::dwarf::DW_TAG_restrict_type; 566 Qc.removeRestrict(); 567 } else { 568 assert(Qc.empty() && "Unknown type qualifier for debug info"); 569 return getOrCreateType(QualType(T, 0), Unit); 570 } 571 572 llvm::DIType FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit); 573 574 // No need to fill in the Name, Line, Size, Alignment, Offset in case of 575 // CVR derived types. 576 llvm::DIType DbgTy = DBuilder.createQualifiedType(Tag, FromTy); 577 578 return DbgTy; 579} 580 581llvm::DIType CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty, 582 llvm::DIFile Unit) { 583 584 // The frontend treats 'id' as a typedef to an ObjCObjectType, 585 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the 586 // debug info, we want to emit 'id' in both cases. 587 if (Ty->isObjCQualifiedIdType()) 588 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit); 589 590 llvm::DIType DbgTy = 591 CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty, 592 Ty->getPointeeType(), Unit); 593 return DbgTy; 594} 595 596llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty, 597 llvm::DIFile Unit) { 598 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty, 599 Ty->getPointeeType(), Unit); 600} 601 602// Creates a forward declaration for a RecordDecl in the given context. 603llvm::DICompositeType 604CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty, 605 llvm::DIDescriptor Ctx) { 606 const RecordDecl *RD = Ty->getDecl(); 607 if (llvm::DIType T = getTypeOrNull(CGM.getContext().getRecordType(RD))) 608 return llvm::DICompositeType(T); 609 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation()); 610 unsigned Line = getLineNumber(RD->getLocation()); 611 StringRef RDName = getClassName(RD); 612 613 unsigned Tag = 0; 614 if (RD->isStruct() || RD->isInterface()) 615 Tag = llvm::dwarf::DW_TAG_structure_type; 616 else if (RD->isUnion()) 617 Tag = llvm::dwarf::DW_TAG_union_type; 618 else { 619 assert(RD->isClass()); 620 Tag = llvm::dwarf::DW_TAG_class_type; 621 } 622 623 // Create the type. 624 return DBuilder.createForwardDecl(Tag, RDName, Ctx, DefUnit, Line); 625} 626 627// Walk up the context chain and create forward decls for record decls, 628// and normal descriptors for namespaces. 629llvm::DIDescriptor CGDebugInfo::createContextChain(const Decl *Context) { 630 if (!Context) 631 return TheCU; 632 633 // See if we already have the parent. 634 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator 635 I = RegionMap.find(Context); 636 if (I != RegionMap.end()) { 637 llvm::Value *V = I->second; 638 return llvm::DIDescriptor(dyn_cast_or_null<llvm::MDNode>(V)); 639 } 640 641 // Check namespace. 642 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context)) 643 return llvm::DIDescriptor(getOrCreateNameSpace(NSDecl)); 644 645 if (const RecordDecl *RD = dyn_cast<RecordDecl>(Context)) 646 if (!RD->isDependentType()) 647 return getOrCreateLimitedType( 648 CGM.getContext().getRecordType(RD)->castAs<RecordType>(), 649 getOrCreateMainFile()); 650 return TheCU; 651} 652 653llvm::DIType CGDebugInfo::CreatePointerLikeType(unsigned Tag, 654 const Type *Ty, 655 QualType PointeeTy, 656 llvm::DIFile Unit) { 657 if (Tag == llvm::dwarf::DW_TAG_reference_type || 658 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type) 659 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit)); 660 661 // Bit size, align and offset of the type. 662 // Size is always the size of a pointer. We can't use getTypeSize here 663 // because that does not return the correct value for references. 664 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy); 665 uint64_t Size = CGM.getTarget().getPointerWidth(AS); 666 uint64_t Align = CGM.getContext().getTypeAlign(Ty); 667 668 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size, 669 Align); 670} 671 672llvm::DIType CGDebugInfo::getOrCreateStructPtrType(StringRef Name, 673 llvm::DIType &Cache) { 674 if (Cache) 675 return Cache; 676 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name, 677 TheCU, getOrCreateMainFile(), 0); 678 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); 679 Cache = DBuilder.createPointerType(Cache, Size); 680 return Cache; 681} 682 683llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty, 684 llvm::DIFile Unit) { 685 if (BlockLiteralGeneric) 686 return BlockLiteralGeneric; 687 688 SmallVector<llvm::Value *, 8> EltTys; 689 llvm::DIType FieldTy; 690 QualType FType; 691 uint64_t FieldSize, FieldOffset; 692 unsigned FieldAlign; 693 llvm::DIArray Elements; 694 llvm::DIType EltTy, DescTy; 695 696 FieldOffset = 0; 697 FType = CGM.getContext().UnsignedLongTy; 698 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset)); 699 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset)); 700 701 Elements = DBuilder.getOrCreateArray(EltTys); 702 EltTys.clear(); 703 704 unsigned Flags = llvm::DIDescriptor::FlagAppleBlock; 705 unsigned LineNo = getLineNumber(CurLoc); 706 707 EltTy = DBuilder.createStructType(Unit, "__block_descriptor", 708 Unit, LineNo, FieldOffset, 0, 709 Flags, llvm::DIType(), Elements); 710 711 // Bit size, align and offset of the type. 712 uint64_t Size = CGM.getContext().getTypeSize(Ty); 713 714 DescTy = DBuilder.createPointerType(EltTy, Size); 715 716 FieldOffset = 0; 717 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); 718 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset)); 719 FType = CGM.getContext().IntTy; 720 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset)); 721 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset)); 722 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); 723 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset)); 724 725 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); 726 FieldTy = DescTy; 727 FieldSize = CGM.getContext().getTypeSize(Ty); 728 FieldAlign = CGM.getContext().getTypeAlign(Ty); 729 FieldTy = DBuilder.createMemberType(Unit, "__descriptor", Unit, 730 LineNo, FieldSize, FieldAlign, 731 FieldOffset, 0, FieldTy); 732 EltTys.push_back(FieldTy); 733 734 FieldOffset += FieldSize; 735 Elements = DBuilder.getOrCreateArray(EltTys); 736 737 EltTy = DBuilder.createStructType(Unit, "__block_literal_generic", 738 Unit, LineNo, FieldOffset, 0, 739 Flags, llvm::DIType(), Elements); 740 741 BlockLiteralGeneric = DBuilder.createPointerType(EltTy, Size); 742 return BlockLiteralGeneric; 743} 744 745llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty, llvm::DIFile Unit) { 746 // Typedefs are derived from some other type. If we have a typedef of a 747 // typedef, make sure to emit the whole chain. 748 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit); 749 if (!Src) 750 return llvm::DIType(); 751 // We don't set size information, but do specify where the typedef was 752 // declared. 753 unsigned Line = getLineNumber(Ty->getDecl()->getLocation()); 754 const TypedefNameDecl *TyDecl = Ty->getDecl(); 755 756 llvm::DIDescriptor TypedefContext = 757 getContextDescriptor(cast<Decl>(Ty->getDecl()->getDeclContext())); 758 759 return 760 DBuilder.createTypedef(Src, TyDecl->getName(), Unit, Line, TypedefContext); 761} 762 763llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty, 764 llvm::DIFile Unit) { 765 SmallVector<llvm::Value *, 16> EltTys; 766 767 // Add the result type at least. 768 EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit)); 769 770 // Set up remainder of arguments if there is a prototype. 771 // FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'! 772 if (isa<FunctionNoProtoType>(Ty)) 773 EltTys.push_back(DBuilder.createUnspecifiedParameter()); 774 else if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(Ty)) { 775 for (unsigned i = 0, e = FPT->getNumArgs(); i != e; ++i) 776 EltTys.push_back(getOrCreateType(FPT->getArgType(i), Unit)); 777 } 778 779 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(EltTys); 780 return DBuilder.createSubroutineType(Unit, EltTypeArray); 781} 782 783 784llvm::DIType CGDebugInfo::createFieldType(StringRef name, 785 QualType type, 786 uint64_t sizeInBitsOverride, 787 SourceLocation loc, 788 AccessSpecifier AS, 789 uint64_t offsetInBits, 790 llvm::DIFile tunit, 791 llvm::DIDescriptor scope) { 792 llvm::DIType debugType = getOrCreateType(type, tunit); 793 794 // Get the location for the field. 795 llvm::DIFile file = getOrCreateFile(loc); 796 unsigned line = getLineNumber(loc); 797 798 uint64_t sizeInBits = 0; 799 unsigned alignInBits = 0; 800 if (!type->isIncompleteArrayType()) { 801 llvm::tie(sizeInBits, alignInBits) = CGM.getContext().getTypeInfo(type); 802 803 if (sizeInBitsOverride) 804 sizeInBits = sizeInBitsOverride; 805 } 806 807 unsigned flags = 0; 808 if (AS == clang::AS_private) 809 flags |= llvm::DIDescriptor::FlagPrivate; 810 else if (AS == clang::AS_protected) 811 flags |= llvm::DIDescriptor::FlagProtected; 812 813 return DBuilder.createMemberType(scope, name, file, line, sizeInBits, 814 alignInBits, offsetInBits, flags, debugType); 815} 816 817/// CollectRecordLambdaFields - Helper for CollectRecordFields. 818void CGDebugInfo:: 819CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl, 820 SmallVectorImpl<llvm::Value *> &elements, 821 llvm::DIType RecordTy) { 822 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture 823 // has the name and the location of the variable so we should iterate over 824 // both concurrently. 825 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl); 826 RecordDecl::field_iterator Field = CXXDecl->field_begin(); 827 unsigned fieldno = 0; 828 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(), 829 E = CXXDecl->captures_end(); I != E; ++I, ++Field, ++fieldno) { 830 const LambdaExpr::Capture C = *I; 831 if (C.capturesVariable()) { 832 VarDecl *V = C.getCapturedVar(); 833 llvm::DIFile VUnit = getOrCreateFile(C.getLocation()); 834 StringRef VName = V->getName(); 835 uint64_t SizeInBitsOverride = 0; 836 if (Field->isBitField()) { 837 SizeInBitsOverride = Field->getBitWidthValue(CGM.getContext()); 838 assert(SizeInBitsOverride && "found named 0-width bitfield"); 839 } 840 llvm::DIType fieldType 841 = createFieldType(VName, Field->getType(), SizeInBitsOverride, 842 C.getLocation(), Field->getAccess(), 843 layout.getFieldOffset(fieldno), VUnit, RecordTy); 844 elements.push_back(fieldType); 845 } else { 846 // TODO: Need to handle 'this' in some way by probably renaming the 847 // this of the lambda class and having a field member of 'this' or 848 // by using AT_object_pointer for the function and having that be 849 // used as 'this' for semantic references. 850 assert(C.capturesThis() && "Field that isn't captured and isn't this?"); 851 FieldDecl *f = *Field; 852 llvm::DIFile VUnit = getOrCreateFile(f->getLocation()); 853 QualType type = f->getType(); 854 llvm::DIType fieldType 855 = createFieldType("this", type, 0, f->getLocation(), f->getAccess(), 856 layout.getFieldOffset(fieldno), VUnit, RecordTy); 857 858 elements.push_back(fieldType); 859 } 860 } 861} 862 863/// Helper for CollectRecordFields. 864llvm::DIDerivedType 865CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, 866 llvm::DIType RecordTy) { 867 // Create the descriptor for the static variable, with or without 868 // constant initializers. 869 llvm::DIFile VUnit = getOrCreateFile(Var->getLocation()); 870 llvm::DIType VTy = getOrCreateType(Var->getType(), VUnit); 871 872 unsigned LineNumber = getLineNumber(Var->getLocation()); 873 StringRef VName = Var->getName(); 874 llvm::Constant *C = NULL; 875 if (Var->getInit()) { 876 const APValue *Value = Var->evaluateValue(); 877 if (Value) { 878 if (Value->isInt()) 879 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt()); 880 if (Value->isFloat()) 881 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat()); 882 } 883 } 884 885 unsigned Flags = 0; 886 AccessSpecifier Access = Var->getAccess(); 887 if (Access == clang::AS_private) 888 Flags |= llvm::DIDescriptor::FlagPrivate; 889 else if (Access == clang::AS_protected) 890 Flags |= llvm::DIDescriptor::FlagProtected; 891 892 llvm::DIDerivedType GV = DBuilder.createStaticMemberType( 893 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C); 894 StaticDataMemberCache[Var->getCanonicalDecl()] = llvm::WeakVH(GV); 895 return GV; 896} 897 898/// CollectRecordNormalField - Helper for CollectRecordFields. 899void CGDebugInfo:: 900CollectRecordNormalField(const FieldDecl *field, uint64_t OffsetInBits, 901 llvm::DIFile tunit, 902 SmallVectorImpl<llvm::Value *> &elements, 903 llvm::DIType RecordTy) { 904 StringRef name = field->getName(); 905 QualType type = field->getType(); 906 907 // Ignore unnamed fields unless they're anonymous structs/unions. 908 if (name.empty() && !type->isRecordType()) 909 return; 910 911 uint64_t SizeInBitsOverride = 0; 912 if (field->isBitField()) { 913 SizeInBitsOverride = field->getBitWidthValue(CGM.getContext()); 914 assert(SizeInBitsOverride && "found named 0-width bitfield"); 915 } 916 917 llvm::DIType fieldType 918 = createFieldType(name, type, SizeInBitsOverride, 919 field->getLocation(), field->getAccess(), 920 OffsetInBits, tunit, RecordTy); 921 922 elements.push_back(fieldType); 923} 924 925/// CollectRecordFields - A helper function to collect debug info for 926/// record fields. This is used while creating debug info entry for a Record. 927void CGDebugInfo::CollectRecordFields(const RecordDecl *record, 928 llvm::DIFile tunit, 929 SmallVectorImpl<llvm::Value *> &elements, 930 llvm::DICompositeType RecordTy) { 931 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(record); 932 933 if (CXXDecl && CXXDecl->isLambda()) 934 CollectRecordLambdaFields(CXXDecl, elements, RecordTy); 935 else { 936 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record); 937 938 // Field number for non-static fields. 939 unsigned fieldNo = 0; 940 941 // Static and non-static members should appear in the same order as 942 // the corresponding declarations in the source program. 943 for (RecordDecl::decl_iterator I = record->decls_begin(), 944 E = record->decls_end(); I != E; ++I) 945 if (const VarDecl *V = dyn_cast<VarDecl>(*I)) { 946 // Reuse the existing static member declaration if one exists 947 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator MI = 948 StaticDataMemberCache.find(V->getCanonicalDecl()); 949 if (MI != StaticDataMemberCache.end()) { 950 assert(MI->second && 951 "Static data member declaration should still exist"); 952 elements.push_back( 953 llvm::DIDerivedType(cast<llvm::MDNode>(MI->second))); 954 } else 955 elements.push_back(CreateRecordStaticField(V, RecordTy)); 956 } else if (FieldDecl *field = dyn_cast<FieldDecl>(*I)) { 957 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), 958 tunit, elements, RecordTy); 959 960 // Bump field number for next field. 961 ++fieldNo; 962 } 963 } 964} 965 966/// getOrCreateMethodType - CXXMethodDecl's type is a FunctionType. This 967/// function type is not updated to include implicit "this" pointer. Use this 968/// routine to get a method type which includes "this" pointer. 969llvm::DICompositeType 970CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method, 971 llvm::DIFile Unit) { 972 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>(); 973 if (Method->isStatic()) 974 return llvm::DICompositeType(getOrCreateType(QualType(Func, 0), Unit)); 975 return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()), 976 Func, Unit); 977} 978 979llvm::DICompositeType CGDebugInfo::getOrCreateInstanceMethodType( 980 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile Unit) { 981 // Add "this" pointer. 982 llvm::DIArray Args = llvm::DICompositeType( 983 getOrCreateType(QualType(Func, 0), Unit)).getTypeArray(); 984 assert (Args.getNumElements() && "Invalid number of arguments!"); 985 986 SmallVector<llvm::Value *, 16> Elts; 987 988 // First element is always return type. For 'void' functions it is NULL. 989 Elts.push_back(Args.getElement(0)); 990 991 // "this" pointer is always first argument. 992 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl(); 993 if (isa<ClassTemplateSpecializationDecl>(RD)) { 994 // Create pointer type directly in this case. 995 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr); 996 QualType PointeeTy = ThisPtrTy->getPointeeType(); 997 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy); 998 uint64_t Size = CGM.getTarget().getPointerWidth(AS); 999 uint64_t Align = CGM.getContext().getTypeAlign(ThisPtrTy); 1000 llvm::DIType PointeeType = getOrCreateType(PointeeTy, Unit); 1001 llvm::DIType ThisPtrType = 1002 DBuilder.createPointerType(PointeeType, Size, Align); 1003 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType; 1004 // TODO: This and the artificial type below are misleading, the 1005 // types aren't artificial the argument is, but the current 1006 // metadata doesn't represent that. 1007 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType); 1008 Elts.push_back(ThisPtrType); 1009 } else { 1010 llvm::DIType ThisPtrType = getOrCreateType(ThisPtr, Unit); 1011 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType; 1012 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType); 1013 Elts.push_back(ThisPtrType); 1014 } 1015 1016 // Copy rest of the arguments. 1017 for (unsigned i = 1, e = Args.getNumElements(); i != e; ++i) 1018 Elts.push_back(Args.getElement(i)); 1019 1020 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(Elts); 1021 1022 return DBuilder.createSubroutineType(Unit, EltTypeArray); 1023} 1024 1025/// isFunctionLocalClass - Return true if CXXRecordDecl is defined 1026/// inside a function. 1027static bool isFunctionLocalClass(const CXXRecordDecl *RD) { 1028 if (const CXXRecordDecl *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext())) 1029 return isFunctionLocalClass(NRD); 1030 if (isa<FunctionDecl>(RD->getDeclContext())) 1031 return true; 1032 return false; 1033} 1034 1035/// CreateCXXMemberFunction - A helper function to create a DISubprogram for 1036/// a single member function GlobalDecl. 1037llvm::DISubprogram 1038CGDebugInfo::CreateCXXMemberFunction(const CXXMethodDecl *Method, 1039 llvm::DIFile Unit, 1040 llvm::DIType RecordTy) { 1041 bool IsCtorOrDtor = 1042 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method); 1043 1044 StringRef MethodName = getFunctionName(Method); 1045 llvm::DICompositeType MethodTy = getOrCreateMethodType(Method, Unit); 1046 1047 // Since a single ctor/dtor corresponds to multiple functions, it doesn't 1048 // make sense to give a single ctor/dtor a linkage name. 1049 StringRef MethodLinkageName; 1050 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent())) 1051 MethodLinkageName = CGM.getMangledName(Method); 1052 1053 // Get the location for the method. 1054 llvm::DIFile MethodDefUnit; 1055 unsigned MethodLine = 0; 1056 if (!Method->isImplicit()) { 1057 MethodDefUnit = getOrCreateFile(Method->getLocation()); 1058 MethodLine = getLineNumber(Method->getLocation()); 1059 } 1060 1061 // Collect virtual method info. 1062 llvm::DIType ContainingType; 1063 unsigned Virtuality = 0; 1064 unsigned VIndex = 0; 1065 1066 if (Method->isVirtual()) { 1067 if (Method->isPure()) 1068 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual; 1069 else 1070 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual; 1071 1072 // It doesn't make sense to give a virtual destructor a vtable index, 1073 // since a single destructor has two entries in the vtable. 1074 if (!isa<CXXDestructorDecl>(Method)) 1075 VIndex = CGM.getVTableContext().getMethodVTableIndex(Method); 1076 ContainingType = RecordTy; 1077 } 1078 1079 unsigned Flags = 0; 1080 if (Method->isImplicit()) 1081 Flags |= llvm::DIDescriptor::FlagArtificial; 1082 AccessSpecifier Access = Method->getAccess(); 1083 if (Access == clang::AS_private) 1084 Flags |= llvm::DIDescriptor::FlagPrivate; 1085 else if (Access == clang::AS_protected) 1086 Flags |= llvm::DIDescriptor::FlagProtected; 1087 if (const CXXConstructorDecl *CXXC = dyn_cast<CXXConstructorDecl>(Method)) { 1088 if (CXXC->isExplicit()) 1089 Flags |= llvm::DIDescriptor::FlagExplicit; 1090 } else if (const CXXConversionDecl *CXXC = 1091 dyn_cast<CXXConversionDecl>(Method)) { 1092 if (CXXC->isExplicit()) 1093 Flags |= llvm::DIDescriptor::FlagExplicit; 1094 } 1095 if (Method->hasPrototype()) 1096 Flags |= llvm::DIDescriptor::FlagPrototyped; 1097 1098 llvm::DIArray TParamsArray = CollectFunctionTemplateParams(Method, Unit); 1099 llvm::DISubprogram SP = 1100 DBuilder.createMethod(RecordTy, MethodName, MethodLinkageName, 1101 MethodDefUnit, MethodLine, 1102 MethodTy, /*isLocalToUnit=*/false, 1103 /* isDefinition=*/ false, 1104 Virtuality, VIndex, ContainingType, 1105 Flags, CGM.getLangOpts().Optimize, NULL, 1106 TParamsArray); 1107 1108 SPCache[Method->getCanonicalDecl()] = llvm::WeakVH(SP); 1109 1110 return SP; 1111} 1112 1113/// CollectCXXMemberFunctions - A helper function to collect debug info for 1114/// C++ member functions. This is used while creating debug info entry for 1115/// a Record. 1116void CGDebugInfo:: 1117CollectCXXMemberFunctions(const CXXRecordDecl *RD, llvm::DIFile Unit, 1118 SmallVectorImpl<llvm::Value *> &EltTys, 1119 llvm::DIType RecordTy) { 1120 1121 // Since we want more than just the individual member decls if we 1122 // have templated functions iterate over every declaration to gather 1123 // the functions. 1124 for(DeclContext::decl_iterator I = RD->decls_begin(), 1125 E = RD->decls_end(); I != E; ++I) { 1126 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*I)) { 1127 // Reuse the existing member function declaration if it exists. 1128 // It may be associated with the declaration of the type & should be 1129 // reused as we're building the definition. 1130 // 1131 // This situation can arise in the vtable-based debug info reduction where 1132 // implicit members are emitted in a non-vtable TU. 1133 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator MI = 1134 SPCache.find(Method->getCanonicalDecl()); 1135 if (MI == SPCache.end()) { 1136 // If the member is implicit, lazily create it when we see the 1137 // definition, not before. (an ODR-used implicit default ctor that's 1138 // never actually code generated should not produce debug info) 1139 if (!Method->isImplicit()) 1140 EltTys.push_back(CreateCXXMemberFunction(Method, Unit, RecordTy)); 1141 } else 1142 EltTys.push_back(MI->second); 1143 } 1144 } 1145} 1146 1147/// CollectCXXFriends - A helper function to collect debug info for 1148/// C++ base classes. This is used while creating debug info entry for 1149/// a Record. 1150void CGDebugInfo:: 1151CollectCXXFriends(const CXXRecordDecl *RD, llvm::DIFile Unit, 1152 SmallVectorImpl<llvm::Value *> &EltTys, 1153 llvm::DIType RecordTy) { 1154 for (CXXRecordDecl::friend_iterator BI = RD->friend_begin(), 1155 BE = RD->friend_end(); BI != BE; ++BI) { 1156 if ((*BI)->isUnsupportedFriend()) 1157 continue; 1158 if (TypeSourceInfo *TInfo = (*BI)->getFriendType()) 1159 EltTys.push_back(DBuilder.createFriend( 1160 RecordTy, getOrCreateType(TInfo->getType(), Unit))); 1161 } 1162} 1163 1164/// CollectCXXBases - A helper function to collect debug info for 1165/// C++ base classes. This is used while creating debug info entry for 1166/// a Record. 1167void CGDebugInfo:: 1168CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile Unit, 1169 SmallVectorImpl<llvm::Value *> &EltTys, 1170 llvm::DIType RecordTy) { 1171 1172 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); 1173 for (CXXRecordDecl::base_class_const_iterator BI = RD->bases_begin(), 1174 BE = RD->bases_end(); BI != BE; ++BI) { 1175 unsigned BFlags = 0; 1176 uint64_t BaseOffset; 1177 1178 const CXXRecordDecl *Base = 1179 cast<CXXRecordDecl>(BI->getType()->getAs<RecordType>()->getDecl()); 1180 1181 if (BI->isVirtual()) { 1182 // virtual base offset offset is -ve. The code generator emits dwarf 1183 // expression where it expects +ve number. 1184 BaseOffset = 1185 0 - CGM.getVTableContext() 1186 .getVirtualBaseOffsetOffset(RD, Base).getQuantity(); 1187 BFlags = llvm::DIDescriptor::FlagVirtual; 1188 } else 1189 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base)); 1190 // FIXME: Inconsistent units for BaseOffset. It is in bytes when 1191 // BI->isVirtual() and bits when not. 1192 1193 AccessSpecifier Access = BI->getAccessSpecifier(); 1194 if (Access == clang::AS_private) 1195 BFlags |= llvm::DIDescriptor::FlagPrivate; 1196 else if (Access == clang::AS_protected) 1197 BFlags |= llvm::DIDescriptor::FlagProtected; 1198 1199 llvm::DIType DTy = 1200 DBuilder.createInheritance(RecordTy, 1201 getOrCreateType(BI->getType(), Unit), 1202 BaseOffset, BFlags); 1203 EltTys.push_back(DTy); 1204 } 1205} 1206 1207/// CollectTemplateParams - A helper function to collect template parameters. 1208llvm::DIArray CGDebugInfo:: 1209CollectTemplateParams(const TemplateParameterList *TPList, 1210 ArrayRef<TemplateArgument> TAList, 1211 llvm::DIFile Unit) { 1212 SmallVector<llvm::Value *, 16> TemplateParams; 1213 for (unsigned i = 0, e = TAList.size(); i != e; ++i) { 1214 const TemplateArgument &TA = TAList[i]; 1215 StringRef Name; 1216 if (TPList) 1217 Name = TPList->getParam(i)->getName(); 1218 switch (TA.getKind()) { 1219 case TemplateArgument::Type: { 1220 llvm::DIType TTy = getOrCreateType(TA.getAsType(), Unit); 1221 llvm::DITemplateTypeParameter TTP = 1222 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy); 1223 TemplateParams.push_back(TTP); 1224 } break; 1225 case TemplateArgument::Integral: { 1226 llvm::DIType TTy = getOrCreateType(TA.getIntegralType(), Unit); 1227 llvm::DITemplateValueParameter TVP = 1228 DBuilder.createTemplateValueParameter( 1229 TheCU, Name, TTy, 1230 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())); 1231 TemplateParams.push_back(TVP); 1232 } break; 1233 case TemplateArgument::Declaration: { 1234 const ValueDecl *D = TA.getAsDecl(); 1235 bool InstanceMember = D->isCXXInstanceMember(); 1236 QualType T = InstanceMember 1237 ? CGM.getContext().getMemberPointerType( 1238 D->getType(), cast<RecordDecl>(D->getDeclContext()) 1239 ->getTypeForDecl()) 1240 : CGM.getContext().getPointerType(D->getType()); 1241 llvm::DIType TTy = getOrCreateType(T, Unit); 1242 llvm::Value *V = 0; 1243 // Variable pointer template parameters have a value that is the address 1244 // of the variable. 1245 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 1246 V = CGM.GetAddrOfGlobalVar(VD); 1247 // Member function pointers have special support for building them, though 1248 // this is currently unsupported in LLVM CodeGen. 1249 if (InstanceMember) { 1250 if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(D)) 1251 V = CGM.getCXXABI().EmitMemberPointer(method); 1252 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 1253 V = CGM.GetAddrOfFunction(FD); 1254 // Member data pointers have special handling too to compute the fixed 1255 // offset within the object. 1256 if (isa<FieldDecl>(D)) { 1257 // These five lines (& possibly the above member function pointer 1258 // handling) might be able to be refactored to use similar code in 1259 // CodeGenModule::getMemberPointerConstant 1260 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D); 1261 CharUnits chars = 1262 CGM.getContext().toCharUnitsFromBits((int64_t) fieldOffset); 1263 V = CGM.getCXXABI().EmitMemberDataPointer( 1264 cast<MemberPointerType>(T.getTypePtr()), chars); 1265 } 1266 llvm::DITemplateValueParameter TVP = 1267 DBuilder.createTemplateValueParameter(TheCU, Name, TTy, 1268 V->stripPointerCasts()); 1269 TemplateParams.push_back(TVP); 1270 } break; 1271 case TemplateArgument::NullPtr: { 1272 QualType T = TA.getNullPtrType(); 1273 llvm::DIType TTy = getOrCreateType(T, Unit); 1274 llvm::Value *V = 0; 1275 // Special case member data pointer null values since they're actually -1 1276 // instead of zero. 1277 if (const MemberPointerType *MPT = 1278 dyn_cast<MemberPointerType>(T.getTypePtr())) 1279 // But treat member function pointers as simple zero integers because 1280 // it's easier than having a special case in LLVM's CodeGen. If LLVM 1281 // CodeGen grows handling for values of non-null member function 1282 // pointers then perhaps we could remove this special case and rely on 1283 // EmitNullMemberPointer for member function pointers. 1284 if (MPT->isMemberDataPointer()) 1285 V = CGM.getCXXABI().EmitNullMemberPointer(MPT); 1286 if (!V) 1287 V = llvm::ConstantInt::get(CGM.Int8Ty, 0); 1288 llvm::DITemplateValueParameter TVP = 1289 DBuilder.createTemplateValueParameter(TheCU, Name, TTy, V); 1290 TemplateParams.push_back(TVP); 1291 } break; 1292 case TemplateArgument::Template: { 1293 llvm::DITemplateValueParameter TVP = 1294 DBuilder.createTemplateTemplateParameter( 1295 TheCU, Name, llvm::DIType(), 1296 TA.getAsTemplate().getAsTemplateDecl() 1297 ->getQualifiedNameAsString()); 1298 TemplateParams.push_back(TVP); 1299 } break; 1300 case TemplateArgument::Pack: { 1301 llvm::DITemplateValueParameter TVP = 1302 DBuilder.createTemplateParameterPack( 1303 TheCU, Name, llvm::DIType(), 1304 CollectTemplateParams(NULL, TA.getPackAsArray(), Unit)); 1305 TemplateParams.push_back(TVP); 1306 } break; 1307 case TemplateArgument::Expression: { 1308 const Expr *E = TA.getAsExpr(); 1309 QualType T = E->getType(); 1310 llvm::Value *V = CGM.EmitConstantExpr(E, T); 1311 assert(V && "Expression in template argument isn't constant"); 1312 llvm::DIType TTy = getOrCreateType(T, Unit); 1313 llvm::DITemplateValueParameter TVP = 1314 DBuilder.createTemplateValueParameter(TheCU, Name, TTy, 1315 V->stripPointerCasts()); 1316 TemplateParams.push_back(TVP); 1317 } break; 1318 // And the following should never occur: 1319 case TemplateArgument::TemplateExpansion: 1320 case TemplateArgument::Null: 1321 llvm_unreachable( 1322 "These argument types shouldn't exist in concrete types"); 1323 } 1324 } 1325 return DBuilder.getOrCreateArray(TemplateParams); 1326} 1327 1328/// CollectFunctionTemplateParams - A helper function to collect debug 1329/// info for function template parameters. 1330llvm::DIArray CGDebugInfo:: 1331CollectFunctionTemplateParams(const FunctionDecl *FD, llvm::DIFile Unit) { 1332 if (FD->getTemplatedKind() == 1333 FunctionDecl::TK_FunctionTemplateSpecialization) { 1334 const TemplateParameterList *TList = 1335 FD->getTemplateSpecializationInfo()->getTemplate() 1336 ->getTemplateParameters(); 1337 return CollectTemplateParams( 1338 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit); 1339 } 1340 return llvm::DIArray(); 1341} 1342 1343/// CollectCXXTemplateParams - A helper function to collect debug info for 1344/// template parameters. 1345llvm::DIArray CGDebugInfo:: 1346CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TSpecial, 1347 llvm::DIFile Unit) { 1348 llvm::PointerUnion<ClassTemplateDecl *, 1349 ClassTemplatePartialSpecializationDecl *> 1350 PU = TSpecial->getSpecializedTemplateOrPartial(); 1351 1352 TemplateParameterList *TPList = PU.is<ClassTemplateDecl *>() ? 1353 PU.get<ClassTemplateDecl *>()->getTemplateParameters() : 1354 PU.get<ClassTemplatePartialSpecializationDecl *>()->getTemplateParameters(); 1355 const TemplateArgumentList &TAList = TSpecial->getTemplateInstantiationArgs(); 1356 return CollectTemplateParams(TPList, TAList.asArray(), Unit); 1357} 1358 1359/// getOrCreateVTablePtrType - Return debug info descriptor for vtable. 1360llvm::DIType CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile Unit) { 1361 if (VTablePtrType.isValid()) 1362 return VTablePtrType; 1363 1364 ASTContext &Context = CGM.getContext(); 1365 1366 /* Function type */ 1367 llvm::Value *STy = getOrCreateType(Context.IntTy, Unit); 1368 llvm::DIArray SElements = DBuilder.getOrCreateArray(STy); 1369 llvm::DIType SubTy = DBuilder.createSubroutineType(Unit, SElements); 1370 unsigned Size = Context.getTypeSize(Context.VoidPtrTy); 1371 llvm::DIType vtbl_ptr_type = DBuilder.createPointerType(SubTy, Size, 0, 1372 "__vtbl_ptr_type"); 1373 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size); 1374 return VTablePtrType; 1375} 1376 1377/// getVTableName - Get vtable name for the given Class. 1378StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) { 1379 // Construct gdb compatible name name. 1380 std::string Name = "_vptr$" + RD->getNameAsString(); 1381 1382 // Copy this name on the side and use its reference. 1383 char *StrPtr = DebugInfoNames.Allocate<char>(Name.length()); 1384 memcpy(StrPtr, Name.data(), Name.length()); 1385 return StringRef(StrPtr, Name.length()); 1386} 1387 1388 1389/// CollectVTableInfo - If the C++ class has vtable info then insert appropriate 1390/// debug info entry in EltTys vector. 1391void CGDebugInfo:: 1392CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile Unit, 1393 SmallVectorImpl<llvm::Value *> &EltTys) { 1394 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); 1395 1396 // If there is a primary base then it will hold vtable info. 1397 if (RL.getPrimaryBase()) 1398 return; 1399 1400 // If this class is not dynamic then there is not any vtable info to collect. 1401 if (!RD->isDynamicClass()) 1402 return; 1403 1404 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); 1405 llvm::DIType VPTR 1406 = DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 1407 0, Size, 0, 0, 1408 llvm::DIDescriptor::FlagArtificial, 1409 getOrCreateVTablePtrType(Unit)); 1410 EltTys.push_back(VPTR); 1411} 1412 1413/// getOrCreateRecordType - Emit record type's standalone debug info. 1414llvm::DIType CGDebugInfo::getOrCreateRecordType(QualType RTy, 1415 SourceLocation Loc) { 1416 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 1417 llvm::DIType T = getOrCreateType(RTy, getOrCreateFile(Loc)); 1418 return T; 1419} 1420 1421/// getOrCreateInterfaceType - Emit an objective c interface type standalone 1422/// debug info. 1423llvm::DIType CGDebugInfo::getOrCreateInterfaceType(QualType D, 1424 SourceLocation Loc) { 1425 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 1426 llvm::DIType T = getOrCreateType(D, getOrCreateFile(Loc)); 1427 RetainedTypes.push_back(D.getAsOpaquePtr()); 1428 return T; 1429} 1430 1431void CGDebugInfo::completeType(const RecordDecl *RD) { 1432 if (DebugKind > CodeGenOptions::LimitedDebugInfo || 1433 !CGM.getLangOpts().CPlusPlus) 1434 completeRequiredType(RD); 1435} 1436 1437void CGDebugInfo::completeRequiredType(const RecordDecl *RD) { 1438 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) 1439 if (CXXDecl->isDynamicClass()) 1440 return; 1441 1442 QualType Ty = CGM.getContext().getRecordType(RD); 1443 llvm::DIType T = getTypeOrNull(Ty); 1444 if (T && T.isForwardDecl()) 1445 completeClassData(RD); 1446} 1447 1448void CGDebugInfo::completeClassData(const RecordDecl *RD) { 1449 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly) 1450 return; 1451 QualType Ty = CGM.getContext().getRecordType(RD); 1452 void* TyPtr = Ty.getAsOpaquePtr(); 1453 if (CompletedTypeCache.count(TyPtr)) 1454 return; 1455 llvm::DIType Res = CreateTypeDefinition(Ty->castAs<RecordType>()); 1456 assert(!Res.isForwardDecl()); 1457 CompletedTypeCache[TyPtr] = Res; 1458 TypeCache[TyPtr] = Res; 1459} 1460 1461/// CreateType - get structure or union type. 1462llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty) { 1463 RecordDecl *RD = Ty->getDecl(); 1464 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD); 1465 // Always emit declarations for types that aren't required to be complete when 1466 // in limit-debug-info mode. If the type is later found to be required to be 1467 // complete this declaration will be upgraded to a definition by 1468 // `completeRequiredType`. 1469 // If the type is dynamic, only emit the definition in TUs that require class 1470 // data. This is handled by `completeClassData`. 1471 if ((DebugKind <= CodeGenOptions::LimitedDebugInfo && 1472 !RD->isCompleteDefinitionRequired() && CGM.getLangOpts().CPlusPlus) || 1473 (CXXDecl && CXXDecl->hasDefinition() && CXXDecl->isDynamicClass())) { 1474 llvm::DIDescriptor FDContext = 1475 getContextDescriptor(cast<Decl>(RD->getDeclContext())); 1476 llvm::DIType RetTy = getOrCreateRecordFwdDecl(Ty, FDContext); 1477 // FIXME: This is conservatively correct. If we return a non-forward decl 1478 // that's not a full definition (such as those created by 1479 // createContextChain) then getOrCreateType will record is as a complete 1480 // type and we'll never record all its members. But this means we're 1481 // emitting full debug info in TUs where GCC successfully emits a partial 1482 // definition of the type. 1483 if (RetTy.isForwardDecl()) 1484 return RetTy; 1485 } 1486 1487 return CreateTypeDefinition(Ty); 1488} 1489 1490llvm::DIType CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) { 1491 RecordDecl *RD = Ty->getDecl(); 1492 1493 // Get overall information about the record type for the debug info. 1494 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation()); 1495 1496 // Records and classes and unions can all be recursive. To handle them, we 1497 // first generate a debug descriptor for the struct as a forward declaration. 1498 // Then (if it is a definition) we go through and get debug info for all of 1499 // its members. Finally, we create a descriptor for the complete type (which 1500 // may refer to the forward decl if the struct is recursive) and replace all 1501 // uses of the forward declaration with the final definition. 1502 1503 llvm::DICompositeType FwdDecl(getOrCreateLimitedType(Ty, DefUnit)); 1504 assert(FwdDecl.isCompositeType() && 1505 "The debug type of a RecordType should be a llvm::DICompositeType"); 1506 1507 if (FwdDecl.isForwardDecl()) 1508 return FwdDecl; 1509 1510 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) 1511 CollectContainingType(CXXDecl, FwdDecl); 1512 1513 // Push the struct on region stack. 1514 LexicalBlockStack.push_back(&*FwdDecl); 1515 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl); 1516 1517 // Add this to the completed-type cache while we're completing it recursively. 1518 CompletedTypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl; 1519 1520 // Convert all the elements. 1521 SmallVector<llvm::Value *, 16> EltTys; 1522 // what about nested types? 1523 1524 // Note: The split of CXXDecl information here is intentional, the 1525 // gdb tests will depend on a certain ordering at printout. The debug 1526 // information offsets are still correct if we merge them all together 1527 // though. 1528 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD); 1529 if (CXXDecl) { 1530 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl); 1531 CollectVTableInfo(CXXDecl, DefUnit, EltTys); 1532 } 1533 1534 // Collect data fields (including static variables and any initializers). 1535 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl); 1536 if (CXXDecl) { 1537 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl); 1538 CollectCXXFriends(CXXDecl, DefUnit, EltTys, FwdDecl); 1539 } 1540 1541 LexicalBlockStack.pop_back(); 1542 RegionMap.erase(Ty->getDecl()); 1543 1544 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys); 1545 FwdDecl.setTypeArray(Elements); 1546 1547 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl); 1548 return FwdDecl; 1549} 1550 1551/// CreateType - get objective-c object type. 1552llvm::DIType CGDebugInfo::CreateType(const ObjCObjectType *Ty, 1553 llvm::DIFile Unit) { 1554 // Ignore protocols. 1555 return getOrCreateType(Ty->getBaseType(), Unit); 1556} 1557 1558 1559/// \return true if Getter has the default name for the property PD. 1560static bool hasDefaultGetterName(const ObjCPropertyDecl *PD, 1561 const ObjCMethodDecl *Getter) { 1562 assert(PD); 1563 if (!Getter) 1564 return true; 1565 1566 assert(Getter->getDeclName().isObjCZeroArgSelector()); 1567 return PD->getName() == 1568 Getter->getDeclName().getObjCSelector().getNameForSlot(0); 1569} 1570 1571/// \return true if Setter has the default name for the property PD. 1572static bool hasDefaultSetterName(const ObjCPropertyDecl *PD, 1573 const ObjCMethodDecl *Setter) { 1574 assert(PD); 1575 if (!Setter) 1576 return true; 1577 1578 assert(Setter->getDeclName().isObjCOneArgSelector()); 1579 return SelectorTable::constructSetterName(PD->getName()) == 1580 Setter->getDeclName().getObjCSelector().getNameForSlot(0); 1581} 1582 1583/// CreateType - get objective-c interface type. 1584llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, 1585 llvm::DIFile Unit) { 1586 ObjCInterfaceDecl *ID = Ty->getDecl(); 1587 if (!ID) 1588 return llvm::DIType(); 1589 1590 // Get overall information about the record type for the debug info. 1591 llvm::DIFile DefUnit = getOrCreateFile(ID->getLocation()); 1592 unsigned Line = getLineNumber(ID->getLocation()); 1593 unsigned RuntimeLang = TheCU.getLanguage(); 1594 1595 // If this is just a forward declaration return a special forward-declaration 1596 // debug type since we won't be able to lay out the entire type. 1597 ObjCInterfaceDecl *Def = ID->getDefinition(); 1598 if (!Def) { 1599 llvm::DIType FwdDecl = 1600 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, 1601 ID->getName(), TheCU, DefUnit, Line, 1602 RuntimeLang); 1603 return FwdDecl; 1604 } 1605 1606 ID = Def; 1607 1608 // Bit size, align and offset of the type. 1609 uint64_t Size = CGM.getContext().getTypeSize(Ty); 1610 uint64_t Align = CGM.getContext().getTypeAlign(Ty); 1611 1612 unsigned Flags = 0; 1613 if (ID->getImplementation()) 1614 Flags |= llvm::DIDescriptor::FlagObjcClassComplete; 1615 1616 llvm::DICompositeType RealDecl = 1617 DBuilder.createStructType(Unit, ID->getName(), DefUnit, 1618 Line, Size, Align, Flags, 1619 llvm::DIType(), llvm::DIArray(), RuntimeLang); 1620 1621 // Otherwise, insert it into the CompletedTypeCache so that recursive uses 1622 // will find it and we're emitting the complete type. 1623 QualType QualTy = QualType(Ty, 0); 1624 CompletedTypeCache[QualTy.getAsOpaquePtr()] = RealDecl; 1625 1626 // Push the struct on region stack. 1627 LexicalBlockStack.push_back(static_cast<llvm::MDNode*>(RealDecl)); 1628 RegionMap[Ty->getDecl()] = llvm::WeakVH(RealDecl); 1629 1630 // Convert all the elements. 1631 SmallVector<llvm::Value *, 16> EltTys; 1632 1633 ObjCInterfaceDecl *SClass = ID->getSuperClass(); 1634 if (SClass) { 1635 llvm::DIType SClassTy = 1636 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit); 1637 if (!SClassTy.isValid()) 1638 return llvm::DIType(); 1639 1640 llvm::DIType InhTag = 1641 DBuilder.createInheritance(RealDecl, SClassTy, 0, 0); 1642 EltTys.push_back(InhTag); 1643 } 1644 1645 // Create entries for all of the properties. 1646 for (ObjCContainerDecl::prop_iterator I = ID->prop_begin(), 1647 E = ID->prop_end(); I != E; ++I) { 1648 const ObjCPropertyDecl *PD = *I; 1649 SourceLocation Loc = PD->getLocation(); 1650 llvm::DIFile PUnit = getOrCreateFile(Loc); 1651 unsigned PLine = getLineNumber(Loc); 1652 ObjCMethodDecl *Getter = PD->getGetterMethodDecl(); 1653 ObjCMethodDecl *Setter = PD->getSetterMethodDecl(); 1654 llvm::MDNode *PropertyNode = 1655 DBuilder.createObjCProperty(PD->getName(), 1656 PUnit, PLine, 1657 hasDefaultGetterName(PD, Getter) ? "" : 1658 getSelectorName(PD->getGetterName()), 1659 hasDefaultSetterName(PD, Setter) ? "" : 1660 getSelectorName(PD->getSetterName()), 1661 PD->getPropertyAttributes(), 1662 getOrCreateType(PD->getType(), PUnit)); 1663 EltTys.push_back(PropertyNode); 1664 } 1665 1666 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID); 1667 unsigned FieldNo = 0; 1668 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field; 1669 Field = Field->getNextIvar(), ++FieldNo) { 1670 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit); 1671 if (!FieldTy.isValid()) 1672 return llvm::DIType(); 1673 1674 StringRef FieldName = Field->getName(); 1675 1676 // Ignore unnamed fields. 1677 if (FieldName.empty()) 1678 continue; 1679 1680 // Get the location for the field. 1681 llvm::DIFile FieldDefUnit = getOrCreateFile(Field->getLocation()); 1682 unsigned FieldLine = getLineNumber(Field->getLocation()); 1683 QualType FType = Field->getType(); 1684 uint64_t FieldSize = 0; 1685 unsigned FieldAlign = 0; 1686 1687 if (!FType->isIncompleteArrayType()) { 1688 1689 // Bit size, align and offset of the type. 1690 FieldSize = Field->isBitField() 1691 ? Field->getBitWidthValue(CGM.getContext()) 1692 : CGM.getContext().getTypeSize(FType); 1693 FieldAlign = CGM.getContext().getTypeAlign(FType); 1694 } 1695 1696 uint64_t FieldOffset; 1697 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { 1698 // We don't know the runtime offset of an ivar if we're using the 1699 // non-fragile ABI. For bitfields, use the bit offset into the first 1700 // byte of storage of the bitfield. For other fields, use zero. 1701 if (Field->isBitField()) { 1702 FieldOffset = CGM.getObjCRuntime().ComputeBitfieldBitOffset( 1703 CGM, ID, Field); 1704 FieldOffset %= CGM.getContext().getCharWidth(); 1705 } else { 1706 FieldOffset = 0; 1707 } 1708 } else { 1709 FieldOffset = RL.getFieldOffset(FieldNo); 1710 } 1711 1712 unsigned Flags = 0; 1713 if (Field->getAccessControl() == ObjCIvarDecl::Protected) 1714 Flags = llvm::DIDescriptor::FlagProtected; 1715 else if (Field->getAccessControl() == ObjCIvarDecl::Private) 1716 Flags = llvm::DIDescriptor::FlagPrivate; 1717 1718 llvm::MDNode *PropertyNode = NULL; 1719 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) { 1720 if (ObjCPropertyImplDecl *PImpD = 1721 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) { 1722 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) { 1723 SourceLocation Loc = PD->getLocation(); 1724 llvm::DIFile PUnit = getOrCreateFile(Loc); 1725 unsigned PLine = getLineNumber(Loc); 1726 ObjCMethodDecl *Getter = PD->getGetterMethodDecl(); 1727 ObjCMethodDecl *Setter = PD->getSetterMethodDecl(); 1728 PropertyNode = 1729 DBuilder.createObjCProperty(PD->getName(), 1730 PUnit, PLine, 1731 hasDefaultGetterName(PD, Getter) ? "" : 1732 getSelectorName(PD->getGetterName()), 1733 hasDefaultSetterName(PD, Setter) ? "" : 1734 getSelectorName(PD->getSetterName()), 1735 PD->getPropertyAttributes(), 1736 getOrCreateType(PD->getType(), PUnit)); 1737 } 1738 } 1739 } 1740 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, 1741 FieldLine, FieldSize, FieldAlign, 1742 FieldOffset, Flags, FieldTy, 1743 PropertyNode); 1744 EltTys.push_back(FieldTy); 1745 } 1746 1747 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys); 1748 RealDecl.setTypeArray(Elements); 1749 1750 // If the implementation is not yet set, we do not want to mark it 1751 // as complete. An implementation may declare additional 1752 // private ivars that we would miss otherwise. 1753 if (ID->getImplementation() == 0) 1754 CompletedTypeCache.erase(QualTy.getAsOpaquePtr()); 1755 1756 LexicalBlockStack.pop_back(); 1757 return RealDecl; 1758} 1759 1760llvm::DIType CGDebugInfo::CreateType(const VectorType *Ty, llvm::DIFile Unit) { 1761 llvm::DIType ElementTy = getOrCreateType(Ty->getElementType(), Unit); 1762 int64_t Count = Ty->getNumElements(); 1763 if (Count == 0) 1764 // If number of elements are not known then this is an unbounded array. 1765 // Use Count == -1 to express such arrays. 1766 Count = -1; 1767 1768 llvm::Value *Subscript = DBuilder.getOrCreateSubrange(0, Count); 1769 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscript); 1770 1771 uint64_t Size = CGM.getContext().getTypeSize(Ty); 1772 uint64_t Align = CGM.getContext().getTypeAlign(Ty); 1773 1774 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray); 1775} 1776 1777llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty, 1778 llvm::DIFile Unit) { 1779 uint64_t Size; 1780 uint64_t Align; 1781 1782 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types 1783 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) { 1784 Size = 0; 1785 Align = 1786 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT)); 1787 } else if (Ty->isIncompleteArrayType()) { 1788 Size = 0; 1789 if (Ty->getElementType()->isIncompleteType()) 1790 Align = 0; 1791 else 1792 Align = CGM.getContext().getTypeAlign(Ty->getElementType()); 1793 } else if (Ty->isIncompleteType()) { 1794 Size = 0; 1795 Align = 0; 1796 } else { 1797 // Size and align of the whole array, not the element type. 1798 Size = CGM.getContext().getTypeSize(Ty); 1799 Align = CGM.getContext().getTypeAlign(Ty); 1800 } 1801 1802 // Add the dimensions of the array. FIXME: This loses CV qualifiers from 1803 // interior arrays, do we care? Why aren't nested arrays represented the 1804 // obvious/recursive way? 1805 SmallVector<llvm::Value *, 8> Subscripts; 1806 QualType EltTy(Ty, 0); 1807 while ((Ty = dyn_cast<ArrayType>(EltTy))) { 1808 // If the number of elements is known, then count is that number. Otherwise, 1809 // it's -1. This allows us to represent a subrange with an array of 0 1810 // elements, like this: 1811 // 1812 // struct foo { 1813 // int x[0]; 1814 // }; 1815 int64_t Count = -1; // Count == -1 is an unbounded array. 1816 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty)) 1817 Count = CAT->getSize().getZExtValue(); 1818 1819 // FIXME: Verify this is right for VLAs. 1820 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count)); 1821 EltTy = Ty->getElementType(); 1822 } 1823 1824 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts); 1825 1826 llvm::DIType DbgTy = 1827 DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit), 1828 SubscriptArray); 1829 return DbgTy; 1830} 1831 1832llvm::DIType CGDebugInfo::CreateType(const LValueReferenceType *Ty, 1833 llvm::DIFile Unit) { 1834 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, 1835 Ty, Ty->getPointeeType(), Unit); 1836} 1837 1838llvm::DIType CGDebugInfo::CreateType(const RValueReferenceType *Ty, 1839 llvm::DIFile Unit) { 1840 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, 1841 Ty, Ty->getPointeeType(), Unit); 1842} 1843 1844llvm::DIType CGDebugInfo::CreateType(const MemberPointerType *Ty, 1845 llvm::DIFile U) { 1846 llvm::DIType ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U); 1847 if (!Ty->getPointeeType()->isFunctionType()) 1848 return DBuilder.createMemberPointerType( 1849 getOrCreateType(Ty->getPointeeType(), U), ClassType); 1850 return DBuilder.createMemberPointerType(getOrCreateInstanceMethodType( 1851 CGM.getContext().getPointerType( 1852 QualType(Ty->getClass(), Ty->getPointeeType().getCVRQualifiers())), 1853 Ty->getPointeeType()->getAs<FunctionProtoType>(), U), 1854 ClassType); 1855} 1856 1857llvm::DIType CGDebugInfo::CreateType(const AtomicType *Ty, 1858 llvm::DIFile U) { 1859 // Ignore the atomic wrapping 1860 // FIXME: What is the correct representation? 1861 return getOrCreateType(Ty->getValueType(), U); 1862} 1863 1864/// CreateEnumType - get enumeration type. 1865llvm::DIType CGDebugInfo::CreateEnumType(const EnumType *Ty) { 1866 const EnumDecl *ED = Ty->getDecl(); 1867 uint64_t Size = 0; 1868 uint64_t Align = 0; 1869 if (!ED->getTypeForDecl()->isIncompleteType()) { 1870 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl()); 1871 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl()); 1872 } 1873 1874 // If this is just a forward declaration, construct an appropriately 1875 // marked node and just return it. 1876 if (!ED->getDefinition()) { 1877 llvm::DIDescriptor EDContext; 1878 EDContext = getContextDescriptor(cast<Decl>(ED->getDeclContext())); 1879 llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation()); 1880 unsigned Line = getLineNumber(ED->getLocation()); 1881 StringRef EDName = ED->getName(); 1882 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_enumeration_type, 1883 EDName, EDContext, DefUnit, Line, 0, 1884 Size, Align); 1885 } 1886 1887 // Create DIEnumerator elements for each enumerator. 1888 SmallVector<llvm::Value *, 16> Enumerators; 1889 ED = ED->getDefinition(); 1890 for (EnumDecl::enumerator_iterator 1891 Enum = ED->enumerator_begin(), EnumEnd = ED->enumerator_end(); 1892 Enum != EnumEnd; ++Enum) { 1893 Enumerators.push_back( 1894 DBuilder.createEnumerator(Enum->getName(), 1895 Enum->getInitVal().getSExtValue())); 1896 } 1897 1898 // Return a CompositeType for the enum itself. 1899 llvm::DIArray EltArray = DBuilder.getOrCreateArray(Enumerators); 1900 1901 llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation()); 1902 unsigned Line = getLineNumber(ED->getLocation()); 1903 llvm::DIDescriptor EnumContext = 1904 getContextDescriptor(cast<Decl>(ED->getDeclContext())); 1905 llvm::DIType ClassTy = ED->isFixed() ? 1906 getOrCreateType(ED->getIntegerType(), DefUnit) : llvm::DIType(); 1907 llvm::DIType DbgTy = 1908 DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit, Line, 1909 Size, Align, EltArray, 1910 ClassTy); 1911 return DbgTy; 1912} 1913 1914static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) { 1915 Qualifiers Quals; 1916 do { 1917 Quals += T.getLocalQualifiers(); 1918 QualType LastT = T; 1919 switch (T->getTypeClass()) { 1920 default: 1921 return C.getQualifiedType(T.getTypePtr(), Quals); 1922 case Type::TemplateSpecialization: 1923 T = cast<TemplateSpecializationType>(T)->desugar(); 1924 break; 1925 case Type::TypeOfExpr: 1926 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType(); 1927 break; 1928 case Type::TypeOf: 1929 T = cast<TypeOfType>(T)->getUnderlyingType(); 1930 break; 1931 case Type::Decltype: 1932 T = cast<DecltypeType>(T)->getUnderlyingType(); 1933 break; 1934 case Type::UnaryTransform: 1935 T = cast<UnaryTransformType>(T)->getUnderlyingType(); 1936 break; 1937 case Type::Attributed: 1938 T = cast<AttributedType>(T)->getEquivalentType(); 1939 break; 1940 case Type::Elaborated: 1941 T = cast<ElaboratedType>(T)->getNamedType(); 1942 break; 1943 case Type::Paren: 1944 T = cast<ParenType>(T)->getInnerType(); 1945 break; 1946 case Type::SubstTemplateTypeParm: 1947 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType(); 1948 break; 1949 case Type::Auto: 1950 QualType DT = cast<AutoType>(T)->getDeducedType(); 1951 if (DT.isNull()) 1952 return T; 1953 T = DT; 1954 break; 1955 } 1956 1957 assert(T != LastT && "Type unwrapping failed to unwrap!"); 1958 (void)LastT; 1959 } while (true); 1960} 1961 1962/// getType - Get the type from the cache or return null type if it doesn't 1963/// exist. 1964llvm::DIType CGDebugInfo::getTypeOrNull(QualType Ty) { 1965 1966 // Unwrap the type as needed for debug information. 1967 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext()); 1968 1969 // Check for existing entry. 1970 if (Ty->getTypeClass() == Type::ObjCInterface) { 1971 llvm::Value *V = getCachedInterfaceTypeOrNull(Ty); 1972 if (V) 1973 return llvm::DIType(cast<llvm::MDNode>(V)); 1974 else return llvm::DIType(); 1975 } 1976 1977 llvm::DenseMap<void *, llvm::WeakVH>::iterator it = 1978 TypeCache.find(Ty.getAsOpaquePtr()); 1979 if (it != TypeCache.end()) { 1980 // Verify that the debug info still exists. 1981 if (llvm::Value *V = it->second) 1982 return llvm::DIType(cast<llvm::MDNode>(V)); 1983 } 1984 1985 return llvm::DIType(); 1986} 1987 1988/// getCompletedTypeOrNull - Get the type from the cache or return null if it 1989/// doesn't exist. 1990llvm::DIType CGDebugInfo::getCompletedTypeOrNull(QualType Ty) { 1991 1992 // Unwrap the type as needed for debug information. 1993 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext()); 1994 1995 // Check for existing entry. 1996 llvm::Value *V = 0; 1997 llvm::DenseMap<void *, llvm::WeakVH>::iterator it = 1998 CompletedTypeCache.find(Ty.getAsOpaquePtr()); 1999 if (it != CompletedTypeCache.end()) 2000 V = it->second; 2001 else { 2002 V = getCachedInterfaceTypeOrNull(Ty); 2003 } 2004 2005 // Verify that any cached debug info still exists. 2006 return llvm::DIType(cast_or_null<llvm::MDNode>(V)); 2007} 2008 2009/// getCachedInterfaceTypeOrNull - Get the type from the interface 2010/// cache, unless it needs to regenerated. Otherwise return null. 2011llvm::Value *CGDebugInfo::getCachedInterfaceTypeOrNull(QualType Ty) { 2012 // Is there a cached interface that hasn't changed? 2013 llvm::DenseMap<void *, std::pair<llvm::WeakVH, unsigned > > 2014 ::iterator it1 = ObjCInterfaceCache.find(Ty.getAsOpaquePtr()); 2015 2016 if (it1 != ObjCInterfaceCache.end()) 2017 if (ObjCInterfaceDecl* Decl = getObjCInterfaceDecl(Ty)) 2018 if (Checksum(Decl) == it1->second.second) 2019 // Return cached forward declaration. 2020 return it1->second.first; 2021 2022 return 0; 2023} 2024 2025/// getOrCreateType - Get the type from the cache or create a new 2026/// one if necessary. 2027llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile Unit) { 2028 if (Ty.isNull()) 2029 return llvm::DIType(); 2030 2031 // Unwrap the type as needed for debug information. 2032 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext()); 2033 2034 if (llvm::DIType T = getCompletedTypeOrNull(Ty)) 2035 return T; 2036 2037 // Otherwise create the type. 2038 llvm::DIType Res = CreateTypeNode(Ty, Unit); 2039 void* TyPtr = Ty.getAsOpaquePtr(); 2040 2041 // And update the type cache. 2042 TypeCache[TyPtr] = Res; 2043 2044 // FIXME: this getTypeOrNull call seems silly when we just inserted the type 2045 // into the cache - but getTypeOrNull has a special case for cached interface 2046 // types. We should probably just pull that out as a special case for the 2047 // "else" block below & skip the otherwise needless lookup. 2048 llvm::DIType TC = getTypeOrNull(Ty); 2049 if (TC && TC.isForwardDecl()) 2050 ReplaceMap.push_back(std::make_pair(TyPtr, static_cast<llvm::Value*>(TC))); 2051 else if (ObjCInterfaceDecl* Decl = getObjCInterfaceDecl(Ty)) { 2052 // Interface types may have elements added to them by a 2053 // subsequent implementation or extension, so we keep them in 2054 // the ObjCInterfaceCache together with a checksum. Instead of 2055 // the (possibly) incomplete interface type, we return a forward 2056 // declaration that gets RAUW'd in CGDebugInfo::finalize(). 2057 std::pair<llvm::WeakVH, unsigned> &V = ObjCInterfaceCache[TyPtr]; 2058 if (V.first) 2059 return llvm::DIType(cast<llvm::MDNode>(V.first)); 2060 TC = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, 2061 Decl->getName(), TheCU, Unit, 2062 getLineNumber(Decl->getLocation()), 2063 TheCU.getLanguage()); 2064 // Store the forward declaration in the cache. 2065 V.first = TC; 2066 V.second = Checksum(Decl); 2067 2068 // Register the type for replacement in finalize(). 2069 ReplaceMap.push_back(std::make_pair(TyPtr, static_cast<llvm::Value*>(TC))); 2070 2071 return TC; 2072 } 2073 2074 if (!Res.isForwardDecl()) 2075 CompletedTypeCache[TyPtr] = Res; 2076 2077 return Res; 2078} 2079 2080/// Currently the checksum of an interface includes the number of 2081/// ivars and property accessors. 2082unsigned CGDebugInfo::Checksum(const ObjCInterfaceDecl *ID) { 2083 // The assumption is that the number of ivars can only increase 2084 // monotonically, so it is safe to just use their current number as 2085 // a checksum. 2086 unsigned Sum = 0; 2087 for (const ObjCIvarDecl *Ivar = ID->all_declared_ivar_begin(); 2088 Ivar != 0; Ivar = Ivar->getNextIvar()) 2089 ++Sum; 2090 2091 return Sum; 2092} 2093 2094ObjCInterfaceDecl *CGDebugInfo::getObjCInterfaceDecl(QualType Ty) { 2095 switch (Ty->getTypeClass()) { 2096 case Type::ObjCObjectPointer: 2097 return getObjCInterfaceDecl(cast<ObjCObjectPointerType>(Ty) 2098 ->getPointeeType()); 2099 case Type::ObjCInterface: 2100 return cast<ObjCInterfaceType>(Ty)->getDecl(); 2101 default: 2102 return 0; 2103 } 2104} 2105 2106/// CreateTypeNode - Create a new debug type node. 2107llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile Unit) { 2108 // Handle qualifiers, which recursively handles what they refer to. 2109 if (Ty.hasLocalQualifiers()) 2110 return CreateQualifiedType(Ty, Unit); 2111 2112 const char *Diag = 0; 2113 2114 // Work out details of type. 2115 switch (Ty->getTypeClass()) { 2116#define TYPE(Class, Base) 2117#define ABSTRACT_TYPE(Class, Base) 2118#define NON_CANONICAL_TYPE(Class, Base) 2119#define DEPENDENT_TYPE(Class, Base) case Type::Class: 2120#include "clang/AST/TypeNodes.def" 2121 llvm_unreachable("Dependent types cannot show up in debug information"); 2122 2123 case Type::ExtVector: 2124 case Type::Vector: 2125 return CreateType(cast<VectorType>(Ty), Unit); 2126 case Type::ObjCObjectPointer: 2127 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit); 2128 case Type::ObjCObject: 2129 return CreateType(cast<ObjCObjectType>(Ty), Unit); 2130 case Type::ObjCInterface: 2131 return CreateType(cast<ObjCInterfaceType>(Ty), Unit); 2132 case Type::Builtin: 2133 return CreateType(cast<BuiltinType>(Ty)); 2134 case Type::Complex: 2135 return CreateType(cast<ComplexType>(Ty)); 2136 case Type::Pointer: 2137 return CreateType(cast<PointerType>(Ty), Unit); 2138 case Type::Decayed: 2139 // Decayed types are just pointers in LLVM and DWARF. 2140 return CreateType( 2141 cast<PointerType>(cast<DecayedType>(Ty)->getDecayedType()), Unit); 2142 case Type::BlockPointer: 2143 return CreateType(cast<BlockPointerType>(Ty), Unit); 2144 case Type::Typedef: 2145 return CreateType(cast<TypedefType>(Ty), Unit); 2146 case Type::Record: 2147 return CreateType(cast<RecordType>(Ty)); 2148 case Type::Enum: 2149 return CreateEnumType(cast<EnumType>(Ty)); 2150 case Type::FunctionProto: 2151 case Type::FunctionNoProto: 2152 return CreateType(cast<FunctionType>(Ty), Unit); 2153 case Type::ConstantArray: 2154 case Type::VariableArray: 2155 case Type::IncompleteArray: 2156 return CreateType(cast<ArrayType>(Ty), Unit); 2157 2158 case Type::LValueReference: 2159 return CreateType(cast<LValueReferenceType>(Ty), Unit); 2160 case Type::RValueReference: 2161 return CreateType(cast<RValueReferenceType>(Ty), Unit); 2162 2163 case Type::MemberPointer: 2164 return CreateType(cast<MemberPointerType>(Ty), Unit); 2165 2166 case Type::Atomic: 2167 return CreateType(cast<AtomicType>(Ty), Unit); 2168 2169 case Type::Attributed: 2170 case Type::TemplateSpecialization: 2171 case Type::Elaborated: 2172 case Type::Paren: 2173 case Type::SubstTemplateTypeParm: 2174 case Type::TypeOfExpr: 2175 case Type::TypeOf: 2176 case Type::Decltype: 2177 case Type::UnaryTransform: 2178 case Type::PackExpansion: 2179 llvm_unreachable("type should have been unwrapped!"); 2180 case Type::Auto: 2181 Diag = "auto"; 2182 break; 2183 } 2184 2185 assert(Diag && "Fall through without a diagnostic?"); 2186 unsigned DiagID = CGM.getDiags().getCustomDiagID(DiagnosticsEngine::Error, 2187 "debug information for %0 is not yet supported"); 2188 CGM.getDiags().Report(DiagID) 2189 << Diag; 2190 return llvm::DIType(); 2191} 2192 2193/// getOrCreateLimitedType - Get the type from the cache or create a new 2194/// limited type if necessary. 2195llvm::DIType CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty, 2196 llvm::DIFile Unit) { 2197 QualType QTy(Ty, 0); 2198 2199 llvm::DICompositeType T(getTypeOrNull(QTy)); 2200 2201 // We may have cached a forward decl when we could have created 2202 // a non-forward decl. Go ahead and create a non-forward decl 2203 // now. 2204 if (T && !T.isForwardDecl()) return T; 2205 2206 // Otherwise create the type. 2207 llvm::DICompositeType Res = CreateLimitedType(Ty); 2208 2209 // Propagate members from the declaration to the definition 2210 // CreateType(const RecordType*) will overwrite this with the members in the 2211 // correct order if the full type is needed. 2212 Res.setTypeArray(T.getTypeArray()); 2213 2214 if (T && T.isForwardDecl()) 2215 ReplaceMap.push_back( 2216 std::make_pair(QTy.getAsOpaquePtr(), static_cast<llvm::Value *>(T))); 2217 2218 // And update the type cache. 2219 TypeCache[QTy.getAsOpaquePtr()] = Res; 2220 return Res; 2221} 2222 2223// TODO: Currently used for context chains when limiting debug info. 2224llvm::DICompositeType CGDebugInfo::CreateLimitedType(const RecordType *Ty) { 2225 RecordDecl *RD = Ty->getDecl(); 2226 2227 // Get overall information about the record type for the debug info. 2228 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation()); 2229 unsigned Line = getLineNumber(RD->getLocation()); 2230 StringRef RDName = getClassName(RD); 2231 2232 llvm::DIDescriptor RDContext; 2233 if (DebugKind == CodeGenOptions::LimitedDebugInfo) 2234 RDContext = createContextChain(cast<Decl>(RD->getDeclContext())); 2235 else 2236 RDContext = getContextDescriptor(cast<Decl>(RD->getDeclContext())); 2237 2238 // If we ended up creating the type during the context chain construction, 2239 // just return that. 2240 // FIXME: this could be dealt with better if the type was recorded as 2241 // completed before we started this (see the CompletedTypeCache usage in 2242 // CGDebugInfo::CreateTypeDefinition(const RecordType*) - that would need to 2243 // be pushed to before context creation, but after it was known to be 2244 // destined for completion (might still have an issue if this caller only 2245 // required a declaration but the context construction ended up creating a 2246 // definition) 2247 llvm::DICompositeType T(getTypeOrNull(CGM.getContext().getRecordType(RD))); 2248 if (T && (!T.isForwardDecl() || !RD->getDefinition())) 2249 return T; 2250 2251 // If this is just a forward declaration, construct an appropriately 2252 // marked node and just return it. 2253 if (!RD->getDefinition()) 2254 return getOrCreateRecordFwdDecl(Ty, RDContext); 2255 2256 uint64_t Size = CGM.getContext().getTypeSize(Ty); 2257 uint64_t Align = CGM.getContext().getTypeAlign(Ty); 2258 llvm::DICompositeType RealDecl; 2259 2260 if (RD->isUnion()) 2261 RealDecl = DBuilder.createUnionType(RDContext, RDName, DefUnit, Line, 2262 Size, Align, 0, llvm::DIArray()); 2263 else if (RD->isClass()) { 2264 // FIXME: This could be a struct type giving a default visibility different 2265 // than C++ class type, but needs llvm metadata changes first. 2266 RealDecl = DBuilder.createClassType(RDContext, RDName, DefUnit, Line, 2267 Size, Align, 0, 0, llvm::DIType(), 2268 llvm::DIArray(), llvm::DIType(), 2269 llvm::DIArray()); 2270 } else 2271 RealDecl = DBuilder.createStructType(RDContext, RDName, DefUnit, Line, 2272 Size, Align, 0, llvm::DIType(), 2273 llvm::DIArray()); 2274 2275 RegionMap[Ty->getDecl()] = llvm::WeakVH(RealDecl); 2276 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = RealDecl; 2277 2278 if (const ClassTemplateSpecializationDecl *TSpecial = 2279 dyn_cast<ClassTemplateSpecializationDecl>(RD)) 2280 RealDecl.setTypeArray(llvm::DIArray(), 2281 CollectCXXTemplateParams(TSpecial, DefUnit)); 2282 return RealDecl; 2283} 2284 2285void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD, 2286 llvm::DICompositeType RealDecl) { 2287 // A class's primary base or the class itself contains the vtable. 2288 llvm::DICompositeType ContainingType; 2289 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); 2290 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) { 2291 // Seek non virtual primary base root. 2292 while (1) { 2293 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase); 2294 const CXXRecordDecl *PBT = BRL.getPrimaryBase(); 2295 if (PBT && !BRL.isPrimaryBaseVirtual()) 2296 PBase = PBT; 2297 else 2298 break; 2299 } 2300 ContainingType = llvm::DICompositeType( 2301 getOrCreateType(QualType(PBase->getTypeForDecl(), 0), 2302 getOrCreateFile(RD->getLocation()))); 2303 } else if (RD->isDynamicClass()) 2304 ContainingType = RealDecl; 2305 2306 RealDecl.setContainingType(ContainingType); 2307} 2308 2309/// CreateMemberType - Create new member and increase Offset by FType's size. 2310llvm::DIType CGDebugInfo::CreateMemberType(llvm::DIFile Unit, QualType FType, 2311 StringRef Name, 2312 uint64_t *Offset) { 2313 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 2314 uint64_t FieldSize = CGM.getContext().getTypeSize(FType); 2315 unsigned FieldAlign = CGM.getContext().getTypeAlign(FType); 2316 llvm::DIType Ty = DBuilder.createMemberType(Unit, Name, Unit, 0, 2317 FieldSize, FieldAlign, 2318 *Offset, 0, FieldTy); 2319 *Offset += FieldSize; 2320 return Ty; 2321} 2322 2323llvm::DIDescriptor CGDebugInfo::getDeclarationOrDefinition(const Decl *D) { 2324 // We only need a declaration (not a definition) of the type - so use whatever 2325 // we would otherwise do to get a type for a pointee. (forward declarations in 2326 // limited debug info, full definitions (if the type definition is available) 2327 // in unlimited debug info) 2328 if (const TypeDecl *TD = dyn_cast<TypeDecl>(D)) 2329 return getOrCreateType(CGM.getContext().getTypeDeclType(TD), 2330 getOrCreateFile(TD->getLocation())); 2331 // Otherwise fall back to a fairly rudimentary cache of existing declarations. 2332 // This doesn't handle providing declarations (for functions or variables) for 2333 // entities without definitions in this TU, nor when the definition proceeds 2334 // the call to this function. 2335 // FIXME: This should be split out into more specific maps with support for 2336 // emitting forward declarations and merging definitions with declarations, 2337 // the same way as we do for types. 2338 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator I = 2339 DeclCache.find(D->getCanonicalDecl()); 2340 if (I == DeclCache.end()) 2341 return llvm::DIDescriptor(); 2342 llvm::Value *V = I->second; 2343 return llvm::DIDescriptor(dyn_cast_or_null<llvm::MDNode>(V)); 2344} 2345 2346/// getFunctionDeclaration - Return debug info descriptor to describe method 2347/// declaration for the given method definition. 2348llvm::DISubprogram CGDebugInfo::getFunctionDeclaration(const Decl *D) { 2349 if (!D || DebugKind == CodeGenOptions::DebugLineTablesOnly) 2350 return llvm::DISubprogram(); 2351 2352 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 2353 if (!FD) return llvm::DISubprogram(); 2354 2355 // Setup context. 2356 llvm::DIScope S = getContextDescriptor(cast<Decl>(D->getDeclContext())); 2357 2358 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator 2359 MI = SPCache.find(FD->getCanonicalDecl()); 2360 if (MI == SPCache.end()) { 2361 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) { 2362 llvm::DICompositeType T(S); 2363 llvm::DISubprogram SP = CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()), T); 2364 T.addMember(SP); 2365 return SP; 2366 } 2367 } 2368 if (MI != SPCache.end()) { 2369 llvm::Value *V = MI->second; 2370 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(V)); 2371 if (SP.isSubprogram() && !SP.isDefinition()) 2372 return SP; 2373 } 2374 2375 for (FunctionDecl::redecl_iterator I = FD->redecls_begin(), 2376 E = FD->redecls_end(); I != E; ++I) { 2377 const FunctionDecl *NextFD = *I; 2378 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator 2379 MI = SPCache.find(NextFD->getCanonicalDecl()); 2380 if (MI != SPCache.end()) { 2381 llvm::Value *V = MI->second; 2382 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(V)); 2383 if (SP.isSubprogram() && !SP.isDefinition()) 2384 return SP; 2385 } 2386 } 2387 return llvm::DISubprogram(); 2388} 2389 2390// getOrCreateFunctionType - Construct DIType. If it is a c++ method, include 2391// implicit parameter "this". 2392llvm::DICompositeType CGDebugInfo::getOrCreateFunctionType(const Decl *D, 2393 QualType FnType, 2394 llvm::DIFile F) { 2395 if (!D || DebugKind == CodeGenOptions::DebugLineTablesOnly) 2396 // Create fake but valid subroutine type. Otherwise 2397 // llvm::DISubprogram::Verify() would return false, and 2398 // subprogram DIE will miss DW_AT_decl_file and 2399 // DW_AT_decl_line fields. 2400 return DBuilder.createSubroutineType(F, DBuilder.getOrCreateArray(None)); 2401 2402 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 2403 return getOrCreateMethodType(Method, F); 2404 if (const ObjCMethodDecl *OMethod = dyn_cast<ObjCMethodDecl>(D)) { 2405 // Add "self" and "_cmd" 2406 SmallVector<llvm::Value *, 16> Elts; 2407 2408 // First element is always return type. For 'void' functions it is NULL. 2409 QualType ResultTy = OMethod->getResultType(); 2410 2411 // Replace the instancetype keyword with the actual type. 2412 if (ResultTy == CGM.getContext().getObjCInstanceType()) 2413 ResultTy = CGM.getContext().getPointerType( 2414 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0)); 2415 2416 Elts.push_back(getOrCreateType(ResultTy, F)); 2417 // "self" pointer is always first argument. 2418 QualType SelfDeclTy = OMethod->getSelfDecl()->getType(); 2419 llvm::DIType SelfTy = getOrCreateType(SelfDeclTy, F); 2420 Elts.push_back(CreateSelfType(SelfDeclTy, SelfTy)); 2421 // "_cmd" pointer is always second argument. 2422 llvm::DIType CmdTy = getOrCreateType(OMethod->getCmdDecl()->getType(), F); 2423 Elts.push_back(DBuilder.createArtificialType(CmdTy)); 2424 // Get rest of the arguments. 2425 for (ObjCMethodDecl::param_const_iterator PI = OMethod->param_begin(), 2426 PE = OMethod->param_end(); PI != PE; ++PI) 2427 Elts.push_back(getOrCreateType((*PI)->getType(), F)); 2428 2429 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(Elts); 2430 return DBuilder.createSubroutineType(F, EltTypeArray); 2431 } 2432 return llvm::DICompositeType(getOrCreateType(FnType, F)); 2433} 2434 2435/// EmitFunctionStart - Constructs the debug code for entering a function. 2436void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType, 2437 llvm::Function *Fn, 2438 CGBuilderTy &Builder) { 2439 2440 StringRef Name; 2441 StringRef LinkageName; 2442 2443 FnBeginRegionCount.push_back(LexicalBlockStack.size()); 2444 2445 const Decl *D = GD.getDecl(); 2446 // Function may lack declaration in source code if it is created by Clang 2447 // CodeGen (examples: _GLOBAL__I_a, __cxx_global_array_dtor, thunk). 2448 bool HasDecl = (D != 0); 2449 // Use the location of the declaration. 2450 SourceLocation Loc; 2451 if (HasDecl) 2452 Loc = D->getLocation(); 2453 2454 unsigned Flags = 0; 2455 llvm::DIFile Unit = getOrCreateFile(Loc); 2456 llvm::DIDescriptor FDContext(Unit); 2457 llvm::DIArray TParamsArray; 2458 if (!HasDecl) { 2459 // Use llvm function name. 2460 LinkageName = Fn->getName(); 2461 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2462 // If there is a DISubprogram for this function available then use it. 2463 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator 2464 FI = SPCache.find(FD->getCanonicalDecl()); 2465 if (FI != SPCache.end()) { 2466 llvm::Value *V = FI->second; 2467 llvm::DIDescriptor SP(dyn_cast_or_null<llvm::MDNode>(V)); 2468 if (SP.isSubprogram() && llvm::DISubprogram(SP).isDefinition()) { 2469 llvm::MDNode *SPN = SP; 2470 LexicalBlockStack.push_back(SPN); 2471 RegionMap[D] = llvm::WeakVH(SP); 2472 return; 2473 } 2474 } 2475 Name = getFunctionName(FD); 2476 // Use mangled name as linkage name for C/C++ functions. 2477 if (FD->hasPrototype()) { 2478 LinkageName = CGM.getMangledName(GD); 2479 Flags |= llvm::DIDescriptor::FlagPrototyped; 2480 } 2481 // No need to replicate the linkage name if it isn't different from the 2482 // subprogram name, no need to have it at all unless coverage is enabled or 2483 // debug is set to more than just line tables. 2484 if (LinkageName == Name || 2485 (!CGM.getCodeGenOpts().EmitGcovArcs && 2486 !CGM.getCodeGenOpts().EmitGcovNotes && 2487 DebugKind <= CodeGenOptions::DebugLineTablesOnly)) 2488 LinkageName = StringRef(); 2489 2490 if (DebugKind >= CodeGenOptions::LimitedDebugInfo) { 2491 if (const NamespaceDecl *NSDecl = 2492 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext())) 2493 FDContext = getOrCreateNameSpace(NSDecl); 2494 else if (const RecordDecl *RDecl = 2495 dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) 2496 FDContext = getContextDescriptor(cast<Decl>(RDecl->getDeclContext())); 2497 2498 // Collect template parameters. 2499 TParamsArray = CollectFunctionTemplateParams(FD, Unit); 2500 } 2501 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) { 2502 Name = getObjCMethodName(OMD); 2503 Flags |= llvm::DIDescriptor::FlagPrototyped; 2504 } else { 2505 // Use llvm function name. 2506 Name = Fn->getName(); 2507 Flags |= llvm::DIDescriptor::FlagPrototyped; 2508 } 2509 if (!Name.empty() && Name[0] == '\01') 2510 Name = Name.substr(1); 2511 2512 unsigned LineNo = getLineNumber(Loc); 2513 if (!HasDecl || D->isImplicit()) 2514 Flags |= llvm::DIDescriptor::FlagArtificial; 2515 2516 llvm::DISubprogram SP = DBuilder.createFunction( 2517 FDContext, Name, LinkageName, Unit, LineNo, 2518 getOrCreateFunctionType(D, FnType, Unit), Fn->hasInternalLinkage(), 2519 true /*definition*/, getLineNumber(CurLoc), Flags, 2520 CGM.getLangOpts().Optimize, Fn, TParamsArray, getFunctionDeclaration(D)); 2521 if (HasDecl) 2522 DeclCache.insert(std::make_pair(D->getCanonicalDecl(), llvm::WeakVH(SP))); 2523 2524 // Push function on region stack. 2525 llvm::MDNode *SPN = SP; 2526 LexicalBlockStack.push_back(SPN); 2527 if (HasDecl) 2528 RegionMap[D] = llvm::WeakVH(SP); 2529} 2530 2531/// EmitLocation - Emit metadata to indicate a change in line/column 2532/// information in the source file. If the location is invalid, the 2533/// previous location will be reused. 2534void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc, 2535 bool ForceColumnInfo) { 2536 // Update our current location 2537 setLocation(Loc); 2538 2539 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return; 2540 2541 // Don't bother if things are the same as last time. 2542 SourceManager &SM = CGM.getContext().getSourceManager(); 2543 if (CurLoc == PrevLoc || 2544 SM.getExpansionLoc(CurLoc) == SM.getExpansionLoc(PrevLoc)) 2545 // New Builder may not be in sync with CGDebugInfo. 2546 if (!Builder.getCurrentDebugLocation().isUnknown() && 2547 Builder.getCurrentDebugLocation().getScope(CGM.getLLVMContext()) == 2548 LexicalBlockStack.back()) 2549 return; 2550 2551 // Update last state. 2552 PrevLoc = CurLoc; 2553 2554 llvm::MDNode *Scope = LexicalBlockStack.back(); 2555 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get 2556 (getLineNumber(CurLoc), 2557 getColumnNumber(CurLoc, ForceColumnInfo), 2558 Scope)); 2559} 2560 2561/// CreateLexicalBlock - Creates a new lexical block node and pushes it on 2562/// the stack. 2563void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) { 2564 llvm::DIDescriptor D = 2565 DBuilder.createLexicalBlock(LexicalBlockStack.empty() ? 2566 llvm::DIDescriptor() : 2567 llvm::DIDescriptor(LexicalBlockStack.back()), 2568 getOrCreateFile(CurLoc), 2569 getLineNumber(CurLoc), 2570 getColumnNumber(CurLoc)); 2571 llvm::MDNode *DN = D; 2572 LexicalBlockStack.push_back(DN); 2573} 2574 2575/// EmitLexicalBlockStart - Constructs the debug code for entering a declarative 2576/// region - beginning of a DW_TAG_lexical_block. 2577void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder, 2578 SourceLocation Loc) { 2579 // Set our current location. 2580 setLocation(Loc); 2581 2582 // Create a new lexical block and push it on the stack. 2583 CreateLexicalBlock(Loc); 2584 2585 // Emit a line table change for the current location inside the new scope. 2586 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(getLineNumber(Loc), 2587 getColumnNumber(Loc), 2588 LexicalBlockStack.back())); 2589} 2590 2591/// EmitLexicalBlockEnd - Constructs the debug code for exiting a declarative 2592/// region - end of a DW_TAG_lexical_block. 2593void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder, 2594 SourceLocation Loc) { 2595 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); 2596 2597 // Provide an entry in the line table for the end of the block. 2598 EmitLocation(Builder, Loc); 2599 2600 LexicalBlockStack.pop_back(); 2601} 2602 2603/// EmitFunctionEnd - Constructs the debug code for exiting a function. 2604void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) { 2605 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); 2606 unsigned RCount = FnBeginRegionCount.back(); 2607 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch"); 2608 2609 // Pop all regions for this function. 2610 while (LexicalBlockStack.size() != RCount) 2611 EmitLexicalBlockEnd(Builder, CurLoc); 2612 FnBeginRegionCount.pop_back(); 2613} 2614 2615// EmitTypeForVarWithBlocksAttr - Build up structure info for the byref. 2616// See BuildByRefType. 2617llvm::DIType CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD, 2618 uint64_t *XOffset) { 2619 2620 SmallVector<llvm::Value *, 5> EltTys; 2621 QualType FType; 2622 uint64_t FieldSize, FieldOffset; 2623 unsigned FieldAlign; 2624 2625 llvm::DIFile Unit = getOrCreateFile(VD->getLocation()); 2626 QualType Type = VD->getType(); 2627 2628 FieldOffset = 0; 2629 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); 2630 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset)); 2631 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset)); 2632 FType = CGM.getContext().IntTy; 2633 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset)); 2634 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset)); 2635 2636 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD); 2637 if (HasCopyAndDispose) { 2638 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); 2639 EltTys.push_back(CreateMemberType(Unit, FType, "__copy_helper", 2640 &FieldOffset)); 2641 EltTys.push_back(CreateMemberType(Unit, FType, "__destroy_helper", 2642 &FieldOffset)); 2643 } 2644 bool HasByrefExtendedLayout; 2645 Qualifiers::ObjCLifetime Lifetime; 2646 if (CGM.getContext().getByrefLifetime(Type, 2647 Lifetime, HasByrefExtendedLayout) 2648 && HasByrefExtendedLayout) { 2649 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); 2650 EltTys.push_back(CreateMemberType(Unit, FType, 2651 "__byref_variable_layout", 2652 &FieldOffset)); 2653 } 2654 2655 CharUnits Align = CGM.getContext().getDeclAlign(VD); 2656 if (Align > CGM.getContext().toCharUnitsFromBits( 2657 CGM.getTarget().getPointerAlign(0))) { 2658 CharUnits FieldOffsetInBytes 2659 = CGM.getContext().toCharUnitsFromBits(FieldOffset); 2660 CharUnits AlignedOffsetInBytes 2661 = FieldOffsetInBytes.RoundUpToAlignment(Align); 2662 CharUnits NumPaddingBytes 2663 = AlignedOffsetInBytes - FieldOffsetInBytes; 2664 2665 if (NumPaddingBytes.isPositive()) { 2666 llvm::APInt pad(32, NumPaddingBytes.getQuantity()); 2667 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy, 2668 pad, ArrayType::Normal, 0); 2669 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset)); 2670 } 2671 } 2672 2673 FType = Type; 2674 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); 2675 FieldSize = CGM.getContext().getTypeSize(FType); 2676 FieldAlign = CGM.getContext().toBits(Align); 2677 2678 *XOffset = FieldOffset; 2679 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit, 2680 0, FieldSize, FieldAlign, 2681 FieldOffset, 0, FieldTy); 2682 EltTys.push_back(FieldTy); 2683 FieldOffset += FieldSize; 2684 2685 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys); 2686 2687 unsigned Flags = llvm::DIDescriptor::FlagBlockByrefStruct; 2688 2689 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags, 2690 llvm::DIType(), Elements); 2691} 2692 2693/// EmitDeclare - Emit local variable declaration debug info. 2694void CGDebugInfo::EmitDeclare(const VarDecl *VD, unsigned Tag, 2695 llvm::Value *Storage, 2696 unsigned ArgNo, CGBuilderTy &Builder) { 2697 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 2698 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); 2699 2700 bool Unwritten = 2701 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) && 2702 cast<Decl>(VD->getDeclContext())->isImplicit()); 2703 llvm::DIFile Unit; 2704 if (!Unwritten) 2705 Unit = getOrCreateFile(VD->getLocation()); 2706 llvm::DIType Ty; 2707 uint64_t XOffset = 0; 2708 if (VD->hasAttr<BlocksAttr>()) 2709 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset); 2710 else 2711 Ty = getOrCreateType(VD->getType(), Unit); 2712 2713 // If there is no debug info for this type then do not emit debug info 2714 // for this variable. 2715 if (!Ty) 2716 return; 2717 2718 // Get location information. 2719 unsigned Line = 0; 2720 unsigned Column = 0; 2721 if (!Unwritten) { 2722 Line = getLineNumber(VD->getLocation()); 2723 Column = getColumnNumber(VD->getLocation()); 2724 } 2725 unsigned Flags = 0; 2726 if (VD->isImplicit()) 2727 Flags |= llvm::DIDescriptor::FlagArtificial; 2728 // If this is the first argument and it is implicit then 2729 // give it an object pointer flag. 2730 // FIXME: There has to be a better way to do this, but for static 2731 // functions there won't be an implicit param at arg1 and 2732 // otherwise it is 'self' or 'this'. 2733 if (isa<ImplicitParamDecl>(VD) && ArgNo == 1) 2734 Flags |= llvm::DIDescriptor::FlagObjectPointer; 2735 if (llvm::Argument *Arg = dyn_cast<llvm::Argument>(Storage)) 2736 if (Arg->getType()->isPointerTy() && !Arg->hasByValAttr() && 2737 !VD->getType()->isPointerType()) 2738 Flags |= llvm::DIDescriptor::FlagIndirectVariable; 2739 2740 llvm::MDNode *Scope = LexicalBlockStack.back(); 2741 2742 StringRef Name = VD->getName(); 2743 if (!Name.empty()) { 2744 if (VD->hasAttr<BlocksAttr>()) { 2745 CharUnits offset = CharUnits::fromQuantity(32); 2746 SmallVector<llvm::Value *, 9> addr; 2747 llvm::Type *Int64Ty = CGM.Int64Ty; 2748 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus)); 2749 // offset of __forwarding field 2750 offset = CGM.getContext().toCharUnitsFromBits( 2751 CGM.getTarget().getPointerWidth(0)); 2752 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity())); 2753 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref)); 2754 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus)); 2755 // offset of x field 2756 offset = CGM.getContext().toCharUnitsFromBits(XOffset); 2757 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity())); 2758 2759 // Create the descriptor for the variable. 2760 llvm::DIVariable D = 2761 DBuilder.createComplexVariable(Tag, 2762 llvm::DIDescriptor(Scope), 2763 VD->getName(), Unit, Line, Ty, 2764 addr, ArgNo); 2765 2766 // Insert an llvm.dbg.declare into the current block. 2767 llvm::Instruction *Call = 2768 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock()); 2769 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope)); 2770 return; 2771 } 2772 } else if (const RecordType *RT = dyn_cast<RecordType>(VD->getType())) { 2773 // If VD is an anonymous union then Storage represents value for 2774 // all union fields. 2775 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl()); 2776 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) { 2777 for (RecordDecl::field_iterator I = RD->field_begin(), 2778 E = RD->field_end(); 2779 I != E; ++I) { 2780 FieldDecl *Field = *I; 2781 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit); 2782 StringRef FieldName = Field->getName(); 2783 2784 // Ignore unnamed fields. Do not ignore unnamed records. 2785 if (FieldName.empty() && !isa<RecordType>(Field->getType())) 2786 continue; 2787 2788 // Use VarDecl's Tag, Scope and Line number. 2789 llvm::DIVariable D = 2790 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope), 2791 FieldName, Unit, Line, FieldTy, 2792 CGM.getLangOpts().Optimize, Flags, 2793 ArgNo); 2794 2795 // Insert an llvm.dbg.declare into the current block. 2796 llvm::Instruction *Call = 2797 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock()); 2798 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope)); 2799 } 2800 return; 2801 } 2802 } 2803 2804 // Create the descriptor for the variable. 2805 llvm::DIVariable D = 2806 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope), 2807 Name, Unit, Line, Ty, 2808 CGM.getLangOpts().Optimize, Flags, ArgNo); 2809 2810 // Insert an llvm.dbg.declare into the current block. 2811 llvm::Instruction *Call = 2812 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock()); 2813 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope)); 2814} 2815 2816void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, 2817 llvm::Value *Storage, 2818 CGBuilderTy &Builder) { 2819 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 2820 EmitDeclare(VD, llvm::dwarf::DW_TAG_auto_variable, Storage, 0, Builder); 2821} 2822 2823/// Look up the completed type for a self pointer in the TypeCache and 2824/// create a copy of it with the ObjectPointer and Artificial flags 2825/// set. If the type is not cached, a new one is created. This should 2826/// never happen though, since creating a type for the implicit self 2827/// argument implies that we already parsed the interface definition 2828/// and the ivar declarations in the implementation. 2829llvm::DIType CGDebugInfo::CreateSelfType(const QualType &QualTy, 2830 llvm::DIType Ty) { 2831 llvm::DIType CachedTy = getTypeOrNull(QualTy); 2832 if (CachedTy) Ty = CachedTy; 2833 else DEBUG(llvm::dbgs() << "No cached type for self."); 2834 return DBuilder.createObjectPointerType(Ty); 2835} 2836 2837void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(const VarDecl *VD, 2838 llvm::Value *Storage, 2839 CGBuilderTy &Builder, 2840 const CGBlockInfo &blockInfo) { 2841 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 2842 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); 2843 2844 if (Builder.GetInsertBlock() == 0) 2845 return; 2846 2847 bool isByRef = VD->hasAttr<BlocksAttr>(); 2848 2849 uint64_t XOffset = 0; 2850 llvm::DIFile Unit = getOrCreateFile(VD->getLocation()); 2851 llvm::DIType Ty; 2852 if (isByRef) 2853 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset); 2854 else 2855 Ty = getOrCreateType(VD->getType(), Unit); 2856 2857 // Self is passed along as an implicit non-arg variable in a 2858 // block. Mark it as the object pointer. 2859 if (isa<ImplicitParamDecl>(VD) && VD->getName() == "self") 2860 Ty = CreateSelfType(VD->getType(), Ty); 2861 2862 // Get location information. 2863 unsigned Line = getLineNumber(VD->getLocation()); 2864 unsigned Column = getColumnNumber(VD->getLocation()); 2865 2866 const llvm::DataLayout &target = CGM.getDataLayout(); 2867 2868 CharUnits offset = CharUnits::fromQuantity( 2869 target.getStructLayout(blockInfo.StructureType) 2870 ->getElementOffset(blockInfo.getCapture(VD).getIndex())); 2871 2872 SmallVector<llvm::Value *, 9> addr; 2873 llvm::Type *Int64Ty = CGM.Int64Ty; 2874 if (isa<llvm::AllocaInst>(Storage)) 2875 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref)); 2876 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus)); 2877 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity())); 2878 if (isByRef) { 2879 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref)); 2880 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus)); 2881 // offset of __forwarding field 2882 offset = CGM.getContext() 2883 .toCharUnitsFromBits(target.getPointerSizeInBits(0)); 2884 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity())); 2885 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref)); 2886 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus)); 2887 // offset of x field 2888 offset = CGM.getContext().toCharUnitsFromBits(XOffset); 2889 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity())); 2890 } 2891 2892 // Create the descriptor for the variable. 2893 llvm::DIVariable D = 2894 DBuilder.createComplexVariable(llvm::dwarf::DW_TAG_auto_variable, 2895 llvm::DIDescriptor(LexicalBlockStack.back()), 2896 VD->getName(), Unit, Line, Ty, addr); 2897 2898 // Insert an llvm.dbg.declare into the current block. 2899 llvm::Instruction *Call = 2900 DBuilder.insertDeclare(Storage, D, Builder.GetInsertPoint()); 2901 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, 2902 LexicalBlockStack.back())); 2903} 2904 2905/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument 2906/// variable declaration. 2907void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI, 2908 unsigned ArgNo, 2909 CGBuilderTy &Builder) { 2910 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 2911 EmitDeclare(VD, llvm::dwarf::DW_TAG_arg_variable, AI, ArgNo, Builder); 2912} 2913 2914namespace { 2915 struct BlockLayoutChunk { 2916 uint64_t OffsetInBits; 2917 const BlockDecl::Capture *Capture; 2918 }; 2919 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) { 2920 return l.OffsetInBits < r.OffsetInBits; 2921 } 2922} 2923 2924void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block, 2925 llvm::Value *Arg, 2926 llvm::Value *LocalAddr, 2927 CGBuilderTy &Builder) { 2928 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 2929 ASTContext &C = CGM.getContext(); 2930 const BlockDecl *blockDecl = block.getBlockDecl(); 2931 2932 // Collect some general information about the block's location. 2933 SourceLocation loc = blockDecl->getCaretLocation(); 2934 llvm::DIFile tunit = getOrCreateFile(loc); 2935 unsigned line = getLineNumber(loc); 2936 unsigned column = getColumnNumber(loc); 2937 2938 // Build the debug-info type for the block literal. 2939 getContextDescriptor(cast<Decl>(blockDecl->getDeclContext())); 2940 2941 const llvm::StructLayout *blockLayout = 2942 CGM.getDataLayout().getStructLayout(block.StructureType); 2943 2944 SmallVector<llvm::Value*, 16> fields; 2945 fields.push_back(createFieldType("__isa", C.VoidPtrTy, 0, loc, AS_public, 2946 blockLayout->getElementOffsetInBits(0), 2947 tunit, tunit)); 2948 fields.push_back(createFieldType("__flags", C.IntTy, 0, loc, AS_public, 2949 blockLayout->getElementOffsetInBits(1), 2950 tunit, tunit)); 2951 fields.push_back(createFieldType("__reserved", C.IntTy, 0, loc, AS_public, 2952 blockLayout->getElementOffsetInBits(2), 2953 tunit, tunit)); 2954 fields.push_back(createFieldType("__FuncPtr", C.VoidPtrTy, 0, loc, AS_public, 2955 blockLayout->getElementOffsetInBits(3), 2956 tunit, tunit)); 2957 fields.push_back(createFieldType("__descriptor", 2958 C.getPointerType(block.NeedsCopyDispose ? 2959 C.getBlockDescriptorExtendedType() : 2960 C.getBlockDescriptorType()), 2961 0, loc, AS_public, 2962 blockLayout->getElementOffsetInBits(4), 2963 tunit, tunit)); 2964 2965 // We want to sort the captures by offset, not because DWARF 2966 // requires this, but because we're paranoid about debuggers. 2967 SmallVector<BlockLayoutChunk, 8> chunks; 2968 2969 // 'this' capture. 2970 if (blockDecl->capturesCXXThis()) { 2971 BlockLayoutChunk chunk; 2972 chunk.OffsetInBits = 2973 blockLayout->getElementOffsetInBits(block.CXXThisIndex); 2974 chunk.Capture = 0; 2975 chunks.push_back(chunk); 2976 } 2977 2978 // Variable captures. 2979 for (BlockDecl::capture_const_iterator 2980 i = blockDecl->capture_begin(), e = blockDecl->capture_end(); 2981 i != e; ++i) { 2982 const BlockDecl::Capture &capture = *i; 2983 const VarDecl *variable = capture.getVariable(); 2984 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable); 2985 2986 // Ignore constant captures. 2987 if (captureInfo.isConstant()) 2988 continue; 2989 2990 BlockLayoutChunk chunk; 2991 chunk.OffsetInBits = 2992 blockLayout->getElementOffsetInBits(captureInfo.getIndex()); 2993 chunk.Capture = &capture; 2994 chunks.push_back(chunk); 2995 } 2996 2997 // Sort by offset. 2998 llvm::array_pod_sort(chunks.begin(), chunks.end()); 2999 3000 for (SmallVectorImpl<BlockLayoutChunk>::iterator 3001 i = chunks.begin(), e = chunks.end(); i != e; ++i) { 3002 uint64_t offsetInBits = i->OffsetInBits; 3003 const BlockDecl::Capture *capture = i->Capture; 3004 3005 // If we have a null capture, this must be the C++ 'this' capture. 3006 if (!capture) { 3007 const CXXMethodDecl *method = 3008 cast<CXXMethodDecl>(blockDecl->getNonClosureContext()); 3009 QualType type = method->getThisType(C); 3010 3011 fields.push_back(createFieldType("this", type, 0, loc, AS_public, 3012 offsetInBits, tunit, tunit)); 3013 continue; 3014 } 3015 3016 const VarDecl *variable = capture->getVariable(); 3017 StringRef name = variable->getName(); 3018 3019 llvm::DIType fieldType; 3020 if (capture->isByRef()) { 3021 std::pair<uint64_t,unsigned> ptrInfo = C.getTypeInfo(C.VoidPtrTy); 3022 3023 // FIXME: this creates a second copy of this type! 3024 uint64_t xoffset; 3025 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset); 3026 fieldType = DBuilder.createPointerType(fieldType, ptrInfo.first); 3027 fieldType = DBuilder.createMemberType(tunit, name, tunit, line, 3028 ptrInfo.first, ptrInfo.second, 3029 offsetInBits, 0, fieldType); 3030 } else { 3031 fieldType = createFieldType(name, variable->getType(), 0, 3032 loc, AS_public, offsetInBits, tunit, tunit); 3033 } 3034 fields.push_back(fieldType); 3035 } 3036 3037 SmallString<36> typeName; 3038 llvm::raw_svector_ostream(typeName) 3039 << "__block_literal_" << CGM.getUniqueBlockCount(); 3040 3041 llvm::DIArray fieldsArray = DBuilder.getOrCreateArray(fields); 3042 3043 llvm::DIType type = 3044 DBuilder.createStructType(tunit, typeName.str(), tunit, line, 3045 CGM.getContext().toBits(block.BlockSize), 3046 CGM.getContext().toBits(block.BlockAlign), 3047 0, llvm::DIType(), fieldsArray); 3048 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits); 3049 3050 // Get overall information about the block. 3051 unsigned flags = llvm::DIDescriptor::FlagArtificial; 3052 llvm::MDNode *scope = LexicalBlockStack.back(); 3053 3054 // Create the descriptor for the parameter. 3055 llvm::DIVariable debugVar = 3056 DBuilder.createLocalVariable(llvm::dwarf::DW_TAG_arg_variable, 3057 llvm::DIDescriptor(scope), 3058 Arg->getName(), tunit, line, type, 3059 CGM.getLangOpts().Optimize, flags, 3060 cast<llvm::Argument>(Arg)->getArgNo() + 1); 3061 3062 if (LocalAddr) { 3063 // Insert an llvm.dbg.value into the current block. 3064 llvm::Instruction *DbgVal = 3065 DBuilder.insertDbgValueIntrinsic(LocalAddr, 0, debugVar, 3066 Builder.GetInsertBlock()); 3067 DbgVal->setDebugLoc(llvm::DebugLoc::get(line, column, scope)); 3068 } 3069 3070 // Insert an llvm.dbg.declare into the current block. 3071 llvm::Instruction *DbgDecl = 3072 DBuilder.insertDeclare(Arg, debugVar, Builder.GetInsertBlock()); 3073 DbgDecl->setDebugLoc(llvm::DebugLoc::get(line, column, scope)); 3074} 3075 3076/// If D is an out-of-class definition of a static data member of a class, find 3077/// its corresponding in-class declaration. 3078llvm::DIDerivedType 3079CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) { 3080 if (!D->isStaticDataMember()) 3081 return llvm::DIDerivedType(); 3082 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator MI = 3083 StaticDataMemberCache.find(D->getCanonicalDecl()); 3084 if (MI != StaticDataMemberCache.end()) { 3085 assert(MI->second && "Static data member declaration should still exist"); 3086 return llvm::DIDerivedType(cast<llvm::MDNode>(MI->second)); 3087 } 3088 3089 // If the member wasn't found in the cache, lazily construct and add it to the 3090 // type (used when a limited form of the type is emitted). 3091 llvm::DICompositeType Ctxt( 3092 getContextDescriptor(cast<Decl>(D->getDeclContext()))); 3093 llvm::DIDerivedType T = CreateRecordStaticField(D, Ctxt); 3094 Ctxt.addMember(T); 3095 return T; 3096} 3097 3098/// EmitGlobalVariable - Emit information about a global variable. 3099void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, 3100 const VarDecl *D) { 3101 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 3102 // Create global variable debug descriptor. 3103 llvm::DIFile Unit = getOrCreateFile(D->getLocation()); 3104 unsigned LineNo = getLineNumber(D->getLocation()); 3105 3106 setLocation(D->getLocation()); 3107 3108 QualType T = D->getType(); 3109 if (T->isIncompleteArrayType()) { 3110 3111 // CodeGen turns int[] into int[1] so we'll do the same here. 3112 llvm::APInt ConstVal(32, 1); 3113 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType(); 3114 3115 T = CGM.getContext().getConstantArrayType(ET, ConstVal, 3116 ArrayType::Normal, 0); 3117 } 3118 StringRef DeclName = D->getName(); 3119 StringRef LinkageName; 3120 if (D->getDeclContext() && !isa<FunctionDecl>(D->getDeclContext()) 3121 && !isa<ObjCMethodDecl>(D->getDeclContext())) 3122 LinkageName = Var->getName(); 3123 if (LinkageName == DeclName) 3124 LinkageName = StringRef(); 3125 llvm::DIDescriptor DContext = 3126 getContextDescriptor(dyn_cast<Decl>(D->getDeclContext())); 3127 llvm::DIGlobalVariable GV = DBuilder.createStaticVariable( 3128 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit), 3129 Var->hasInternalLinkage(), Var, 3130 getOrCreateStaticDataMemberDeclarationOrNull(D)); 3131 DeclCache.insert(std::make_pair(D->getCanonicalDecl(), llvm::WeakVH(GV))); 3132} 3133 3134/// EmitGlobalVariable - Emit information about an objective-c interface. 3135void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, 3136 ObjCInterfaceDecl *ID) { 3137 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 3138 // Create global variable debug descriptor. 3139 llvm::DIFile Unit = getOrCreateFile(ID->getLocation()); 3140 unsigned LineNo = getLineNumber(ID->getLocation()); 3141 3142 StringRef Name = ID->getName(); 3143 3144 QualType T = CGM.getContext().getObjCInterfaceType(ID); 3145 if (T->isIncompleteArrayType()) { 3146 3147 // CodeGen turns int[] into int[1] so we'll do the same here. 3148 llvm::APInt ConstVal(32, 1); 3149 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType(); 3150 3151 T = CGM.getContext().getConstantArrayType(ET, ConstVal, 3152 ArrayType::Normal, 0); 3153 } 3154 3155 DBuilder.createGlobalVariable(Name, Unit, LineNo, 3156 getOrCreateType(T, Unit), 3157 Var->hasInternalLinkage(), Var); 3158} 3159 3160/// EmitGlobalVariable - Emit global variable's debug info. 3161void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, 3162 llvm::Constant *Init) { 3163 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo); 3164 // Create the descriptor for the variable. 3165 llvm::DIFile Unit = getOrCreateFile(VD->getLocation()); 3166 StringRef Name = VD->getName(); 3167 llvm::DIType Ty = getOrCreateType(VD->getType(), Unit); 3168 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) { 3169 const EnumDecl *ED = cast<EnumDecl>(ECD->getDeclContext()); 3170 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?"); 3171 Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit); 3172 } 3173 // Do not use DIGlobalVariable for enums. 3174 if (Ty.getTag() == llvm::dwarf::DW_TAG_enumeration_type) 3175 return; 3176 llvm::DIGlobalVariable GV = DBuilder.createStaticVariable( 3177 Unit, Name, Name, Unit, getLineNumber(VD->getLocation()), Ty, true, Init, 3178 getOrCreateStaticDataMemberDeclarationOrNull(cast<VarDecl>(VD))); 3179 DeclCache.insert(std::make_pair(VD->getCanonicalDecl(), llvm::WeakVH(GV))); 3180} 3181 3182llvm::DIScope CGDebugInfo::getCurrentContextDescriptor(const Decl *D) { 3183 if (!LexicalBlockStack.empty()) 3184 return llvm::DIScope(LexicalBlockStack.back()); 3185 return getContextDescriptor(D); 3186} 3187 3188void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) { 3189 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo) 3190 return; 3191 DBuilder.createImportedModule( 3192 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())), 3193 getOrCreateNameSpace(UD.getNominatedNamespace()), 3194 getLineNumber(UD.getLocation())); 3195} 3196 3197void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) { 3198 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo) 3199 return; 3200 assert(UD.shadow_size() && 3201 "We shouldn't be codegening an invalid UsingDecl containing no decls"); 3202 // Emitting one decl is sufficient - debuggers can detect that this is an 3203 // overloaded name & provide lookup for all the overloads. 3204 const UsingShadowDecl &USD = **UD.shadow_begin(); 3205 if (llvm::DIDescriptor Target = 3206 getDeclarationOrDefinition(USD.getUnderlyingDecl())) 3207 DBuilder.createImportedDeclaration( 3208 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target, 3209 getLineNumber(USD.getLocation())); 3210} 3211 3212llvm::DIImportedEntity 3213CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) { 3214 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo) 3215 return llvm::DIImportedEntity(0); 3216 llvm::WeakVH &VH = NamespaceAliasCache[&NA]; 3217 if (VH) 3218 return llvm::DIImportedEntity(cast<llvm::MDNode>(VH)); 3219 llvm::DIImportedEntity R(0); 3220 if (const NamespaceAliasDecl *Underlying = 3221 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace())) 3222 // This could cache & dedup here rather than relying on metadata deduping. 3223 R = DBuilder.createImportedModule( 3224 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())), 3225 EmitNamespaceAlias(*Underlying), getLineNumber(NA.getLocation()), 3226 NA.getName()); 3227 else 3228 R = DBuilder.createImportedModule( 3229 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())), 3230 getOrCreateNameSpace(cast<NamespaceDecl>(NA.getAliasedNamespace())), 3231 getLineNumber(NA.getLocation()), NA.getName()); 3232 VH = R; 3233 return R; 3234} 3235 3236/// getOrCreateNamesSpace - Return namespace descriptor for the given 3237/// namespace decl. 3238llvm::DINameSpace 3239CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl) { 3240 NSDecl = NSDecl->getCanonicalDecl(); 3241 llvm::DenseMap<const NamespaceDecl *, llvm::WeakVH>::iterator I = 3242 NameSpaceCache.find(NSDecl); 3243 if (I != NameSpaceCache.end()) 3244 return llvm::DINameSpace(cast<llvm::MDNode>(I->second)); 3245 3246 unsigned LineNo = getLineNumber(NSDecl->getLocation()); 3247 llvm::DIFile FileD = getOrCreateFile(NSDecl->getLocation()); 3248 llvm::DIDescriptor Context = 3249 getContextDescriptor(dyn_cast<Decl>(NSDecl->getDeclContext())); 3250 llvm::DINameSpace NS = 3251 DBuilder.createNameSpace(Context, NSDecl->getName(), FileD, LineNo); 3252 NameSpaceCache[NSDecl] = llvm::WeakVH(NS); 3253 return NS; 3254} 3255 3256void CGDebugInfo::finalize() { 3257 for (std::vector<std::pair<void *, llvm::WeakVH> >::const_iterator VI 3258 = ReplaceMap.begin(), VE = ReplaceMap.end(); VI != VE; ++VI) { 3259 llvm::DIType Ty, RepTy; 3260 // Verify that the debug info still exists. 3261 if (llvm::Value *V = VI->second) 3262 Ty = llvm::DIType(cast<llvm::MDNode>(V)); 3263 3264 llvm::DenseMap<void *, llvm::WeakVH>::iterator it = 3265 TypeCache.find(VI->first); 3266 if (it != TypeCache.end()) { 3267 // Verify that the debug info still exists. 3268 if (llvm::Value *V = it->second) 3269 RepTy = llvm::DIType(cast<llvm::MDNode>(V)); 3270 } 3271 3272 if (Ty && Ty.isForwardDecl() && RepTy) 3273 Ty.replaceAllUsesWith(RepTy); 3274 } 3275 3276 // We keep our own list of retained types, because we need to look 3277 // up the final type in the type cache. 3278 for (std::vector<void *>::const_iterator RI = RetainedTypes.begin(), 3279 RE = RetainedTypes.end(); RI != RE; ++RI) 3280 DBuilder.retainType(llvm::DIType(cast<llvm::MDNode>(TypeCache[*RI]))); 3281 3282 DBuilder.finalize(); 3283} 3284