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