1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs 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 per-module state used while generating code. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CodeGenModule.h" 15 #include "CGCUDARuntime.h" 16 #include "CGCXXABI.h" 17 #include "CGCall.h" 18 #include "CGDebugInfo.h" 19 #include "CGObjCRuntime.h" 20 #include "CGOpenCLRuntime.h" 21 #include "CGOpenMPRuntime.h" 22 #include "CodeGenFunction.h" 23 #include "CodeGenPGO.h" 24 #include "CodeGenTBAA.h" 25 #include "CoverageMappingGen.h" 26 #include "TargetInfo.h" 27 #include "clang/AST/ASTContext.h" 28 #include "clang/AST/CharUnits.h" 29 #include "clang/AST/DeclCXX.h" 30 #include "clang/AST/DeclObjC.h" 31 #include "clang/AST/DeclTemplate.h" 32 #include "clang/AST/Mangle.h" 33 #include "clang/AST/RecordLayout.h" 34 #include "clang/AST/RecursiveASTVisitor.h" 35 #include "clang/Basic/Builtins.h" 36 #include "clang/Basic/CharInfo.h" 37 #include "clang/Basic/Diagnostic.h" 38 #include "clang/Basic/Module.h" 39 #include "clang/Basic/SourceManager.h" 40 #include "clang/Basic/TargetInfo.h" 41 #include "clang/Basic/Version.h" 42 #include "clang/Frontend/CodeGenOptions.h" 43 #include "clang/Sema/SemaDiagnostic.h" 44 #include "llvm/ADT/APSInt.h" 45 #include "llvm/ADT/Triple.h" 46 #include "llvm/IR/CallSite.h" 47 #include "llvm/IR/CallingConv.h" 48 #include "llvm/IR/DataLayout.h" 49 #include "llvm/IR/Intrinsics.h" 50 #include "llvm/IR/LLVMContext.h" 51 #include "llvm/IR/Module.h" 52 #include "llvm/ProfileData/InstrProfReader.h" 53 #include "llvm/Support/ConvertUTF.h" 54 #include "llvm/Support/ErrorHandling.h" 55 56 using namespace clang; 57 using namespace CodeGen; 58 59 static const char AnnotationSection[] = "llvm.metadata"; 60 61 static CGCXXABI *createCXXABI(CodeGenModule &CGM) { 62 switch (CGM.getTarget().getCXXABI().getKind()) { 63 case TargetCXXABI::GenericAArch64: 64 case TargetCXXABI::GenericARM: 65 case TargetCXXABI::iOS: 66 case TargetCXXABI::iOS64: 67 case TargetCXXABI::GenericItanium: 68 return CreateItaniumCXXABI(CGM); 69 case TargetCXXABI::Microsoft: 70 return CreateMicrosoftCXXABI(CGM); 71 } 72 73 llvm_unreachable("invalid C++ ABI kind"); 74 } 75 76 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 77 llvm::Module &M, const llvm::DataLayout &TD, 78 DiagnosticsEngine &diags, 79 CoverageSourceInfo *CoverageInfo) 80 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M), 81 Diags(diags), TheDataLayout(TD), Target(C.getTargetInfo()), 82 ABI(createCXXABI(*this)), VMContext(M.getContext()), TBAA(nullptr), 83 TheTargetCodeGenInfo(nullptr), Types(*this), VTables(*this), 84 ObjCRuntime(nullptr), OpenCLRuntime(nullptr), OpenMPRuntime(nullptr), 85 CUDARuntime(nullptr), DebugInfo(nullptr), ARCData(nullptr), 86 NoObjCARCExceptionsMetadata(nullptr), RRData(nullptr), PGOReader(nullptr), 87 CFConstantStringClassRef(nullptr), ConstantStringClassRef(nullptr), 88 NSConstantStringType(nullptr), NSConcreteGlobalBlock(nullptr), 89 NSConcreteStackBlock(nullptr), BlockObjectAssign(nullptr), 90 BlockObjectDispose(nullptr), BlockDescriptorType(nullptr), 91 GenericBlockLiteralType(nullptr), LifetimeStartFn(nullptr), 92 LifetimeEndFn(nullptr), SanitizerMD(new SanitizerMetadata(*this)) { 93 94 // Initialize the type cache. 95 llvm::LLVMContext &LLVMContext = M.getContext(); 96 VoidTy = llvm::Type::getVoidTy(LLVMContext); 97 Int8Ty = llvm::Type::getInt8Ty(LLVMContext); 98 Int16Ty = llvm::Type::getInt16Ty(LLVMContext); 99 Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 100 Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 101 FloatTy = llvm::Type::getFloatTy(LLVMContext); 102 DoubleTy = llvm::Type::getDoubleTy(LLVMContext); 103 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0); 104 PointerAlignInBytes = 105 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity(); 106 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth()); 107 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits); 108 Int8PtrTy = Int8Ty->getPointerTo(0); 109 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); 110 111 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC(); 112 BuiltinCC = getTargetCodeGenInfo().getABIInfo().getBuiltinCC(); 113 114 if (LangOpts.ObjC1) 115 createObjCRuntime(); 116 if (LangOpts.OpenCL) 117 createOpenCLRuntime(); 118 if (LangOpts.OpenMP) 119 createOpenMPRuntime(); 120 if (LangOpts.CUDA) 121 createCUDARuntime(); 122 123 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0. 124 if (LangOpts.Sanitize.has(SanitizerKind::Thread) || 125 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)) 126 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(), 127 getCXXABI().getMangleContext()); 128 129 // If debug info or coverage generation is enabled, create the CGDebugInfo 130 // object. 131 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo || 132 CodeGenOpts.EmitGcovArcs || 133 CodeGenOpts.EmitGcovNotes) 134 DebugInfo = new CGDebugInfo(*this); 135 136 Block.GlobalUniqueCount = 0; 137 138 if (C.getLangOpts().ObjCAutoRefCount) 139 ARCData = new ARCEntrypoints(); 140 RRData = new RREntrypoints(); 141 142 if (!CodeGenOpts.InstrProfileInput.empty()) { 143 if (std::error_code EC = llvm::IndexedInstrProfReader::create( 144 CodeGenOpts.InstrProfileInput, PGOReader)) { 145 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 146 "Could not read profile: %0"); 147 getDiags().Report(DiagID) << EC.message(); 148 } 149 } 150 151 // If coverage mapping generation is enabled, create the 152 // CoverageMappingModuleGen object. 153 if (CodeGenOpts.CoverageMapping) 154 CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo)); 155 } 156 157 CodeGenModule::~CodeGenModule() { 158 delete ObjCRuntime; 159 delete OpenCLRuntime; 160 delete OpenMPRuntime; 161 delete CUDARuntime; 162 delete TheTargetCodeGenInfo; 163 delete TBAA; 164 delete DebugInfo; 165 delete ARCData; 166 delete RRData; 167 } 168 169 void CodeGenModule::createObjCRuntime() { 170 // This is just isGNUFamily(), but we want to force implementors of 171 // new ABIs to decide how best to do this. 172 switch (LangOpts.ObjCRuntime.getKind()) { 173 case ObjCRuntime::GNUstep: 174 case ObjCRuntime::GCC: 175 case ObjCRuntime::ObjFW: 176 ObjCRuntime = CreateGNUObjCRuntime(*this); 177 return; 178 179 case ObjCRuntime::FragileMacOSX: 180 case ObjCRuntime::MacOSX: 181 case ObjCRuntime::iOS: 182 ObjCRuntime = CreateMacObjCRuntime(*this); 183 return; 184 } 185 llvm_unreachable("bad runtime kind"); 186 } 187 188 void CodeGenModule::createOpenCLRuntime() { 189 OpenCLRuntime = new CGOpenCLRuntime(*this); 190 } 191 192 void CodeGenModule::createOpenMPRuntime() { 193 OpenMPRuntime = new CGOpenMPRuntime(*this); 194 } 195 196 void CodeGenModule::createCUDARuntime() { 197 CUDARuntime = CreateNVCUDARuntime(*this); 198 } 199 200 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) { 201 Replacements[Name] = C; 202 } 203 204 void CodeGenModule::applyReplacements() { 205 for (ReplacementsTy::iterator I = Replacements.begin(), 206 E = Replacements.end(); 207 I != E; ++I) { 208 StringRef MangledName = I->first(); 209 llvm::Constant *Replacement = I->second; 210 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 211 if (!Entry) 212 continue; 213 auto *OldF = cast<llvm::Function>(Entry); 214 auto *NewF = dyn_cast<llvm::Function>(Replacement); 215 if (!NewF) { 216 if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) { 217 NewF = dyn_cast<llvm::Function>(Alias->getAliasee()); 218 } else { 219 auto *CE = cast<llvm::ConstantExpr>(Replacement); 220 assert(CE->getOpcode() == llvm::Instruction::BitCast || 221 CE->getOpcode() == llvm::Instruction::GetElementPtr); 222 NewF = dyn_cast<llvm::Function>(CE->getOperand(0)); 223 } 224 } 225 226 // Replace old with new, but keep the old order. 227 OldF->replaceAllUsesWith(Replacement); 228 if (NewF) { 229 NewF->removeFromParent(); 230 OldF->getParent()->getFunctionList().insertAfter(OldF, NewF); 231 } 232 OldF->eraseFromParent(); 233 } 234 } 235 236 // This is only used in aliases that we created and we know they have a 237 // linear structure. 238 static const llvm::GlobalObject *getAliasedGlobal(const llvm::GlobalAlias &GA) { 239 llvm::SmallPtrSet<const llvm::GlobalAlias*, 4> Visited; 240 const llvm::Constant *C = &GA; 241 for (;;) { 242 C = C->stripPointerCasts(); 243 if (auto *GO = dyn_cast<llvm::GlobalObject>(C)) 244 return GO; 245 // stripPointerCasts will not walk over weak aliases. 246 auto *GA2 = dyn_cast<llvm::GlobalAlias>(C); 247 if (!GA2) 248 return nullptr; 249 if (!Visited.insert(GA2).second) 250 return nullptr; 251 C = GA2->getAliasee(); 252 } 253 } 254 255 void CodeGenModule::checkAliases() { 256 // Check if the constructed aliases are well formed. It is really unfortunate 257 // that we have to do this in CodeGen, but we only construct mangled names 258 // and aliases during codegen. 259 bool Error = false; 260 DiagnosticsEngine &Diags = getDiags(); 261 for (std::vector<GlobalDecl>::iterator I = Aliases.begin(), 262 E = Aliases.end(); I != E; ++I) { 263 const GlobalDecl &GD = *I; 264 const auto *D = cast<ValueDecl>(GD.getDecl()); 265 const AliasAttr *AA = D->getAttr<AliasAttr>(); 266 StringRef MangledName = getMangledName(GD); 267 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 268 auto *Alias = cast<llvm::GlobalAlias>(Entry); 269 const llvm::GlobalValue *GV = getAliasedGlobal(*Alias); 270 if (!GV) { 271 Error = true; 272 Diags.Report(AA->getLocation(), diag::err_cyclic_alias); 273 } else if (GV->isDeclaration()) { 274 Error = true; 275 Diags.Report(AA->getLocation(), diag::err_alias_to_undefined); 276 } 277 278 llvm::Constant *Aliasee = Alias->getAliasee(); 279 llvm::GlobalValue *AliaseeGV; 280 if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee)) 281 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0)); 282 else 283 AliaseeGV = cast<llvm::GlobalValue>(Aliasee); 284 285 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) { 286 StringRef AliasSection = SA->getName(); 287 if (AliasSection != AliaseeGV->getSection()) 288 Diags.Report(SA->getLocation(), diag::warn_alias_with_section) 289 << AliasSection; 290 } 291 292 // We have to handle alias to weak aliases in here. LLVM itself disallows 293 // this since the object semantics would not match the IL one. For 294 // compatibility with gcc we implement it by just pointing the alias 295 // to its aliasee's aliasee. We also warn, since the user is probably 296 // expecting the link to be weak. 297 if (auto GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) { 298 if (GA->mayBeOverridden()) { 299 Diags.Report(AA->getLocation(), diag::warn_alias_to_weak_alias) 300 << GV->getName() << GA->getName(); 301 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast( 302 GA->getAliasee(), Alias->getType()); 303 Alias->setAliasee(Aliasee); 304 } 305 } 306 } 307 if (!Error) 308 return; 309 310 for (std::vector<GlobalDecl>::iterator I = Aliases.begin(), 311 E = Aliases.end(); I != E; ++I) { 312 const GlobalDecl &GD = *I; 313 StringRef MangledName = getMangledName(GD); 314 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 315 auto *Alias = cast<llvm::GlobalAlias>(Entry); 316 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType())); 317 Alias->eraseFromParent(); 318 } 319 } 320 321 void CodeGenModule::clear() { 322 DeferredDeclsToEmit.clear(); 323 } 324 325 void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags, 326 StringRef MainFile) { 327 if (!hasDiagnostics()) 328 return; 329 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) { 330 if (MainFile.empty()) 331 MainFile = "<stdin>"; 332 Diags.Report(diag::warn_profile_data_unprofiled) << MainFile; 333 } else 334 Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Missing 335 << Mismatched; 336 } 337 338 void CodeGenModule::Release() { 339 EmitDeferred(); 340 applyReplacements(); 341 checkAliases(); 342 EmitCXXGlobalInitFunc(); 343 EmitCXXGlobalDtorFunc(); 344 EmitCXXThreadLocalInitFunc(); 345 if (ObjCRuntime) 346 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction()) 347 AddGlobalCtor(ObjCInitFunction); 348 if (PGOReader && PGOStats.hasDiagnostics()) 349 PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName); 350 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 351 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 352 EmitGlobalAnnotations(); 353 EmitStaticExternCAliases(); 354 EmitDeferredUnusedCoverageMappings(); 355 if (CoverageMapping) 356 CoverageMapping->emit(); 357 emitLLVMUsed(); 358 359 if (CodeGenOpts.Autolink && 360 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) { 361 EmitModuleLinkOptions(); 362 } 363 if (CodeGenOpts.DwarfVersion) 364 // We actually want the latest version when there are conflicts. 365 // We can change from Warning to Latest if such mode is supported. 366 getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version", 367 CodeGenOpts.DwarfVersion); 368 if (DebugInfo) 369 // We support a single version in the linked module. The LLVM 370 // parser will drop debug info with a different version number 371 // (and warn about it, too). 372 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version", 373 llvm::DEBUG_METADATA_VERSION); 374 375 // We need to record the widths of enums and wchar_t, so that we can generate 376 // the correct build attributes in the ARM backend. 377 llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch(); 378 if ( Arch == llvm::Triple::arm 379 || Arch == llvm::Triple::armeb 380 || Arch == llvm::Triple::thumb 381 || Arch == llvm::Triple::thumbeb) { 382 // Width of wchar_t in bytes 383 uint64_t WCharWidth = 384 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity(); 385 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth); 386 387 // The minimum width of an enum in bytes 388 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4; 389 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth); 390 } 391 392 if (uint32_t PLevel = Context.getLangOpts().PICLevel) { 393 llvm::PICLevel::Level PL = llvm::PICLevel::Default; 394 switch (PLevel) { 395 case 0: break; 396 case 1: PL = llvm::PICLevel::Small; break; 397 case 2: PL = llvm::PICLevel::Large; break; 398 default: llvm_unreachable("Invalid PIC Level"); 399 } 400 401 getModule().setPICLevel(PL); 402 } 403 404 SimplifyPersonality(); 405 406 if (getCodeGenOpts().EmitDeclMetadata) 407 EmitDeclMetadata(); 408 409 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes) 410 EmitCoverageFile(); 411 412 if (DebugInfo) 413 DebugInfo->finalize(); 414 415 EmitVersionIdentMetadata(); 416 417 EmitTargetMetadata(); 418 } 419 420 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 421 // Make sure that this type is translated. 422 Types.UpdateCompletedType(TD); 423 } 424 425 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { 426 if (!TBAA) 427 return nullptr; 428 return TBAA->getTBAAInfo(QTy); 429 } 430 431 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() { 432 if (!TBAA) 433 return nullptr; 434 return TBAA->getTBAAInfoForVTablePtr(); 435 } 436 437 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { 438 if (!TBAA) 439 return nullptr; 440 return TBAA->getTBAAStructInfo(QTy); 441 } 442 443 llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) { 444 if (!TBAA) 445 return nullptr; 446 return TBAA->getTBAAStructTypeInfo(QTy); 447 } 448 449 llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy, 450 llvm::MDNode *AccessN, 451 uint64_t O) { 452 if (!TBAA) 453 return nullptr; 454 return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O); 455 } 456 457 /// Decorate the instruction with a TBAA tag. For both scalar TBAA 458 /// and struct-path aware TBAA, the tag has the same format: 459 /// base type, access type and offset. 460 /// When ConvertTypeToTag is true, we create a tag based on the scalar type. 461 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, 462 llvm::MDNode *TBAAInfo, 463 bool ConvertTypeToTag) { 464 if (ConvertTypeToTag && TBAA) 465 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, 466 TBAA->getTBAAScalarTagInfo(TBAAInfo)); 467 else 468 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); 469 } 470 471 void CodeGenModule::Error(SourceLocation loc, StringRef message) { 472 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0"); 473 getDiags().Report(Context.getFullLoc(loc), diagID) << message; 474 } 475 476 /// ErrorUnsupported - Print out an error that codegen doesn't support the 477 /// specified stmt yet. 478 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) { 479 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 480 "cannot compile this %0 yet"); 481 std::string Msg = Type; 482 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 483 << Msg << S->getSourceRange(); 484 } 485 486 /// ErrorUnsupported - Print out an error that codegen doesn't support the 487 /// specified decl yet. 488 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) { 489 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 490 "cannot compile this %0 yet"); 491 std::string Msg = Type; 492 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 493 } 494 495 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { 496 return llvm::ConstantInt::get(SizeTy, size.getQuantity()); 497 } 498 499 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 500 const NamedDecl *D) const { 501 // Internal definitions always have default visibility. 502 if (GV->hasLocalLinkage()) { 503 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 504 return; 505 } 506 507 // Set visibility for definitions. 508 LinkageInfo LV = D->getLinkageAndVisibility(); 509 if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage()) 510 GV->setVisibility(GetLLVMVisibility(LV.getVisibility())); 511 } 512 513 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) { 514 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S) 515 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel) 516 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel) 517 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel) 518 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel); 519 } 520 521 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel( 522 CodeGenOptions::TLSModel M) { 523 switch (M) { 524 case CodeGenOptions::GeneralDynamicTLSModel: 525 return llvm::GlobalVariable::GeneralDynamicTLSModel; 526 case CodeGenOptions::LocalDynamicTLSModel: 527 return llvm::GlobalVariable::LocalDynamicTLSModel; 528 case CodeGenOptions::InitialExecTLSModel: 529 return llvm::GlobalVariable::InitialExecTLSModel; 530 case CodeGenOptions::LocalExecTLSModel: 531 return llvm::GlobalVariable::LocalExecTLSModel; 532 } 533 llvm_unreachable("Invalid TLS model!"); 534 } 535 536 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const { 537 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!"); 538 539 llvm::GlobalValue::ThreadLocalMode TLM; 540 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel()); 541 542 // Override the TLS model if it is explicitly specified. 543 if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) { 544 TLM = GetLLVMTLSModel(Attr->getModel()); 545 } 546 547 GV->setThreadLocalMode(TLM); 548 } 549 550 StringRef CodeGenModule::getMangledName(GlobalDecl GD) { 551 StringRef &FoundStr = MangledDeclNames[GD.getCanonicalDecl()]; 552 if (!FoundStr.empty()) 553 return FoundStr; 554 555 const auto *ND = cast<NamedDecl>(GD.getDecl()); 556 SmallString<256> Buffer; 557 StringRef Str; 558 if (getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { 559 llvm::raw_svector_ostream Out(Buffer); 560 if (const auto *D = dyn_cast<CXXConstructorDecl>(ND)) 561 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); 562 else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND)) 563 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); 564 else 565 getCXXABI().getMangleContext().mangleName(ND, Out); 566 Str = Out.str(); 567 } else { 568 IdentifierInfo *II = ND->getIdentifier(); 569 assert(II && "Attempt to mangle unnamed decl."); 570 Str = II->getName(); 571 } 572 573 // Keep the first result in the case of a mangling collision. 574 auto Result = Manglings.insert(std::make_pair(Str, GD)); 575 return FoundStr = Result.first->first(); 576 } 577 578 StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD, 579 const BlockDecl *BD) { 580 MangleContext &MangleCtx = getCXXABI().getMangleContext(); 581 const Decl *D = GD.getDecl(); 582 583 SmallString<256> Buffer; 584 llvm::raw_svector_ostream Out(Buffer); 585 if (!D) 586 MangleCtx.mangleGlobalBlock(BD, 587 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out); 588 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D)) 589 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); 590 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) 591 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); 592 else 593 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); 594 595 auto Result = Manglings.insert(std::make_pair(Out.str(), BD)); 596 return Result.first->first(); 597 } 598 599 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { 600 return getModule().getNamedValue(Name); 601 } 602 603 /// AddGlobalCtor - Add a function to the list that will be called before 604 /// main() runs. 605 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority, 606 llvm::Constant *AssociatedData) { 607 // FIXME: Type coercion of void()* types. 608 GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData)); 609 } 610 611 /// AddGlobalDtor - Add a function to the list that will be called 612 /// when the module is unloaded. 613 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) { 614 // FIXME: Type coercion of void()* types. 615 GlobalDtors.push_back(Structor(Priority, Dtor, nullptr)); 616 } 617 618 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 619 // Ctor function type is void()*. 620 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); 621 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 622 623 // Get the type of a ctor entry, { i32, void ()*, i8* }. 624 llvm::StructType *CtorStructTy = llvm::StructType::get( 625 Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy, nullptr); 626 627 // Construct the constructor and destructor arrays. 628 SmallVector<llvm::Constant*, 8> Ctors; 629 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 630 llvm::Constant *S[] = { 631 llvm::ConstantInt::get(Int32Ty, I->Priority, false), 632 llvm::ConstantExpr::getBitCast(I->Initializer, CtorPFTy), 633 (I->AssociatedData 634 ? llvm::ConstantExpr::getBitCast(I->AssociatedData, VoidPtrTy) 635 : llvm::Constant::getNullValue(VoidPtrTy)) 636 }; 637 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 638 } 639 640 if (!Ctors.empty()) { 641 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 642 new llvm::GlobalVariable(TheModule, AT, false, 643 llvm::GlobalValue::AppendingLinkage, 644 llvm::ConstantArray::get(AT, Ctors), 645 GlobalName); 646 } 647 } 648 649 llvm::GlobalValue::LinkageTypes 650 CodeGenModule::getFunctionLinkage(GlobalDecl GD) { 651 const auto *D = cast<FunctionDecl>(GD.getDecl()); 652 653 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); 654 655 if (isa<CXXDestructorDecl>(D) && 656 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), 657 GD.getDtorType())) { 658 // Destructor variants in the Microsoft C++ ABI are always internal or 659 // linkonce_odr thunks emitted on an as-needed basis. 660 return Linkage == GVA_Internal ? llvm::GlobalValue::InternalLinkage 661 : llvm::GlobalValue::LinkOnceODRLinkage; 662 } 663 664 return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false); 665 } 666 667 void CodeGenModule::setFunctionDefinitionAttributes(const FunctionDecl *D, 668 llvm::Function *F) { 669 setNonAliasAttributes(D, F); 670 } 671 672 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 673 const CGFunctionInfo &Info, 674 llvm::Function *F) { 675 unsigned CallingConv; 676 AttributeListType AttributeList; 677 ConstructAttributeList(Info, D, AttributeList, CallingConv, false); 678 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList)); 679 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 680 } 681 682 /// Determines whether the language options require us to model 683 /// unwind exceptions. We treat -fexceptions as mandating this 684 /// except under the fragile ObjC ABI with only ObjC exceptions 685 /// enabled. This means, for example, that C with -fexceptions 686 /// enables this. 687 static bool hasUnwindExceptions(const LangOptions &LangOpts) { 688 // If exceptions are completely disabled, obviously this is false. 689 if (!LangOpts.Exceptions) return false; 690 691 // If C++ exceptions are enabled, this is true. 692 if (LangOpts.CXXExceptions) return true; 693 694 // If ObjC exceptions are enabled, this depends on the ABI. 695 if (LangOpts.ObjCExceptions) { 696 return LangOpts.ObjCRuntime.hasUnwindExceptions(); 697 } 698 699 return true; 700 } 701 702 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 703 llvm::Function *F) { 704 llvm::AttrBuilder B; 705 706 if (CodeGenOpts.UnwindTables) 707 B.addAttribute(llvm::Attribute::UWTable); 708 709 if (!hasUnwindExceptions(LangOpts)) 710 B.addAttribute(llvm::Attribute::NoUnwind); 711 712 if (D->hasAttr<NakedAttr>()) { 713 // Naked implies noinline: we should not be inlining such functions. 714 B.addAttribute(llvm::Attribute::Naked); 715 B.addAttribute(llvm::Attribute::NoInline); 716 } else if (D->hasAttr<NoDuplicateAttr>()) { 717 B.addAttribute(llvm::Attribute::NoDuplicate); 718 } else if (D->hasAttr<NoInlineAttr>()) { 719 B.addAttribute(llvm::Attribute::NoInline); 720 } else if (D->hasAttr<AlwaysInlineAttr>() && 721 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex, 722 llvm::Attribute::NoInline)) { 723 // (noinline wins over always_inline, and we can't specify both in IR) 724 B.addAttribute(llvm::Attribute::AlwaysInline); 725 } 726 727 if (D->hasAttr<ColdAttr>()) { 728 if (!D->hasAttr<OptimizeNoneAttr>()) 729 B.addAttribute(llvm::Attribute::OptimizeForSize); 730 B.addAttribute(llvm::Attribute::Cold); 731 } 732 733 if (D->hasAttr<MinSizeAttr>()) 734 B.addAttribute(llvm::Attribute::MinSize); 735 736 if (LangOpts.getStackProtector() == LangOptions::SSPOn) 737 B.addAttribute(llvm::Attribute::StackProtect); 738 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) 739 B.addAttribute(llvm::Attribute::StackProtectStrong); 740 else if (LangOpts.getStackProtector() == LangOptions::SSPReq) 741 B.addAttribute(llvm::Attribute::StackProtectReq); 742 743 // Add sanitizer attributes if function is not blacklisted. 744 if (!isInSanitizerBlacklist(F, D->getLocation())) { 745 // When AddressSanitizer is enabled, set SanitizeAddress attribute 746 // unless __attribute__((no_sanitize_address)) is used. 747 if (LangOpts.Sanitize.has(SanitizerKind::Address) && 748 !D->hasAttr<NoSanitizeAddressAttr>()) 749 B.addAttribute(llvm::Attribute::SanitizeAddress); 750 // Same for ThreadSanitizer and __attribute__((no_sanitize_thread)) 751 if (LangOpts.Sanitize.has(SanitizerKind::Thread) && 752 !D->hasAttr<NoSanitizeThreadAttr>()) 753 B.addAttribute(llvm::Attribute::SanitizeThread); 754 // Same for MemorySanitizer and __attribute__((no_sanitize_memory)) 755 if (LangOpts.Sanitize.has(SanitizerKind::Memory) && 756 !D->hasAttr<NoSanitizeMemoryAttr>()) 757 B.addAttribute(llvm::Attribute::SanitizeMemory); 758 } 759 760 F->addAttributes(llvm::AttributeSet::FunctionIndex, 761 llvm::AttributeSet::get( 762 F->getContext(), llvm::AttributeSet::FunctionIndex, B)); 763 764 if (D->hasAttr<OptimizeNoneAttr>()) { 765 // OptimizeNone implies noinline; we should not be inlining such functions. 766 F->addFnAttr(llvm::Attribute::OptimizeNone); 767 F->addFnAttr(llvm::Attribute::NoInline); 768 769 // OptimizeNone wins over OptimizeForSize, MinSize, AlwaysInline. 770 assert(!F->hasFnAttribute(llvm::Attribute::OptimizeForSize) && 771 "OptimizeNone and OptimizeForSize on same function!"); 772 assert(!F->hasFnAttribute(llvm::Attribute::MinSize) && 773 "OptimizeNone and MinSize on same function!"); 774 assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) && 775 "OptimizeNone and AlwaysInline on same function!"); 776 777 // Attribute 'inlinehint' has no effect on 'optnone' functions. 778 // Explicitly remove it from the set of function attributes. 779 F->removeFnAttr(llvm::Attribute::InlineHint); 780 } 781 782 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D)) 783 F->setUnnamedAddr(true); 784 else if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) 785 if (MD->isVirtual()) 786 F->setUnnamedAddr(true); 787 788 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth(); 789 if (alignment) 790 F->setAlignment(alignment); 791 792 // C++ ABI requires 2-byte alignment for member functions. 793 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 794 F->setAlignment(2); 795 } 796 797 void CodeGenModule::SetCommonAttributes(const Decl *D, 798 llvm::GlobalValue *GV) { 799 if (const auto *ND = dyn_cast<NamedDecl>(D)) 800 setGlobalVisibility(GV, ND); 801 else 802 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 803 804 if (D->hasAttr<UsedAttr>()) 805 addUsedGlobal(GV); 806 } 807 808 void CodeGenModule::setAliasAttributes(const Decl *D, 809 llvm::GlobalValue *GV) { 810 SetCommonAttributes(D, GV); 811 812 // Process the dllexport attribute based on whether the original definition 813 // (not necessarily the aliasee) was exported. 814 if (D->hasAttr<DLLExportAttr>()) 815 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 816 } 817 818 void CodeGenModule::setNonAliasAttributes(const Decl *D, 819 llvm::GlobalObject *GO) { 820 SetCommonAttributes(D, GO); 821 822 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 823 GO->setSection(SA->getName()); 824 825 getTargetCodeGenInfo().SetTargetAttributes(D, GO, *this); 826 } 827 828 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 829 llvm::Function *F, 830 const CGFunctionInfo &FI) { 831 SetLLVMFunctionAttributes(D, FI, F); 832 SetLLVMFunctionAttributesForDefinition(D, F); 833 834 F->setLinkage(llvm::Function::InternalLinkage); 835 836 setNonAliasAttributes(D, F); 837 } 838 839 static void setLinkageAndVisibilityForGV(llvm::GlobalValue *GV, 840 const NamedDecl *ND) { 841 // Set linkage and visibility in case we never see a definition. 842 LinkageInfo LV = ND->getLinkageAndVisibility(); 843 if (LV.getLinkage() != ExternalLinkage) { 844 // Don't set internal linkage on declarations. 845 } else { 846 if (ND->hasAttr<DLLImportAttr>()) { 847 GV->setLinkage(llvm::GlobalValue::ExternalLinkage); 848 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 849 } else if (ND->hasAttr<DLLExportAttr>()) { 850 GV->setLinkage(llvm::GlobalValue::ExternalLinkage); 851 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 852 } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) { 853 // "extern_weak" is overloaded in LLVM; we probably should have 854 // separate linkage types for this. 855 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 856 } 857 858 // Set visibility on a declaration only if it's explicit. 859 if (LV.isVisibilityExplicit()) 860 GV->setVisibility(CodeGenModule::GetLLVMVisibility(LV.getVisibility())); 861 } 862 } 863 864 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F, 865 bool IsIncompleteFunction, 866 bool IsThunk) { 867 if (unsigned IID = F->getIntrinsicID()) { 868 // If this is an intrinsic function, set the function's attributes 869 // to the intrinsic's attributes. 870 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), 871 (llvm::Intrinsic::ID)IID)); 872 return; 873 } 874 875 const auto *FD = cast<FunctionDecl>(GD.getDecl()); 876 877 if (!IsIncompleteFunction) 878 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); 879 880 // Add the Returned attribute for "this", except for iOS 5 and earlier 881 // where substantial code, including the libstdc++ dylib, was compiled with 882 // GCC and does not actually return "this". 883 if (!IsThunk && getCXXABI().HasThisReturn(GD) && 884 !(getTarget().getTriple().isiOS() && 885 getTarget().getTriple().isOSVersionLT(6))) { 886 assert(!F->arg_empty() && 887 F->arg_begin()->getType() 888 ->canLosslesslyBitCastTo(F->getReturnType()) && 889 "unexpected this return"); 890 F->addAttribute(1, llvm::Attribute::Returned); 891 } 892 893 // Only a few attributes are set on declarations; these may later be 894 // overridden by a definition. 895 896 setLinkageAndVisibilityForGV(F, FD); 897 898 if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) { 899 if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) { 900 // Don't dllexport/import destructor thunks. 901 F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); 902 } 903 } 904 905 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 906 F->setSection(SA->getName()); 907 908 // A replaceable global allocation function does not act like a builtin by 909 // default, only if it is invoked by a new-expression or delete-expression. 910 if (FD->isReplaceableGlobalAllocationFunction()) 911 F->addAttribute(llvm::AttributeSet::FunctionIndex, 912 llvm::Attribute::NoBuiltin); 913 } 914 915 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) { 916 assert(!GV->isDeclaration() && 917 "Only globals with definition can force usage."); 918 LLVMUsed.push_back(GV); 919 } 920 921 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) { 922 assert(!GV->isDeclaration() && 923 "Only globals with definition can force usage."); 924 LLVMCompilerUsed.push_back(GV); 925 } 926 927 static void emitUsed(CodeGenModule &CGM, StringRef Name, 928 std::vector<llvm::WeakVH> &List) { 929 // Don't create llvm.used if there is no need. 930 if (List.empty()) 931 return; 932 933 // Convert List to what ConstantArray needs. 934 SmallVector<llvm::Constant*, 8> UsedArray; 935 UsedArray.resize(List.size()); 936 for (unsigned i = 0, e = List.size(); i != e; ++i) { 937 UsedArray[i] = 938 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast( 939 cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy); 940 } 941 942 if (UsedArray.empty()) 943 return; 944 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size()); 945 946 auto *GV = new llvm::GlobalVariable( 947 CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage, 948 llvm::ConstantArray::get(ATy, UsedArray), Name); 949 950 GV->setSection("llvm.metadata"); 951 } 952 953 void CodeGenModule::emitLLVMUsed() { 954 emitUsed(*this, "llvm.used", LLVMUsed); 955 emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed); 956 } 957 958 void CodeGenModule::AppendLinkerOptions(StringRef Opts) { 959 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts); 960 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); 961 } 962 963 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) { 964 llvm::SmallString<32> Opt; 965 getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt); 966 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt); 967 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); 968 } 969 970 void CodeGenModule::AddDependentLib(StringRef Lib) { 971 llvm::SmallString<24> Opt; 972 getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt); 973 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt); 974 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); 975 } 976 977 /// \brief Add link options implied by the given module, including modules 978 /// it depends on, using a postorder walk. 979 static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, 980 SmallVectorImpl<llvm::Metadata *> &Metadata, 981 llvm::SmallPtrSet<Module *, 16> &Visited) { 982 // Import this module's parent. 983 if (Mod->Parent && Visited.insert(Mod->Parent).second) { 984 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited); 985 } 986 987 // Import this module's dependencies. 988 for (unsigned I = Mod->Imports.size(); I > 0; --I) { 989 if (Visited.insert(Mod->Imports[I - 1]).second) 990 addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited); 991 } 992 993 // Add linker options to link against the libraries/frameworks 994 // described by this module. 995 llvm::LLVMContext &Context = CGM.getLLVMContext(); 996 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) { 997 // Link against a framework. Frameworks are currently Darwin only, so we 998 // don't to ask TargetCodeGenInfo for the spelling of the linker option. 999 if (Mod->LinkLibraries[I-1].IsFramework) { 1000 llvm::Metadata *Args[2] = { 1001 llvm::MDString::get(Context, "-framework"), 1002 llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)}; 1003 1004 Metadata.push_back(llvm::MDNode::get(Context, Args)); 1005 continue; 1006 } 1007 1008 // Link against a library. 1009 llvm::SmallString<24> Opt; 1010 CGM.getTargetCodeGenInfo().getDependentLibraryOption( 1011 Mod->LinkLibraries[I-1].Library, Opt); 1012 auto *OptString = llvm::MDString::get(Context, Opt); 1013 Metadata.push_back(llvm::MDNode::get(Context, OptString)); 1014 } 1015 } 1016 1017 void CodeGenModule::EmitModuleLinkOptions() { 1018 // Collect the set of all of the modules we want to visit to emit link 1019 // options, which is essentially the imported modules and all of their 1020 // non-explicit child modules. 1021 llvm::SetVector<clang::Module *> LinkModules; 1022 llvm::SmallPtrSet<clang::Module *, 16> Visited; 1023 SmallVector<clang::Module *, 16> Stack; 1024 1025 // Seed the stack with imported modules. 1026 for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(), 1027 MEnd = ImportedModules.end(); 1028 M != MEnd; ++M) { 1029 if (Visited.insert(*M).second) 1030 Stack.push_back(*M); 1031 } 1032 1033 // Find all of the modules to import, making a little effort to prune 1034 // non-leaf modules. 1035 while (!Stack.empty()) { 1036 clang::Module *Mod = Stack.pop_back_val(); 1037 1038 bool AnyChildren = false; 1039 1040 // Visit the submodules of this module. 1041 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(), 1042 SubEnd = Mod->submodule_end(); 1043 Sub != SubEnd; ++Sub) { 1044 // Skip explicit children; they need to be explicitly imported to be 1045 // linked against. 1046 if ((*Sub)->IsExplicit) 1047 continue; 1048 1049 if (Visited.insert(*Sub).second) { 1050 Stack.push_back(*Sub); 1051 AnyChildren = true; 1052 } 1053 } 1054 1055 // We didn't find any children, so add this module to the list of 1056 // modules to link against. 1057 if (!AnyChildren) { 1058 LinkModules.insert(Mod); 1059 } 1060 } 1061 1062 // Add link options for all of the imported modules in reverse topological 1063 // order. We don't do anything to try to order import link flags with respect 1064 // to linker options inserted by things like #pragma comment(). 1065 SmallVector<llvm::Metadata *, 16> MetadataArgs; 1066 Visited.clear(); 1067 for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(), 1068 MEnd = LinkModules.end(); 1069 M != MEnd; ++M) { 1070 if (Visited.insert(*M).second) 1071 addLinkOptionsPostorder(*this, *M, MetadataArgs, Visited); 1072 } 1073 std::reverse(MetadataArgs.begin(), MetadataArgs.end()); 1074 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end()); 1075 1076 // Add the linker options metadata flag. 1077 getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options", 1078 llvm::MDNode::get(getLLVMContext(), 1079 LinkerOptionsMetadata)); 1080 } 1081 1082 void CodeGenModule::EmitDeferred() { 1083 // Emit code for any potentially referenced deferred decls. Since a 1084 // previously unused static decl may become used during the generation of code 1085 // for a static function, iterate until no changes are made. 1086 1087 if (!DeferredVTables.empty()) { 1088 EmitDeferredVTables(); 1089 1090 // Emitting a v-table doesn't directly cause more v-tables to 1091 // become deferred, although it can cause functions to be 1092 // emitted that then need those v-tables. 1093 assert(DeferredVTables.empty()); 1094 } 1095 1096 // Stop if we're out of both deferred v-tables and deferred declarations. 1097 if (DeferredDeclsToEmit.empty()) 1098 return; 1099 1100 // Grab the list of decls to emit. If EmitGlobalDefinition schedules more 1101 // work, it will not interfere with this. 1102 std::vector<DeferredGlobal> CurDeclsToEmit; 1103 CurDeclsToEmit.swap(DeferredDeclsToEmit); 1104 1105 for (DeferredGlobal &G : CurDeclsToEmit) { 1106 GlobalDecl D = G.GD; 1107 llvm::GlobalValue *GV = G.GV; 1108 G.GV = nullptr; 1109 1110 assert(!GV || GV == GetGlobalValue(getMangledName(D))); 1111 if (!GV) 1112 GV = GetGlobalValue(getMangledName(D)); 1113 1114 // Check to see if we've already emitted this. This is necessary 1115 // for a couple of reasons: first, decls can end up in the 1116 // deferred-decls queue multiple times, and second, decls can end 1117 // up with definitions in unusual ways (e.g. by an extern inline 1118 // function acquiring a strong function redefinition). Just 1119 // ignore these cases. 1120 if (GV && !GV->isDeclaration()) 1121 continue; 1122 1123 // Otherwise, emit the definition and move on to the next one. 1124 EmitGlobalDefinition(D, GV); 1125 1126 // If we found out that we need to emit more decls, do that recursively. 1127 // This has the advantage that the decls are emitted in a DFS and related 1128 // ones are close together, which is convenient for testing. 1129 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) { 1130 EmitDeferred(); 1131 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty()); 1132 } 1133 } 1134 } 1135 1136 void CodeGenModule::EmitGlobalAnnotations() { 1137 if (Annotations.empty()) 1138 return; 1139 1140 // Create a new global variable for the ConstantStruct in the Module. 1141 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( 1142 Annotations[0]->getType(), Annotations.size()), Annotations); 1143 auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false, 1144 llvm::GlobalValue::AppendingLinkage, 1145 Array, "llvm.global.annotations"); 1146 gv->setSection(AnnotationSection); 1147 } 1148 1149 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) { 1150 llvm::Constant *&AStr = AnnotationStrings[Str]; 1151 if (AStr) 1152 return AStr; 1153 1154 // Not found yet, create a new global. 1155 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); 1156 auto *gv = 1157 new llvm::GlobalVariable(getModule(), s->getType(), true, 1158 llvm::GlobalValue::PrivateLinkage, s, ".str"); 1159 gv->setSection(AnnotationSection); 1160 gv->setUnnamedAddr(true); 1161 AStr = gv; 1162 return gv; 1163 } 1164 1165 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { 1166 SourceManager &SM = getContext().getSourceManager(); 1167 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 1168 if (PLoc.isValid()) 1169 return EmitAnnotationString(PLoc.getFilename()); 1170 return EmitAnnotationString(SM.getBufferName(Loc)); 1171 } 1172 1173 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { 1174 SourceManager &SM = getContext().getSourceManager(); 1175 PresumedLoc PLoc = SM.getPresumedLoc(L); 1176 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() : 1177 SM.getExpansionLineNumber(L); 1178 return llvm::ConstantInt::get(Int32Ty, LineNo); 1179 } 1180 1181 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 1182 const AnnotateAttr *AA, 1183 SourceLocation L) { 1184 // Get the globals for file name, annotation, and the line number. 1185 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()), 1186 *UnitGV = EmitAnnotationUnit(L), 1187 *LineNoCst = EmitAnnotationLineNo(L); 1188 1189 // Create the ConstantStruct for the global annotation. 1190 llvm::Constant *Fields[4] = { 1191 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy), 1192 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy), 1193 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy), 1194 LineNoCst 1195 }; 1196 return llvm::ConstantStruct::getAnon(Fields); 1197 } 1198 1199 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, 1200 llvm::GlobalValue *GV) { 1201 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 1202 // Get the struct elements for these annotations. 1203 for (const auto *I : D->specific_attrs<AnnotateAttr>()) 1204 Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation())); 1205 } 1206 1207 bool CodeGenModule::isInSanitizerBlacklist(llvm::Function *Fn, 1208 SourceLocation Loc) const { 1209 const auto &SanitizerBL = getContext().getSanitizerBlacklist(); 1210 // Blacklist by function name. 1211 if (SanitizerBL.isBlacklistedFunction(Fn->getName())) 1212 return true; 1213 // Blacklist by location. 1214 if (!Loc.isInvalid()) 1215 return SanitizerBL.isBlacklistedLocation(Loc); 1216 // If location is unknown, this may be a compiler-generated function. Assume 1217 // it's located in the main file. 1218 auto &SM = Context.getSourceManager(); 1219 if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 1220 return SanitizerBL.isBlacklistedFile(MainFile->getName()); 1221 } 1222 return false; 1223 } 1224 1225 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV, 1226 SourceLocation Loc, QualType Ty, 1227 StringRef Category) const { 1228 // For now globals can be blacklisted only in ASan. 1229 if (!LangOpts.Sanitize.has(SanitizerKind::Address)) 1230 return false; 1231 const auto &SanitizerBL = getContext().getSanitizerBlacklist(); 1232 if (SanitizerBL.isBlacklistedGlobal(GV->getName(), Category)) 1233 return true; 1234 if (SanitizerBL.isBlacklistedLocation(Loc, Category)) 1235 return true; 1236 // Check global type. 1237 if (!Ty.isNull()) { 1238 // Drill down the array types: if global variable of a fixed type is 1239 // blacklisted, we also don't instrument arrays of them. 1240 while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr())) 1241 Ty = AT->getElementType(); 1242 Ty = Ty.getCanonicalType().getUnqualifiedType(); 1243 // We allow to blacklist only record types (classes, structs etc.) 1244 if (Ty->isRecordType()) { 1245 std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy()); 1246 if (SanitizerBL.isBlacklistedType(TypeStr, Category)) 1247 return true; 1248 } 1249 } 1250 return false; 1251 } 1252 1253 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) { 1254 // Never defer when EmitAllDecls is specified. 1255 if (LangOpts.EmitAllDecls) 1256 return true; 1257 1258 return getContext().DeclMustBeEmitted(Global); 1259 } 1260 1261 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) { 1262 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) 1263 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1264 // Implicit template instantiations may change linkage if they are later 1265 // explicitly instantiated, so they should not be emitted eagerly. 1266 return false; 1267 1268 return true; 1269 } 1270 1271 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor( 1272 const CXXUuidofExpr* E) { 1273 // Sema has verified that IIDSource has a __declspec(uuid()), and that its 1274 // well-formed. 1275 StringRef Uuid = E->getUuidAsStringRef(Context); 1276 std::string Name = "_GUID_" + Uuid.lower(); 1277 std::replace(Name.begin(), Name.end(), '-', '_'); 1278 1279 // Look for an existing global. 1280 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name)) 1281 return GV; 1282 1283 llvm::Constant *Init = EmitUuidofInitializer(Uuid); 1284 assert(Init && "failed to initialize as constant"); 1285 1286 auto *GV = new llvm::GlobalVariable( 1287 getModule(), Init->getType(), 1288 /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name); 1289 if (supportsCOMDAT()) 1290 GV->setComdat(TheModule.getOrInsertComdat(GV->getName())); 1291 return GV; 1292 } 1293 1294 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 1295 const AliasAttr *AA = VD->getAttr<AliasAttr>(); 1296 assert(AA && "No alias?"); 1297 1298 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 1299 1300 // See if there is already something with the target's name in the module. 1301 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 1302 if (Entry) { 1303 unsigned AS = getContext().getTargetAddressSpace(VD->getType()); 1304 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS)); 1305 } 1306 1307 llvm::Constant *Aliasee; 1308 if (isa<llvm::FunctionType>(DeclTy)) 1309 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, 1310 GlobalDecl(cast<FunctionDecl>(VD)), 1311 /*ForVTable=*/false); 1312 else 1313 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 1314 llvm::PointerType::getUnqual(DeclTy), 1315 nullptr); 1316 1317 auto *F = cast<llvm::GlobalValue>(Aliasee); 1318 F->setLinkage(llvm::Function::ExternalWeakLinkage); 1319 WeakRefReferences.insert(F); 1320 1321 return Aliasee; 1322 } 1323 1324 void CodeGenModule::EmitGlobal(GlobalDecl GD) { 1325 const auto *Global = cast<ValueDecl>(GD.getDecl()); 1326 1327 // Weak references don't produce any output by themselves. 1328 if (Global->hasAttr<WeakRefAttr>()) 1329 return; 1330 1331 // If this is an alias definition (which otherwise looks like a declaration) 1332 // emit it now. 1333 if (Global->hasAttr<AliasAttr>()) 1334 return EmitAliasDefinition(GD); 1335 1336 // If this is CUDA, be selective about which declarations we emit. 1337 if (LangOpts.CUDA) { 1338 if (CodeGenOpts.CUDAIsDevice) { 1339 if (!Global->hasAttr<CUDADeviceAttr>() && 1340 !Global->hasAttr<CUDAGlobalAttr>() && 1341 !Global->hasAttr<CUDAConstantAttr>() && 1342 !Global->hasAttr<CUDASharedAttr>()) 1343 return; 1344 } else { 1345 if (!Global->hasAttr<CUDAHostAttr>() && ( 1346 Global->hasAttr<CUDADeviceAttr>() || 1347 Global->hasAttr<CUDAConstantAttr>() || 1348 Global->hasAttr<CUDASharedAttr>())) 1349 return; 1350 } 1351 } 1352 1353 // Ignore declarations, they will be emitted on their first use. 1354 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) { 1355 // Forward declarations are emitted lazily on first use. 1356 if (!FD->doesThisDeclarationHaveABody()) { 1357 if (!FD->doesDeclarationForceExternallyVisibleDefinition()) 1358 return; 1359 1360 StringRef MangledName = getMangledName(GD); 1361 1362 // Compute the function info and LLVM type. 1363 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 1364 llvm::Type *Ty = getTypes().GetFunctionType(FI); 1365 1366 GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false, 1367 /*DontDefer=*/false); 1368 return; 1369 } 1370 } else { 1371 const auto *VD = cast<VarDecl>(Global); 1372 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 1373 1374 if (VD->isThisDeclarationADefinition() != VarDecl::Definition && 1375 !Context.isMSStaticDataMemberInlineDefinition(VD)) 1376 return; 1377 } 1378 1379 // Defer code generation to first use when possible, e.g. if this is an inline 1380 // function. If the global must always be emitted, do it eagerly if possible 1381 // to benefit from cache locality. 1382 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) { 1383 // Emit the definition if it can't be deferred. 1384 EmitGlobalDefinition(GD); 1385 return; 1386 } 1387 1388 // If we're deferring emission of a C++ variable with an 1389 // initializer, remember the order in which it appeared in the file. 1390 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) && 1391 cast<VarDecl>(Global)->hasInit()) { 1392 DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 1393 CXXGlobalInits.push_back(nullptr); 1394 } 1395 1396 StringRef MangledName = getMangledName(GD); 1397 if (llvm::GlobalValue *GV = GetGlobalValue(MangledName)) { 1398 // The value has already been used and should therefore be emitted. 1399 addDeferredDeclToEmit(GV, GD); 1400 } else if (MustBeEmitted(Global)) { 1401 // The value must be emitted, but cannot be emitted eagerly. 1402 assert(!MayBeEmittedEagerly(Global)); 1403 addDeferredDeclToEmit(/*GV=*/nullptr, GD); 1404 } else { 1405 // Otherwise, remember that we saw a deferred decl with this name. The 1406 // first use of the mangled name will cause it to move into 1407 // DeferredDeclsToEmit. 1408 DeferredDecls[MangledName] = GD; 1409 } 1410 } 1411 1412 namespace { 1413 struct FunctionIsDirectlyRecursive : 1414 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> { 1415 const StringRef Name; 1416 const Builtin::Context &BI; 1417 bool Result; 1418 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) : 1419 Name(N), BI(C), Result(false) { 1420 } 1421 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base; 1422 1423 bool TraverseCallExpr(CallExpr *E) { 1424 const FunctionDecl *FD = E->getDirectCallee(); 1425 if (!FD) 1426 return true; 1427 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 1428 if (Attr && Name == Attr->getLabel()) { 1429 Result = true; 1430 return false; 1431 } 1432 unsigned BuiltinID = FD->getBuiltinID(); 1433 if (!BuiltinID) 1434 return true; 1435 StringRef BuiltinName = BI.GetName(BuiltinID); 1436 if (BuiltinName.startswith("__builtin_") && 1437 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) { 1438 Result = true; 1439 return false; 1440 } 1441 return true; 1442 } 1443 }; 1444 } 1445 1446 // isTriviallyRecursive - Check if this function calls another 1447 // decl that, because of the asm attribute or the other decl being a builtin, 1448 // ends up pointing to itself. 1449 bool 1450 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) { 1451 StringRef Name; 1452 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) { 1453 // asm labels are a special kind of mangling we have to support. 1454 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 1455 if (!Attr) 1456 return false; 1457 Name = Attr->getLabel(); 1458 } else { 1459 Name = FD->getName(); 1460 } 1461 1462 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo); 1463 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD)); 1464 return Walker.Result; 1465 } 1466 1467 bool 1468 CodeGenModule::shouldEmitFunction(GlobalDecl GD) { 1469 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage) 1470 return true; 1471 const auto *F = cast<FunctionDecl>(GD.getDecl()); 1472 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>()) 1473 return false; 1474 // PR9614. Avoid cases where the source code is lying to us. An available 1475 // externally function should have an equivalent function somewhere else, 1476 // but a function that calls itself is clearly not equivalent to the real 1477 // implementation. 1478 // This happens in glibc's btowc and in some configure checks. 1479 return !isTriviallyRecursive(F); 1480 } 1481 1482 /// If the type for the method's class was generated by 1483 /// CGDebugInfo::createContextChain(), the cache contains only a 1484 /// limited DIType without any declarations. Since EmitFunctionStart() 1485 /// needs to find the canonical declaration for each method, we need 1486 /// to construct the complete type prior to emitting the method. 1487 void CodeGenModule::CompleteDIClassType(const CXXMethodDecl* D) { 1488 if (!D->isInstance()) 1489 return; 1490 1491 if (CGDebugInfo *DI = getModuleDebugInfo()) 1492 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { 1493 const auto *ThisPtr = cast<PointerType>(D->getThisType(getContext())); 1494 DI->getOrCreateRecordType(ThisPtr->getPointeeType(), D->getLocation()); 1495 } 1496 } 1497 1498 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { 1499 const auto *D = cast<ValueDecl>(GD.getDecl()); 1500 1501 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 1502 Context.getSourceManager(), 1503 "Generating code for declaration"); 1504 1505 if (isa<FunctionDecl>(D)) { 1506 // At -O0, don't generate IR for functions with available_externally 1507 // linkage. 1508 if (!shouldEmitFunction(GD)) 1509 return; 1510 1511 if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) { 1512 CompleteDIClassType(Method); 1513 // Make sure to emit the definition(s) before we emit the thunks. 1514 // This is necessary for the generation of certain thunks. 1515 if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method)) 1516 ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType())); 1517 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method)) 1518 ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType())); 1519 else 1520 EmitGlobalFunctionDefinition(GD, GV); 1521 1522 if (Method->isVirtual()) 1523 getVTables().EmitThunks(GD); 1524 1525 return; 1526 } 1527 1528 return EmitGlobalFunctionDefinition(GD, GV); 1529 } 1530 1531 if (const auto *VD = dyn_cast<VarDecl>(D)) 1532 return EmitGlobalVarDefinition(VD); 1533 1534 llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); 1535 } 1536 1537 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the 1538 /// module, create and return an llvm Function with the specified type. If there 1539 /// is something in the module with the specified name, return it potentially 1540 /// bitcasted to the right type. 1541 /// 1542 /// If D is non-null, it specifies a decl that correspond to this. This is used 1543 /// to set the attributes on the function when it is first created. 1544 llvm::Constant * 1545 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, 1546 llvm::Type *Ty, 1547 GlobalDecl GD, bool ForVTable, 1548 bool DontDefer, bool IsThunk, 1549 llvm::AttributeSet ExtraAttrs) { 1550 const Decl *D = GD.getDecl(); 1551 1552 // Lookup the entry, lazily creating it if necessary. 1553 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1554 if (Entry) { 1555 if (WeakRefReferences.erase(Entry)) { 1556 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D); 1557 if (FD && !FD->hasAttr<WeakAttr>()) 1558 Entry->setLinkage(llvm::Function::ExternalLinkage); 1559 } 1560 1561 // Handle dropped DLL attributes. 1562 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) 1563 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); 1564 1565 if (Entry->getType()->getElementType() == Ty) 1566 return Entry; 1567 1568 // Make sure the result is of the correct type. 1569 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); 1570 } 1571 1572 // This function doesn't have a complete type (for example, the return 1573 // type is an incomplete struct). Use a fake type instead, and make 1574 // sure not to try to set attributes. 1575 bool IsIncompleteFunction = false; 1576 1577 llvm::FunctionType *FTy; 1578 if (isa<llvm::FunctionType>(Ty)) { 1579 FTy = cast<llvm::FunctionType>(Ty); 1580 } else { 1581 FTy = llvm::FunctionType::get(VoidTy, false); 1582 IsIncompleteFunction = true; 1583 } 1584 1585 llvm::Function *F = llvm::Function::Create(FTy, 1586 llvm::Function::ExternalLinkage, 1587 MangledName, &getModule()); 1588 assert(F->getName() == MangledName && "name was uniqued!"); 1589 if (D) 1590 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk); 1591 if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) { 1592 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex); 1593 F->addAttributes(llvm::AttributeSet::FunctionIndex, 1594 llvm::AttributeSet::get(VMContext, 1595 llvm::AttributeSet::FunctionIndex, 1596 B)); 1597 } 1598 1599 if (!DontDefer) { 1600 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to 1601 // each other bottoming out with the base dtor. Therefore we emit non-base 1602 // dtors on usage, even if there is no dtor definition in the TU. 1603 if (D && isa<CXXDestructorDecl>(D) && 1604 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), 1605 GD.getDtorType())) 1606 addDeferredDeclToEmit(F, GD); 1607 1608 // This is the first use or definition of a mangled name. If there is a 1609 // deferred decl with this name, remember that we need to emit it at the end 1610 // of the file. 1611 auto DDI = DeferredDecls.find(MangledName); 1612 if (DDI != DeferredDecls.end()) { 1613 // Move the potentially referenced deferred decl to the 1614 // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we 1615 // don't need it anymore). 1616 addDeferredDeclToEmit(F, DDI->second); 1617 DeferredDecls.erase(DDI); 1618 1619 // Otherwise, if this is a sized deallocation function, emit a weak 1620 // definition 1621 // for it at the end of the translation unit. 1622 } else if (D && cast<FunctionDecl>(D) 1623 ->getCorrespondingUnsizedGlobalDeallocationFunction()) { 1624 addDeferredDeclToEmit(F, GD); 1625 1626 // Otherwise, there are cases we have to worry about where we're 1627 // using a declaration for which we must emit a definition but where 1628 // we might not find a top-level definition: 1629 // - member functions defined inline in their classes 1630 // - friend functions defined inline in some class 1631 // - special member functions with implicit definitions 1632 // If we ever change our AST traversal to walk into class methods, 1633 // this will be unnecessary. 1634 // 1635 // We also don't emit a definition for a function if it's going to be an 1636 // entry in a vtable, unless it's already marked as used. 1637 } else if (getLangOpts().CPlusPlus && D) { 1638 // Look for a declaration that's lexically in a record. 1639 for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD; 1640 FD = FD->getPreviousDecl()) { 1641 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 1642 if (FD->doesThisDeclarationHaveABody()) { 1643 addDeferredDeclToEmit(F, GD.getWithDecl(FD)); 1644 break; 1645 } 1646 } 1647 } 1648 } 1649 } 1650 1651 // Make sure the result is of the requested type. 1652 if (!IsIncompleteFunction) { 1653 assert(F->getType()->getElementType() == Ty); 1654 return F; 1655 } 1656 1657 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 1658 return llvm::ConstantExpr::getBitCast(F, PTy); 1659 } 1660 1661 /// GetAddrOfFunction - Return the address of the given function. If Ty is 1662 /// non-null, then this function will use the specified type if it has to 1663 /// create it (this occurs when we see a definition of the function). 1664 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 1665 llvm::Type *Ty, 1666 bool ForVTable, 1667 bool DontDefer) { 1668 // If there was no specific requested type, just convert it now. 1669 if (!Ty) 1670 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 1671 1672 StringRef MangledName = getMangledName(GD); 1673 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer); 1674 } 1675 1676 /// CreateRuntimeFunction - Create a new runtime function with the specified 1677 /// type and name. 1678 llvm::Constant * 1679 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, 1680 StringRef Name, 1681 llvm::AttributeSet ExtraAttrs) { 1682 llvm::Constant *C = 1683 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 1684 /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs); 1685 if (auto *F = dyn_cast<llvm::Function>(C)) 1686 if (F->empty()) 1687 F->setCallingConv(getRuntimeCC()); 1688 return C; 1689 } 1690 1691 /// CreateBuiltinFunction - Create a new builtin function with the specified 1692 /// type and name. 1693 llvm::Constant * 1694 CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy, 1695 StringRef Name, 1696 llvm::AttributeSet ExtraAttrs) { 1697 llvm::Constant *C = 1698 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 1699 /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs); 1700 if (auto *F = dyn_cast<llvm::Function>(C)) 1701 if (F->empty()) 1702 F->setCallingConv(getBuiltinCC()); 1703 return C; 1704 } 1705 1706 /// isTypeConstant - Determine whether an object of this type can be emitted 1707 /// as a constant. 1708 /// 1709 /// If ExcludeCtor is true, the duration when the object's constructor runs 1710 /// will not be considered. The caller will need to verify that the object is 1711 /// not written to during its construction. 1712 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) { 1713 if (!Ty.isConstant(Context) && !Ty->isReferenceType()) 1714 return false; 1715 1716 if (Context.getLangOpts().CPlusPlus) { 1717 if (const CXXRecordDecl *Record 1718 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl()) 1719 return ExcludeCtor && !Record->hasMutableFields() && 1720 Record->hasTrivialDestructor(); 1721 } 1722 1723 return true; 1724 } 1725 1726 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 1727 /// create and return an llvm GlobalVariable with the specified type. If there 1728 /// is something in the module with the specified name, return it potentially 1729 /// bitcasted to the right type. 1730 /// 1731 /// If D is non-null, it specifies a decl that correspond to this. This is used 1732 /// to set the attributes on the global when it is first created. 1733 llvm::Constant * 1734 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, 1735 llvm::PointerType *Ty, 1736 const VarDecl *D) { 1737 // Lookup the entry, lazily creating it if necessary. 1738 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1739 if (Entry) { 1740 if (WeakRefReferences.erase(Entry)) { 1741 if (D && !D->hasAttr<WeakAttr>()) 1742 Entry->setLinkage(llvm::Function::ExternalLinkage); 1743 } 1744 1745 // Handle dropped DLL attributes. 1746 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) 1747 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); 1748 1749 if (Entry->getType() == Ty) 1750 return Entry; 1751 1752 // Make sure the result is of the correct type. 1753 if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace()) 1754 return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty); 1755 1756 return llvm::ConstantExpr::getBitCast(Entry, Ty); 1757 } 1758 1759 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); 1760 auto *GV = new llvm::GlobalVariable( 1761 getModule(), Ty->getElementType(), false, 1762 llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr, 1763 llvm::GlobalVariable::NotThreadLocal, AddrSpace); 1764 1765 // This is the first use or definition of a mangled name. If there is a 1766 // deferred decl with this name, remember that we need to emit it at the end 1767 // of the file. 1768 auto DDI = DeferredDecls.find(MangledName); 1769 if (DDI != DeferredDecls.end()) { 1770 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1771 // list, and remove it from DeferredDecls (since we don't need it anymore). 1772 addDeferredDeclToEmit(GV, DDI->second); 1773 DeferredDecls.erase(DDI); 1774 } 1775 1776 // Handle things which are present even on external declarations. 1777 if (D) { 1778 // FIXME: This code is overly simple and should be merged with other global 1779 // handling. 1780 GV->setConstant(isTypeConstant(D->getType(), false)); 1781 1782 setLinkageAndVisibilityForGV(GV, D); 1783 1784 if (D->getTLSKind()) { 1785 if (D->getTLSKind() == VarDecl::TLS_Dynamic) 1786 CXXThreadLocals.push_back(std::make_pair(D, GV)); 1787 setTLSMode(GV, *D); 1788 } 1789 1790 // If required by the ABI, treat declarations of static data members with 1791 // inline initializers as definitions. 1792 if (getContext().isMSStaticDataMemberInlineDefinition(D)) { 1793 EmitGlobalVarDefinition(D); 1794 } 1795 1796 // Handle XCore specific ABI requirements. 1797 if (getTarget().getTriple().getArch() == llvm::Triple::xcore && 1798 D->getLanguageLinkage() == CLanguageLinkage && 1799 D->getType().isConstant(Context) && 1800 isExternallyVisible(D->getLinkageAndVisibility().getLinkage())) 1801 GV->setSection(".cp.rodata"); 1802 } 1803 1804 if (AddrSpace != Ty->getAddressSpace()) 1805 return llvm::ConstantExpr::getAddrSpaceCast(GV, Ty); 1806 1807 return GV; 1808 } 1809 1810 1811 llvm::GlobalVariable * 1812 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, 1813 llvm::Type *Ty, 1814 llvm::GlobalValue::LinkageTypes Linkage) { 1815 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 1816 llvm::GlobalVariable *OldGV = nullptr; 1817 1818 if (GV) { 1819 // Check if the variable has the right type. 1820 if (GV->getType()->getElementType() == Ty) 1821 return GV; 1822 1823 // Because C++ name mangling, the only way we can end up with an already 1824 // existing global with the same name is if it has been declared extern "C". 1825 assert(GV->isDeclaration() && "Declaration has wrong type!"); 1826 OldGV = GV; 1827 } 1828 1829 // Create a new variable. 1830 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 1831 Linkage, nullptr, Name); 1832 1833 if (OldGV) { 1834 // Replace occurrences of the old variable if needed. 1835 GV->takeName(OldGV); 1836 1837 if (!OldGV->use_empty()) { 1838 llvm::Constant *NewPtrForOldDecl = 1839 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 1840 OldGV->replaceAllUsesWith(NewPtrForOldDecl); 1841 } 1842 1843 OldGV->eraseFromParent(); 1844 } 1845 1846 if (supportsCOMDAT() && GV->isWeakForLinker()) 1847 GV->setComdat(TheModule.getOrInsertComdat(GV->getName())); 1848 1849 return GV; 1850 } 1851 1852 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 1853 /// given global variable. If Ty is non-null and if the global doesn't exist, 1854 /// then it will be created with the specified type instead of whatever the 1855 /// normal requested type would be. 1856 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 1857 llvm::Type *Ty) { 1858 assert(D->hasGlobalStorage() && "Not a global variable"); 1859 QualType ASTTy = D->getType(); 1860 if (!Ty) 1861 Ty = getTypes().ConvertTypeForMem(ASTTy); 1862 1863 llvm::PointerType *PTy = 1864 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 1865 1866 StringRef MangledName = getMangledName(D); 1867 return GetOrCreateLLVMGlobal(MangledName, PTy, D); 1868 } 1869 1870 /// CreateRuntimeVariable - Create a new runtime global variable with the 1871 /// specified type and name. 1872 llvm::Constant * 1873 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, 1874 StringRef Name) { 1875 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr); 1876 } 1877 1878 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 1879 assert(!D->getInit() && "Cannot emit definite definitions here!"); 1880 1881 if (!MustBeEmitted(D)) { 1882 // If we have not seen a reference to this variable yet, place it 1883 // into the deferred declarations table to be emitted if needed 1884 // later. 1885 StringRef MangledName = getMangledName(D); 1886 if (!GetGlobalValue(MangledName)) { 1887 DeferredDecls[MangledName] = D; 1888 return; 1889 } 1890 } 1891 1892 // The tentative definition is the only definition. 1893 EmitGlobalVarDefinition(D); 1894 } 1895 1896 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { 1897 return Context.toCharUnitsFromBits( 1898 TheDataLayout.getTypeStoreSizeInBits(Ty)); 1899 } 1900 1901 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D, 1902 unsigned AddrSpace) { 1903 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) { 1904 if (D->hasAttr<CUDAConstantAttr>()) 1905 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant); 1906 else if (D->hasAttr<CUDASharedAttr>()) 1907 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared); 1908 else 1909 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device); 1910 } 1911 1912 return AddrSpace; 1913 } 1914 1915 template<typename SomeDecl> 1916 void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D, 1917 llvm::GlobalValue *GV) { 1918 if (!getLangOpts().CPlusPlus) 1919 return; 1920 1921 // Must have 'used' attribute, or else inline assembly can't rely on 1922 // the name existing. 1923 if (!D->template hasAttr<UsedAttr>()) 1924 return; 1925 1926 // Must have internal linkage and an ordinary name. 1927 if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage) 1928 return; 1929 1930 // Must be in an extern "C" context. Entities declared directly within 1931 // a record are not extern "C" even if the record is in such a context. 1932 const SomeDecl *First = D->getFirstDecl(); 1933 if (First->getDeclContext()->isRecord() || !First->isInExternCContext()) 1934 return; 1935 1936 // OK, this is an internal linkage entity inside an extern "C" linkage 1937 // specification. Make a note of that so we can give it the "expected" 1938 // mangled name if nothing else is using that name. 1939 std::pair<StaticExternCMap::iterator, bool> R = 1940 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV)); 1941 1942 // If we have multiple internal linkage entities with the same name 1943 // in extern "C" regions, none of them gets that name. 1944 if (!R.second) 1945 R.first->second = nullptr; 1946 } 1947 1948 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) { 1949 if (!CGM.supportsCOMDAT()) 1950 return false; 1951 1952 if (D.hasAttr<SelectAnyAttr>()) 1953 return true; 1954 1955 GVALinkage Linkage; 1956 if (auto *VD = dyn_cast<VarDecl>(&D)) 1957 Linkage = CGM.getContext().GetGVALinkageForVariable(VD); 1958 else 1959 Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D)); 1960 1961 switch (Linkage) { 1962 case GVA_Internal: 1963 case GVA_AvailableExternally: 1964 case GVA_StrongExternal: 1965 return false; 1966 case GVA_DiscardableODR: 1967 case GVA_StrongODR: 1968 return true; 1969 } 1970 llvm_unreachable("No such linkage"); 1971 } 1972 1973 void CodeGenModule::maybeSetTrivialComdat(const Decl &D, 1974 llvm::GlobalObject &GO) { 1975 if (!shouldBeInCOMDAT(*this, D)) 1976 return; 1977 GO.setComdat(TheModule.getOrInsertComdat(GO.getName())); 1978 } 1979 1980 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 1981 llvm::Constant *Init = nullptr; 1982 QualType ASTTy = D->getType(); 1983 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 1984 bool NeedsGlobalCtor = false; 1985 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor(); 1986 1987 const VarDecl *InitDecl; 1988 const Expr *InitExpr = D->getAnyInitializer(InitDecl); 1989 1990 if (!InitExpr) { 1991 // This is a tentative definition; tentative definitions are 1992 // implicitly initialized with { 0 }. 1993 // 1994 // Note that tentative definitions are only emitted at the end of 1995 // a translation unit, so they should never have incomplete 1996 // type. In addition, EmitTentativeDefinition makes sure that we 1997 // never attempt to emit a tentative definition if a real one 1998 // exists. A use may still exists, however, so we still may need 1999 // to do a RAUW. 2000 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 2001 Init = EmitNullConstant(D->getType()); 2002 } else { 2003 initializedGlobalDecl = GlobalDecl(D); 2004 Init = EmitConstantInit(*InitDecl); 2005 2006 if (!Init) { 2007 QualType T = InitExpr->getType(); 2008 if (D->getType()->isReferenceType()) 2009 T = D->getType(); 2010 2011 if (getLangOpts().CPlusPlus) { 2012 Init = EmitNullConstant(T); 2013 NeedsGlobalCtor = true; 2014 } else { 2015 ErrorUnsupported(D, "static initializer"); 2016 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 2017 } 2018 } else { 2019 // We don't need an initializer, so remove the entry for the delayed 2020 // initializer position (just in case this entry was delayed) if we 2021 // also don't need to register a destructor. 2022 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor) 2023 DelayedCXXInitPosition.erase(D); 2024 } 2025 } 2026 2027 llvm::Type* InitType = Init->getType(); 2028 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 2029 2030 // Strip off a bitcast if we got one back. 2031 if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 2032 assert(CE->getOpcode() == llvm::Instruction::BitCast || 2033 CE->getOpcode() == llvm::Instruction::AddrSpaceCast || 2034 // All zero index gep. 2035 CE->getOpcode() == llvm::Instruction::GetElementPtr); 2036 Entry = CE->getOperand(0); 2037 } 2038 2039 // Entry is now either a Function or GlobalVariable. 2040 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry); 2041 2042 // We have a definition after a declaration with the wrong type. 2043 // We must make a new GlobalVariable* and update everything that used OldGV 2044 // (a declaration or tentative definition) with the new GlobalVariable* 2045 // (which will be a definition). 2046 // 2047 // This happens if there is a prototype for a global (e.g. 2048 // "extern int x[];") and then a definition of a different type (e.g. 2049 // "int x[10];"). This also happens when an initializer has a different type 2050 // from the type of the global (this happens with unions). 2051 if (!GV || 2052 GV->getType()->getElementType() != InitType || 2053 GV->getType()->getAddressSpace() != 2054 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) { 2055 2056 // Move the old entry aside so that we'll create a new one. 2057 Entry->setName(StringRef()); 2058 2059 // Make a new global with the correct type, this is now guaranteed to work. 2060 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 2061 2062 // Replace all uses of the old global with the new global 2063 llvm::Constant *NewPtrForOldDecl = 2064 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 2065 Entry->replaceAllUsesWith(NewPtrForOldDecl); 2066 2067 // Erase the old global, since it is no longer used. 2068 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 2069 } 2070 2071 MaybeHandleStaticInExternC(D, GV); 2072 2073 if (D->hasAttr<AnnotateAttr>()) 2074 AddGlobalAnnotations(D, GV); 2075 2076 GV->setInitializer(Init); 2077 2078 // If it is safe to mark the global 'constant', do so now. 2079 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor && 2080 isTypeConstant(D->getType(), true)); 2081 2082 // If it is in a read-only section, mark it 'constant'. 2083 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) { 2084 const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()]; 2085 if ((SI.SectionFlags & ASTContext::PSF_Write) == 0) 2086 GV->setConstant(true); 2087 } 2088 2089 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 2090 2091 // Set the llvm linkage type as appropriate. 2092 llvm::GlobalValue::LinkageTypes Linkage = 2093 getLLVMLinkageVarDefinition(D, GV->isConstant()); 2094 2095 // On Darwin, the backing variable for a C++11 thread_local variable always 2096 // has internal linkage; all accesses should just be calls to the 2097 // Itanium-specified entry point, which has the normal linkage of the 2098 // variable. 2099 if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic && 2100 Context.getTargetInfo().getTriple().isMacOSX()) 2101 Linkage = llvm::GlobalValue::InternalLinkage; 2102 2103 GV->setLinkage(Linkage); 2104 if (D->hasAttr<DLLImportAttr>()) 2105 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass); 2106 else if (D->hasAttr<DLLExportAttr>()) 2107 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass); 2108 else 2109 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass); 2110 2111 if (Linkage == llvm::GlobalVariable::CommonLinkage) 2112 // common vars aren't constant even if declared const. 2113 GV->setConstant(false); 2114 2115 setNonAliasAttributes(D, GV); 2116 2117 if (D->getTLSKind() && !GV->isThreadLocal()) { 2118 if (D->getTLSKind() == VarDecl::TLS_Dynamic) 2119 CXXThreadLocals.push_back(std::make_pair(D, GV)); 2120 setTLSMode(GV, *D); 2121 } 2122 2123 maybeSetTrivialComdat(*D, *GV); 2124 2125 // Emit the initializer function if necessary. 2126 if (NeedsGlobalCtor || NeedsGlobalDtor) 2127 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor); 2128 2129 SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor); 2130 2131 // Emit global variable debug information. 2132 if (CGDebugInfo *DI = getModuleDebugInfo()) 2133 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 2134 DI->EmitGlobalVariable(GV, D); 2135 } 2136 2137 static bool isVarDeclStrongDefinition(const ASTContext &Context, 2138 const VarDecl *D, bool NoCommon) { 2139 // Don't give variables common linkage if -fno-common was specified unless it 2140 // was overridden by a NoCommon attribute. 2141 if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>()) 2142 return true; 2143 2144 // C11 6.9.2/2: 2145 // A declaration of an identifier for an object that has file scope without 2146 // an initializer, and without a storage-class specifier or with the 2147 // storage-class specifier static, constitutes a tentative definition. 2148 if (D->getInit() || D->hasExternalStorage()) 2149 return true; 2150 2151 // A variable cannot be both common and exist in a section. 2152 if (D->hasAttr<SectionAttr>()) 2153 return true; 2154 2155 // Thread local vars aren't considered common linkage. 2156 if (D->getTLSKind()) 2157 return true; 2158 2159 // Tentative definitions marked with WeakImportAttr are true definitions. 2160 if (D->hasAttr<WeakImportAttr>()) 2161 return true; 2162 2163 // Declarations with a required alignment do not have common linakge in MSVC 2164 // mode. 2165 if (Context.getLangOpts().MSVCCompat && 2166 (Context.isAlignmentRequired(D->getType()) || D->hasAttr<AlignedAttr>())) 2167 return true; 2168 2169 return false; 2170 } 2171 2172 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator( 2173 const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) { 2174 if (Linkage == GVA_Internal) 2175 return llvm::Function::InternalLinkage; 2176 2177 if (D->hasAttr<WeakAttr>()) { 2178 if (IsConstantVariable) 2179 return llvm::GlobalVariable::WeakODRLinkage; 2180 else 2181 return llvm::GlobalVariable::WeakAnyLinkage; 2182 } 2183 2184 // We are guaranteed to have a strong definition somewhere else, 2185 // so we can use available_externally linkage. 2186 if (Linkage == GVA_AvailableExternally) 2187 return llvm::Function::AvailableExternallyLinkage; 2188 2189 // Note that Apple's kernel linker doesn't support symbol 2190 // coalescing, so we need to avoid linkonce and weak linkages there. 2191 // Normally, this means we just map to internal, but for explicit 2192 // instantiations we'll map to external. 2193 2194 // In C++, the compiler has to emit a definition in every translation unit 2195 // that references the function. We should use linkonce_odr because 2196 // a) if all references in this translation unit are optimized away, we 2197 // don't need to codegen it. b) if the function persists, it needs to be 2198 // merged with other definitions. c) C++ has the ODR, so we know the 2199 // definition is dependable. 2200 if (Linkage == GVA_DiscardableODR) 2201 return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage 2202 : llvm::Function::InternalLinkage; 2203 2204 // An explicit instantiation of a template has weak linkage, since 2205 // explicit instantiations can occur in multiple translation units 2206 // and must all be equivalent. However, we are not allowed to 2207 // throw away these explicit instantiations. 2208 if (Linkage == GVA_StrongODR) 2209 return !Context.getLangOpts().AppleKext ? llvm::Function::WeakODRLinkage 2210 : llvm::Function::ExternalLinkage; 2211 2212 // C++ doesn't have tentative definitions and thus cannot have common 2213 // linkage. 2214 if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) && 2215 !isVarDeclStrongDefinition(Context, cast<VarDecl>(D), 2216 CodeGenOpts.NoCommon)) 2217 return llvm::GlobalVariable::CommonLinkage; 2218 2219 // selectany symbols are externally visible, so use weak instead of 2220 // linkonce. MSVC optimizes away references to const selectany globals, so 2221 // all definitions should be the same and ODR linkage should be used. 2222 // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx 2223 if (D->hasAttr<SelectAnyAttr>()) 2224 return llvm::GlobalVariable::WeakODRLinkage; 2225 2226 // Otherwise, we have strong external linkage. 2227 assert(Linkage == GVA_StrongExternal); 2228 return llvm::GlobalVariable::ExternalLinkage; 2229 } 2230 2231 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition( 2232 const VarDecl *VD, bool IsConstant) { 2233 GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD); 2234 return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant); 2235 } 2236 2237 /// Replace the uses of a function that was declared with a non-proto type. 2238 /// We want to silently drop extra arguments from call sites 2239 static void replaceUsesOfNonProtoConstant(llvm::Constant *old, 2240 llvm::Function *newFn) { 2241 // Fast path. 2242 if (old->use_empty()) return; 2243 2244 llvm::Type *newRetTy = newFn->getReturnType(); 2245 SmallVector<llvm::Value*, 4> newArgs; 2246 2247 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end(); 2248 ui != ue; ) { 2249 llvm::Value::use_iterator use = ui++; // Increment before the use is erased. 2250 llvm::User *user = use->getUser(); 2251 2252 // Recognize and replace uses of bitcasts. Most calls to 2253 // unprototyped functions will use bitcasts. 2254 if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) { 2255 if (bitcast->getOpcode() == llvm::Instruction::BitCast) 2256 replaceUsesOfNonProtoConstant(bitcast, newFn); 2257 continue; 2258 } 2259 2260 // Recognize calls to the function. 2261 llvm::CallSite callSite(user); 2262 if (!callSite) continue; 2263 if (!callSite.isCallee(&*use)) continue; 2264 2265 // If the return types don't match exactly, then we can't 2266 // transform this call unless it's dead. 2267 if (callSite->getType() != newRetTy && !callSite->use_empty()) 2268 continue; 2269 2270 // Get the call site's attribute list. 2271 SmallVector<llvm::AttributeSet, 8> newAttrs; 2272 llvm::AttributeSet oldAttrs = callSite.getAttributes(); 2273 2274 // Collect any return attributes from the call. 2275 if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex)) 2276 newAttrs.push_back( 2277 llvm::AttributeSet::get(newFn->getContext(), 2278 oldAttrs.getRetAttributes())); 2279 2280 // If the function was passed too few arguments, don't transform. 2281 unsigned newNumArgs = newFn->arg_size(); 2282 if (callSite.arg_size() < newNumArgs) continue; 2283 2284 // If extra arguments were passed, we silently drop them. 2285 // If any of the types mismatch, we don't transform. 2286 unsigned argNo = 0; 2287 bool dontTransform = false; 2288 for (llvm::Function::arg_iterator ai = newFn->arg_begin(), 2289 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) { 2290 if (callSite.getArgument(argNo)->getType() != ai->getType()) { 2291 dontTransform = true; 2292 break; 2293 } 2294 2295 // Add any parameter attributes. 2296 if (oldAttrs.hasAttributes(argNo + 1)) 2297 newAttrs. 2298 push_back(llvm:: 2299 AttributeSet::get(newFn->getContext(), 2300 oldAttrs.getParamAttributes(argNo + 1))); 2301 } 2302 if (dontTransform) 2303 continue; 2304 2305 if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) 2306 newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(), 2307 oldAttrs.getFnAttributes())); 2308 2309 // Okay, we can transform this. Create the new call instruction and copy 2310 // over the required information. 2311 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo); 2312 2313 llvm::CallSite newCall; 2314 if (callSite.isCall()) { 2315 newCall = llvm::CallInst::Create(newFn, newArgs, "", 2316 callSite.getInstruction()); 2317 } else { 2318 auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction()); 2319 newCall = llvm::InvokeInst::Create(newFn, 2320 oldInvoke->getNormalDest(), 2321 oldInvoke->getUnwindDest(), 2322 newArgs, "", 2323 callSite.getInstruction()); 2324 } 2325 newArgs.clear(); // for the next iteration 2326 2327 if (!newCall->getType()->isVoidTy()) 2328 newCall->takeName(callSite.getInstruction()); 2329 newCall.setAttributes( 2330 llvm::AttributeSet::get(newFn->getContext(), newAttrs)); 2331 newCall.setCallingConv(callSite.getCallingConv()); 2332 2333 // Finally, remove the old call, replacing any uses with the new one. 2334 if (!callSite->use_empty()) 2335 callSite->replaceAllUsesWith(newCall.getInstruction()); 2336 2337 // Copy debug location attached to CI. 2338 if (!callSite->getDebugLoc().isUnknown()) 2339 newCall->setDebugLoc(callSite->getDebugLoc()); 2340 callSite->eraseFromParent(); 2341 } 2342 } 2343 2344 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 2345 /// implement a function with no prototype, e.g. "int foo() {}". If there are 2346 /// existing call uses of the old function in the module, this adjusts them to 2347 /// call the new function directly. 2348 /// 2349 /// This is not just a cleanup: the always_inline pass requires direct calls to 2350 /// functions to be able to inline them. If there is a bitcast in the way, it 2351 /// won't inline them. Instcombine normally deletes these calls, but it isn't 2352 /// run at -O0. 2353 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 2354 llvm::Function *NewFn) { 2355 // If we're redefining a global as a function, don't transform it. 2356 if (!isa<llvm::Function>(Old)) return; 2357 2358 replaceUsesOfNonProtoConstant(Old, NewFn); 2359 } 2360 2361 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 2362 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind(); 2363 // If we have a definition, this might be a deferred decl. If the 2364 // instantiation is explicit, make sure we emit it at the end. 2365 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition) 2366 GetAddrOfGlobalVar(VD); 2367 2368 EmitTopLevelDecl(VD); 2369 } 2370 2371 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, 2372 llvm::GlobalValue *GV) { 2373 const auto *D = cast<FunctionDecl>(GD.getDecl()); 2374 2375 // Compute the function info and LLVM type. 2376 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 2377 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 2378 2379 // Get or create the prototype for the function. 2380 if (!GV) { 2381 llvm::Constant *C = 2382 GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer*/ true); 2383 2384 // Strip off a bitcast if we got one back. 2385 if (auto *CE = dyn_cast<llvm::ConstantExpr>(C)) { 2386 assert(CE->getOpcode() == llvm::Instruction::BitCast); 2387 GV = cast<llvm::GlobalValue>(CE->getOperand(0)); 2388 } else { 2389 GV = cast<llvm::GlobalValue>(C); 2390 } 2391 } 2392 2393 if (!GV->isDeclaration()) { 2394 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name); 2395 GlobalDecl OldGD = Manglings.lookup(GV->getName()); 2396 if (auto *Prev = OldGD.getDecl()) 2397 getDiags().Report(Prev->getLocation(), diag::note_previous_definition); 2398 return; 2399 } 2400 2401 if (GV->getType()->getElementType() != Ty) { 2402 // If the types mismatch then we have to rewrite the definition. 2403 assert(GV->isDeclaration() && "Shouldn't replace non-declaration"); 2404 2405 // F is the Function* for the one with the wrong type, we must make a new 2406 // Function* and update everything that used F (a declaration) with the new 2407 // Function* (which will be a definition). 2408 // 2409 // This happens if there is a prototype for a function 2410 // (e.g. "int f()") and then a definition of a different type 2411 // (e.g. "int f(int x)"). Move the old function aside so that it 2412 // doesn't interfere with GetAddrOfFunction. 2413 GV->setName(StringRef()); 2414 auto *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 2415 2416 // This might be an implementation of a function without a 2417 // prototype, in which case, try to do special replacement of 2418 // calls which match the new prototype. The really key thing here 2419 // is that we also potentially drop arguments from the call site 2420 // so as to make a direct call, which makes the inliner happier 2421 // and suppresses a number of optimizer warnings (!) about 2422 // dropping arguments. 2423 if (!GV->use_empty()) { 2424 ReplaceUsesOfNonProtoTypeWithRealFunction(GV, NewFn); 2425 GV->removeDeadConstantUsers(); 2426 } 2427 2428 // Replace uses of F with the Function we will endow with a body. 2429 if (!GV->use_empty()) { 2430 llvm::Constant *NewPtrForOldDecl = 2431 llvm::ConstantExpr::getBitCast(NewFn, GV->getType()); 2432 GV->replaceAllUsesWith(NewPtrForOldDecl); 2433 } 2434 2435 // Ok, delete the old function now, which is dead. 2436 GV->eraseFromParent(); 2437 2438 GV = NewFn; 2439 } 2440 2441 // We need to set linkage and visibility on the function before 2442 // generating code for it because various parts of IR generation 2443 // want to propagate this information down (e.g. to local static 2444 // declarations). 2445 auto *Fn = cast<llvm::Function>(GV); 2446 setFunctionLinkage(GD, Fn); 2447 if (D->hasAttr<DLLImportAttr>()) 2448 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass); 2449 else if (D->hasAttr<DLLExportAttr>()) 2450 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass); 2451 else 2452 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass); 2453 2454 // FIXME: this is redundant with part of setFunctionDefinitionAttributes 2455 setGlobalVisibility(Fn, D); 2456 2457 MaybeHandleStaticInExternC(D, Fn); 2458 2459 maybeSetTrivialComdat(*D, *Fn); 2460 2461 CodeGenFunction(*this).GenerateCode(D, Fn, FI); 2462 2463 setFunctionDefinitionAttributes(D, Fn); 2464 SetLLVMFunctionAttributesForDefinition(D, Fn); 2465 2466 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 2467 AddGlobalCtor(Fn, CA->getPriority()); 2468 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 2469 AddGlobalDtor(Fn, DA->getPriority()); 2470 if (D->hasAttr<AnnotateAttr>()) 2471 AddGlobalAnnotations(D, Fn); 2472 } 2473 2474 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 2475 const auto *D = cast<ValueDecl>(GD.getDecl()); 2476 const AliasAttr *AA = D->getAttr<AliasAttr>(); 2477 assert(AA && "Not an alias?"); 2478 2479 StringRef MangledName = getMangledName(GD); 2480 2481 // If there is a definition in the module, then it wins over the alias. 2482 // This is dubious, but allow it to be safe. Just ignore the alias. 2483 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 2484 if (Entry && !Entry->isDeclaration()) 2485 return; 2486 2487 Aliases.push_back(GD); 2488 2489 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 2490 2491 // Create a reference to the named value. This ensures that it is emitted 2492 // if a deferred decl. 2493 llvm::Constant *Aliasee; 2494 if (isa<llvm::FunctionType>(DeclTy)) 2495 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD, 2496 /*ForVTable=*/false); 2497 else 2498 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 2499 llvm::PointerType::getUnqual(DeclTy), 2500 /*D=*/nullptr); 2501 2502 // Create the new alias itself, but don't set a name yet. 2503 auto *GA = llvm::GlobalAlias::create( 2504 cast<llvm::PointerType>(Aliasee->getType())->getElementType(), 0, 2505 llvm::Function::ExternalLinkage, "", Aliasee, &getModule()); 2506 2507 if (Entry) { 2508 if (GA->getAliasee() == Entry) { 2509 Diags.Report(AA->getLocation(), diag::err_cyclic_alias); 2510 return; 2511 } 2512 2513 assert(Entry->isDeclaration()); 2514 2515 // If there is a declaration in the module, then we had an extern followed 2516 // by the alias, as in: 2517 // extern int test6(); 2518 // ... 2519 // int test6() __attribute__((alias("test7"))); 2520 // 2521 // Remove it and replace uses of it with the alias. 2522 GA->takeName(Entry); 2523 2524 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 2525 Entry->getType())); 2526 Entry->eraseFromParent(); 2527 } else { 2528 GA->setName(MangledName); 2529 } 2530 2531 // Set attributes which are particular to an alias; this is a 2532 // specialization of the attributes which may be set on a global 2533 // variable/function. 2534 if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() || 2535 D->isWeakImported()) { 2536 GA->setLinkage(llvm::Function::WeakAnyLinkage); 2537 } 2538 2539 if (const auto *VD = dyn_cast<VarDecl>(D)) 2540 if (VD->getTLSKind()) 2541 setTLSMode(GA, *VD); 2542 2543 setAliasAttributes(D, GA); 2544 } 2545 2546 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID, 2547 ArrayRef<llvm::Type*> Tys) { 2548 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID, 2549 Tys); 2550 } 2551 2552 static llvm::StringMapEntry<llvm::Constant*> & 2553 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2554 const StringLiteral *Literal, 2555 bool TargetIsLSB, 2556 bool &IsUTF16, 2557 unsigned &StringLength) { 2558 StringRef String = Literal->getString(); 2559 unsigned NumBytes = String.size(); 2560 2561 // Check for simple case. 2562 if (!Literal->containsNonAsciiOrNull()) { 2563 StringLength = NumBytes; 2564 return *Map.insert(std::make_pair(String, nullptr)).first; 2565 } 2566 2567 // Otherwise, convert the UTF8 literals into a string of shorts. 2568 IsUTF16 = true; 2569 2570 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls. 2571 const UTF8 *FromPtr = (const UTF8 *)String.data(); 2572 UTF16 *ToPtr = &ToBuf[0]; 2573 2574 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 2575 &ToPtr, ToPtr + NumBytes, 2576 strictConversion); 2577 2578 // ConvertUTF8toUTF16 returns the length in ToPtr. 2579 StringLength = ToPtr - &ToBuf[0]; 2580 2581 // Add an explicit null. 2582 *ToPtr = 0; 2583 return *Map.insert(std::make_pair( 2584 StringRef(reinterpret_cast<const char *>(ToBuf.data()), 2585 (StringLength + 1) * 2), 2586 nullptr)).first; 2587 } 2588 2589 static llvm::StringMapEntry<llvm::Constant*> & 2590 GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2591 const StringLiteral *Literal, 2592 unsigned &StringLength) { 2593 StringRef String = Literal->getString(); 2594 StringLength = String.size(); 2595 return *Map.insert(std::make_pair(String, nullptr)).first; 2596 } 2597 2598 llvm::Constant * 2599 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 2600 unsigned StringLength = 0; 2601 bool isUTF16 = false; 2602 llvm::StringMapEntry<llvm::Constant*> &Entry = 2603 GetConstantCFStringEntry(CFConstantStringMap, Literal, 2604 getDataLayout().isLittleEndian(), 2605 isUTF16, StringLength); 2606 2607 if (auto *C = Entry.second) 2608 return C; 2609 2610 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2611 llvm::Constant *Zeros[] = { Zero, Zero }; 2612 llvm::Value *V; 2613 2614 // If we don't already have it, get __CFConstantStringClassReference. 2615 if (!CFConstantStringClassRef) { 2616 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2617 Ty = llvm::ArrayType::get(Ty, 0); 2618 llvm::Constant *GV = CreateRuntimeVariable(Ty, 2619 "__CFConstantStringClassReference"); 2620 // Decay array -> ptr 2621 V = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2622 CFConstantStringClassRef = V; 2623 } 2624 else 2625 V = CFConstantStringClassRef; 2626 2627 QualType CFTy = getContext().getCFConstantStringType(); 2628 2629 auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 2630 2631 llvm::Constant *Fields[4]; 2632 2633 // Class pointer. 2634 Fields[0] = cast<llvm::ConstantExpr>(V); 2635 2636 // Flags. 2637 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2638 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 2639 llvm::ConstantInt::get(Ty, 0x07C8); 2640 2641 // String pointer. 2642 llvm::Constant *C = nullptr; 2643 if (isUTF16) { 2644 ArrayRef<uint16_t> Arr = llvm::makeArrayRef<uint16_t>( 2645 reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())), 2646 Entry.first().size() / 2); 2647 C = llvm::ConstantDataArray::get(VMContext, Arr); 2648 } else { 2649 C = llvm::ConstantDataArray::getString(VMContext, Entry.first()); 2650 } 2651 2652 // Note: -fwritable-strings doesn't make the backing store strings of 2653 // CFStrings writable. (See <rdar://problem/10657500>) 2654 auto *GV = 2655 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, 2656 llvm::GlobalValue::PrivateLinkage, C, ".str"); 2657 GV->setUnnamedAddr(true); 2658 // Don't enforce the target's minimum global alignment, since the only use 2659 // of the string is via this class initializer. 2660 // FIXME: We set the section explicitly to avoid a bug in ld64 224.1. Without 2661 // it LLVM can merge the string with a non unnamed_addr one during LTO. Doing 2662 // that changes the section it ends in, which surprises ld64. 2663 if (isUTF16) { 2664 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 2665 GV->setAlignment(Align.getQuantity()); 2666 GV->setSection("__TEXT,__ustring"); 2667 } else { 2668 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2669 GV->setAlignment(Align.getQuantity()); 2670 GV->setSection("__TEXT,__cstring,cstring_literals"); 2671 } 2672 2673 // String. 2674 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2675 2676 if (isUTF16) 2677 // Cast the UTF16 string to the correct type. 2678 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy); 2679 2680 // String length. 2681 Ty = getTypes().ConvertType(getContext().LongTy); 2682 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 2683 2684 // The struct. 2685 C = llvm::ConstantStruct::get(STy, Fields); 2686 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2687 llvm::GlobalVariable::PrivateLinkage, C, 2688 "_unnamed_cfstring_"); 2689 GV->setSection("__DATA,__cfstring"); 2690 Entry.second = GV; 2691 2692 return GV; 2693 } 2694 2695 llvm::Constant * 2696 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { 2697 unsigned StringLength = 0; 2698 llvm::StringMapEntry<llvm::Constant*> &Entry = 2699 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength); 2700 2701 if (auto *C = Entry.second) 2702 return C; 2703 2704 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2705 llvm::Constant *Zeros[] = { Zero, Zero }; 2706 llvm::Value *V; 2707 // If we don't already have it, get _NSConstantStringClassReference. 2708 if (!ConstantStringClassRef) { 2709 std::string StringClass(getLangOpts().ObjCConstantStringClass); 2710 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2711 llvm::Constant *GV; 2712 if (LangOpts.ObjCRuntime.isNonFragile()) { 2713 std::string str = 2714 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 2715 : "OBJC_CLASS_$_" + StringClass; 2716 GV = getObjCRuntime().GetClassGlobal(str); 2717 // Make sure the result is of the correct type. 2718 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 2719 V = llvm::ConstantExpr::getBitCast(GV, PTy); 2720 ConstantStringClassRef = V; 2721 } else { 2722 std::string str = 2723 StringClass.empty() ? "_NSConstantStringClassReference" 2724 : "_" + StringClass + "ClassReference"; 2725 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0); 2726 GV = CreateRuntimeVariable(PTy, str); 2727 // Decay array -> ptr 2728 V = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2729 ConstantStringClassRef = V; 2730 } 2731 } 2732 else 2733 V = ConstantStringClassRef; 2734 2735 if (!NSConstantStringType) { 2736 // Construct the type for a constant NSString. 2737 RecordDecl *D = Context.buildImplicitRecord("__builtin_NSString"); 2738 D->startDefinition(); 2739 2740 QualType FieldTypes[3]; 2741 2742 // const int *isa; 2743 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst()); 2744 // const char *str; 2745 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst()); 2746 // unsigned int length; 2747 FieldTypes[2] = Context.UnsignedIntTy; 2748 2749 // Create fields 2750 for (unsigned i = 0; i < 3; ++i) { 2751 FieldDecl *Field = FieldDecl::Create(Context, D, 2752 SourceLocation(), 2753 SourceLocation(), nullptr, 2754 FieldTypes[i], /*TInfo=*/nullptr, 2755 /*BitWidth=*/nullptr, 2756 /*Mutable=*/false, 2757 ICIS_NoInit); 2758 Field->setAccess(AS_public); 2759 D->addDecl(Field); 2760 } 2761 2762 D->completeDefinition(); 2763 QualType NSTy = Context.getTagDeclType(D); 2764 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 2765 } 2766 2767 llvm::Constant *Fields[3]; 2768 2769 // Class pointer. 2770 Fields[0] = cast<llvm::ConstantExpr>(V); 2771 2772 // String pointer. 2773 llvm::Constant *C = 2774 llvm::ConstantDataArray::getString(VMContext, Entry.first()); 2775 2776 llvm::GlobalValue::LinkageTypes Linkage; 2777 bool isConstant; 2778 Linkage = llvm::GlobalValue::PrivateLinkage; 2779 isConstant = !LangOpts.WritableStrings; 2780 2781 auto *GV = new llvm::GlobalVariable(getModule(), C->getType(), isConstant, 2782 Linkage, C, ".str"); 2783 GV->setUnnamedAddr(true); 2784 // Don't enforce the target's minimum global alignment, since the only use 2785 // of the string is via this class initializer. 2786 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2787 GV->setAlignment(Align.getQuantity()); 2788 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2789 2790 // String length. 2791 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2792 Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 2793 2794 // The struct. 2795 C = llvm::ConstantStruct::get(NSConstantStringType, Fields); 2796 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2797 llvm::GlobalVariable::PrivateLinkage, C, 2798 "_unnamed_nsstring_"); 2799 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip"; 2800 const char *NSStringNonFragileABISection = 2801 "__DATA,__objc_stringobj,regular,no_dead_strip"; 2802 // FIXME. Fix section. 2803 GV->setSection(LangOpts.ObjCRuntime.isNonFragile() 2804 ? NSStringNonFragileABISection 2805 : NSStringSection); 2806 Entry.second = GV; 2807 2808 return GV; 2809 } 2810 2811 QualType CodeGenModule::getObjCFastEnumerationStateType() { 2812 if (ObjCFastEnumerationStateType.isNull()) { 2813 RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState"); 2814 D->startDefinition(); 2815 2816 QualType FieldTypes[] = { 2817 Context.UnsignedLongTy, 2818 Context.getPointerType(Context.getObjCIdType()), 2819 Context.getPointerType(Context.UnsignedLongTy), 2820 Context.getConstantArrayType(Context.UnsignedLongTy, 2821 llvm::APInt(32, 5), ArrayType::Normal, 0) 2822 }; 2823 2824 for (size_t i = 0; i < 4; ++i) { 2825 FieldDecl *Field = FieldDecl::Create(Context, 2826 D, 2827 SourceLocation(), 2828 SourceLocation(), nullptr, 2829 FieldTypes[i], /*TInfo=*/nullptr, 2830 /*BitWidth=*/nullptr, 2831 /*Mutable=*/false, 2832 ICIS_NoInit); 2833 Field->setAccess(AS_public); 2834 D->addDecl(Field); 2835 } 2836 2837 D->completeDefinition(); 2838 ObjCFastEnumerationStateType = Context.getTagDeclType(D); 2839 } 2840 2841 return ObjCFastEnumerationStateType; 2842 } 2843 2844 llvm::Constant * 2845 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { 2846 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 2847 2848 // Don't emit it as the address of the string, emit the string data itself 2849 // as an inline array. 2850 if (E->getCharByteWidth() == 1) { 2851 SmallString<64> Str(E->getString()); 2852 2853 // Resize the string to the right size, which is indicated by its type. 2854 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType()); 2855 Str.resize(CAT->getSize().getZExtValue()); 2856 return llvm::ConstantDataArray::getString(VMContext, Str, false); 2857 } 2858 2859 auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); 2860 llvm::Type *ElemTy = AType->getElementType(); 2861 unsigned NumElements = AType->getNumElements(); 2862 2863 // Wide strings have either 2-byte or 4-byte elements. 2864 if (ElemTy->getPrimitiveSizeInBits() == 16) { 2865 SmallVector<uint16_t, 32> Elements; 2866 Elements.reserve(NumElements); 2867 2868 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2869 Elements.push_back(E->getCodeUnit(i)); 2870 Elements.resize(NumElements); 2871 return llvm::ConstantDataArray::get(VMContext, Elements); 2872 } 2873 2874 assert(ElemTy->getPrimitiveSizeInBits() == 32); 2875 SmallVector<uint32_t, 32> Elements; 2876 Elements.reserve(NumElements); 2877 2878 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2879 Elements.push_back(E->getCodeUnit(i)); 2880 Elements.resize(NumElements); 2881 return llvm::ConstantDataArray::get(VMContext, Elements); 2882 } 2883 2884 static llvm::GlobalVariable * 2885 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, 2886 CodeGenModule &CGM, StringRef GlobalName, 2887 unsigned Alignment) { 2888 // OpenCL v1.2 s6.5.3: a string literal is in the constant address space. 2889 unsigned AddrSpace = 0; 2890 if (CGM.getLangOpts().OpenCL) 2891 AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant); 2892 2893 llvm::Module &M = CGM.getModule(); 2894 // Create a global variable for this string 2895 auto *GV = new llvm::GlobalVariable( 2896 M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName, 2897 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace); 2898 GV->setAlignment(Alignment); 2899 GV->setUnnamedAddr(true); 2900 if (GV->isWeakForLinker()) { 2901 assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals"); 2902 GV->setComdat(M.getOrInsertComdat(GV->getName())); 2903 } 2904 2905 return GV; 2906 } 2907 2908 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a 2909 /// constant array for the given string literal. 2910 llvm::GlobalVariable * 2911 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S, 2912 StringRef Name) { 2913 auto Alignment = 2914 getContext().getAlignOfGlobalVarInChars(S->getType()).getQuantity(); 2915 2916 llvm::Constant *C = GetConstantArrayFromStringLiteral(S); 2917 llvm::GlobalVariable **Entry = nullptr; 2918 if (!LangOpts.WritableStrings) { 2919 Entry = &ConstantStringMap[C]; 2920 if (auto GV = *Entry) { 2921 if (Alignment > GV->getAlignment()) 2922 GV->setAlignment(Alignment); 2923 return GV; 2924 } 2925 } 2926 2927 SmallString<256> MangledNameBuffer; 2928 StringRef GlobalVariableName; 2929 llvm::GlobalValue::LinkageTypes LT; 2930 2931 // Mangle the string literal if the ABI allows for it. However, we cannot 2932 // do this if we are compiling with ASan or -fwritable-strings because they 2933 // rely on strings having normal linkage. 2934 if (!LangOpts.WritableStrings && 2935 !LangOpts.Sanitize.has(SanitizerKind::Address) && 2936 getCXXABI().getMangleContext().shouldMangleStringLiteral(S)) { 2937 llvm::raw_svector_ostream Out(MangledNameBuffer); 2938 getCXXABI().getMangleContext().mangleStringLiteral(S, Out); 2939 Out.flush(); 2940 2941 LT = llvm::GlobalValue::LinkOnceODRLinkage; 2942 GlobalVariableName = MangledNameBuffer; 2943 } else { 2944 LT = llvm::GlobalValue::PrivateLinkage; 2945 GlobalVariableName = Name; 2946 } 2947 2948 auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment); 2949 if (Entry) 2950 *Entry = GV; 2951 2952 SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>", 2953 QualType()); 2954 return GV; 2955 } 2956 2957 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 2958 /// array for the given ObjCEncodeExpr node. 2959 llvm::GlobalVariable * 2960 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 2961 std::string Str; 2962 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 2963 2964 return GetAddrOfConstantCString(Str); 2965 } 2966 2967 /// GetAddrOfConstantCString - Returns a pointer to a character array containing 2968 /// the literal and a terminating '\0' character. 2969 /// The result has pointer to array type. 2970 llvm::GlobalVariable *CodeGenModule::GetAddrOfConstantCString( 2971 const std::string &Str, const char *GlobalName, unsigned Alignment) { 2972 StringRef StrWithNull(Str.c_str(), Str.size() + 1); 2973 if (Alignment == 0) { 2974 Alignment = getContext() 2975 .getAlignOfGlobalVarInChars(getContext().CharTy) 2976 .getQuantity(); 2977 } 2978 2979 llvm::Constant *C = 2980 llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false); 2981 2982 // Don't share any string literals if strings aren't constant. 2983 llvm::GlobalVariable **Entry = nullptr; 2984 if (!LangOpts.WritableStrings) { 2985 Entry = &ConstantStringMap[C]; 2986 if (auto GV = *Entry) { 2987 if (Alignment > GV->getAlignment()) 2988 GV->setAlignment(Alignment); 2989 return GV; 2990 } 2991 } 2992 2993 // Get the default prefix if a name wasn't specified. 2994 if (!GlobalName) 2995 GlobalName = ".str"; 2996 // Create a global variable for this. 2997 auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this, 2998 GlobalName, Alignment); 2999 if (Entry) 3000 *Entry = GV; 3001 return GV; 3002 } 3003 3004 llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( 3005 const MaterializeTemporaryExpr *E, const Expr *Init) { 3006 assert((E->getStorageDuration() == SD_Static || 3007 E->getStorageDuration() == SD_Thread) && "not a global temporary"); 3008 const auto *VD = cast<VarDecl>(E->getExtendingDecl()); 3009 3010 // If we're not materializing a subobject of the temporary, keep the 3011 // cv-qualifiers from the type of the MaterializeTemporaryExpr. 3012 QualType MaterializedType = Init->getType(); 3013 if (Init == E->GetTemporaryExpr()) 3014 MaterializedType = E->getType(); 3015 3016 llvm::Constant *&Slot = MaterializedGlobalTemporaryMap[E]; 3017 if (Slot) 3018 return Slot; 3019 3020 // FIXME: If an externally-visible declaration extends multiple temporaries, 3021 // we need to give each temporary the same name in every translation unit (and 3022 // we also need to make the temporaries externally-visible). 3023 SmallString<256> Name; 3024 llvm::raw_svector_ostream Out(Name); 3025 getCXXABI().getMangleContext().mangleReferenceTemporary( 3026 VD, E->getManglingNumber(), Out); 3027 Out.flush(); 3028 3029 APValue *Value = nullptr; 3030 if (E->getStorageDuration() == SD_Static) { 3031 // We might have a cached constant initializer for this temporary. Note 3032 // that this might have a different value from the value computed by 3033 // evaluating the initializer if the surrounding constant expression 3034 // modifies the temporary. 3035 Value = getContext().getMaterializedTemporaryValue(E, false); 3036 if (Value && Value->isUninit()) 3037 Value = nullptr; 3038 } 3039 3040 // Try evaluating it now, it might have a constant initializer. 3041 Expr::EvalResult EvalResult; 3042 if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) && 3043 !EvalResult.hasSideEffects()) 3044 Value = &EvalResult.Val; 3045 3046 llvm::Constant *InitialValue = nullptr; 3047 bool Constant = false; 3048 llvm::Type *Type; 3049 if (Value) { 3050 // The temporary has a constant initializer, use it. 3051 InitialValue = EmitConstantValue(*Value, MaterializedType, nullptr); 3052 Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value); 3053 Type = InitialValue->getType(); 3054 } else { 3055 // No initializer, the initialization will be provided when we 3056 // initialize the declaration which performed lifetime extension. 3057 Type = getTypes().ConvertTypeForMem(MaterializedType); 3058 } 3059 3060 // Create a global variable for this lifetime-extended temporary. 3061 llvm::GlobalValue::LinkageTypes Linkage = 3062 getLLVMLinkageVarDefinition(VD, Constant); 3063 // There is no need for this temporary to have global linkage if the global 3064 // variable has external linkage. 3065 if (Linkage == llvm::GlobalVariable::ExternalLinkage) 3066 Linkage = llvm::GlobalVariable::PrivateLinkage; 3067 unsigned AddrSpace = GetGlobalVarAddressSpace( 3068 VD, getContext().getTargetAddressSpace(MaterializedType)); 3069 auto *GV = new llvm::GlobalVariable( 3070 getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(), 3071 /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, 3072 AddrSpace); 3073 setGlobalVisibility(GV, VD); 3074 GV->setAlignment( 3075 getContext().getTypeAlignInChars(MaterializedType).getQuantity()); 3076 if (VD->getTLSKind()) 3077 setTLSMode(GV, *VD); 3078 Slot = GV; 3079 return GV; 3080 } 3081 3082 /// EmitObjCPropertyImplementations - Emit information for synthesized 3083 /// properties for an implementation. 3084 void CodeGenModule::EmitObjCPropertyImplementations(const 3085 ObjCImplementationDecl *D) { 3086 for (const auto *PID : D->property_impls()) { 3087 // Dynamic is just for type-checking. 3088 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 3089 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 3090 3091 // Determine which methods need to be implemented, some may have 3092 // been overridden. Note that ::isPropertyAccessor is not the method 3093 // we want, that just indicates if the decl came from a 3094 // property. What we want to know is if the method is defined in 3095 // this implementation. 3096 if (!D->getInstanceMethod(PD->getGetterName())) 3097 CodeGenFunction(*this).GenerateObjCGetter( 3098 const_cast<ObjCImplementationDecl *>(D), PID); 3099 if (!PD->isReadOnly() && 3100 !D->getInstanceMethod(PD->getSetterName())) 3101 CodeGenFunction(*this).GenerateObjCSetter( 3102 const_cast<ObjCImplementationDecl *>(D), PID); 3103 } 3104 } 3105 } 3106 3107 static bool needsDestructMethod(ObjCImplementationDecl *impl) { 3108 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 3109 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 3110 ivar; ivar = ivar->getNextIvar()) 3111 if (ivar->getType().isDestructedType()) 3112 return true; 3113 3114 return false; 3115 } 3116 3117 static bool AllTrivialInitializers(CodeGenModule &CGM, 3118 ObjCImplementationDecl *D) { 3119 CodeGenFunction CGF(CGM); 3120 for (ObjCImplementationDecl::init_iterator B = D->init_begin(), 3121 E = D->init_end(); B != E; ++B) { 3122 CXXCtorInitializer *CtorInitExp = *B; 3123 Expr *Init = CtorInitExp->getInit(); 3124 if (!CGF.isTrivialInitializer(Init)) 3125 return false; 3126 } 3127 return true; 3128 } 3129 3130 /// EmitObjCIvarInitializations - Emit information for ivar initialization 3131 /// for an implementation. 3132 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 3133 // We might need a .cxx_destruct even if we don't have any ivar initializers. 3134 if (needsDestructMethod(D)) { 3135 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 3136 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 3137 ObjCMethodDecl *DTORMethod = 3138 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 3139 cxxSelector, getContext().VoidTy, nullptr, D, 3140 /*isInstance=*/true, /*isVariadic=*/false, 3141 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, 3142 /*isDefined=*/false, ObjCMethodDecl::Required); 3143 D->addInstanceMethod(DTORMethod); 3144 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 3145 D->setHasDestructors(true); 3146 } 3147 3148 // If the implementation doesn't have any ivar initializers, we don't need 3149 // a .cxx_construct. 3150 if (D->getNumIvarInitializers() == 0 || 3151 AllTrivialInitializers(*this, D)) 3152 return; 3153 3154 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 3155 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 3156 // The constructor returns 'self'. 3157 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 3158 D->getLocation(), 3159 D->getLocation(), 3160 cxxSelector, 3161 getContext().getObjCIdType(), 3162 nullptr, D, /*isInstance=*/true, 3163 /*isVariadic=*/false, 3164 /*isPropertyAccessor=*/true, 3165 /*isImplicitlyDeclared=*/true, 3166 /*isDefined=*/false, 3167 ObjCMethodDecl::Required); 3168 D->addInstanceMethod(CTORMethod); 3169 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 3170 D->setHasNonZeroConstructors(true); 3171 } 3172 3173 /// EmitNamespace - Emit all declarations in a namespace. 3174 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 3175 for (auto *I : ND->decls()) { 3176 if (const auto *VD = dyn_cast<VarDecl>(I)) 3177 if (VD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization && 3178 VD->getTemplateSpecializationKind() != TSK_Undeclared) 3179 continue; 3180 EmitTopLevelDecl(I); 3181 } 3182 } 3183 3184 // EmitLinkageSpec - Emit all declarations in a linkage spec. 3185 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 3186 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 3187 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 3188 ErrorUnsupported(LSD, "linkage spec"); 3189 return; 3190 } 3191 3192 for (auto *I : LSD->decls()) { 3193 // Meta-data for ObjC class includes references to implemented methods. 3194 // Generate class's method definitions first. 3195 if (auto *OID = dyn_cast<ObjCImplDecl>(I)) { 3196 for (auto *M : OID->methods()) 3197 EmitTopLevelDecl(M); 3198 } 3199 EmitTopLevelDecl(I); 3200 } 3201 } 3202 3203 /// EmitTopLevelDecl - Emit code for a single top level declaration. 3204 void CodeGenModule::EmitTopLevelDecl(Decl *D) { 3205 // Ignore dependent declarations. 3206 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 3207 return; 3208 3209 switch (D->getKind()) { 3210 case Decl::CXXConversion: 3211 case Decl::CXXMethod: 3212 case Decl::Function: 3213 // Skip function templates 3214 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 3215 cast<FunctionDecl>(D)->isLateTemplateParsed()) 3216 return; 3217 3218 EmitGlobal(cast<FunctionDecl>(D)); 3219 // Always provide some coverage mapping 3220 // even for the functions that aren't emitted. 3221 AddDeferredUnusedCoverageMapping(D); 3222 break; 3223 3224 case Decl::Var: 3225 // Skip variable templates 3226 if (cast<VarDecl>(D)->getDescribedVarTemplate()) 3227 return; 3228 case Decl::VarTemplateSpecialization: 3229 EmitGlobal(cast<VarDecl>(D)); 3230 break; 3231 3232 // Indirect fields from global anonymous structs and unions can be 3233 // ignored; only the actual variable requires IR gen support. 3234 case Decl::IndirectField: 3235 break; 3236 3237 // C++ Decls 3238 case Decl::Namespace: 3239 EmitNamespace(cast<NamespaceDecl>(D)); 3240 break; 3241 // No code generation needed. 3242 case Decl::UsingShadow: 3243 case Decl::ClassTemplate: 3244 case Decl::VarTemplate: 3245 case Decl::VarTemplatePartialSpecialization: 3246 case Decl::FunctionTemplate: 3247 case Decl::TypeAliasTemplate: 3248 case Decl::Block: 3249 case Decl::Empty: 3250 break; 3251 case Decl::Using: // using X; [C++] 3252 if (CGDebugInfo *DI = getModuleDebugInfo()) 3253 DI->EmitUsingDecl(cast<UsingDecl>(*D)); 3254 return; 3255 case Decl::NamespaceAlias: 3256 if (CGDebugInfo *DI = getModuleDebugInfo()) 3257 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D)); 3258 return; 3259 case Decl::UsingDirective: // using namespace X; [C++] 3260 if (CGDebugInfo *DI = getModuleDebugInfo()) 3261 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D)); 3262 return; 3263 case Decl::CXXConstructor: 3264 // Skip function templates 3265 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 3266 cast<FunctionDecl>(D)->isLateTemplateParsed()) 3267 return; 3268 3269 getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 3270 break; 3271 case Decl::CXXDestructor: 3272 if (cast<FunctionDecl>(D)->isLateTemplateParsed()) 3273 return; 3274 getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 3275 break; 3276 3277 case Decl::StaticAssert: 3278 // Nothing to do. 3279 break; 3280 3281 // Objective-C Decls 3282 3283 // Forward declarations, no (immediate) code generation. 3284 case Decl::ObjCInterface: 3285 case Decl::ObjCCategory: 3286 break; 3287 3288 case Decl::ObjCProtocol: { 3289 auto *Proto = cast<ObjCProtocolDecl>(D); 3290 if (Proto->isThisDeclarationADefinition()) 3291 ObjCRuntime->GenerateProtocol(Proto); 3292 break; 3293 } 3294 3295 case Decl::ObjCCategoryImpl: 3296 // Categories have properties but don't support synthesize so we 3297 // can ignore them here. 3298 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 3299 break; 3300 3301 case Decl::ObjCImplementation: { 3302 auto *OMD = cast<ObjCImplementationDecl>(D); 3303 EmitObjCPropertyImplementations(OMD); 3304 EmitObjCIvarInitializations(OMD); 3305 ObjCRuntime->GenerateClass(OMD); 3306 // Emit global variable debug information. 3307 if (CGDebugInfo *DI = getModuleDebugInfo()) 3308 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 3309 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType( 3310 OMD->getClassInterface()), OMD->getLocation()); 3311 break; 3312 } 3313 case Decl::ObjCMethod: { 3314 auto *OMD = cast<ObjCMethodDecl>(D); 3315 // If this is not a prototype, emit the body. 3316 if (OMD->getBody()) 3317 CodeGenFunction(*this).GenerateObjCMethod(OMD); 3318 break; 3319 } 3320 case Decl::ObjCCompatibleAlias: 3321 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D)); 3322 break; 3323 3324 case Decl::LinkageSpec: 3325 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 3326 break; 3327 3328 case Decl::FileScopeAsm: { 3329 auto *AD = cast<FileScopeAsmDecl>(D); 3330 StringRef AsmString = AD->getAsmString()->getString(); 3331 3332 const std::string &S = getModule().getModuleInlineAsm(); 3333 if (S.empty()) 3334 getModule().setModuleInlineAsm(AsmString); 3335 else if (S.end()[-1] == '\n') 3336 getModule().setModuleInlineAsm(S + AsmString.str()); 3337 else 3338 getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 3339 break; 3340 } 3341 3342 case Decl::Import: { 3343 auto *Import = cast<ImportDecl>(D); 3344 3345 // Ignore import declarations that come from imported modules. 3346 if (clang::Module *Owner = Import->getOwningModule()) { 3347 if (getLangOpts().CurrentModule.empty() || 3348 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule) 3349 break; 3350 } 3351 3352 ImportedModules.insert(Import->getImportedModule()); 3353 break; 3354 } 3355 3356 case Decl::OMPThreadPrivate: 3357 EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D)); 3358 break; 3359 3360 case Decl::ClassTemplateSpecialization: { 3361 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D); 3362 if (DebugInfo && 3363 Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition && 3364 Spec->hasDefinition()) 3365 DebugInfo->completeTemplateDefinition(*Spec); 3366 break; 3367 } 3368 3369 default: 3370 // Make sure we handled everything we should, every other kind is a 3371 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 3372 // function. Need to recode Decl::Kind to do that easily. 3373 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 3374 break; 3375 } 3376 } 3377 3378 void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) { 3379 // Do we need to generate coverage mapping? 3380 if (!CodeGenOpts.CoverageMapping) 3381 return; 3382 switch (D->getKind()) { 3383 case Decl::CXXConversion: 3384 case Decl::CXXMethod: 3385 case Decl::Function: 3386 case Decl::ObjCMethod: 3387 case Decl::CXXConstructor: 3388 case Decl::CXXDestructor: { 3389 if (!cast<FunctionDecl>(D)->hasBody()) 3390 return; 3391 auto I = DeferredEmptyCoverageMappingDecls.find(D); 3392 if (I == DeferredEmptyCoverageMappingDecls.end()) 3393 DeferredEmptyCoverageMappingDecls[D] = true; 3394 break; 3395 } 3396 default: 3397 break; 3398 }; 3399 } 3400 3401 void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) { 3402 // Do we need to generate coverage mapping? 3403 if (!CodeGenOpts.CoverageMapping) 3404 return; 3405 if (const auto *Fn = dyn_cast<FunctionDecl>(D)) { 3406 if (Fn->isTemplateInstantiation()) 3407 ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern()); 3408 } 3409 auto I = DeferredEmptyCoverageMappingDecls.find(D); 3410 if (I == DeferredEmptyCoverageMappingDecls.end()) 3411 DeferredEmptyCoverageMappingDecls[D] = false; 3412 else 3413 I->second = false; 3414 } 3415 3416 void CodeGenModule::EmitDeferredUnusedCoverageMappings() { 3417 std::vector<const Decl *> DeferredDecls; 3418 for (const auto I : DeferredEmptyCoverageMappingDecls) { 3419 if (!I.second) 3420 continue; 3421 DeferredDecls.push_back(I.first); 3422 } 3423 // Sort the declarations by their location to make sure that the tests get a 3424 // predictable order for the coverage mapping for the unused declarations. 3425 if (CodeGenOpts.DumpCoverageMapping) 3426 std::sort(DeferredDecls.begin(), DeferredDecls.end(), 3427 [] (const Decl *LHS, const Decl *RHS) { 3428 return LHS->getLocStart() < RHS->getLocStart(); 3429 }); 3430 for (const auto *D : DeferredDecls) { 3431 switch (D->getKind()) { 3432 case Decl::CXXConversion: 3433 case Decl::CXXMethod: 3434 case Decl::Function: 3435 case Decl::ObjCMethod: { 3436 CodeGenPGO PGO(*this); 3437 GlobalDecl GD(cast<FunctionDecl>(D)); 3438 PGO.emitEmptyCounterMapping(D, getMangledName(GD), 3439 getFunctionLinkage(GD)); 3440 break; 3441 } 3442 case Decl::CXXConstructor: { 3443 CodeGenPGO PGO(*this); 3444 GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base); 3445 PGO.emitEmptyCounterMapping(D, getMangledName(GD), 3446 getFunctionLinkage(GD)); 3447 break; 3448 } 3449 case Decl::CXXDestructor: { 3450 CodeGenPGO PGO(*this); 3451 GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base); 3452 PGO.emitEmptyCounterMapping(D, getMangledName(GD), 3453 getFunctionLinkage(GD)); 3454 break; 3455 } 3456 default: 3457 break; 3458 }; 3459 } 3460 } 3461 3462 /// Turns the given pointer into a constant. 3463 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 3464 const void *Ptr) { 3465 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 3466 llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 3467 return llvm::ConstantInt::get(i64, PtrInt); 3468 } 3469 3470 static void EmitGlobalDeclMetadata(CodeGenModule &CGM, 3471 llvm::NamedMDNode *&GlobalMetadata, 3472 GlobalDecl D, 3473 llvm::GlobalValue *Addr) { 3474 if (!GlobalMetadata) 3475 GlobalMetadata = 3476 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 3477 3478 // TODO: should we report variant information for ctors/dtors? 3479 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr), 3480 llvm::ConstantAsMetadata::get(GetPointerConstant( 3481 CGM.getLLVMContext(), D.getDecl()))}; 3482 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 3483 } 3484 3485 /// For each function which is declared within an extern "C" region and marked 3486 /// as 'used', but has internal linkage, create an alias from the unmangled 3487 /// name to the mangled name if possible. People expect to be able to refer 3488 /// to such functions with an unmangled name from inline assembly within the 3489 /// same translation unit. 3490 void CodeGenModule::EmitStaticExternCAliases() { 3491 for (StaticExternCMap::iterator I = StaticExternCValues.begin(), 3492 E = StaticExternCValues.end(); 3493 I != E; ++I) { 3494 IdentifierInfo *Name = I->first; 3495 llvm::GlobalValue *Val = I->second; 3496 if (Val && !getModule().getNamedValue(Name->getName())) 3497 addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val)); 3498 } 3499 } 3500 3501 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName, 3502 GlobalDecl &Result) const { 3503 auto Res = Manglings.find(MangledName); 3504 if (Res == Manglings.end()) 3505 return false; 3506 Result = Res->getValue(); 3507 return true; 3508 } 3509 3510 /// Emits metadata nodes associating all the global values in the 3511 /// current module with the Decls they came from. This is useful for 3512 /// projects using IR gen as a subroutine. 3513 /// 3514 /// Since there's currently no way to associate an MDNode directly 3515 /// with an llvm::GlobalValue, we create a global named metadata 3516 /// with the name 'clang.global.decl.ptrs'. 3517 void CodeGenModule::EmitDeclMetadata() { 3518 llvm::NamedMDNode *GlobalMetadata = nullptr; 3519 3520 // StaticLocalDeclMap 3521 for (auto &I : MangledDeclNames) { 3522 llvm::GlobalValue *Addr = getModule().getNamedValue(I.second); 3523 EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr); 3524 } 3525 } 3526 3527 /// Emits metadata nodes for all the local variables in the current 3528 /// function. 3529 void CodeGenFunction::EmitDeclMetadata() { 3530 if (LocalDeclMap.empty()) return; 3531 3532 llvm::LLVMContext &Context = getLLVMContext(); 3533 3534 // Find the unique metadata ID for this name. 3535 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 3536 3537 llvm::NamedMDNode *GlobalMetadata = nullptr; 3538 3539 for (auto &I : LocalDeclMap) { 3540 const Decl *D = I.first; 3541 llvm::Value *Addr = I.second; 3542 if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 3543 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 3544 Alloca->setMetadata( 3545 DeclPtrKind, llvm::MDNode::get( 3546 Context, llvm::ValueAsMetadata::getConstant(DAddr))); 3547 } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 3548 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 3549 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 3550 } 3551 } 3552 } 3553 3554 void CodeGenModule::EmitVersionIdentMetadata() { 3555 llvm::NamedMDNode *IdentMetadata = 3556 TheModule.getOrInsertNamedMetadata("llvm.ident"); 3557 std::string Version = getClangFullVersion(); 3558 llvm::LLVMContext &Ctx = TheModule.getContext(); 3559 3560 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)}; 3561 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode)); 3562 } 3563 3564 void CodeGenModule::EmitTargetMetadata() { 3565 // Warning, new MangledDeclNames may be appended within this loop. 3566 // We rely on MapVector insertions adding new elements to the end 3567 // of the container. 3568 // FIXME: Move this loop into the one target that needs it, and only 3569 // loop over those declarations for which we couldn't emit the target 3570 // metadata when we emitted the declaration. 3571 for (unsigned I = 0; I != MangledDeclNames.size(); ++I) { 3572 auto Val = *(MangledDeclNames.begin() + I); 3573 const Decl *D = Val.first.getDecl()->getMostRecentDecl(); 3574 llvm::GlobalValue *GV = GetGlobalValue(Val.second); 3575 getTargetCodeGenInfo().emitTargetMD(D, GV, *this); 3576 } 3577 } 3578 3579 void CodeGenModule::EmitCoverageFile() { 3580 if (!getCodeGenOpts().CoverageFile.empty()) { 3581 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { 3582 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 3583 llvm::LLVMContext &Ctx = TheModule.getContext(); 3584 llvm::MDString *CoverageFile = 3585 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile); 3586 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 3587 llvm::MDNode *CU = CUNode->getOperand(i); 3588 llvm::Metadata *Elts[] = {CoverageFile, CU}; 3589 GCov->addOperand(llvm::MDNode::get(Ctx, Elts)); 3590 } 3591 } 3592 } 3593 } 3594 3595 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) { 3596 // Sema has checked that all uuid strings are of the form 3597 // "12345678-1234-1234-1234-1234567890ab". 3598 assert(Uuid.size() == 36); 3599 for (unsigned i = 0; i < 36; ++i) { 3600 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-'); 3601 else assert(isHexDigit(Uuid[i])); 3602 } 3603 3604 // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab". 3605 const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 }; 3606 3607 llvm::Constant *Field3[8]; 3608 for (unsigned Idx = 0; Idx < 8; ++Idx) 3609 Field3[Idx] = llvm::ConstantInt::get( 3610 Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16); 3611 3612 llvm::Constant *Fields[4] = { 3613 llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16), 3614 llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16), 3615 llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16), 3616 llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3) 3617 }; 3618 3619 return llvm::ConstantStruct::getAnon(Fields); 3620 } 3621 3622 llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty, 3623 bool ForEH) { 3624 // Return a bogus pointer if RTTI is disabled, unless it's for EH. 3625 // FIXME: should we even be calling this method if RTTI is disabled 3626 // and it's not for EH? 3627 if (!ForEH && !getLangOpts().RTTI) 3628 return llvm::Constant::getNullValue(Int8PtrTy); 3629 3630 if (ForEH && Ty->isObjCObjectPointerType() && 3631 LangOpts.ObjCRuntime.isGNUFamily()) 3632 return ObjCRuntime->GetEHType(Ty); 3633 3634 return getCXXABI().getAddrOfRTTIDescriptor(Ty); 3635 } 3636 3637 void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { 3638 for (auto RefExpr : D->varlists()) { 3639 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl()); 3640 bool PerformInit = 3641 VD->getAnyInitializer() && 3642 !VD->getAnyInitializer()->isConstantInitializer(getContext(), 3643 /*ForRef=*/false); 3644 if (auto InitFunction = 3645 getOpenMPRuntime().EmitOMPThreadPrivateVarDefinition( 3646 VD, GetAddrOfGlobalVar(VD), RefExpr->getLocStart(), 3647 PerformInit)) 3648 CXXGlobalInits.push_back(InitFunction); 3649 } 3650 } 3651 3652