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 "CGBlocks.h" 16 #include "CGCUDARuntime.h" 17 #include "CGCXXABI.h" 18 #include "CGCall.h" 19 #include "CGDebugInfo.h" 20 #include "CGObjCRuntime.h" 21 #include "CGOpenCLRuntime.h" 22 #include "CGOpenMPRuntime.h" 23 #include "CGOpenMPRuntimeNVPTX.h" 24 #include "CodeGenFunction.h" 25 #include "CodeGenPGO.h" 26 #include "ConstantEmitter.h" 27 #include "CoverageMappingGen.h" 28 #include "TargetInfo.h" 29 #include "clang/AST/ASTContext.h" 30 #include "clang/AST/CharUnits.h" 31 #include "clang/AST/DeclCXX.h" 32 #include "clang/AST/DeclObjC.h" 33 #include "clang/AST/DeclTemplate.h" 34 #include "clang/AST/Mangle.h" 35 #include "clang/AST/RecordLayout.h" 36 #include "clang/AST/RecursiveASTVisitor.h" 37 #include "clang/Basic/Builtins.h" 38 #include "clang/Basic/CharInfo.h" 39 #include "clang/Basic/Diagnostic.h" 40 #include "clang/Basic/Module.h" 41 #include "clang/Basic/SourceManager.h" 42 #include "clang/Basic/TargetInfo.h" 43 #include "clang/Basic/Version.h" 44 #include "clang/CodeGen/ConstantInitBuilder.h" 45 #include "clang/Frontend/CodeGenOptions.h" 46 #include "clang/Sema/SemaDiagnostic.h" 47 #include "llvm/ADT/Triple.h" 48 #include "llvm/Analysis/TargetLibraryInfo.h" 49 #include "llvm/IR/CallSite.h" 50 #include "llvm/IR/CallingConv.h" 51 #include "llvm/IR/DataLayout.h" 52 #include "llvm/IR/Intrinsics.h" 53 #include "llvm/IR/LLVMContext.h" 54 #include "llvm/IR/Module.h" 55 #include "llvm/ProfileData/InstrProfReader.h" 56 #include "llvm/Support/ConvertUTF.h" 57 #include "llvm/Support/ErrorHandling.h" 58 #include "llvm/Support/MD5.h" 59 60 using namespace clang; 61 using namespace CodeGen; 62 63 static llvm::cl::opt<bool> LimitedCoverage( 64 "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden, 65 llvm::cl::desc("Emit limited coverage mapping information (experimental)"), 66 llvm::cl::init(false)); 67 68 static const char AnnotationSection[] = "llvm.metadata"; 69 70 static CGCXXABI *createCXXABI(CodeGenModule &CGM) { 71 switch (CGM.getTarget().getCXXABI().getKind()) { 72 case TargetCXXABI::GenericAArch64: 73 case TargetCXXABI::GenericARM: 74 case TargetCXXABI::iOS: 75 case TargetCXXABI::iOS64: 76 case TargetCXXABI::WatchOS: 77 case TargetCXXABI::GenericMIPS: 78 case TargetCXXABI::GenericItanium: 79 case TargetCXXABI::WebAssembly: 80 return CreateItaniumCXXABI(CGM); 81 case TargetCXXABI::Microsoft: 82 return CreateMicrosoftCXXABI(CGM); 83 } 84 85 llvm_unreachable("invalid C++ ABI kind"); 86 } 87 88 CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO, 89 const PreprocessorOptions &PPO, 90 const CodeGenOptions &CGO, llvm::Module &M, 91 DiagnosticsEngine &diags, 92 CoverageSourceInfo *CoverageInfo) 93 : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO), 94 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags), 95 Target(C.getTargetInfo()), ABI(createCXXABI(*this)), 96 VMContext(M.getContext()), Types(*this), VTables(*this), 97 SanitizerMD(new SanitizerMetadata(*this)) { 98 99 // Initialize the type cache. 100 llvm::LLVMContext &LLVMContext = M.getContext(); 101 VoidTy = llvm::Type::getVoidTy(LLVMContext); 102 Int8Ty = llvm::Type::getInt8Ty(LLVMContext); 103 Int16Ty = llvm::Type::getInt16Ty(LLVMContext); 104 Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 105 Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 106 HalfTy = llvm::Type::getHalfTy(LLVMContext); 107 FloatTy = llvm::Type::getFloatTy(LLVMContext); 108 DoubleTy = llvm::Type::getDoubleTy(LLVMContext); 109 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0); 110 PointerAlignInBytes = 111 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity(); 112 SizeSizeInBytes = 113 C.toCharUnitsFromBits(C.getTargetInfo().getMaxPointerWidth()).getQuantity(); 114 IntAlignInBytes = 115 C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity(); 116 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth()); 117 IntPtrTy = llvm::IntegerType::get(LLVMContext, 118 C.getTargetInfo().getMaxPointerWidth()); 119 Int8PtrTy = Int8Ty->getPointerTo(0); 120 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); 121 AllocaInt8PtrTy = Int8Ty->getPointerTo( 122 M.getDataLayout().getAllocaAddrSpace()); 123 ASTAllocaAddressSpace = getTargetCodeGenInfo().getASTAllocaAddressSpace(); 124 125 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC(); 126 127 if (LangOpts.ObjC1) 128 createObjCRuntime(); 129 if (LangOpts.OpenCL) 130 createOpenCLRuntime(); 131 if (LangOpts.OpenMP) 132 createOpenMPRuntime(); 133 if (LangOpts.CUDA) 134 createCUDARuntime(); 135 136 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0. 137 if (LangOpts.Sanitize.has(SanitizerKind::Thread) || 138 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)) 139 TBAA.reset(new CodeGenTBAA(Context, TheModule, CodeGenOpts, getLangOpts(), 140 getCXXABI().getMangleContext())); 141 142 // If debug info or coverage generation is enabled, create the CGDebugInfo 143 // object. 144 if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo || 145 CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) 146 DebugInfo.reset(new CGDebugInfo(*this)); 147 148 Block.GlobalUniqueCount = 0; 149 150 if (C.getLangOpts().ObjC1) 151 ObjCData.reset(new ObjCEntrypoints()); 152 153 if (CodeGenOpts.hasProfileClangUse()) { 154 auto ReaderOrErr = llvm::IndexedInstrProfReader::create( 155 CodeGenOpts.ProfileInstrumentUsePath); 156 if (auto E = ReaderOrErr.takeError()) { 157 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 158 "Could not read profile %0: %1"); 159 llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) { 160 getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath 161 << EI.message(); 162 }); 163 } else 164 PGOReader = std::move(ReaderOrErr.get()); 165 } 166 167 // If coverage mapping generation is enabled, create the 168 // CoverageMappingModuleGen object. 169 if (CodeGenOpts.CoverageMapping) 170 CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo)); 171 } 172 173 CodeGenModule::~CodeGenModule() {} 174 175 void CodeGenModule::createObjCRuntime() { 176 // This is just isGNUFamily(), but we want to force implementors of 177 // new ABIs to decide how best to do this. 178 switch (LangOpts.ObjCRuntime.getKind()) { 179 case ObjCRuntime::GNUstep: 180 case ObjCRuntime::GCC: 181 case ObjCRuntime::ObjFW: 182 ObjCRuntime.reset(CreateGNUObjCRuntime(*this)); 183 return; 184 185 case ObjCRuntime::FragileMacOSX: 186 case ObjCRuntime::MacOSX: 187 case ObjCRuntime::iOS: 188 case ObjCRuntime::WatchOS: 189 ObjCRuntime.reset(CreateMacObjCRuntime(*this)); 190 return; 191 } 192 llvm_unreachable("bad runtime kind"); 193 } 194 195 void CodeGenModule::createOpenCLRuntime() { 196 OpenCLRuntime.reset(new CGOpenCLRuntime(*this)); 197 } 198 199 void CodeGenModule::createOpenMPRuntime() { 200 // Select a specialized code generation class based on the target, if any. 201 // If it does not exist use the default implementation. 202 switch (getTriple().getArch()) { 203 case llvm::Triple::nvptx: 204 case llvm::Triple::nvptx64: 205 assert(getLangOpts().OpenMPIsDevice && 206 "OpenMP NVPTX is only prepared to deal with device code."); 207 OpenMPRuntime.reset(new CGOpenMPRuntimeNVPTX(*this)); 208 break; 209 default: 210 if (LangOpts.OpenMPSimd) 211 OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this)); 212 else 213 OpenMPRuntime.reset(new CGOpenMPRuntime(*this)); 214 break; 215 } 216 } 217 218 void CodeGenModule::createCUDARuntime() { 219 CUDARuntime.reset(CreateNVCUDARuntime(*this)); 220 } 221 222 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) { 223 Replacements[Name] = C; 224 } 225 226 void CodeGenModule::applyReplacements() { 227 for (auto &I : Replacements) { 228 StringRef MangledName = I.first(); 229 llvm::Constant *Replacement = I.second; 230 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 231 if (!Entry) 232 continue; 233 auto *OldF = cast<llvm::Function>(Entry); 234 auto *NewF = dyn_cast<llvm::Function>(Replacement); 235 if (!NewF) { 236 if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) { 237 NewF = dyn_cast<llvm::Function>(Alias->getAliasee()); 238 } else { 239 auto *CE = cast<llvm::ConstantExpr>(Replacement); 240 assert(CE->getOpcode() == llvm::Instruction::BitCast || 241 CE->getOpcode() == llvm::Instruction::GetElementPtr); 242 NewF = dyn_cast<llvm::Function>(CE->getOperand(0)); 243 } 244 } 245 246 // Replace old with new, but keep the old order. 247 OldF->replaceAllUsesWith(Replacement); 248 if (NewF) { 249 NewF->removeFromParent(); 250 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(), 251 NewF); 252 } 253 OldF->eraseFromParent(); 254 } 255 } 256 257 void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) { 258 GlobalValReplacements.push_back(std::make_pair(GV, C)); 259 } 260 261 void CodeGenModule::applyGlobalValReplacements() { 262 for (auto &I : GlobalValReplacements) { 263 llvm::GlobalValue *GV = I.first; 264 llvm::Constant *C = I.second; 265 266 GV->replaceAllUsesWith(C); 267 GV->eraseFromParent(); 268 } 269 } 270 271 // This is only used in aliases that we created and we know they have a 272 // linear structure. 273 static const llvm::GlobalObject *getAliasedGlobal( 274 const llvm::GlobalIndirectSymbol &GIS) { 275 llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited; 276 const llvm::Constant *C = &GIS; 277 for (;;) { 278 C = C->stripPointerCasts(); 279 if (auto *GO = dyn_cast<llvm::GlobalObject>(C)) 280 return GO; 281 // stripPointerCasts will not walk over weak aliases. 282 auto *GIS2 = dyn_cast<llvm::GlobalIndirectSymbol>(C); 283 if (!GIS2) 284 return nullptr; 285 if (!Visited.insert(GIS2).second) 286 return nullptr; 287 C = GIS2->getIndirectSymbol(); 288 } 289 } 290 291 void CodeGenModule::checkAliases() { 292 // Check if the constructed aliases are well formed. It is really unfortunate 293 // that we have to do this in CodeGen, but we only construct mangled names 294 // and aliases during codegen. 295 bool Error = false; 296 DiagnosticsEngine &Diags = getDiags(); 297 for (const GlobalDecl &GD : Aliases) { 298 const auto *D = cast<ValueDecl>(GD.getDecl()); 299 SourceLocation Location; 300 bool IsIFunc = D->hasAttr<IFuncAttr>(); 301 if (const Attr *A = D->getDefiningAttr()) 302 Location = A->getLocation(); 303 else 304 llvm_unreachable("Not an alias or ifunc?"); 305 StringRef MangledName = getMangledName(GD); 306 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 307 auto *Alias = cast<llvm::GlobalIndirectSymbol>(Entry); 308 const llvm::GlobalValue *GV = getAliasedGlobal(*Alias); 309 if (!GV) { 310 Error = true; 311 Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc; 312 } else if (GV->isDeclaration()) { 313 Error = true; 314 Diags.Report(Location, diag::err_alias_to_undefined) 315 << IsIFunc << IsIFunc; 316 } else if (IsIFunc) { 317 // Check resolver function type. 318 llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>( 319 GV->getType()->getPointerElementType()); 320 assert(FTy); 321 if (!FTy->getReturnType()->isPointerTy()) 322 Diags.Report(Location, diag::err_ifunc_resolver_return); 323 if (FTy->getNumParams()) 324 Diags.Report(Location, diag::err_ifunc_resolver_params); 325 } 326 327 llvm::Constant *Aliasee = Alias->getIndirectSymbol(); 328 llvm::GlobalValue *AliaseeGV; 329 if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee)) 330 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0)); 331 else 332 AliaseeGV = cast<llvm::GlobalValue>(Aliasee); 333 334 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) { 335 StringRef AliasSection = SA->getName(); 336 if (AliasSection != AliaseeGV->getSection()) 337 Diags.Report(SA->getLocation(), diag::warn_alias_with_section) 338 << AliasSection << IsIFunc << IsIFunc; 339 } 340 341 // We have to handle alias to weak aliases in here. LLVM itself disallows 342 // this since the object semantics would not match the IL one. For 343 // compatibility with gcc we implement it by just pointing the alias 344 // to its aliasee's aliasee. We also warn, since the user is probably 345 // expecting the link to be weak. 346 if (auto GA = dyn_cast<llvm::GlobalIndirectSymbol>(AliaseeGV)) { 347 if (GA->isInterposable()) { 348 Diags.Report(Location, diag::warn_alias_to_weak_alias) 349 << GV->getName() << GA->getName() << IsIFunc; 350 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast( 351 GA->getIndirectSymbol(), Alias->getType()); 352 Alias->setIndirectSymbol(Aliasee); 353 } 354 } 355 } 356 if (!Error) 357 return; 358 359 for (const GlobalDecl &GD : Aliases) { 360 StringRef MangledName = getMangledName(GD); 361 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 362 auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry); 363 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType())); 364 Alias->eraseFromParent(); 365 } 366 } 367 368 void CodeGenModule::clear() { 369 DeferredDeclsToEmit.clear(); 370 if (OpenMPRuntime) 371 OpenMPRuntime->clear(); 372 } 373 374 void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags, 375 StringRef MainFile) { 376 if (!hasDiagnostics()) 377 return; 378 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) { 379 if (MainFile.empty()) 380 MainFile = "<stdin>"; 381 Diags.Report(diag::warn_profile_data_unprofiled) << MainFile; 382 } else { 383 if (Mismatched > 0) 384 Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched; 385 386 if (Missing > 0) 387 Diags.Report(diag::warn_profile_data_missing) << Visited << Missing; 388 } 389 } 390 391 void CodeGenModule::Release() { 392 EmitDeferred(); 393 EmitVTablesOpportunistically(); 394 applyGlobalValReplacements(); 395 applyReplacements(); 396 checkAliases(); 397 emitMultiVersionFunctions(); 398 EmitCXXGlobalInitFunc(); 399 EmitCXXGlobalDtorFunc(); 400 registerGlobalDtorsWithAtExit(); 401 EmitCXXThreadLocalInitFunc(); 402 if (ObjCRuntime) 403 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction()) 404 AddGlobalCtor(ObjCInitFunction); 405 if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice && 406 CUDARuntime) { 407 if (llvm::Function *CudaCtorFunction = 408 CUDARuntime->makeModuleCtorFunction()) 409 AddGlobalCtor(CudaCtorFunction); 410 } 411 if (OpenMPRuntime) { 412 if (llvm::Function *OpenMPRegistrationFunction = 413 OpenMPRuntime->emitRegistrationFunction()) { 414 auto ComdatKey = OpenMPRegistrationFunction->hasComdat() ? 415 OpenMPRegistrationFunction : nullptr; 416 AddGlobalCtor(OpenMPRegistrationFunction, 0, ComdatKey); 417 } 418 OpenMPRuntime->clear(); 419 } 420 if (PGOReader) { 421 getModule().setProfileSummary(PGOReader->getSummary().getMD(VMContext)); 422 if (PGOStats.hasDiagnostics()) 423 PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName); 424 } 425 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 426 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 427 EmitGlobalAnnotations(); 428 EmitStaticExternCAliases(); 429 EmitDeferredUnusedCoverageMappings(); 430 if (CoverageMapping) 431 CoverageMapping->emit(); 432 if (CodeGenOpts.SanitizeCfiCrossDso) { 433 CodeGenFunction(*this).EmitCfiCheckFail(); 434 CodeGenFunction(*this).EmitCfiCheckStub(); 435 } 436 emitAtAvailableLinkGuard(); 437 emitLLVMUsed(); 438 if (SanStats) 439 SanStats->finish(); 440 441 if (CodeGenOpts.Autolink && 442 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) { 443 EmitModuleLinkOptions(); 444 } 445 446 // Record mregparm value now so it is visible through rest of codegen. 447 if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86) 448 getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters", 449 CodeGenOpts.NumRegisterParameters); 450 451 if (CodeGenOpts.DwarfVersion) { 452 // We actually want the latest version when there are conflicts. 453 // We can change from Warning to Latest if such mode is supported. 454 getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version", 455 CodeGenOpts.DwarfVersion); 456 } 457 if (CodeGenOpts.EmitCodeView) { 458 // Indicate that we want CodeView in the metadata. 459 getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1); 460 } 461 if (CodeGenOpts.ControlFlowGuard) { 462 // We want function ID tables for Control Flow Guard. 463 getModule().addModuleFlag(llvm::Module::Warning, "cfguardtable", 1); 464 } 465 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) { 466 // We don't support LTO with 2 with different StrictVTablePointers 467 // FIXME: we could support it by stripping all the information introduced 468 // by StrictVTablePointers. 469 470 getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1); 471 472 llvm::Metadata *Ops[2] = { 473 llvm::MDString::get(VMContext, "StrictVTablePointers"), 474 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 475 llvm::Type::getInt32Ty(VMContext), 1))}; 476 477 getModule().addModuleFlag(llvm::Module::Require, 478 "StrictVTablePointersRequirement", 479 llvm::MDNode::get(VMContext, Ops)); 480 } 481 if (DebugInfo) 482 // We support a single version in the linked module. The LLVM 483 // parser will drop debug info with a different version number 484 // (and warn about it, too). 485 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version", 486 llvm::DEBUG_METADATA_VERSION); 487 488 // We need to record the widths of enums and wchar_t, so that we can generate 489 // the correct build attributes in the ARM backend. wchar_size is also used by 490 // TargetLibraryInfo. 491 uint64_t WCharWidth = 492 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity(); 493 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth); 494 495 llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch(); 496 if ( Arch == llvm::Triple::arm 497 || Arch == llvm::Triple::armeb 498 || Arch == llvm::Triple::thumb 499 || Arch == llvm::Triple::thumbeb) { 500 // The minimum width of an enum in bytes 501 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4; 502 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth); 503 } 504 505 if (CodeGenOpts.SanitizeCfiCrossDso) { 506 // Indicate that we want cross-DSO control flow integrity checks. 507 getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1); 508 } 509 510 if (CodeGenOpts.CFProtectionReturn && 511 Target.checkCFProtectionReturnSupported(getDiags())) { 512 // Indicate that we want to instrument return control flow protection. 513 getModule().addModuleFlag(llvm::Module::Override, "cf-protection-return", 514 1); 515 } 516 517 if (CodeGenOpts.CFProtectionBranch && 518 Target.checkCFProtectionBranchSupported(getDiags())) { 519 // Indicate that we want to instrument branch control flow protection. 520 getModule().addModuleFlag(llvm::Module::Override, "cf-protection-branch", 521 1); 522 } 523 524 if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) { 525 // Indicate whether __nvvm_reflect should be configured to flush denormal 526 // floating point values to 0. (This corresponds to its "__CUDA_FTZ" 527 // property.) 528 getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz", 529 CodeGenOpts.FlushDenorm ? 1 : 0); 530 } 531 532 // Emit OpenCL specific module metadata: OpenCL/SPIR version. 533 if (LangOpts.OpenCL) { 534 EmitOpenCLMetadata(); 535 // Emit SPIR version. 536 if (getTriple().getArch() == llvm::Triple::spir || 537 getTriple().getArch() == llvm::Triple::spir64) { 538 // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the 539 // opencl.spir.version named metadata. 540 llvm::Metadata *SPIRVerElts[] = { 541 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 542 Int32Ty, LangOpts.OpenCLVersion / 100)), 543 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 544 Int32Ty, (LangOpts.OpenCLVersion / 100 > 1) ? 0 : 2))}; 545 llvm::NamedMDNode *SPIRVerMD = 546 TheModule.getOrInsertNamedMetadata("opencl.spir.version"); 547 llvm::LLVMContext &Ctx = TheModule.getContext(); 548 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts)); 549 } 550 } 551 552 if (uint32_t PLevel = Context.getLangOpts().PICLevel) { 553 assert(PLevel < 3 && "Invalid PIC Level"); 554 getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel)); 555 if (Context.getLangOpts().PIE) 556 getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel)); 557 } 558 559 if (CodeGenOpts.NoPLT) 560 getModule().setRtLibUseGOT(); 561 562 SimplifyPersonality(); 563 564 if (getCodeGenOpts().EmitDeclMetadata) 565 EmitDeclMetadata(); 566 567 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes) 568 EmitCoverageFile(); 569 570 if (DebugInfo) 571 DebugInfo->finalize(); 572 573 if (getCodeGenOpts().EmitVersionIdentMetadata) 574 EmitVersionIdentMetadata(); 575 576 EmitTargetMetadata(); 577 } 578 579 void CodeGenModule::EmitOpenCLMetadata() { 580 // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the 581 // opencl.ocl.version named metadata node. 582 llvm::Metadata *OCLVerElts[] = { 583 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 584 Int32Ty, LangOpts.OpenCLVersion / 100)), 585 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 586 Int32Ty, (LangOpts.OpenCLVersion % 100) / 10))}; 587 llvm::NamedMDNode *OCLVerMD = 588 TheModule.getOrInsertNamedMetadata("opencl.ocl.version"); 589 llvm::LLVMContext &Ctx = TheModule.getContext(); 590 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts)); 591 } 592 593 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 594 // Make sure that this type is translated. 595 Types.UpdateCompletedType(TD); 596 } 597 598 void CodeGenModule::RefreshTypeCacheForClass(const CXXRecordDecl *RD) { 599 // Make sure that this type is translated. 600 Types.RefreshTypeCacheForClass(RD); 601 } 602 603 llvm::MDNode *CodeGenModule::getTBAATypeInfo(QualType QTy) { 604 if (!TBAA) 605 return nullptr; 606 return TBAA->getTypeInfo(QTy); 607 } 608 609 TBAAAccessInfo CodeGenModule::getTBAAAccessInfo(QualType AccessType) { 610 if (!TBAA) 611 return TBAAAccessInfo(); 612 return TBAA->getAccessInfo(AccessType); 613 } 614 615 TBAAAccessInfo 616 CodeGenModule::getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType) { 617 if (!TBAA) 618 return TBAAAccessInfo(); 619 return TBAA->getVTablePtrAccessInfo(VTablePtrType); 620 } 621 622 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { 623 if (!TBAA) 624 return nullptr; 625 return TBAA->getTBAAStructInfo(QTy); 626 } 627 628 llvm::MDNode *CodeGenModule::getTBAABaseTypeInfo(QualType QTy) { 629 if (!TBAA) 630 return nullptr; 631 return TBAA->getBaseTypeInfo(QTy); 632 } 633 634 llvm::MDNode *CodeGenModule::getTBAAAccessTagInfo(TBAAAccessInfo Info) { 635 if (!TBAA) 636 return nullptr; 637 return TBAA->getAccessTagInfo(Info); 638 } 639 640 TBAAAccessInfo CodeGenModule::mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, 641 TBAAAccessInfo TargetInfo) { 642 if (!TBAA) 643 return TBAAAccessInfo(); 644 return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo); 645 } 646 647 TBAAAccessInfo 648 CodeGenModule::mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, 649 TBAAAccessInfo InfoB) { 650 if (!TBAA) 651 return TBAAAccessInfo(); 652 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB); 653 } 654 655 TBAAAccessInfo 656 CodeGenModule::mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, 657 TBAAAccessInfo SrcInfo) { 658 if (!TBAA) 659 return TBAAAccessInfo(); 660 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo); 661 } 662 663 void CodeGenModule::DecorateInstructionWithTBAA(llvm::Instruction *Inst, 664 TBAAAccessInfo TBAAInfo) { 665 if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo)) 666 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag); 667 } 668 669 void CodeGenModule::DecorateInstructionWithInvariantGroup( 670 llvm::Instruction *I, const CXXRecordDecl *RD) { 671 I->setMetadata(llvm::LLVMContext::MD_invariant_group, 672 llvm::MDNode::get(getLLVMContext(), {})); 673 } 674 675 void CodeGenModule::Error(SourceLocation loc, StringRef message) { 676 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0"); 677 getDiags().Report(Context.getFullLoc(loc), diagID) << message; 678 } 679 680 /// ErrorUnsupported - Print out an error that codegen doesn't support the 681 /// specified stmt yet. 682 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) { 683 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 684 "cannot compile this %0 yet"); 685 std::string Msg = Type; 686 getDiags().Report(Context.getFullLoc(S->getBeginLoc()), DiagID) 687 << Msg << S->getSourceRange(); 688 } 689 690 /// ErrorUnsupported - Print out an error that codegen doesn't support the 691 /// specified decl yet. 692 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) { 693 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 694 "cannot compile this %0 yet"); 695 std::string Msg = Type; 696 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 697 } 698 699 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { 700 return llvm::ConstantInt::get(SizeTy, size.getQuantity()); 701 } 702 703 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 704 const NamedDecl *D) const { 705 if (GV->hasDLLImportStorageClass()) 706 return; 707 // Internal definitions always have default visibility. 708 if (GV->hasLocalLinkage()) { 709 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 710 return; 711 } 712 if (!D) 713 return; 714 // Set visibility for definitions. 715 LinkageInfo LV = D->getLinkageAndVisibility(); 716 if (LV.isVisibilityExplicit() || !GV->isDeclarationForLinker()) 717 GV->setVisibility(GetLLVMVisibility(LV.getVisibility())); 718 } 719 720 static bool shouldAssumeDSOLocal(const CodeGenModule &CGM, 721 llvm::GlobalValue *GV) { 722 if (GV->hasLocalLinkage()) 723 return true; 724 725 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage()) 726 return true; 727 728 // DLLImport explicitly marks the GV as external. 729 if (GV->hasDLLImportStorageClass()) 730 return false; 731 732 const llvm::Triple &TT = CGM.getTriple(); 733 if (TT.isWindowsGNUEnvironment()) { 734 // In MinGW, variables without DLLImport can still be automatically 735 // imported from a DLL by the linker; don't mark variables that 736 // potentially could come from another DLL as DSO local. 737 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) && 738 !GV->isThreadLocal()) 739 return false; 740 } 741 // Every other GV is local on COFF. 742 // Make an exception for windows OS in the triple: Some firmware builds use 743 // *-win32-macho triples. This (accidentally?) produced windows relocations 744 // without GOT tables in older clang versions; Keep this behaviour. 745 // FIXME: even thread local variables? 746 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO())) 747 return true; 748 749 // Only handle COFF and ELF for now. 750 if (!TT.isOSBinFormatELF()) 751 return false; 752 753 // If this is not an executable, don't assume anything is local. 754 const auto &CGOpts = CGM.getCodeGenOpts(); 755 llvm::Reloc::Model RM = CGOpts.RelocationModel; 756 const auto &LOpts = CGM.getLangOpts(); 757 if (RM != llvm::Reloc::Static && !LOpts.PIE) 758 return false; 759 760 // A definition cannot be preempted from an executable. 761 if (!GV->isDeclarationForLinker()) 762 return true; 763 764 // Most PIC code sequences that assume that a symbol is local cannot produce a 765 // 0 if it turns out the symbol is undefined. While this is ABI and relocation 766 // depended, it seems worth it to handle it here. 767 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage()) 768 return false; 769 770 // PPC has no copy relocations and cannot use a plt entry as a symbol address. 771 llvm::Triple::ArchType Arch = TT.getArch(); 772 if (Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 || 773 Arch == llvm::Triple::ppc64le) 774 return false; 775 776 // If we can use copy relocations we can assume it is local. 777 if (auto *Var = dyn_cast<llvm::GlobalVariable>(GV)) 778 if (!Var->isThreadLocal() && 779 (RM == llvm::Reloc::Static || CGOpts.PIECopyRelocations)) 780 return true; 781 782 // If we can use a plt entry as the symbol address we can assume it 783 // is local. 784 // FIXME: This should work for PIE, but the gold linker doesn't support it. 785 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static) 786 return true; 787 788 // Otherwise don't assue it is local. 789 return false; 790 } 791 792 void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const { 793 GV->setDSOLocal(shouldAssumeDSOLocal(*this, GV)); 794 } 795 796 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV, 797 GlobalDecl GD) const { 798 const auto *D = dyn_cast<NamedDecl>(GD.getDecl()); 799 // C++ destructors have a few C++ ABI specific special cases. 800 if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) { 801 getCXXABI().setCXXDestructorDLLStorage(GV, Dtor, GD.getDtorType()); 802 return; 803 } 804 setDLLImportDLLExport(GV, D); 805 } 806 807 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV, 808 const NamedDecl *D) const { 809 if (D && D->isExternallyVisible()) { 810 if (D->hasAttr<DLLImportAttr>()) 811 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass); 812 else if (D->hasAttr<DLLExportAttr>() && !GV->isDeclarationForLinker()) 813 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass); 814 } 815 } 816 817 void CodeGenModule::setGVProperties(llvm::GlobalValue *GV, 818 GlobalDecl GD) const { 819 setDLLImportDLLExport(GV, GD); 820 setGlobalVisibilityAndLocal(GV, dyn_cast<NamedDecl>(GD.getDecl())); 821 } 822 823 void CodeGenModule::setGVProperties(llvm::GlobalValue *GV, 824 const NamedDecl *D) const { 825 setDLLImportDLLExport(GV, D); 826 setGlobalVisibilityAndLocal(GV, D); 827 } 828 829 void CodeGenModule::setGlobalVisibilityAndLocal(llvm::GlobalValue *GV, 830 const NamedDecl *D) const { 831 setGlobalVisibility(GV, D); 832 setDSOLocal(GV); 833 } 834 835 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) { 836 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S) 837 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel) 838 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel) 839 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel) 840 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel); 841 } 842 843 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel( 844 CodeGenOptions::TLSModel M) { 845 switch (M) { 846 case CodeGenOptions::GeneralDynamicTLSModel: 847 return llvm::GlobalVariable::GeneralDynamicTLSModel; 848 case CodeGenOptions::LocalDynamicTLSModel: 849 return llvm::GlobalVariable::LocalDynamicTLSModel; 850 case CodeGenOptions::InitialExecTLSModel: 851 return llvm::GlobalVariable::InitialExecTLSModel; 852 case CodeGenOptions::LocalExecTLSModel: 853 return llvm::GlobalVariable::LocalExecTLSModel; 854 } 855 llvm_unreachable("Invalid TLS model!"); 856 } 857 858 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const { 859 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!"); 860 861 llvm::GlobalValue::ThreadLocalMode TLM; 862 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel()); 863 864 // Override the TLS model if it is explicitly specified. 865 if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) { 866 TLM = GetLLVMTLSModel(Attr->getModel()); 867 } 868 869 GV->setThreadLocalMode(TLM); 870 } 871 872 static std::string getCPUSpecificMangling(const CodeGenModule &CGM, 873 StringRef Name) { 874 const TargetInfo &Target = CGM.getTarget(); 875 return (Twine('.') + Twine(Target.CPUSpecificManglingCharacter(Name))).str(); 876 } 877 878 static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM, 879 const CPUSpecificAttr *Attr, 880 raw_ostream &Out) { 881 // cpu_specific gets the current name, dispatch gets the resolver. 882 if (Attr) 883 Out << getCPUSpecificMangling(CGM, Attr->getCurCPUName()->getName()); 884 else 885 Out << ".resolver"; 886 } 887 888 static void AppendTargetMangling(const CodeGenModule &CGM, 889 const TargetAttr *Attr, raw_ostream &Out) { 890 if (Attr->isDefaultVersion()) 891 return; 892 893 Out << '.'; 894 const TargetInfo &Target = CGM.getTarget(); 895 TargetAttr::ParsedTargetAttr Info = 896 Attr->parse([&Target](StringRef LHS, StringRef RHS) { 897 // Multiversioning doesn't allow "no-${feature}", so we can 898 // only have "+" prefixes here. 899 assert(LHS.startswith("+") && RHS.startswith("+") && 900 "Features should always have a prefix."); 901 return Target.multiVersionSortPriority(LHS.substr(1)) > 902 Target.multiVersionSortPriority(RHS.substr(1)); 903 }); 904 905 bool IsFirst = true; 906 907 if (!Info.Architecture.empty()) { 908 IsFirst = false; 909 Out << "arch_" << Info.Architecture; 910 } 911 912 for (StringRef Feat : Info.Features) { 913 if (!IsFirst) 914 Out << '_'; 915 IsFirst = false; 916 Out << Feat.substr(1); 917 } 918 } 919 920 static std::string getMangledNameImpl(const CodeGenModule &CGM, GlobalDecl GD, 921 const NamedDecl *ND, 922 bool OmitMultiVersionMangling = false) { 923 SmallString<256> Buffer; 924 llvm::raw_svector_ostream Out(Buffer); 925 MangleContext &MC = CGM.getCXXABI().getMangleContext(); 926 if (MC.shouldMangleDeclName(ND)) { 927 llvm::raw_svector_ostream Out(Buffer); 928 if (const auto *D = dyn_cast<CXXConstructorDecl>(ND)) 929 MC.mangleCXXCtor(D, GD.getCtorType(), Out); 930 else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND)) 931 MC.mangleCXXDtor(D, GD.getDtorType(), Out); 932 else 933 MC.mangleName(ND, Out); 934 } else { 935 IdentifierInfo *II = ND->getIdentifier(); 936 assert(II && "Attempt to mangle unnamed decl."); 937 const auto *FD = dyn_cast<FunctionDecl>(ND); 938 939 if (FD && 940 FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) { 941 llvm::raw_svector_ostream Out(Buffer); 942 Out << "__regcall3__" << II->getName(); 943 } else { 944 Out << II->getName(); 945 } 946 } 947 948 if (const auto *FD = dyn_cast<FunctionDecl>(ND)) 949 if (FD->isMultiVersion() && !OmitMultiVersionMangling) { 950 if (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion()) 951 AppendCPUSpecificCPUDispatchMangling( 952 CGM, FD->getAttr<CPUSpecificAttr>(), Out); 953 else 954 AppendTargetMangling(CGM, FD->getAttr<TargetAttr>(), Out); 955 } 956 957 return Out.str(); 958 } 959 960 void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD, 961 const FunctionDecl *FD) { 962 if (!FD->isMultiVersion()) 963 return; 964 965 // Get the name of what this would be without the 'target' attribute. This 966 // allows us to lookup the version that was emitted when this wasn't a 967 // multiversion function. 968 std::string NonTargetName = 969 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true); 970 GlobalDecl OtherGD; 971 if (lookupRepresentativeDecl(NonTargetName, OtherGD)) { 972 assert(OtherGD.getCanonicalDecl() 973 .getDecl() 974 ->getAsFunction() 975 ->isMultiVersion() && 976 "Other GD should now be a multiversioned function"); 977 // OtherFD is the version of this function that was mangled BEFORE 978 // becoming a MultiVersion function. It potentially needs to be updated. 979 const FunctionDecl *OtherFD = 980 OtherGD.getCanonicalDecl().getDecl()->getAsFunction(); 981 std::string OtherName = getMangledNameImpl(*this, OtherGD, OtherFD); 982 // This is so that if the initial version was already the 'default' 983 // version, we don't try to update it. 984 if (OtherName != NonTargetName) { 985 // Remove instead of erase, since others may have stored the StringRef 986 // to this. 987 const auto ExistingRecord = Manglings.find(NonTargetName); 988 if (ExistingRecord != std::end(Manglings)) 989 Manglings.remove(&(*ExistingRecord)); 990 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD)); 991 MangledDeclNames[OtherGD.getCanonicalDecl()] = Result.first->first(); 992 if (llvm::GlobalValue *Entry = GetGlobalValue(NonTargetName)) 993 Entry->setName(OtherName); 994 } 995 } 996 } 997 998 StringRef CodeGenModule::getMangledName(GlobalDecl GD) { 999 GlobalDecl CanonicalGD = GD.getCanonicalDecl(); 1000 1001 // Some ABIs don't have constructor variants. Make sure that base and 1002 // complete constructors get mangled the same. 1003 if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) { 1004 if (!getTarget().getCXXABI().hasConstructorVariants()) { 1005 CXXCtorType OrigCtorType = GD.getCtorType(); 1006 assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete); 1007 if (OrigCtorType == Ctor_Base) 1008 CanonicalGD = GlobalDecl(CD, Ctor_Complete); 1009 } 1010 } 1011 1012 const auto *FD = dyn_cast<FunctionDecl>(GD.getDecl()); 1013 // Since CPUSpecific can require multiple emits per decl, store the manglings 1014 // separately. 1015 if (FD && 1016 (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion())) { 1017 const auto *SD = FD->getAttr<CPUSpecificAttr>(); 1018 1019 std::pair<GlobalDecl, unsigned> SpecCanonicalGD{ 1020 CanonicalGD, 1021 SD ? SD->ActiveArgIndex : std::numeric_limits<unsigned>::max()}; 1022 1023 auto FoundName = CPUSpecificMangledDeclNames.find(SpecCanonicalGD); 1024 if (FoundName != CPUSpecificMangledDeclNames.end()) 1025 return FoundName->second; 1026 1027 auto Result = CPUSpecificManglings.insert( 1028 std::make_pair(getMangledNameImpl(*this, GD, FD), SpecCanonicalGD)); 1029 return CPUSpecificMangledDeclNames[SpecCanonicalGD] = Result.first->first(); 1030 } 1031 1032 auto FoundName = MangledDeclNames.find(CanonicalGD); 1033 if (FoundName != MangledDeclNames.end()) 1034 return FoundName->second; 1035 1036 // Keep the first result in the case of a mangling collision. 1037 const auto *ND = cast<NamedDecl>(GD.getDecl()); 1038 auto Result = 1039 Manglings.insert(std::make_pair(getMangledNameImpl(*this, GD, ND), GD)); 1040 return MangledDeclNames[CanonicalGD] = Result.first->first(); 1041 } 1042 1043 StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD, 1044 const BlockDecl *BD) { 1045 MangleContext &MangleCtx = getCXXABI().getMangleContext(); 1046 const Decl *D = GD.getDecl(); 1047 1048 SmallString<256> Buffer; 1049 llvm::raw_svector_ostream Out(Buffer); 1050 if (!D) 1051 MangleCtx.mangleGlobalBlock(BD, 1052 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out); 1053 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D)) 1054 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); 1055 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) 1056 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); 1057 else 1058 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); 1059 1060 auto Result = Manglings.insert(std::make_pair(Out.str(), BD)); 1061 return Result.first->first(); 1062 } 1063 1064 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { 1065 return getModule().getNamedValue(Name); 1066 } 1067 1068 /// AddGlobalCtor - Add a function to the list that will be called before 1069 /// main() runs. 1070 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority, 1071 llvm::Constant *AssociatedData) { 1072 // FIXME: Type coercion of void()* types. 1073 GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData)); 1074 } 1075 1076 /// AddGlobalDtor - Add a function to the list that will be called 1077 /// when the module is unloaded. 1078 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) { 1079 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit) { 1080 DtorsUsingAtExit[Priority].push_back(Dtor); 1081 return; 1082 } 1083 1084 // FIXME: Type coercion of void()* types. 1085 GlobalDtors.push_back(Structor(Priority, Dtor, nullptr)); 1086 } 1087 1088 void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) { 1089 if (Fns.empty()) return; 1090 1091 // Ctor function type is void()*. 1092 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); 1093 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 1094 1095 // Get the type of a ctor entry, { i32, void ()*, i8* }. 1096 llvm::StructType *CtorStructTy = llvm::StructType::get( 1097 Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy); 1098 1099 // Construct the constructor and destructor arrays. 1100 ConstantInitBuilder builder(*this); 1101 auto ctors = builder.beginArray(CtorStructTy); 1102 for (const auto &I : Fns) { 1103 auto ctor = ctors.beginStruct(CtorStructTy); 1104 ctor.addInt(Int32Ty, I.Priority); 1105 ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy)); 1106 if (I.AssociatedData) 1107 ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy)); 1108 else 1109 ctor.addNullPointer(VoidPtrTy); 1110 ctor.finishAndAddTo(ctors); 1111 } 1112 1113 auto list = 1114 ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(), 1115 /*constant*/ false, 1116 llvm::GlobalValue::AppendingLinkage); 1117 1118 // The LTO linker doesn't seem to like it when we set an alignment 1119 // on appending variables. Take it off as a workaround. 1120 list->setAlignment(0); 1121 1122 Fns.clear(); 1123 } 1124 1125 llvm::GlobalValue::LinkageTypes 1126 CodeGenModule::getFunctionLinkage(GlobalDecl GD) { 1127 const auto *D = cast<FunctionDecl>(GD.getDecl()); 1128 1129 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); 1130 1131 if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D)) 1132 return getCXXABI().getCXXDestructorLinkage(Linkage, Dtor, GD.getDtorType()); 1133 1134 if (isa<CXXConstructorDecl>(D) && 1135 cast<CXXConstructorDecl>(D)->isInheritingConstructor() && 1136 Context.getTargetInfo().getCXXABI().isMicrosoft()) { 1137 // Our approach to inheriting constructors is fundamentally different from 1138 // that used by the MS ABI, so keep our inheriting constructor thunks 1139 // internal rather than trying to pick an unambiguous mangling for them. 1140 return llvm::GlobalValue::InternalLinkage; 1141 } 1142 1143 return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false); 1144 } 1145 1146 llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) { 1147 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD); 1148 if (!MDS) return nullptr; 1149 1150 return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString())); 1151 } 1152 1153 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 1154 const CGFunctionInfo &Info, 1155 llvm::Function *F) { 1156 unsigned CallingConv; 1157 llvm::AttributeList PAL; 1158 ConstructAttributeList(F->getName(), Info, D, PAL, CallingConv, false); 1159 F->setAttributes(PAL); 1160 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 1161 } 1162 1163 /// Determines whether the language options require us to model 1164 /// unwind exceptions. We treat -fexceptions as mandating this 1165 /// except under the fragile ObjC ABI with only ObjC exceptions 1166 /// enabled. This means, for example, that C with -fexceptions 1167 /// enables this. 1168 static bool hasUnwindExceptions(const LangOptions &LangOpts) { 1169 // If exceptions are completely disabled, obviously this is false. 1170 if (!LangOpts.Exceptions) return false; 1171 1172 // If C++ exceptions are enabled, this is true. 1173 if (LangOpts.CXXExceptions) return true; 1174 1175 // If ObjC exceptions are enabled, this depends on the ABI. 1176 if (LangOpts.ObjCExceptions) { 1177 return LangOpts.ObjCRuntime.hasUnwindExceptions(); 1178 } 1179 1180 return true; 1181 } 1182 1183 static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM, 1184 const CXXMethodDecl *MD) { 1185 // Check that the type metadata can ever actually be used by a call. 1186 if (!CGM.getCodeGenOpts().LTOUnit || 1187 !CGM.HasHiddenLTOVisibility(MD->getParent())) 1188 return false; 1189 1190 // Only functions whose address can be taken with a member function pointer 1191 // need this sort of type metadata. 1192 return !MD->isStatic() && !MD->isVirtual() && !isa<CXXConstructorDecl>(MD) && 1193 !isa<CXXDestructorDecl>(MD); 1194 } 1195 1196 std::vector<const CXXRecordDecl *> 1197 CodeGenModule::getMostBaseClasses(const CXXRecordDecl *RD) { 1198 llvm::SetVector<const CXXRecordDecl *> MostBases; 1199 1200 std::function<void (const CXXRecordDecl *)> CollectMostBases; 1201 CollectMostBases = [&](const CXXRecordDecl *RD) { 1202 if (RD->getNumBases() == 0) 1203 MostBases.insert(RD); 1204 for (const CXXBaseSpecifier &B : RD->bases()) 1205 CollectMostBases(B.getType()->getAsCXXRecordDecl()); 1206 }; 1207 CollectMostBases(RD); 1208 return MostBases.takeVector(); 1209 } 1210 1211 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 1212 llvm::Function *F) { 1213 llvm::AttrBuilder B; 1214 1215 if (CodeGenOpts.UnwindTables) 1216 B.addAttribute(llvm::Attribute::UWTable); 1217 1218 if (!hasUnwindExceptions(LangOpts)) 1219 B.addAttribute(llvm::Attribute::NoUnwind); 1220 1221 if (!D || !D->hasAttr<NoStackProtectorAttr>()) { 1222 if (LangOpts.getStackProtector() == LangOptions::SSPOn) 1223 B.addAttribute(llvm::Attribute::StackProtect); 1224 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) 1225 B.addAttribute(llvm::Attribute::StackProtectStrong); 1226 else if (LangOpts.getStackProtector() == LangOptions::SSPReq) 1227 B.addAttribute(llvm::Attribute::StackProtectReq); 1228 } 1229 1230 if (!D) { 1231 // If we don't have a declaration to control inlining, the function isn't 1232 // explicitly marked as alwaysinline for semantic reasons, and inlining is 1233 // disabled, mark the function as noinline. 1234 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) && 1235 CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) 1236 B.addAttribute(llvm::Attribute::NoInline); 1237 1238 F->addAttributes(llvm::AttributeList::FunctionIndex, B); 1239 return; 1240 } 1241 1242 // Track whether we need to add the optnone LLVM attribute, 1243 // starting with the default for this optimization level. 1244 bool ShouldAddOptNone = 1245 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0; 1246 // We can't add optnone in the following cases, it won't pass the verifier. 1247 ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>(); 1248 ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline); 1249 ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>(); 1250 1251 if (ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) { 1252 B.addAttribute(llvm::Attribute::OptimizeNone); 1253 1254 // OptimizeNone implies noinline; we should not be inlining such functions. 1255 B.addAttribute(llvm::Attribute::NoInline); 1256 assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) && 1257 "OptimizeNone and AlwaysInline on same function!"); 1258 1259 // We still need to handle naked functions even though optnone subsumes 1260 // much of their semantics. 1261 if (D->hasAttr<NakedAttr>()) 1262 B.addAttribute(llvm::Attribute::Naked); 1263 1264 // OptimizeNone wins over OptimizeForSize and MinSize. 1265 F->removeFnAttr(llvm::Attribute::OptimizeForSize); 1266 F->removeFnAttr(llvm::Attribute::MinSize); 1267 } else if (D->hasAttr<NakedAttr>()) { 1268 // Naked implies noinline: we should not be inlining such functions. 1269 B.addAttribute(llvm::Attribute::Naked); 1270 B.addAttribute(llvm::Attribute::NoInline); 1271 } else if (D->hasAttr<NoDuplicateAttr>()) { 1272 B.addAttribute(llvm::Attribute::NoDuplicate); 1273 } else if (D->hasAttr<NoInlineAttr>()) { 1274 B.addAttribute(llvm::Attribute::NoInline); 1275 } else if (D->hasAttr<AlwaysInlineAttr>() && 1276 !F->hasFnAttribute(llvm::Attribute::NoInline)) { 1277 // (noinline wins over always_inline, and we can't specify both in IR) 1278 B.addAttribute(llvm::Attribute::AlwaysInline); 1279 } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) { 1280 // If we're not inlining, then force everything that isn't always_inline to 1281 // carry an explicit noinline attribute. 1282 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline)) 1283 B.addAttribute(llvm::Attribute::NoInline); 1284 } else { 1285 // Otherwise, propagate the inline hint attribute and potentially use its 1286 // absence to mark things as noinline. 1287 if (auto *FD = dyn_cast<FunctionDecl>(D)) { 1288 if (any_of(FD->redecls(), [&](const FunctionDecl *Redecl) { 1289 return Redecl->isInlineSpecified(); 1290 })) { 1291 B.addAttribute(llvm::Attribute::InlineHint); 1292 } else if (CodeGenOpts.getInlining() == 1293 CodeGenOptions::OnlyHintInlining && 1294 !FD->isInlined() && 1295 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) { 1296 B.addAttribute(llvm::Attribute::NoInline); 1297 } 1298 } 1299 } 1300 1301 // Add other optimization related attributes if we are optimizing this 1302 // function. 1303 if (!D->hasAttr<OptimizeNoneAttr>()) { 1304 if (D->hasAttr<ColdAttr>()) { 1305 if (!ShouldAddOptNone) 1306 B.addAttribute(llvm::Attribute::OptimizeForSize); 1307 B.addAttribute(llvm::Attribute::Cold); 1308 } 1309 1310 if (D->hasAttr<MinSizeAttr>()) 1311 B.addAttribute(llvm::Attribute::MinSize); 1312 } 1313 1314 F->addAttributes(llvm::AttributeList::FunctionIndex, B); 1315 1316 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth(); 1317 if (alignment) 1318 F->setAlignment(alignment); 1319 1320 if (!D->hasAttr<AlignedAttr>()) 1321 if (LangOpts.FunctionAlignment) 1322 F->setAlignment(1 << LangOpts.FunctionAlignment); 1323 1324 // Some C++ ABIs require 2-byte alignment for member functions, in order to 1325 // reserve a bit for differentiating between virtual and non-virtual member 1326 // functions. If the current target's C++ ABI requires this and this is a 1327 // member function, set its alignment accordingly. 1328 if (getTarget().getCXXABI().areMemberFunctionsAligned()) { 1329 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 1330 F->setAlignment(2); 1331 } 1332 1333 // In the cross-dso CFI mode, we want !type attributes on definitions only. 1334 if (CodeGenOpts.SanitizeCfiCrossDso) 1335 if (auto *FD = dyn_cast<FunctionDecl>(D)) 1336 CreateFunctionTypeMetadataForIcall(FD, F); 1337 1338 // Emit type metadata on member functions for member function pointer checks. 1339 // These are only ever necessary on definitions; we're guaranteed that the 1340 // definition will be present in the LTO unit as a result of LTO visibility. 1341 auto *MD = dyn_cast<CXXMethodDecl>(D); 1342 if (MD && requiresMemberFunctionPointerTypeMetadata(*this, MD)) { 1343 for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) { 1344 llvm::Metadata *Id = 1345 CreateMetadataIdentifierForType(Context.getMemberPointerType( 1346 MD->getType(), Context.getRecordType(Base).getTypePtr())); 1347 F->addTypeMetadata(0, Id); 1348 } 1349 } 1350 } 1351 1352 void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) { 1353 const Decl *D = GD.getDecl(); 1354 if (dyn_cast_or_null<NamedDecl>(D)) 1355 setGVProperties(GV, GD); 1356 else 1357 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 1358 1359 if (D && D->hasAttr<UsedAttr>()) 1360 addUsedGlobal(GV); 1361 1362 if (CodeGenOpts.KeepStaticConsts && D && isa<VarDecl>(D)) { 1363 const auto *VD = cast<VarDecl>(D); 1364 if (VD->getType().isConstQualified() && VD->getStorageClass() == SC_Static) 1365 addUsedGlobal(GV); 1366 } 1367 } 1368 1369 bool CodeGenModule::GetCPUAndFeaturesAttributes(const Decl *D, 1370 llvm::AttrBuilder &Attrs) { 1371 // Add target-cpu and target-features attributes to functions. If 1372 // we have a decl for the function and it has a target attribute then 1373 // parse that and add it to the feature set. 1374 StringRef TargetCPU = getTarget().getTargetOpts().CPU; 1375 std::vector<std::string> Features; 1376 const auto *FD = dyn_cast_or_null<FunctionDecl>(D); 1377 FD = FD ? FD->getMostRecentDecl() : FD; 1378 const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr; 1379 const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() : nullptr; 1380 bool AddedAttr = false; 1381 if (TD || SD) { 1382 llvm::StringMap<bool> FeatureMap; 1383 getFunctionFeatureMap(FeatureMap, FD); 1384 1385 // Produce the canonical string for this set of features. 1386 for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap) 1387 Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str()); 1388 1389 // Now add the target-cpu and target-features to the function. 1390 // While we populated the feature map above, we still need to 1391 // get and parse the target attribute so we can get the cpu for 1392 // the function. 1393 if (TD) { 1394 TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse(); 1395 if (ParsedAttr.Architecture != "" && 1396 getTarget().isValidCPUName(ParsedAttr.Architecture)) 1397 TargetCPU = ParsedAttr.Architecture; 1398 } 1399 } else { 1400 // Otherwise just add the existing target cpu and target features to the 1401 // function. 1402 Features = getTarget().getTargetOpts().Features; 1403 } 1404 1405 if (TargetCPU != "") { 1406 Attrs.addAttribute("target-cpu", TargetCPU); 1407 AddedAttr = true; 1408 } 1409 if (!Features.empty()) { 1410 llvm::sort(Features.begin(), Features.end()); 1411 Attrs.addAttribute("target-features", llvm::join(Features, ",")); 1412 AddedAttr = true; 1413 } 1414 1415 return AddedAttr; 1416 } 1417 1418 void CodeGenModule::setNonAliasAttributes(GlobalDecl GD, 1419 llvm::GlobalObject *GO) { 1420 const Decl *D = GD.getDecl(); 1421 SetCommonAttributes(GD, GO); 1422 1423 if (D) { 1424 if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) { 1425 if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>()) 1426 GV->addAttribute("bss-section", SA->getName()); 1427 if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>()) 1428 GV->addAttribute("data-section", SA->getName()); 1429 if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>()) 1430 GV->addAttribute("rodata-section", SA->getName()); 1431 } 1432 1433 if (auto *F = dyn_cast<llvm::Function>(GO)) { 1434 if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>()) 1435 if (!D->getAttr<SectionAttr>()) 1436 F->addFnAttr("implicit-section-name", SA->getName()); 1437 1438 llvm::AttrBuilder Attrs; 1439 if (GetCPUAndFeaturesAttributes(D, Attrs)) { 1440 // We know that GetCPUAndFeaturesAttributes will always have the 1441 // newest set, since it has the newest possible FunctionDecl, so the 1442 // new ones should replace the old. 1443 F->removeFnAttr("target-cpu"); 1444 F->removeFnAttr("target-features"); 1445 F->addAttributes(llvm::AttributeList::FunctionIndex, Attrs); 1446 } 1447 } 1448 1449 if (const auto *CSA = D->getAttr<CodeSegAttr>()) 1450 GO->setSection(CSA->getName()); 1451 else if (const auto *SA = D->getAttr<SectionAttr>()) 1452 GO->setSection(SA->getName()); 1453 } 1454 1455 getTargetCodeGenInfo().setTargetAttributes(D, GO, *this); 1456 } 1457 1458 void CodeGenModule::SetInternalFunctionAttributes(GlobalDecl GD, 1459 llvm::Function *F, 1460 const CGFunctionInfo &FI) { 1461 const Decl *D = GD.getDecl(); 1462 SetLLVMFunctionAttributes(D, FI, F); 1463 SetLLVMFunctionAttributesForDefinition(D, F); 1464 1465 F->setLinkage(llvm::Function::InternalLinkage); 1466 1467 setNonAliasAttributes(GD, F); 1468 } 1469 1470 static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) { 1471 // Set linkage and visibility in case we never see a definition. 1472 LinkageInfo LV = ND->getLinkageAndVisibility(); 1473 // Don't set internal linkage on declarations. 1474 // "extern_weak" is overloaded in LLVM; we probably should have 1475 // separate linkage types for this. 1476 if (isExternallyVisible(LV.getLinkage()) && 1477 (ND->hasAttr<WeakAttr>() || ND->isWeakImported())) 1478 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 1479 } 1480 1481 void CodeGenModule::CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD, 1482 llvm::Function *F) { 1483 // Only if we are checking indirect calls. 1484 if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall)) 1485 return; 1486 1487 // Non-static class methods are handled via vtable or member function pointer 1488 // checks elsewhere. 1489 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) 1490 return; 1491 1492 // Additionally, if building with cross-DSO support... 1493 if (CodeGenOpts.SanitizeCfiCrossDso) { 1494 // Skip available_externally functions. They won't be codegen'ed in the 1495 // current module anyway. 1496 if (getContext().GetGVALinkageForFunction(FD) == GVA_AvailableExternally) 1497 return; 1498 } 1499 1500 llvm::Metadata *MD = CreateMetadataIdentifierForType(FD->getType()); 1501 F->addTypeMetadata(0, MD); 1502 F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType())); 1503 1504 // Emit a hash-based bit set entry for cross-DSO calls. 1505 if (CodeGenOpts.SanitizeCfiCrossDso) 1506 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD)) 1507 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId)); 1508 } 1509 1510 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F, 1511 bool IsIncompleteFunction, 1512 bool IsThunk) { 1513 1514 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) { 1515 // If this is an intrinsic function, set the function's attributes 1516 // to the intrinsic's attributes. 1517 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID)); 1518 return; 1519 } 1520 1521 const auto *FD = cast<FunctionDecl>(GD.getDecl()); 1522 1523 if (!IsIncompleteFunction) { 1524 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); 1525 // Setup target-specific attributes. 1526 if (F->isDeclaration()) 1527 getTargetCodeGenInfo().setTargetAttributes(FD, F, *this); 1528 } 1529 1530 // Add the Returned attribute for "this", except for iOS 5 and earlier 1531 // where substantial code, including the libstdc++ dylib, was compiled with 1532 // GCC and does not actually return "this". 1533 if (!IsThunk && getCXXABI().HasThisReturn(GD) && 1534 !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) { 1535 assert(!F->arg_empty() && 1536 F->arg_begin()->getType() 1537 ->canLosslesslyBitCastTo(F->getReturnType()) && 1538 "unexpected this return"); 1539 F->addAttribute(1, llvm::Attribute::Returned); 1540 } 1541 1542 // Only a few attributes are set on declarations; these may later be 1543 // overridden by a definition. 1544 1545 setLinkageForGV(F, FD); 1546 setGVProperties(F, FD); 1547 1548 if (const auto *CSA = FD->getAttr<CodeSegAttr>()) 1549 F->setSection(CSA->getName()); 1550 else if (const auto *SA = FD->getAttr<SectionAttr>()) 1551 F->setSection(SA->getName()); 1552 1553 if (FD->isReplaceableGlobalAllocationFunction()) { 1554 // A replaceable global allocation function does not act like a builtin by 1555 // default, only if it is invoked by a new-expression or delete-expression. 1556 F->addAttribute(llvm::AttributeList::FunctionIndex, 1557 llvm::Attribute::NoBuiltin); 1558 1559 // A sane operator new returns a non-aliasing pointer. 1560 // FIXME: Also add NonNull attribute to the return value 1561 // for the non-nothrow forms? 1562 auto Kind = FD->getDeclName().getCXXOverloadedOperator(); 1563 if (getCodeGenOpts().AssumeSaneOperatorNew && 1564 (Kind == OO_New || Kind == OO_Array_New)) 1565 F->addAttribute(llvm::AttributeList::ReturnIndex, 1566 llvm::Attribute::NoAlias); 1567 } 1568 1569 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD)) 1570 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 1571 else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) 1572 if (MD->isVirtual()) 1573 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 1574 1575 // Don't emit entries for function declarations in the cross-DSO mode. This 1576 // is handled with better precision by the receiving DSO. 1577 if (!CodeGenOpts.SanitizeCfiCrossDso) 1578 CreateFunctionTypeMetadataForIcall(FD, F); 1579 1580 if (getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>()) 1581 getOpenMPRuntime().emitDeclareSimdFunction(FD, F); 1582 } 1583 1584 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) { 1585 assert(!GV->isDeclaration() && 1586 "Only globals with definition can force usage."); 1587 LLVMUsed.emplace_back(GV); 1588 } 1589 1590 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) { 1591 assert(!GV->isDeclaration() && 1592 "Only globals with definition can force usage."); 1593 LLVMCompilerUsed.emplace_back(GV); 1594 } 1595 1596 static void emitUsed(CodeGenModule &CGM, StringRef Name, 1597 std::vector<llvm::WeakTrackingVH> &List) { 1598 // Don't create llvm.used if there is no need. 1599 if (List.empty()) 1600 return; 1601 1602 // Convert List to what ConstantArray needs. 1603 SmallVector<llvm::Constant*, 8> UsedArray; 1604 UsedArray.resize(List.size()); 1605 for (unsigned i = 0, e = List.size(); i != e; ++i) { 1606 UsedArray[i] = 1607 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast( 1608 cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy); 1609 } 1610 1611 if (UsedArray.empty()) 1612 return; 1613 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size()); 1614 1615 auto *GV = new llvm::GlobalVariable( 1616 CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage, 1617 llvm::ConstantArray::get(ATy, UsedArray), Name); 1618 1619 GV->setSection("llvm.metadata"); 1620 } 1621 1622 void CodeGenModule::emitLLVMUsed() { 1623 emitUsed(*this, "llvm.used", LLVMUsed); 1624 emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed); 1625 } 1626 1627 void CodeGenModule::AppendLinkerOptions(StringRef Opts) { 1628 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts); 1629 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); 1630 } 1631 1632 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) { 1633 llvm::SmallString<32> Opt; 1634 getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt); 1635 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt); 1636 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); 1637 } 1638 1639 void CodeGenModule::AddELFLibDirective(StringRef Lib) { 1640 auto &C = getLLVMContext(); 1641 LinkerOptionsMetadata.push_back(llvm::MDNode::get( 1642 C, {llvm::MDString::get(C, "lib"), llvm::MDString::get(C, Lib)})); 1643 } 1644 1645 void CodeGenModule::AddDependentLib(StringRef Lib) { 1646 llvm::SmallString<24> Opt; 1647 getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt); 1648 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt); 1649 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); 1650 } 1651 1652 /// Add link options implied by the given module, including modules 1653 /// it depends on, using a postorder walk. 1654 static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, 1655 SmallVectorImpl<llvm::MDNode *> &Metadata, 1656 llvm::SmallPtrSet<Module *, 16> &Visited) { 1657 // Import this module's parent. 1658 if (Mod->Parent && Visited.insert(Mod->Parent).second) { 1659 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited); 1660 } 1661 1662 // Import this module's dependencies. 1663 for (unsigned I = Mod->Imports.size(); I > 0; --I) { 1664 if (Visited.insert(Mod->Imports[I - 1]).second) 1665 addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited); 1666 } 1667 1668 // Add linker options to link against the libraries/frameworks 1669 // described by this module. 1670 llvm::LLVMContext &Context = CGM.getLLVMContext(); 1671 1672 // For modules that use export_as for linking, use that module 1673 // name instead. 1674 if (Mod->UseExportAsModuleLinkName) 1675 return; 1676 1677 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) { 1678 // Link against a framework. Frameworks are currently Darwin only, so we 1679 // don't to ask TargetCodeGenInfo for the spelling of the linker option. 1680 if (Mod->LinkLibraries[I-1].IsFramework) { 1681 llvm::Metadata *Args[2] = { 1682 llvm::MDString::get(Context, "-framework"), 1683 llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)}; 1684 1685 Metadata.push_back(llvm::MDNode::get(Context, Args)); 1686 continue; 1687 } 1688 1689 // Link against a library. 1690 llvm::SmallString<24> Opt; 1691 CGM.getTargetCodeGenInfo().getDependentLibraryOption( 1692 Mod->LinkLibraries[I-1].Library, Opt); 1693 auto *OptString = llvm::MDString::get(Context, Opt); 1694 Metadata.push_back(llvm::MDNode::get(Context, OptString)); 1695 } 1696 } 1697 1698 void CodeGenModule::EmitModuleLinkOptions() { 1699 // Collect the set of all of the modules we want to visit to emit link 1700 // options, which is essentially the imported modules and all of their 1701 // non-explicit child modules. 1702 llvm::SetVector<clang::Module *> LinkModules; 1703 llvm::SmallPtrSet<clang::Module *, 16> Visited; 1704 SmallVector<clang::Module *, 16> Stack; 1705 1706 // Seed the stack with imported modules. 1707 for (Module *M : ImportedModules) { 1708 // Do not add any link flags when an implementation TU of a module imports 1709 // a header of that same module. 1710 if (M->getTopLevelModuleName() == getLangOpts().CurrentModule && 1711 !getLangOpts().isCompilingModule()) 1712 continue; 1713 if (Visited.insert(M).second) 1714 Stack.push_back(M); 1715 } 1716 1717 // Find all of the modules to import, making a little effort to prune 1718 // non-leaf modules. 1719 while (!Stack.empty()) { 1720 clang::Module *Mod = Stack.pop_back_val(); 1721 1722 bool AnyChildren = false; 1723 1724 // Visit the submodules of this module. 1725 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(), 1726 SubEnd = Mod->submodule_end(); 1727 Sub != SubEnd; ++Sub) { 1728 // Skip explicit children; they need to be explicitly imported to be 1729 // linked against. 1730 if ((*Sub)->IsExplicit) 1731 continue; 1732 1733 if (Visited.insert(*Sub).second) { 1734 Stack.push_back(*Sub); 1735 AnyChildren = true; 1736 } 1737 } 1738 1739 // We didn't find any children, so add this module to the list of 1740 // modules to link against. 1741 if (!AnyChildren) { 1742 LinkModules.insert(Mod); 1743 } 1744 } 1745 1746 // Add link options for all of the imported modules in reverse topological 1747 // order. We don't do anything to try to order import link flags with respect 1748 // to linker options inserted by things like #pragma comment(). 1749 SmallVector<llvm::MDNode *, 16> MetadataArgs; 1750 Visited.clear(); 1751 for (Module *M : LinkModules) 1752 if (Visited.insert(M).second) 1753 addLinkOptionsPostorder(*this, M, MetadataArgs, Visited); 1754 std::reverse(MetadataArgs.begin(), MetadataArgs.end()); 1755 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end()); 1756 1757 // Add the linker options metadata flag. 1758 auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options"); 1759 for (auto *MD : LinkerOptionsMetadata) 1760 NMD->addOperand(MD); 1761 } 1762 1763 void CodeGenModule::EmitDeferred() { 1764 // Emit deferred declare target declarations. 1765 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd) 1766 getOpenMPRuntime().emitDeferredTargetDecls(); 1767 1768 // Emit code for any potentially referenced deferred decls. Since a 1769 // previously unused static decl may become used during the generation of code 1770 // for a static function, iterate until no changes are made. 1771 1772 if (!DeferredVTables.empty()) { 1773 EmitDeferredVTables(); 1774 1775 // Emitting a vtable doesn't directly cause more vtables to 1776 // become deferred, although it can cause functions to be 1777 // emitted that then need those vtables. 1778 assert(DeferredVTables.empty()); 1779 } 1780 1781 // Stop if we're out of both deferred vtables and deferred declarations. 1782 if (DeferredDeclsToEmit.empty()) 1783 return; 1784 1785 // Grab the list of decls to emit. If EmitGlobalDefinition schedules more 1786 // work, it will not interfere with this. 1787 std::vector<GlobalDecl> CurDeclsToEmit; 1788 CurDeclsToEmit.swap(DeferredDeclsToEmit); 1789 1790 for (GlobalDecl &D : CurDeclsToEmit) { 1791 // We should call GetAddrOfGlobal with IsForDefinition set to true in order 1792 // to get GlobalValue with exactly the type we need, not something that 1793 // might had been created for another decl with the same mangled name but 1794 // different type. 1795 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>( 1796 GetAddrOfGlobal(D, ForDefinition)); 1797 1798 // In case of different address spaces, we may still get a cast, even with 1799 // IsForDefinition equal to true. Query mangled names table to get 1800 // GlobalValue. 1801 if (!GV) 1802 GV = GetGlobalValue(getMangledName(D)); 1803 1804 // Make sure GetGlobalValue returned non-null. 1805 assert(GV); 1806 1807 // Check to see if we've already emitted this. This is necessary 1808 // for a couple of reasons: first, decls can end up in the 1809 // deferred-decls queue multiple times, and second, decls can end 1810 // up with definitions in unusual ways (e.g. by an extern inline 1811 // function acquiring a strong function redefinition). Just 1812 // ignore these cases. 1813 if (!GV->isDeclaration()) 1814 continue; 1815 1816 // Otherwise, emit the definition and move on to the next one. 1817 EmitGlobalDefinition(D, GV); 1818 1819 // If we found out that we need to emit more decls, do that recursively. 1820 // This has the advantage that the decls are emitted in a DFS and related 1821 // ones are close together, which is convenient for testing. 1822 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) { 1823 EmitDeferred(); 1824 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty()); 1825 } 1826 } 1827 } 1828 1829 void CodeGenModule::EmitVTablesOpportunistically() { 1830 // Try to emit external vtables as available_externally if they have emitted 1831 // all inlined virtual functions. It runs after EmitDeferred() and therefore 1832 // is not allowed to create new references to things that need to be emitted 1833 // lazily. Note that it also uses fact that we eagerly emitting RTTI. 1834 1835 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables()) 1836 && "Only emit opportunistic vtables with optimizations"); 1837 1838 for (const CXXRecordDecl *RD : OpportunisticVTables) { 1839 assert(getVTables().isVTableExternal(RD) && 1840 "This queue should only contain external vtables"); 1841 if (getCXXABI().canSpeculativelyEmitVTable(RD)) 1842 VTables.GenerateClassData(RD); 1843 } 1844 OpportunisticVTables.clear(); 1845 } 1846 1847 void CodeGenModule::EmitGlobalAnnotations() { 1848 if (Annotations.empty()) 1849 return; 1850 1851 // Create a new global variable for the ConstantStruct in the Module. 1852 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( 1853 Annotations[0]->getType(), Annotations.size()), Annotations); 1854 auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false, 1855 llvm::GlobalValue::AppendingLinkage, 1856 Array, "llvm.global.annotations"); 1857 gv->setSection(AnnotationSection); 1858 } 1859 1860 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) { 1861 llvm::Constant *&AStr = AnnotationStrings[Str]; 1862 if (AStr) 1863 return AStr; 1864 1865 // Not found yet, create a new global. 1866 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); 1867 auto *gv = 1868 new llvm::GlobalVariable(getModule(), s->getType(), true, 1869 llvm::GlobalValue::PrivateLinkage, s, ".str"); 1870 gv->setSection(AnnotationSection); 1871 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 1872 AStr = gv; 1873 return gv; 1874 } 1875 1876 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { 1877 SourceManager &SM = getContext().getSourceManager(); 1878 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 1879 if (PLoc.isValid()) 1880 return EmitAnnotationString(PLoc.getFilename()); 1881 return EmitAnnotationString(SM.getBufferName(Loc)); 1882 } 1883 1884 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { 1885 SourceManager &SM = getContext().getSourceManager(); 1886 PresumedLoc PLoc = SM.getPresumedLoc(L); 1887 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() : 1888 SM.getExpansionLineNumber(L); 1889 return llvm::ConstantInt::get(Int32Ty, LineNo); 1890 } 1891 1892 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 1893 const AnnotateAttr *AA, 1894 SourceLocation L) { 1895 // Get the globals for file name, annotation, and the line number. 1896 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()), 1897 *UnitGV = EmitAnnotationUnit(L), 1898 *LineNoCst = EmitAnnotationLineNo(L); 1899 1900 // Create the ConstantStruct for the global annotation. 1901 llvm::Constant *Fields[4] = { 1902 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy), 1903 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy), 1904 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy), 1905 LineNoCst 1906 }; 1907 return llvm::ConstantStruct::getAnon(Fields); 1908 } 1909 1910 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, 1911 llvm::GlobalValue *GV) { 1912 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 1913 // Get the struct elements for these annotations. 1914 for (const auto *I : D->specific_attrs<AnnotateAttr>()) 1915 Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation())); 1916 } 1917 1918 bool CodeGenModule::isInSanitizerBlacklist(SanitizerMask Kind, 1919 llvm::Function *Fn, 1920 SourceLocation Loc) const { 1921 const auto &SanitizerBL = getContext().getSanitizerBlacklist(); 1922 // Blacklist by function name. 1923 if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName())) 1924 return true; 1925 // Blacklist by location. 1926 if (Loc.isValid()) 1927 return SanitizerBL.isBlacklistedLocation(Kind, Loc); 1928 // If location is unknown, this may be a compiler-generated function. Assume 1929 // it's located in the main file. 1930 auto &SM = Context.getSourceManager(); 1931 if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 1932 return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName()); 1933 } 1934 return false; 1935 } 1936 1937 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV, 1938 SourceLocation Loc, QualType Ty, 1939 StringRef Category) const { 1940 // For now globals can be blacklisted only in ASan and KASan. 1941 const SanitizerMask EnabledAsanMask = LangOpts.Sanitize.Mask & 1942 (SanitizerKind::Address | SanitizerKind::KernelAddress | 1943 SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress); 1944 if (!EnabledAsanMask) 1945 return false; 1946 const auto &SanitizerBL = getContext().getSanitizerBlacklist(); 1947 if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(), Category)) 1948 return true; 1949 if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category)) 1950 return true; 1951 // Check global type. 1952 if (!Ty.isNull()) { 1953 // Drill down the array types: if global variable of a fixed type is 1954 // blacklisted, we also don't instrument arrays of them. 1955 while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr())) 1956 Ty = AT->getElementType(); 1957 Ty = Ty.getCanonicalType().getUnqualifiedType(); 1958 // We allow to blacklist only record types (classes, structs etc.) 1959 if (Ty->isRecordType()) { 1960 std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy()); 1961 if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category)) 1962 return true; 1963 } 1964 } 1965 return false; 1966 } 1967 1968 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, 1969 StringRef Category) const { 1970 if (!LangOpts.XRayInstrument) 1971 return false; 1972 1973 const auto &XRayFilter = getContext().getXRayFilter(); 1974 using ImbueAttr = XRayFunctionFilter::ImbueAttribute; 1975 auto Attr = ImbueAttr::NONE; 1976 if (Loc.isValid()) 1977 Attr = XRayFilter.shouldImbueLocation(Loc, Category); 1978 if (Attr == ImbueAttr::NONE) 1979 Attr = XRayFilter.shouldImbueFunction(Fn->getName()); 1980 switch (Attr) { 1981 case ImbueAttr::NONE: 1982 return false; 1983 case ImbueAttr::ALWAYS: 1984 Fn->addFnAttr("function-instrument", "xray-always"); 1985 break; 1986 case ImbueAttr::ALWAYS_ARG1: 1987 Fn->addFnAttr("function-instrument", "xray-always"); 1988 Fn->addFnAttr("xray-log-args", "1"); 1989 break; 1990 case ImbueAttr::NEVER: 1991 Fn->addFnAttr("function-instrument", "xray-never"); 1992 break; 1993 } 1994 return true; 1995 } 1996 1997 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) { 1998 // Never defer when EmitAllDecls is specified. 1999 if (LangOpts.EmitAllDecls) 2000 return true; 2001 2002 if (CodeGenOpts.KeepStaticConsts) { 2003 const auto *VD = dyn_cast<VarDecl>(Global); 2004 if (VD && VD->getType().isConstQualified() && 2005 VD->getStorageClass() == SC_Static) 2006 return true; 2007 } 2008 2009 return getContext().DeclMustBeEmitted(Global); 2010 } 2011 2012 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) { 2013 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) 2014 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 2015 // Implicit template instantiations may change linkage if they are later 2016 // explicitly instantiated, so they should not be emitted eagerly. 2017 return false; 2018 if (const auto *VD = dyn_cast<VarDecl>(Global)) 2019 if (Context.getInlineVariableDefinitionKind(VD) == 2020 ASTContext::InlineVariableDefinitionKind::WeakUnknown) 2021 // A definition of an inline constexpr static data member may change 2022 // linkage later if it's redeclared outside the class. 2023 return false; 2024 // If OpenMP is enabled and threadprivates must be generated like TLS, delay 2025 // codegen for global variables, because they may be marked as threadprivate. 2026 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS && 2027 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) && 2028 !isTypeConstant(Global->getType(), false) && 2029 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global)) 2030 return false; 2031 2032 return true; 2033 } 2034 2035 ConstantAddress CodeGenModule::GetAddrOfUuidDescriptor( 2036 const CXXUuidofExpr* E) { 2037 // Sema has verified that IIDSource has a __declspec(uuid()), and that its 2038 // well-formed. 2039 StringRef Uuid = E->getUuidStr(); 2040 std::string Name = "_GUID_" + Uuid.lower(); 2041 std::replace(Name.begin(), Name.end(), '-', '_'); 2042 2043 // The UUID descriptor should be pointer aligned. 2044 CharUnits Alignment = CharUnits::fromQuantity(PointerAlignInBytes); 2045 2046 // Look for an existing global. 2047 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name)) 2048 return ConstantAddress(GV, Alignment); 2049 2050 llvm::Constant *Init = EmitUuidofInitializer(Uuid); 2051 assert(Init && "failed to initialize as constant"); 2052 2053 auto *GV = new llvm::GlobalVariable( 2054 getModule(), Init->getType(), 2055 /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name); 2056 if (supportsCOMDAT()) 2057 GV->setComdat(TheModule.getOrInsertComdat(GV->getName())); 2058 setDSOLocal(GV); 2059 return ConstantAddress(GV, Alignment); 2060 } 2061 2062 ConstantAddress CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 2063 const AliasAttr *AA = VD->getAttr<AliasAttr>(); 2064 assert(AA && "No alias?"); 2065 2066 CharUnits Alignment = getContext().getDeclAlign(VD); 2067 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 2068 2069 // See if there is already something with the target's name in the module. 2070 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 2071 if (Entry) { 2072 unsigned AS = getContext().getTargetAddressSpace(VD->getType()); 2073 auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS)); 2074 return ConstantAddress(Ptr, Alignment); 2075 } 2076 2077 llvm::Constant *Aliasee; 2078 if (isa<llvm::FunctionType>(DeclTy)) 2079 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, 2080 GlobalDecl(cast<FunctionDecl>(VD)), 2081 /*ForVTable=*/false); 2082 else 2083 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 2084 llvm::PointerType::getUnqual(DeclTy), 2085 nullptr); 2086 2087 auto *F = cast<llvm::GlobalValue>(Aliasee); 2088 F->setLinkage(llvm::Function::ExternalWeakLinkage); 2089 WeakRefReferences.insert(F); 2090 2091 return ConstantAddress(Aliasee, Alignment); 2092 } 2093 2094 void CodeGenModule::EmitGlobal(GlobalDecl GD) { 2095 const auto *Global = cast<ValueDecl>(GD.getDecl()); 2096 2097 // Weak references don't produce any output by themselves. 2098 if (Global->hasAttr<WeakRefAttr>()) 2099 return; 2100 2101 // If this is an alias definition (which otherwise looks like a declaration) 2102 // emit it now. 2103 if (Global->hasAttr<AliasAttr>()) 2104 return EmitAliasDefinition(GD); 2105 2106 // IFunc like an alias whose value is resolved at runtime by calling resolver. 2107 if (Global->hasAttr<IFuncAttr>()) 2108 return emitIFuncDefinition(GD); 2109 2110 // If this is a cpu_dispatch multiversion function, emit the resolver. 2111 if (Global->hasAttr<CPUDispatchAttr>()) 2112 return emitCPUDispatchDefinition(GD); 2113 2114 // If this is CUDA, be selective about which declarations we emit. 2115 if (LangOpts.CUDA) { 2116 if (LangOpts.CUDAIsDevice) { 2117 if (!Global->hasAttr<CUDADeviceAttr>() && 2118 !Global->hasAttr<CUDAGlobalAttr>() && 2119 !Global->hasAttr<CUDAConstantAttr>() && 2120 !Global->hasAttr<CUDASharedAttr>()) 2121 return; 2122 } else { 2123 // We need to emit host-side 'shadows' for all global 2124 // device-side variables because the CUDA runtime needs their 2125 // size and host-side address in order to provide access to 2126 // their device-side incarnations. 2127 2128 // So device-only functions are the only things we skip. 2129 if (isa<FunctionDecl>(Global) && !Global->hasAttr<CUDAHostAttr>() && 2130 Global->hasAttr<CUDADeviceAttr>()) 2131 return; 2132 2133 assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) && 2134 "Expected Variable or Function"); 2135 } 2136 } 2137 2138 if (LangOpts.OpenMP) { 2139 // If this is OpenMP device, check if it is legal to emit this global 2140 // normally. 2141 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD)) 2142 return; 2143 if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) { 2144 if (MustBeEmitted(Global)) 2145 EmitOMPDeclareReduction(DRD); 2146 return; 2147 } 2148 } 2149 2150 // Ignore declarations, they will be emitted on their first use. 2151 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) { 2152 // Forward declarations are emitted lazily on first use. 2153 if (!FD->doesThisDeclarationHaveABody()) { 2154 if (!FD->doesDeclarationForceExternallyVisibleDefinition()) 2155 return; 2156 2157 StringRef MangledName = getMangledName(GD); 2158 2159 // Compute the function info and LLVM type. 2160 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 2161 llvm::Type *Ty = getTypes().GetFunctionType(FI); 2162 2163 GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false, 2164 /*DontDefer=*/false); 2165 return; 2166 } 2167 } else { 2168 const auto *VD = cast<VarDecl>(Global); 2169 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 2170 // We need to emit device-side global CUDA variables even if a 2171 // variable does not have a definition -- we still need to define 2172 // host-side shadow for it. 2173 bool MustEmitForCuda = LangOpts.CUDA && !LangOpts.CUDAIsDevice && 2174 !VD->hasDefinition() && 2175 (VD->hasAttr<CUDAConstantAttr>() || 2176 VD->hasAttr<CUDADeviceAttr>()); 2177 if (!MustEmitForCuda && 2178 VD->isThisDeclarationADefinition() != VarDecl::Definition && 2179 !Context.isMSStaticDataMemberInlineDefinition(VD)) { 2180 if (LangOpts.OpenMP) { 2181 // Emit declaration of the must-be-emitted declare target variable. 2182 if (llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res = 2183 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) { 2184 if (*Res == OMPDeclareTargetDeclAttr::MT_To) { 2185 (void)GetAddrOfGlobalVar(VD); 2186 } else { 2187 assert(*Res == OMPDeclareTargetDeclAttr::MT_Link && 2188 "link claue expected."); 2189 (void)getOpenMPRuntime().getAddrOfDeclareTargetLink(VD); 2190 } 2191 return; 2192 } 2193 } 2194 // If this declaration may have caused an inline variable definition to 2195 // change linkage, make sure that it's emitted. 2196 if (Context.getInlineVariableDefinitionKind(VD) == 2197 ASTContext::InlineVariableDefinitionKind::Strong) 2198 GetAddrOfGlobalVar(VD); 2199 return; 2200 } 2201 } 2202 2203 // Defer code generation to first use when possible, e.g. if this is an inline 2204 // function. If the global must always be emitted, do it eagerly if possible 2205 // to benefit from cache locality. 2206 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) { 2207 // Emit the definition if it can't be deferred. 2208 EmitGlobalDefinition(GD); 2209 return; 2210 } 2211 2212 // If we're deferring emission of a C++ variable with an 2213 // initializer, remember the order in which it appeared in the file. 2214 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) && 2215 cast<VarDecl>(Global)->hasInit()) { 2216 DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 2217 CXXGlobalInits.push_back(nullptr); 2218 } 2219 2220 StringRef MangledName = getMangledName(GD); 2221 if (GetGlobalValue(MangledName) != nullptr) { 2222 // The value has already been used and should therefore be emitted. 2223 addDeferredDeclToEmit(GD); 2224 } else if (MustBeEmitted(Global)) { 2225 // The value must be emitted, but cannot be emitted eagerly. 2226 assert(!MayBeEmittedEagerly(Global)); 2227 addDeferredDeclToEmit(GD); 2228 } else { 2229 // Otherwise, remember that we saw a deferred decl with this name. The 2230 // first use of the mangled name will cause it to move into 2231 // DeferredDeclsToEmit. 2232 DeferredDecls[MangledName] = GD; 2233 } 2234 } 2235 2236 // Check if T is a class type with a destructor that's not dllimport. 2237 static bool HasNonDllImportDtor(QualType T) { 2238 if (const auto *RT = T->getBaseElementTypeUnsafe()->getAs<RecordType>()) 2239 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) 2240 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>()) 2241 return true; 2242 2243 return false; 2244 } 2245 2246 namespace { 2247 struct FunctionIsDirectlyRecursive : 2248 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> { 2249 const StringRef Name; 2250 const Builtin::Context &BI; 2251 bool Result; 2252 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) : 2253 Name(N), BI(C), Result(false) { 2254 } 2255 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base; 2256 2257 bool TraverseCallExpr(CallExpr *E) { 2258 const FunctionDecl *FD = E->getDirectCallee(); 2259 if (!FD) 2260 return true; 2261 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 2262 if (Attr && Name == Attr->getLabel()) { 2263 Result = true; 2264 return false; 2265 } 2266 unsigned BuiltinID = FD->getBuiltinID(); 2267 if (!BuiltinID || !BI.isLibFunction(BuiltinID)) 2268 return true; 2269 StringRef BuiltinName = BI.getName(BuiltinID); 2270 if (BuiltinName.startswith("__builtin_") && 2271 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) { 2272 Result = true; 2273 return false; 2274 } 2275 return true; 2276 } 2277 }; 2278 2279 // Make sure we're not referencing non-imported vars or functions. 2280 struct DLLImportFunctionVisitor 2281 : public RecursiveASTVisitor<DLLImportFunctionVisitor> { 2282 bool SafeToInline = true; 2283 2284 bool shouldVisitImplicitCode() const { return true; } 2285 2286 bool VisitVarDecl(VarDecl *VD) { 2287 if (VD->getTLSKind()) { 2288 // A thread-local variable cannot be imported. 2289 SafeToInline = false; 2290 return SafeToInline; 2291 } 2292 2293 // A variable definition might imply a destructor call. 2294 if (VD->isThisDeclarationADefinition()) 2295 SafeToInline = !HasNonDllImportDtor(VD->getType()); 2296 2297 return SafeToInline; 2298 } 2299 2300 bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 2301 if (const auto *D = E->getTemporary()->getDestructor()) 2302 SafeToInline = D->hasAttr<DLLImportAttr>(); 2303 return SafeToInline; 2304 } 2305 2306 bool VisitDeclRefExpr(DeclRefExpr *E) { 2307 ValueDecl *VD = E->getDecl(); 2308 if (isa<FunctionDecl>(VD)) 2309 SafeToInline = VD->hasAttr<DLLImportAttr>(); 2310 else if (VarDecl *V = dyn_cast<VarDecl>(VD)) 2311 SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>(); 2312 return SafeToInline; 2313 } 2314 2315 bool VisitCXXConstructExpr(CXXConstructExpr *E) { 2316 SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>(); 2317 return SafeToInline; 2318 } 2319 2320 bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 2321 CXXMethodDecl *M = E->getMethodDecl(); 2322 if (!M) { 2323 // Call through a pointer to member function. This is safe to inline. 2324 SafeToInline = true; 2325 } else { 2326 SafeToInline = M->hasAttr<DLLImportAttr>(); 2327 } 2328 return SafeToInline; 2329 } 2330 2331 bool VisitCXXDeleteExpr(CXXDeleteExpr *E) { 2332 SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>(); 2333 return SafeToInline; 2334 } 2335 2336 bool VisitCXXNewExpr(CXXNewExpr *E) { 2337 SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>(); 2338 return SafeToInline; 2339 } 2340 }; 2341 } 2342 2343 // isTriviallyRecursive - Check if this function calls another 2344 // decl that, because of the asm attribute or the other decl being a builtin, 2345 // ends up pointing to itself. 2346 bool 2347 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) { 2348 StringRef Name; 2349 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) { 2350 // asm labels are a special kind of mangling we have to support. 2351 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 2352 if (!Attr) 2353 return false; 2354 Name = Attr->getLabel(); 2355 } else { 2356 Name = FD->getName(); 2357 } 2358 2359 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo); 2360 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD)); 2361 return Walker.Result; 2362 } 2363 2364 bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) { 2365 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage) 2366 return true; 2367 const auto *F = cast<FunctionDecl>(GD.getDecl()); 2368 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>()) 2369 return false; 2370 2371 if (F->hasAttr<DLLImportAttr>()) { 2372 // Check whether it would be safe to inline this dllimport function. 2373 DLLImportFunctionVisitor Visitor; 2374 Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F)); 2375 if (!Visitor.SafeToInline) 2376 return false; 2377 2378 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) { 2379 // Implicit destructor invocations aren't captured in the AST, so the 2380 // check above can't see them. Check for them manually here. 2381 for (const Decl *Member : Dtor->getParent()->decls()) 2382 if (isa<FieldDecl>(Member)) 2383 if (HasNonDllImportDtor(cast<FieldDecl>(Member)->getType())) 2384 return false; 2385 for (const CXXBaseSpecifier &B : Dtor->getParent()->bases()) 2386 if (HasNonDllImportDtor(B.getType())) 2387 return false; 2388 } 2389 } 2390 2391 // PR9614. Avoid cases where the source code is lying to us. An available 2392 // externally function should have an equivalent function somewhere else, 2393 // but a function that calls itself is clearly not equivalent to the real 2394 // implementation. 2395 // This happens in glibc's btowc and in some configure checks. 2396 return !isTriviallyRecursive(F); 2397 } 2398 2399 bool CodeGenModule::shouldOpportunisticallyEmitVTables() { 2400 return CodeGenOpts.OptimizationLevel > 0; 2401 } 2402 2403 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { 2404 const auto *D = cast<ValueDecl>(GD.getDecl()); 2405 2406 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 2407 Context.getSourceManager(), 2408 "Generating code for declaration"); 2409 2410 if (isa<FunctionDecl>(D)) { 2411 // At -O0, don't generate IR for functions with available_externally 2412 // linkage. 2413 if (!shouldEmitFunction(GD)) 2414 return; 2415 2416 if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) { 2417 // Make sure to emit the definition(s) before we emit the thunks. 2418 // This is necessary for the generation of certain thunks. 2419 if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method)) 2420 ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType())); 2421 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method)) 2422 ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType())); 2423 else 2424 EmitGlobalFunctionDefinition(GD, GV); 2425 2426 if (Method->isVirtual()) 2427 getVTables().EmitThunks(GD); 2428 2429 return; 2430 } 2431 2432 return EmitGlobalFunctionDefinition(GD, GV); 2433 } 2434 2435 if (const auto *VD = dyn_cast<VarDecl>(D)) 2436 return EmitGlobalVarDefinition(VD, !VD->hasDefinition()); 2437 2438 llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); 2439 } 2440 2441 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 2442 llvm::Function *NewFn); 2443 2444 static unsigned 2445 TargetMVPriority(const TargetInfo &TI, 2446 const CodeGenFunction::MultiVersionResolverOption &RO) { 2447 unsigned Priority = 0; 2448 for (StringRef Feat : RO.Conditions.Features) 2449 Priority = std::max(Priority, TI.multiVersionSortPriority(Feat)); 2450 2451 if (!RO.Conditions.Architecture.empty()) 2452 Priority = std::max( 2453 Priority, TI.multiVersionSortPriority(RO.Conditions.Architecture)); 2454 return Priority; 2455 } 2456 2457 void CodeGenModule::emitMultiVersionFunctions() { 2458 for (GlobalDecl GD : MultiVersionFuncs) { 2459 SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options; 2460 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 2461 getContext().forEachMultiversionedFunctionVersion( 2462 FD, [this, &GD, &Options](const FunctionDecl *CurFD) { 2463 GlobalDecl CurGD{ 2464 (CurFD->isDefined() ? CurFD->getDefinition() : CurFD)}; 2465 StringRef MangledName = getMangledName(CurGD); 2466 llvm::Constant *Func = GetGlobalValue(MangledName); 2467 if (!Func) { 2468 if (CurFD->isDefined()) { 2469 EmitGlobalFunctionDefinition(CurGD, nullptr); 2470 Func = GetGlobalValue(MangledName); 2471 } else { 2472 const CGFunctionInfo &FI = 2473 getTypes().arrangeGlobalDeclaration(GD); 2474 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 2475 Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false, 2476 /*DontDefer=*/false, ForDefinition); 2477 } 2478 assert(Func && "This should have just been created"); 2479 } 2480 2481 const auto *TA = CurFD->getAttr<TargetAttr>(); 2482 llvm::SmallVector<StringRef, 8> Feats; 2483 TA->getAddedFeatures(Feats); 2484 2485 Options.emplace_back(cast<llvm::Function>(Func), 2486 TA->getArchitecture(), Feats); 2487 }); 2488 2489 llvm::Function *ResolverFunc = cast<llvm::Function>( 2490 GetGlobalValue((getMangledName(GD) + ".resolver").str())); 2491 if (supportsCOMDAT()) 2492 ResolverFunc->setComdat( 2493 getModule().getOrInsertComdat(ResolverFunc->getName())); 2494 2495 const TargetInfo &TI = getTarget(); 2496 std::stable_sort( 2497 Options.begin(), Options.end(), 2498 [&TI](const CodeGenFunction::MultiVersionResolverOption &LHS, 2499 const CodeGenFunction::MultiVersionResolverOption &RHS) { 2500 return TargetMVPriority(TI, LHS) > TargetMVPriority(TI, RHS); 2501 }); 2502 CodeGenFunction CGF(*this); 2503 CGF.EmitMultiVersionResolver(ResolverFunc, Options); 2504 } 2505 } 2506 2507 void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) { 2508 const auto *FD = cast<FunctionDecl>(GD.getDecl()); 2509 assert(FD && "Not a FunctionDecl?"); 2510 const auto *DD = FD->getAttr<CPUDispatchAttr>(); 2511 assert(DD && "Not a cpu_dispatch Function?"); 2512 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(FD->getType()); 2513 2514 StringRef ResolverName = getMangledName(GD); 2515 llvm::Type *ResolverType = llvm::FunctionType::get( 2516 llvm::PointerType::get(DeclTy, 2517 Context.getTargetAddressSpace(FD->getType())), 2518 false); 2519 auto *ResolverFunc = cast<llvm::Function>( 2520 GetOrCreateLLVMFunction(ResolverName, ResolverType, GlobalDecl{}, 2521 /*ForVTable=*/false)); 2522 2523 SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options; 2524 const TargetInfo &Target = getTarget(); 2525 for (const IdentifierInfo *II : DD->cpus()) { 2526 // Get the name of the target function so we can look it up/create it. 2527 std::string MangledName = getMangledNameImpl(*this, GD, FD, true) + 2528 getCPUSpecificMangling(*this, II->getName()); 2529 llvm::Constant *Func = GetOrCreateLLVMFunction( 2530 MangledName, DeclTy, GD, /*ForVTable=*/false, /*DontDefer=*/false, 2531 /*IsThunk=*/false, llvm::AttributeList(), ForDefinition); 2532 llvm::SmallVector<StringRef, 32> Features; 2533 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features); 2534 llvm::transform(Features, Features.begin(), 2535 [](StringRef Str) { return Str.substr(1); }); 2536 Features.erase(std::remove_if( 2537 Features.begin(), Features.end(), [&Target](StringRef Feat) { 2538 return !Target.validateCpuSupports(Feat); 2539 }), Features.end()); 2540 Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features); 2541 } 2542 2543 llvm::sort( 2544 Options.begin(), Options.end(), 2545 [](const CodeGenFunction::MultiVersionResolverOption &LHS, 2546 const CodeGenFunction::MultiVersionResolverOption &RHS) { 2547 return CodeGenFunction::GetX86CpuSupportsMask(LHS.Conditions.Features) > 2548 CodeGenFunction::GetX86CpuSupportsMask(RHS.Conditions.Features); 2549 }); 2550 CodeGenFunction CGF(*this); 2551 CGF.EmitMultiVersionResolver(ResolverFunc, Options); 2552 } 2553 2554 /// If an ifunc for the specified mangled name is not in the module, create and 2555 /// return an llvm IFunc Function with the specified type. 2556 llvm::Constant * 2557 CodeGenModule::GetOrCreateMultiVersionIFunc(GlobalDecl GD, llvm::Type *DeclTy, 2558 const FunctionDecl *FD) { 2559 std::string MangledName = 2560 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true); 2561 std::string IFuncName = MangledName + ".ifunc"; 2562 if (llvm::GlobalValue *IFuncGV = GetGlobalValue(IFuncName)) 2563 return IFuncGV; 2564 2565 // Since this is the first time we've created this IFunc, make sure 2566 // that we put this multiversioned function into the list to be 2567 // replaced later if necessary (target multiversioning only). 2568 if (!FD->isCPUDispatchMultiVersion() && !FD->isCPUSpecificMultiVersion()) 2569 MultiVersionFuncs.push_back(GD); 2570 2571 std::string ResolverName = MangledName + ".resolver"; 2572 llvm::Type *ResolverType = llvm::FunctionType::get( 2573 llvm::PointerType::get(DeclTy, 2574 Context.getTargetAddressSpace(FD->getType())), 2575 false); 2576 llvm::Constant *Resolver = 2577 GetOrCreateLLVMFunction(ResolverName, ResolverType, GlobalDecl{}, 2578 /*ForVTable=*/false); 2579 llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create( 2580 DeclTy, 0, llvm::Function::ExternalLinkage, "", Resolver, &getModule()); 2581 GIF->setName(IFuncName); 2582 SetCommonAttributes(FD, GIF); 2583 2584 return GIF; 2585 } 2586 2587 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the 2588 /// module, create and return an llvm Function with the specified type. If there 2589 /// is something in the module with the specified name, return it potentially 2590 /// bitcasted to the right type. 2591 /// 2592 /// If D is non-null, it specifies a decl that correspond to this. This is used 2593 /// to set the attributes on the function when it is first created. 2594 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction( 2595 StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable, 2596 bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs, 2597 ForDefinition_t IsForDefinition) { 2598 const Decl *D = GD.getDecl(); 2599 2600 // Any attempts to use a MultiVersion function should result in retrieving 2601 // the iFunc instead. Name Mangling will handle the rest of the changes. 2602 if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) { 2603 // For the device mark the function as one that should be emitted. 2604 if (getLangOpts().OpenMPIsDevice && OpenMPRuntime && 2605 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->isDefined() && 2606 !DontDefer && !IsForDefinition) { 2607 if (const FunctionDecl *FDDef = FD->getDefinition()) { 2608 GlobalDecl GDDef; 2609 if (const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef)) 2610 GDDef = GlobalDecl(CD, GD.getCtorType()); 2611 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef)) 2612 GDDef = GlobalDecl(DD, GD.getDtorType()); 2613 else 2614 GDDef = GlobalDecl(FDDef); 2615 EmitGlobal(GDDef); 2616 } 2617 } 2618 2619 if (FD->isMultiVersion()) { 2620 const auto *TA = FD->getAttr<TargetAttr>(); 2621 if (TA && TA->isDefaultVersion()) 2622 UpdateMultiVersionNames(GD, FD); 2623 if (!IsForDefinition) 2624 return GetOrCreateMultiVersionIFunc(GD, Ty, FD); 2625 } 2626 } 2627 2628 // Lookup the entry, lazily creating it if necessary. 2629 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 2630 if (Entry) { 2631 if (WeakRefReferences.erase(Entry)) { 2632 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D); 2633 if (FD && !FD->hasAttr<WeakAttr>()) 2634 Entry->setLinkage(llvm::Function::ExternalLinkage); 2635 } 2636 2637 // Handle dropped DLL attributes. 2638 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) { 2639 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); 2640 setDSOLocal(Entry); 2641 } 2642 2643 // If there are two attempts to define the same mangled name, issue an 2644 // error. 2645 if (IsForDefinition && !Entry->isDeclaration()) { 2646 GlobalDecl OtherGD; 2647 // Check that GD is not yet in DiagnosedConflictingDefinitions is required 2648 // to make sure that we issue an error only once. 2649 if (lookupRepresentativeDecl(MangledName, OtherGD) && 2650 (GD.getCanonicalDecl().getDecl() != 2651 OtherGD.getCanonicalDecl().getDecl()) && 2652 DiagnosedConflictingDefinitions.insert(GD).second) { 2653 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name) 2654 << MangledName; 2655 getDiags().Report(OtherGD.getDecl()->getLocation(), 2656 diag::note_previous_definition); 2657 } 2658 } 2659 2660 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) && 2661 (Entry->getType()->getElementType() == Ty)) { 2662 return Entry; 2663 } 2664 2665 // Make sure the result is of the correct type. 2666 // (If function is requested for a definition, we always need to create a new 2667 // function, not just return a bitcast.) 2668 if (!IsForDefinition) 2669 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); 2670 } 2671 2672 // This function doesn't have a complete type (for example, the return 2673 // type is an incomplete struct). Use a fake type instead, and make 2674 // sure not to try to set attributes. 2675 bool IsIncompleteFunction = false; 2676 2677 llvm::FunctionType *FTy; 2678 if (isa<llvm::FunctionType>(Ty)) { 2679 FTy = cast<llvm::FunctionType>(Ty); 2680 } else { 2681 FTy = llvm::FunctionType::get(VoidTy, false); 2682 IsIncompleteFunction = true; 2683 } 2684 2685 llvm::Function *F = 2686 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage, 2687 Entry ? StringRef() : MangledName, &getModule()); 2688 2689 // If we already created a function with the same mangled name (but different 2690 // type) before, take its name and add it to the list of functions to be 2691 // replaced with F at the end of CodeGen. 2692 // 2693 // This happens if there is a prototype for a function (e.g. "int f()") and 2694 // then a definition of a different type (e.g. "int f(int x)"). 2695 if (Entry) { 2696 F->takeName(Entry); 2697 2698 // This might be an implementation of a function without a prototype, in 2699 // which case, try to do special replacement of calls which match the new 2700 // prototype. The really key thing here is that we also potentially drop 2701 // arguments from the call site so as to make a direct call, which makes the 2702 // inliner happier and suppresses a number of optimizer warnings (!) about 2703 // dropping arguments. 2704 if (!Entry->use_empty()) { 2705 ReplaceUsesOfNonProtoTypeWithRealFunction(Entry, F); 2706 Entry->removeDeadConstantUsers(); 2707 } 2708 2709 llvm::Constant *BC = llvm::ConstantExpr::getBitCast( 2710 F, Entry->getType()->getElementType()->getPointerTo()); 2711 addGlobalValReplacement(Entry, BC); 2712 } 2713 2714 assert(F->getName() == MangledName && "name was uniqued!"); 2715 if (D) 2716 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk); 2717 if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) { 2718 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex); 2719 F->addAttributes(llvm::AttributeList::FunctionIndex, B); 2720 } 2721 2722 if (!DontDefer) { 2723 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to 2724 // each other bottoming out with the base dtor. Therefore we emit non-base 2725 // dtors on usage, even if there is no dtor definition in the TU. 2726 if (D && isa<CXXDestructorDecl>(D) && 2727 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), 2728 GD.getDtorType())) 2729 addDeferredDeclToEmit(GD); 2730 2731 // This is the first use or definition of a mangled name. If there is a 2732 // deferred decl with this name, remember that we need to emit it at the end 2733 // of the file. 2734 auto DDI = DeferredDecls.find(MangledName); 2735 if (DDI != DeferredDecls.end()) { 2736 // Move the potentially referenced deferred decl to the 2737 // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we 2738 // don't need it anymore). 2739 addDeferredDeclToEmit(DDI->second); 2740 DeferredDecls.erase(DDI); 2741 2742 // Otherwise, there are cases we have to worry about where we're 2743 // using a declaration for which we must emit a definition but where 2744 // we might not find a top-level definition: 2745 // - member functions defined inline in their classes 2746 // - friend functions defined inline in some class 2747 // - special member functions with implicit definitions 2748 // If we ever change our AST traversal to walk into class methods, 2749 // this will be unnecessary. 2750 // 2751 // We also don't emit a definition for a function if it's going to be an 2752 // entry in a vtable, unless it's already marked as used. 2753 } else if (getLangOpts().CPlusPlus && D) { 2754 // Look for a declaration that's lexically in a record. 2755 for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD; 2756 FD = FD->getPreviousDecl()) { 2757 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 2758 if (FD->doesThisDeclarationHaveABody()) { 2759 addDeferredDeclToEmit(GD.getWithDecl(FD)); 2760 break; 2761 } 2762 } 2763 } 2764 } 2765 } 2766 2767 // Make sure the result is of the requested type. 2768 if (!IsIncompleteFunction) { 2769 assert(F->getType()->getElementType() == Ty); 2770 return F; 2771 } 2772 2773 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 2774 return llvm::ConstantExpr::getBitCast(F, PTy); 2775 } 2776 2777 /// GetAddrOfFunction - Return the address of the given function. If Ty is 2778 /// non-null, then this function will use the specified type if it has to 2779 /// create it (this occurs when we see a definition of the function). 2780 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 2781 llvm::Type *Ty, 2782 bool ForVTable, 2783 bool DontDefer, 2784 ForDefinition_t IsForDefinition) { 2785 // If there was no specific requested type, just convert it now. 2786 if (!Ty) { 2787 const auto *FD = cast<FunctionDecl>(GD.getDecl()); 2788 auto CanonTy = Context.getCanonicalType(FD->getType()); 2789 Ty = getTypes().ConvertFunctionType(CanonTy, FD); 2790 } 2791 2792 // Devirtualized destructor calls may come through here instead of via 2793 // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead 2794 // of the complete destructor when necessary. 2795 if (const auto *DD = dyn_cast<CXXDestructorDecl>(GD.getDecl())) { 2796 if (getTarget().getCXXABI().isMicrosoft() && 2797 GD.getDtorType() == Dtor_Complete && 2798 DD->getParent()->getNumVBases() == 0) 2799 GD = GlobalDecl(DD, Dtor_Base); 2800 } 2801 2802 StringRef MangledName = getMangledName(GD); 2803 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer, 2804 /*IsThunk=*/false, llvm::AttributeList(), 2805 IsForDefinition); 2806 } 2807 2808 static const FunctionDecl * 2809 GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) { 2810 TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl(); 2811 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); 2812 2813 IdentifierInfo &CII = C.Idents.get(Name); 2814 for (const auto &Result : DC->lookup(&CII)) 2815 if (const auto FD = dyn_cast<FunctionDecl>(Result)) 2816 return FD; 2817 2818 if (!C.getLangOpts().CPlusPlus) 2819 return nullptr; 2820 2821 // Demangle the premangled name from getTerminateFn() 2822 IdentifierInfo &CXXII = 2823 (Name == "_ZSt9terminatev" || Name == "?terminate@@YAXXZ") 2824 ? C.Idents.get("terminate") 2825 : C.Idents.get(Name); 2826 2827 for (const auto &N : {"__cxxabiv1", "std"}) { 2828 IdentifierInfo &NS = C.Idents.get(N); 2829 for (const auto &Result : DC->lookup(&NS)) { 2830 NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result); 2831 if (auto LSD = dyn_cast<LinkageSpecDecl>(Result)) 2832 for (const auto &Result : LSD->lookup(&NS)) 2833 if ((ND = dyn_cast<NamespaceDecl>(Result))) 2834 break; 2835 2836 if (ND) 2837 for (const auto &Result : ND->lookup(&CXXII)) 2838 if (const auto *FD = dyn_cast<FunctionDecl>(Result)) 2839 return FD; 2840 } 2841 } 2842 2843 return nullptr; 2844 } 2845 2846 /// CreateRuntimeFunction - Create a new runtime function with the specified 2847 /// type and name. 2848 llvm::Constant * 2849 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name, 2850 llvm::AttributeList ExtraAttrs, 2851 bool Local) { 2852 llvm::Constant *C = 2853 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 2854 /*DontDefer=*/false, /*IsThunk=*/false, 2855 ExtraAttrs); 2856 2857 if (auto *F = dyn_cast<llvm::Function>(C)) { 2858 if (F->empty()) { 2859 F->setCallingConv(getRuntimeCC()); 2860 2861 if (!Local && getTriple().isOSBinFormatCOFF() && 2862 !getCodeGenOpts().LTOVisibilityPublicStd && 2863 !getTriple().isWindowsGNUEnvironment()) { 2864 const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name); 2865 if (!FD || FD->hasAttr<DLLImportAttr>()) { 2866 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 2867 F->setLinkage(llvm::GlobalValue::ExternalLinkage); 2868 } 2869 } 2870 setDSOLocal(F); 2871 } 2872 } 2873 2874 return C; 2875 } 2876 2877 /// CreateBuiltinFunction - Create a new builtin function with the specified 2878 /// type and name. 2879 llvm::Constant * 2880 CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy, StringRef Name, 2881 llvm::AttributeList ExtraAttrs) { 2882 return CreateRuntimeFunction(FTy, Name, ExtraAttrs, true); 2883 } 2884 2885 /// isTypeConstant - Determine whether an object of this type can be emitted 2886 /// as a constant. 2887 /// 2888 /// If ExcludeCtor is true, the duration when the object's constructor runs 2889 /// will not be considered. The caller will need to verify that the object is 2890 /// not written to during its construction. 2891 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) { 2892 if (!Ty.isConstant(Context) && !Ty->isReferenceType()) 2893 return false; 2894 2895 if (Context.getLangOpts().CPlusPlus) { 2896 if (const CXXRecordDecl *Record 2897 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl()) 2898 return ExcludeCtor && !Record->hasMutableFields() && 2899 Record->hasTrivialDestructor(); 2900 } 2901 2902 return true; 2903 } 2904 2905 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 2906 /// create and return an llvm GlobalVariable with the specified type. If there 2907 /// is something in the module with the specified name, return it potentially 2908 /// bitcasted to the right type. 2909 /// 2910 /// If D is non-null, it specifies a decl that correspond to this. This is used 2911 /// to set the attributes on the global when it is first created. 2912 /// 2913 /// If IsForDefinition is true, it is guaranteed that an actual global with 2914 /// type Ty will be returned, not conversion of a variable with the same 2915 /// mangled name but some other type. 2916 llvm::Constant * 2917 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, 2918 llvm::PointerType *Ty, 2919 const VarDecl *D, 2920 ForDefinition_t IsForDefinition) { 2921 // Lookup the entry, lazily creating it if necessary. 2922 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 2923 if (Entry) { 2924 if (WeakRefReferences.erase(Entry)) { 2925 if (D && !D->hasAttr<WeakAttr>()) 2926 Entry->setLinkage(llvm::Function::ExternalLinkage); 2927 } 2928 2929 // Handle dropped DLL attributes. 2930 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) 2931 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); 2932 2933 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D) 2934 getOpenMPRuntime().registerTargetGlobalVariable(D, Entry); 2935 2936 if (Entry->getType() == Ty) 2937 return Entry; 2938 2939 // If there are two attempts to define the same mangled name, issue an 2940 // error. 2941 if (IsForDefinition && !Entry->isDeclaration()) { 2942 GlobalDecl OtherGD; 2943 const VarDecl *OtherD; 2944 2945 // Check that D is not yet in DiagnosedConflictingDefinitions is required 2946 // to make sure that we issue an error only once. 2947 if (D && lookupRepresentativeDecl(MangledName, OtherGD) && 2948 (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) && 2949 (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) && 2950 OtherD->hasInit() && 2951 DiagnosedConflictingDefinitions.insert(D).second) { 2952 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name) 2953 << MangledName; 2954 getDiags().Report(OtherGD.getDecl()->getLocation(), 2955 diag::note_previous_definition); 2956 } 2957 } 2958 2959 // Make sure the result is of the correct type. 2960 if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace()) 2961 return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty); 2962 2963 // (If global is requested for a definition, we always need to create a new 2964 // global, not just return a bitcast.) 2965 if (!IsForDefinition) 2966 return llvm::ConstantExpr::getBitCast(Entry, Ty); 2967 } 2968 2969 auto AddrSpace = GetGlobalVarAddressSpace(D); 2970 auto TargetAddrSpace = getContext().getTargetAddressSpace(AddrSpace); 2971 2972 auto *GV = new llvm::GlobalVariable( 2973 getModule(), Ty->getElementType(), false, 2974 llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr, 2975 llvm::GlobalVariable::NotThreadLocal, TargetAddrSpace); 2976 2977 // If we already created a global with the same mangled name (but different 2978 // type) before, take its name and remove it from its parent. 2979 if (Entry) { 2980 GV->takeName(Entry); 2981 2982 if (!Entry->use_empty()) { 2983 llvm::Constant *NewPtrForOldDecl = 2984 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 2985 Entry->replaceAllUsesWith(NewPtrForOldDecl); 2986 } 2987 2988 Entry->eraseFromParent(); 2989 } 2990 2991 // This is the first use or definition of a mangled name. If there is a 2992 // deferred decl with this name, remember that we need to emit it at the end 2993 // of the file. 2994 auto DDI = DeferredDecls.find(MangledName); 2995 if (DDI != DeferredDecls.end()) { 2996 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 2997 // list, and remove it from DeferredDecls (since we don't need it anymore). 2998 addDeferredDeclToEmit(DDI->second); 2999 DeferredDecls.erase(DDI); 3000 } 3001 3002 // Handle things which are present even on external declarations. 3003 if (D) { 3004 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd) 3005 getOpenMPRuntime().registerTargetGlobalVariable(D, GV); 3006 3007 // FIXME: This code is overly simple and should be merged with other global 3008 // handling. 3009 GV->setConstant(isTypeConstant(D->getType(), false)); 3010 3011 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 3012 3013 setLinkageForGV(GV, D); 3014 3015 if (D->getTLSKind()) { 3016 if (D->getTLSKind() == VarDecl::TLS_Dynamic) 3017 CXXThreadLocals.push_back(D); 3018 setTLSMode(GV, *D); 3019 } 3020 3021 setGVProperties(GV, D); 3022 3023 // If required by the ABI, treat declarations of static data members with 3024 // inline initializers as definitions. 3025 if (getContext().isMSStaticDataMemberInlineDefinition(D)) { 3026 EmitGlobalVarDefinition(D); 3027 } 3028 3029 // Emit section information for extern variables. 3030 if (D->hasExternalStorage()) { 3031 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 3032 GV->setSection(SA->getName()); 3033 } 3034 3035 // Handle XCore specific ABI requirements. 3036 if (getTriple().getArch() == llvm::Triple::xcore && 3037 D->getLanguageLinkage() == CLanguageLinkage && 3038 D->getType().isConstant(Context) && 3039 isExternallyVisible(D->getLinkageAndVisibility().getLinkage())) 3040 GV->setSection(".cp.rodata"); 3041 3042 // Check if we a have a const declaration with an initializer, we may be 3043 // able to emit it as available_externally to expose it's value to the 3044 // optimizer. 3045 if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() && 3046 D->getType().isConstQualified() && !GV->hasInitializer() && 3047 !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) { 3048 const auto *Record = 3049 Context.getBaseElementType(D->getType())->getAsCXXRecordDecl(); 3050 bool HasMutableFields = Record && Record->hasMutableFields(); 3051 if (!HasMutableFields) { 3052 const VarDecl *InitDecl; 3053 const Expr *InitExpr = D->getAnyInitializer(InitDecl); 3054 if (InitExpr) { 3055 ConstantEmitter emitter(*this); 3056 llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl); 3057 if (Init) { 3058 auto *InitType = Init->getType(); 3059 if (GV->getType()->getElementType() != InitType) { 3060 // The type of the initializer does not match the definition. 3061 // This happens when an initializer has a different type from 3062 // the type of the global (because of padding at the end of a 3063 // structure for instance). 3064 GV->setName(StringRef()); 3065 // Make a new global with the correct type, this is now guaranteed 3066 // to work. 3067 auto *NewGV = cast<llvm::GlobalVariable>( 3068 GetAddrOfGlobalVar(D, InitType, IsForDefinition)); 3069 3070 // Erase the old global, since it is no longer used. 3071 GV->eraseFromParent(); 3072 GV = NewGV; 3073 } else { 3074 GV->setInitializer(Init); 3075 GV->setConstant(true); 3076 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage); 3077 } 3078 emitter.finalize(GV); 3079 } 3080 } 3081 } 3082 } 3083 } 3084 3085 LangAS ExpectedAS = 3086 D ? D->getType().getAddressSpace() 3087 : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default); 3088 assert(getContext().getTargetAddressSpace(ExpectedAS) == 3089 Ty->getPointerAddressSpace()); 3090 if (AddrSpace != ExpectedAS) 3091 return getTargetCodeGenInfo().performAddrSpaceCast(*this, GV, AddrSpace, 3092 ExpectedAS, Ty); 3093 3094 return GV; 3095 } 3096 3097 llvm::Constant * 3098 CodeGenModule::GetAddrOfGlobal(GlobalDecl GD, 3099 ForDefinition_t IsForDefinition) { 3100 const Decl *D = GD.getDecl(); 3101 if (isa<CXXConstructorDecl>(D)) 3102 return getAddrOfCXXStructor(cast<CXXConstructorDecl>(D), 3103 getFromCtorType(GD.getCtorType()), 3104 /*FnInfo=*/nullptr, /*FnType=*/nullptr, 3105 /*DontDefer=*/false, IsForDefinition); 3106 else if (isa<CXXDestructorDecl>(D)) 3107 return getAddrOfCXXStructor(cast<CXXDestructorDecl>(D), 3108 getFromDtorType(GD.getDtorType()), 3109 /*FnInfo=*/nullptr, /*FnType=*/nullptr, 3110 /*DontDefer=*/false, IsForDefinition); 3111 else if (isa<CXXMethodDecl>(D)) { 3112 auto FInfo = &getTypes().arrangeCXXMethodDeclaration( 3113 cast<CXXMethodDecl>(D)); 3114 auto Ty = getTypes().GetFunctionType(*FInfo); 3115 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false, 3116 IsForDefinition); 3117 } else if (isa<FunctionDecl>(D)) { 3118 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 3119 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 3120 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false, 3121 IsForDefinition); 3122 } else 3123 return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr, 3124 IsForDefinition); 3125 } 3126 3127 llvm::GlobalVariable *CodeGenModule::CreateOrReplaceCXXRuntimeVariable( 3128 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, 3129 unsigned Alignment) { 3130 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 3131 llvm::GlobalVariable *OldGV = nullptr; 3132 3133 if (GV) { 3134 // Check if the variable has the right type. 3135 if (GV->getType()->getElementType() == Ty) 3136 return GV; 3137 3138 // Because C++ name mangling, the only way we can end up with an already 3139 // existing global with the same name is if it has been declared extern "C". 3140 assert(GV->isDeclaration() && "Declaration has wrong type!"); 3141 OldGV = GV; 3142 } 3143 3144 // Create a new variable. 3145 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 3146 Linkage, nullptr, Name); 3147 3148 if (OldGV) { 3149 // Replace occurrences of the old variable if needed. 3150 GV->takeName(OldGV); 3151 3152 if (!OldGV->use_empty()) { 3153 llvm::Constant *NewPtrForOldDecl = 3154 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 3155 OldGV->replaceAllUsesWith(NewPtrForOldDecl); 3156 } 3157 3158 OldGV->eraseFromParent(); 3159 } 3160 3161 if (supportsCOMDAT() && GV->isWeakForLinker() && 3162 !GV->hasAvailableExternallyLinkage()) 3163 GV->setComdat(TheModule.getOrInsertComdat(GV->getName())); 3164 3165 GV->setAlignment(Alignment); 3166 3167 return GV; 3168 } 3169 3170 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 3171 /// given global variable. If Ty is non-null and if the global doesn't exist, 3172 /// then it will be created with the specified type instead of whatever the 3173 /// normal requested type would be. If IsForDefinition is true, it is guaranteed 3174 /// that an actual global with type Ty will be returned, not conversion of a 3175 /// variable with the same mangled name but some other type. 3176 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 3177 llvm::Type *Ty, 3178 ForDefinition_t IsForDefinition) { 3179 assert(D->hasGlobalStorage() && "Not a global variable"); 3180 QualType ASTTy = D->getType(); 3181 if (!Ty) 3182 Ty = getTypes().ConvertTypeForMem(ASTTy); 3183 3184 llvm::PointerType *PTy = 3185 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 3186 3187 StringRef MangledName = getMangledName(D); 3188 return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition); 3189 } 3190 3191 /// CreateRuntimeVariable - Create a new runtime global variable with the 3192 /// specified type and name. 3193 llvm::Constant * 3194 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, 3195 StringRef Name) { 3196 auto *Ret = 3197 GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr); 3198 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts())); 3199 return Ret; 3200 } 3201 3202 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 3203 assert(!D->getInit() && "Cannot emit definite definitions here!"); 3204 3205 StringRef MangledName = getMangledName(D); 3206 llvm::GlobalValue *GV = GetGlobalValue(MangledName); 3207 3208 // We already have a definition, not declaration, with the same mangled name. 3209 // Emitting of declaration is not required (and actually overwrites emitted 3210 // definition). 3211 if (GV && !GV->isDeclaration()) 3212 return; 3213 3214 // If we have not seen a reference to this variable yet, place it into the 3215 // deferred declarations table to be emitted if needed later. 3216 if (!MustBeEmitted(D) && !GV) { 3217 DeferredDecls[MangledName] = D; 3218 return; 3219 } 3220 3221 // The tentative definition is the only definition. 3222 EmitGlobalVarDefinition(D); 3223 } 3224 3225 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { 3226 return Context.toCharUnitsFromBits( 3227 getDataLayout().getTypeStoreSizeInBits(Ty)); 3228 } 3229 3230 LangAS CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D) { 3231 LangAS AddrSpace = LangAS::Default; 3232 if (LangOpts.OpenCL) { 3233 AddrSpace = D ? D->getType().getAddressSpace() : LangAS::opencl_global; 3234 assert(AddrSpace == LangAS::opencl_global || 3235 AddrSpace == LangAS::opencl_constant || 3236 AddrSpace == LangAS::opencl_local || 3237 AddrSpace >= LangAS::FirstTargetAddressSpace); 3238 return AddrSpace; 3239 } 3240 3241 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) { 3242 if (D && D->hasAttr<CUDAConstantAttr>()) 3243 return LangAS::cuda_constant; 3244 else if (D && D->hasAttr<CUDASharedAttr>()) 3245 return LangAS::cuda_shared; 3246 else if (D && D->hasAttr<CUDADeviceAttr>()) 3247 return LangAS::cuda_device; 3248 else if (D && D->getType().isConstQualified()) 3249 return LangAS::cuda_constant; 3250 else 3251 return LangAS::cuda_device; 3252 } 3253 3254 return getTargetCodeGenInfo().getGlobalVarAddressSpace(*this, D); 3255 } 3256 3257 LangAS CodeGenModule::getStringLiteralAddressSpace() const { 3258 // OpenCL v1.2 s6.5.3: a string literal is in the constant address space. 3259 if (LangOpts.OpenCL) 3260 return LangAS::opencl_constant; 3261 if (auto AS = getTarget().getConstantAddressSpace()) 3262 return AS.getValue(); 3263 return LangAS::Default; 3264 } 3265 3266 // In address space agnostic languages, string literals are in default address 3267 // space in AST. However, certain targets (e.g. amdgcn) request them to be 3268 // emitted in constant address space in LLVM IR. To be consistent with other 3269 // parts of AST, string literal global variables in constant address space 3270 // need to be casted to default address space before being put into address 3271 // map and referenced by other part of CodeGen. 3272 // In OpenCL, string literals are in constant address space in AST, therefore 3273 // they should not be casted to default address space. 3274 static llvm::Constant * 3275 castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM, 3276 llvm::GlobalVariable *GV) { 3277 llvm::Constant *Cast = GV; 3278 if (!CGM.getLangOpts().OpenCL) { 3279 if (auto AS = CGM.getTarget().getConstantAddressSpace()) { 3280 if (AS != LangAS::Default) 3281 Cast = CGM.getTargetCodeGenInfo().performAddrSpaceCast( 3282 CGM, GV, AS.getValue(), LangAS::Default, 3283 GV->getValueType()->getPointerTo( 3284 CGM.getContext().getTargetAddressSpace(LangAS::Default))); 3285 } 3286 } 3287 return Cast; 3288 } 3289 3290 template<typename SomeDecl> 3291 void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D, 3292 llvm::GlobalValue *GV) { 3293 if (!getLangOpts().CPlusPlus) 3294 return; 3295 3296 // Must have 'used' attribute, or else inline assembly can't rely on 3297 // the name existing. 3298 if (!D->template hasAttr<UsedAttr>()) 3299 return; 3300 3301 // Must have internal linkage and an ordinary name. 3302 if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage) 3303 return; 3304 3305 // Must be in an extern "C" context. Entities declared directly within 3306 // a record are not extern "C" even if the record is in such a context. 3307 const SomeDecl *First = D->getFirstDecl(); 3308 if (First->getDeclContext()->isRecord() || !First->isInExternCContext()) 3309 return; 3310 3311 // OK, this is an internal linkage entity inside an extern "C" linkage 3312 // specification. Make a note of that so we can give it the "expected" 3313 // mangled name if nothing else is using that name. 3314 std::pair<StaticExternCMap::iterator, bool> R = 3315 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV)); 3316 3317 // If we have multiple internal linkage entities with the same name 3318 // in extern "C" regions, none of them gets that name. 3319 if (!R.second) 3320 R.first->second = nullptr; 3321 } 3322 3323 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) { 3324 if (!CGM.supportsCOMDAT()) 3325 return false; 3326 3327 if (D.hasAttr<SelectAnyAttr>()) 3328 return true; 3329 3330 GVALinkage Linkage; 3331 if (auto *VD = dyn_cast<VarDecl>(&D)) 3332 Linkage = CGM.getContext().GetGVALinkageForVariable(VD); 3333 else 3334 Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D)); 3335 3336 switch (Linkage) { 3337 case GVA_Internal: 3338 case GVA_AvailableExternally: 3339 case GVA_StrongExternal: 3340 return false; 3341 case GVA_DiscardableODR: 3342 case GVA_StrongODR: 3343 return true; 3344 } 3345 llvm_unreachable("No such linkage"); 3346 } 3347 3348 void CodeGenModule::maybeSetTrivialComdat(const Decl &D, 3349 llvm::GlobalObject &GO) { 3350 if (!shouldBeInCOMDAT(*this, D)) 3351 return; 3352 GO.setComdat(TheModule.getOrInsertComdat(GO.getName())); 3353 } 3354 3355 /// Pass IsTentative as true if you want to create a tentative definition. 3356 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D, 3357 bool IsTentative) { 3358 // OpenCL global variables of sampler type are translated to function calls, 3359 // therefore no need to be translated. 3360 QualType ASTTy = D->getType(); 3361 if (getLangOpts().OpenCL && ASTTy->isSamplerT()) 3362 return; 3363 3364 // If this is OpenMP device, check if it is legal to emit this global 3365 // normally. 3366 if (LangOpts.OpenMPIsDevice && OpenMPRuntime && 3367 OpenMPRuntime->emitTargetGlobalVariable(D)) 3368 return; 3369 3370 llvm::Constant *Init = nullptr; 3371 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 3372 bool NeedsGlobalCtor = false; 3373 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor(); 3374 3375 const VarDecl *InitDecl; 3376 const Expr *InitExpr = D->getAnyInitializer(InitDecl); 3377 3378 Optional<ConstantEmitter> emitter; 3379 3380 // CUDA E.2.4.1 "__shared__ variables cannot have an initialization 3381 // as part of their declaration." Sema has already checked for 3382 // error cases, so we just need to set Init to UndefValue. 3383 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice && 3384 D->hasAttr<CUDASharedAttr>()) 3385 Init = llvm::UndefValue::get(getTypes().ConvertType(ASTTy)); 3386 else if (!InitExpr) { 3387 // This is a tentative definition; tentative definitions are 3388 // implicitly initialized with { 0 }. 3389 // 3390 // Note that tentative definitions are only emitted at the end of 3391 // a translation unit, so they should never have incomplete 3392 // type. In addition, EmitTentativeDefinition makes sure that we 3393 // never attempt to emit a tentative definition if a real one 3394 // exists. A use may still exists, however, so we still may need 3395 // to do a RAUW. 3396 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 3397 Init = EmitNullConstant(D->getType()); 3398 } else { 3399 initializedGlobalDecl = GlobalDecl(D); 3400 emitter.emplace(*this); 3401 Init = emitter->tryEmitForInitializer(*InitDecl); 3402 3403 if (!Init) { 3404 QualType T = InitExpr->getType(); 3405 if (D->getType()->isReferenceType()) 3406 T = D->getType(); 3407 3408 if (getLangOpts().CPlusPlus) { 3409 Init = EmitNullConstant(T); 3410 NeedsGlobalCtor = true; 3411 } else { 3412 ErrorUnsupported(D, "static initializer"); 3413 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 3414 } 3415 } else { 3416 // We don't need an initializer, so remove the entry for the delayed 3417 // initializer position (just in case this entry was delayed) if we 3418 // also don't need to register a destructor. 3419 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor) 3420 DelayedCXXInitPosition.erase(D); 3421 } 3422 } 3423 3424 llvm::Type* InitType = Init->getType(); 3425 llvm::Constant *Entry = 3426 GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative)); 3427 3428 // Strip off a bitcast if we got one back. 3429 if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 3430 assert(CE->getOpcode() == llvm::Instruction::BitCast || 3431 CE->getOpcode() == llvm::Instruction::AddrSpaceCast || 3432 // All zero index gep. 3433 CE->getOpcode() == llvm::Instruction::GetElementPtr); 3434 Entry = CE->getOperand(0); 3435 } 3436 3437 // Entry is now either a Function or GlobalVariable. 3438 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry); 3439 3440 // We have a definition after a declaration with the wrong type. 3441 // We must make a new GlobalVariable* and update everything that used OldGV 3442 // (a declaration or tentative definition) with the new GlobalVariable* 3443 // (which will be a definition). 3444 // 3445 // This happens if there is a prototype for a global (e.g. 3446 // "extern int x[];") and then a definition of a different type (e.g. 3447 // "int x[10];"). This also happens when an initializer has a different type 3448 // from the type of the global (this happens with unions). 3449 if (!GV || GV->getType()->getElementType() != InitType || 3450 GV->getType()->getAddressSpace() != 3451 getContext().getTargetAddressSpace(GetGlobalVarAddressSpace(D))) { 3452 3453 // Move the old entry aside so that we'll create a new one. 3454 Entry->setName(StringRef()); 3455 3456 // Make a new global with the correct type, this is now guaranteed to work. 3457 GV = cast<llvm::GlobalVariable>( 3458 GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative))); 3459 3460 // Replace all uses of the old global with the new global 3461 llvm::Constant *NewPtrForOldDecl = 3462 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 3463 Entry->replaceAllUsesWith(NewPtrForOldDecl); 3464 3465 // Erase the old global, since it is no longer used. 3466 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 3467 } 3468 3469 MaybeHandleStaticInExternC(D, GV); 3470 3471 if (D->hasAttr<AnnotateAttr>()) 3472 AddGlobalAnnotations(D, GV); 3473 3474 // Set the llvm linkage type as appropriate. 3475 llvm::GlobalValue::LinkageTypes Linkage = 3476 getLLVMLinkageVarDefinition(D, GV->isConstant()); 3477 3478 // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on 3479 // the device. [...]" 3480 // CUDA B.2.2 "The __constant__ qualifier, optionally used together with 3481 // __device__, declares a variable that: [...] 3482 // Is accessible from all the threads within the grid and from the host 3483 // through the runtime library (cudaGetSymbolAddress() / cudaGetSymbolSize() 3484 // / cudaMemcpyToSymbol() / cudaMemcpyFromSymbol())." 3485 if (GV && LangOpts.CUDA) { 3486 if (LangOpts.CUDAIsDevice) { 3487 if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) 3488 GV->setExternallyInitialized(true); 3489 } else { 3490 // Host-side shadows of external declarations of device-side 3491 // global variables become internal definitions. These have to 3492 // be internal in order to prevent name conflicts with global 3493 // host variables with the same name in a different TUs. 3494 if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) { 3495 Linkage = llvm::GlobalValue::InternalLinkage; 3496 3497 // Shadow variables and their properties must be registered 3498 // with CUDA runtime. 3499 unsigned Flags = 0; 3500 if (!D->hasDefinition()) 3501 Flags |= CGCUDARuntime::ExternDeviceVar; 3502 if (D->hasAttr<CUDAConstantAttr>()) 3503 Flags |= CGCUDARuntime::ConstantDeviceVar; 3504 getCUDARuntime().registerDeviceVar(*GV, Flags); 3505 } else if (D->hasAttr<CUDASharedAttr>()) 3506 // __shared__ variables are odd. Shadows do get created, but 3507 // they are not registered with the CUDA runtime, so they 3508 // can't really be used to access their device-side 3509 // counterparts. It's not clear yet whether it's nvcc's bug or 3510 // a feature, but we've got to do the same for compatibility. 3511 Linkage = llvm::GlobalValue::InternalLinkage; 3512 } 3513 } 3514 3515 GV->setInitializer(Init); 3516 if (emitter) emitter->finalize(GV); 3517 3518 // If it is safe to mark the global 'constant', do so now. 3519 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor && 3520 isTypeConstant(D->getType(), true)); 3521 3522 // If it is in a read-only section, mark it 'constant'. 3523 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) { 3524 const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()]; 3525 if ((SI.SectionFlags & ASTContext::PSF_Write) == 0) 3526 GV->setConstant(true); 3527 } 3528 3529 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 3530 3531 3532 // On Darwin, if the normal linkage of a C++ thread_local variable is 3533 // LinkOnce or Weak, we keep the normal linkage to prevent multiple 3534 // copies within a linkage unit; otherwise, the backing variable has 3535 // internal linkage and all accesses should just be calls to the 3536 // Itanium-specified entry point, which has the normal linkage of the 3537 // variable. This is to preserve the ability to change the implementation 3538 // behind the scenes. 3539 if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic && 3540 Context.getTargetInfo().getTriple().isOSDarwin() && 3541 !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) && 3542 !llvm::GlobalVariable::isWeakLinkage(Linkage)) 3543 Linkage = llvm::GlobalValue::InternalLinkage; 3544 3545 GV->setLinkage(Linkage); 3546 if (D->hasAttr<DLLImportAttr>()) 3547 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass); 3548 else if (D->hasAttr<DLLExportAttr>()) 3549 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass); 3550 else 3551 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass); 3552 3553 if (Linkage == llvm::GlobalVariable::CommonLinkage) { 3554 // common vars aren't constant even if declared const. 3555 GV->setConstant(false); 3556 // Tentative definition of global variables may be initialized with 3557 // non-zero null pointers. In this case they should have weak linkage 3558 // since common linkage must have zero initializer and must not have 3559 // explicit section therefore cannot have non-zero initial value. 3560 if (!GV->getInitializer()->isNullValue()) 3561 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage); 3562 } 3563 3564 setNonAliasAttributes(D, GV); 3565 3566 if (D->getTLSKind() && !GV->isThreadLocal()) { 3567 if (D->getTLSKind() == VarDecl::TLS_Dynamic) 3568 CXXThreadLocals.push_back(D); 3569 setTLSMode(GV, *D); 3570 } 3571 3572 maybeSetTrivialComdat(*D, *GV); 3573 3574 // Emit the initializer function if necessary. 3575 if (NeedsGlobalCtor || NeedsGlobalDtor) 3576 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor); 3577 3578 SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor); 3579 3580 // Emit global variable debug information. 3581 if (CGDebugInfo *DI = getModuleDebugInfo()) 3582 if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) 3583 DI->EmitGlobalVariable(GV, D); 3584 } 3585 3586 static bool isVarDeclStrongDefinition(const ASTContext &Context, 3587 CodeGenModule &CGM, const VarDecl *D, 3588 bool NoCommon) { 3589 // Don't give variables common linkage if -fno-common was specified unless it 3590 // was overridden by a NoCommon attribute. 3591 if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>()) 3592 return true; 3593 3594 // C11 6.9.2/2: 3595 // A declaration of an identifier for an object that has file scope without 3596 // an initializer, and without a storage-class specifier or with the 3597 // storage-class specifier static, constitutes a tentative definition. 3598 if (D->getInit() || D->hasExternalStorage()) 3599 return true; 3600 3601 // A variable cannot be both common and exist in a section. 3602 if (D->hasAttr<SectionAttr>()) 3603 return true; 3604 3605 // A variable cannot be both common and exist in a section. 3606 // We don't try to determine which is the right section in the front-end. 3607 // If no specialized section name is applicable, it will resort to default. 3608 if (D->hasAttr<PragmaClangBSSSectionAttr>() || 3609 D->hasAttr<PragmaClangDataSectionAttr>() || 3610 D->hasAttr<PragmaClangRodataSectionAttr>()) 3611 return true; 3612 3613 // Thread local vars aren't considered common linkage. 3614 if (D->getTLSKind()) 3615 return true; 3616 3617 // Tentative definitions marked with WeakImportAttr are true definitions. 3618 if (D->hasAttr<WeakImportAttr>()) 3619 return true; 3620 3621 // A variable cannot be both common and exist in a comdat. 3622 if (shouldBeInCOMDAT(CGM, *D)) 3623 return true; 3624 3625 // Declarations with a required alignment do not have common linkage in MSVC 3626 // mode. 3627 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { 3628 if (D->hasAttr<AlignedAttr>()) 3629 return true; 3630 QualType VarType = D->getType(); 3631 if (Context.isAlignmentRequired(VarType)) 3632 return true; 3633 3634 if (const auto *RT = VarType->getAs<RecordType>()) { 3635 const RecordDecl *RD = RT->getDecl(); 3636 for (const FieldDecl *FD : RD->fields()) { 3637 if (FD->isBitField()) 3638 continue; 3639 if (FD->hasAttr<AlignedAttr>()) 3640 return true; 3641 if (Context.isAlignmentRequired(FD->getType())) 3642 return true; 3643 } 3644 } 3645 } 3646 3647 return false; 3648 } 3649 3650 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator( 3651 const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) { 3652 if (Linkage == GVA_Internal) 3653 return llvm::Function::InternalLinkage; 3654 3655 if (D->hasAttr<WeakAttr>()) { 3656 if (IsConstantVariable) 3657 return llvm::GlobalVariable::WeakODRLinkage; 3658 else 3659 return llvm::GlobalVariable::WeakAnyLinkage; 3660 } 3661 3662 // We are guaranteed to have a strong definition somewhere else, 3663 // so we can use available_externally linkage. 3664 if (Linkage == GVA_AvailableExternally) 3665 return llvm::GlobalValue::AvailableExternallyLinkage; 3666 3667 // Note that Apple's kernel linker doesn't support symbol 3668 // coalescing, so we need to avoid linkonce and weak linkages there. 3669 // Normally, this means we just map to internal, but for explicit 3670 // instantiations we'll map to external. 3671 3672 // In C++, the compiler has to emit a definition in every translation unit 3673 // that references the function. We should use linkonce_odr because 3674 // a) if all references in this translation unit are optimized away, we 3675 // don't need to codegen it. b) if the function persists, it needs to be 3676 // merged with other definitions. c) C++ has the ODR, so we know the 3677 // definition is dependable. 3678 if (Linkage == GVA_DiscardableODR) 3679 return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage 3680 : llvm::Function::InternalLinkage; 3681 3682 // An explicit instantiation of a template has weak linkage, since 3683 // explicit instantiations can occur in multiple translation units 3684 // and must all be equivalent. However, we are not allowed to 3685 // throw away these explicit instantiations. 3686 // 3687 // We don't currently support CUDA device code spread out across multiple TUs, 3688 // so say that CUDA templates are either external (for kernels) or internal. 3689 // This lets llvm perform aggressive inter-procedural optimizations. 3690 if (Linkage == GVA_StrongODR) { 3691 if (Context.getLangOpts().AppleKext) 3692 return llvm::Function::ExternalLinkage; 3693 if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice) 3694 return D->hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage 3695 : llvm::Function::InternalLinkage; 3696 return llvm::Function::WeakODRLinkage; 3697 } 3698 3699 // C++ doesn't have tentative definitions and thus cannot have common 3700 // linkage. 3701 if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) && 3702 !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D), 3703 CodeGenOpts.NoCommon)) 3704 return llvm::GlobalVariable::CommonLinkage; 3705 3706 // selectany symbols are externally visible, so use weak instead of 3707 // linkonce. MSVC optimizes away references to const selectany globals, so 3708 // all definitions should be the same and ODR linkage should be used. 3709 // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx 3710 if (D->hasAttr<SelectAnyAttr>()) 3711 return llvm::GlobalVariable::WeakODRLinkage; 3712 3713 // Otherwise, we have strong external linkage. 3714 assert(Linkage == GVA_StrongExternal); 3715 return llvm::GlobalVariable::ExternalLinkage; 3716 } 3717 3718 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition( 3719 const VarDecl *VD, bool IsConstant) { 3720 GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD); 3721 return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant); 3722 } 3723 3724 /// Replace the uses of a function that was declared with a non-proto type. 3725 /// We want to silently drop extra arguments from call sites 3726 static void replaceUsesOfNonProtoConstant(llvm::Constant *old, 3727 llvm::Function *newFn) { 3728 // Fast path. 3729 if (old->use_empty()) return; 3730 3731 llvm::Type *newRetTy = newFn->getReturnType(); 3732 SmallVector<llvm::Value*, 4> newArgs; 3733 SmallVector<llvm::OperandBundleDef, 1> newBundles; 3734 3735 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end(); 3736 ui != ue; ) { 3737 llvm::Value::use_iterator use = ui++; // Increment before the use is erased. 3738 llvm::User *user = use->getUser(); 3739 3740 // Recognize and replace uses of bitcasts. Most calls to 3741 // unprototyped functions will use bitcasts. 3742 if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) { 3743 if (bitcast->getOpcode() == llvm::Instruction::BitCast) 3744 replaceUsesOfNonProtoConstant(bitcast, newFn); 3745 continue; 3746 } 3747 3748 // Recognize calls to the function. 3749 llvm::CallSite callSite(user); 3750 if (!callSite) continue; 3751 if (!callSite.isCallee(&*use)) continue; 3752 3753 // If the return types don't match exactly, then we can't 3754 // transform this call unless it's dead. 3755 if (callSite->getType() != newRetTy && !callSite->use_empty()) 3756 continue; 3757 3758 // Get the call site's attribute list. 3759 SmallVector<llvm::AttributeSet, 8> newArgAttrs; 3760 llvm::AttributeList oldAttrs = callSite.getAttributes(); 3761 3762 // If the function was passed too few arguments, don't transform. 3763 unsigned newNumArgs = newFn->arg_size(); 3764 if (callSite.arg_size() < newNumArgs) continue; 3765 3766 // If extra arguments were passed, we silently drop them. 3767 // If any of the types mismatch, we don't transform. 3768 unsigned argNo = 0; 3769 bool dontTransform = false; 3770 for (llvm::Argument &A : newFn->args()) { 3771 if (callSite.getArgument(argNo)->getType() != A.getType()) { 3772 dontTransform = true; 3773 break; 3774 } 3775 3776 // Add any parameter attributes. 3777 newArgAttrs.push_back(oldAttrs.getParamAttributes(argNo)); 3778 argNo++; 3779 } 3780 if (dontTransform) 3781 continue; 3782 3783 // Okay, we can transform this. Create the new call instruction and copy 3784 // over the required information. 3785 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo); 3786 3787 // Copy over any operand bundles. 3788 callSite.getOperandBundlesAsDefs(newBundles); 3789 3790 llvm::CallSite newCall; 3791 if (callSite.isCall()) { 3792 newCall = llvm::CallInst::Create(newFn, newArgs, newBundles, "", 3793 callSite.getInstruction()); 3794 } else { 3795 auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction()); 3796 newCall = llvm::InvokeInst::Create(newFn, 3797 oldInvoke->getNormalDest(), 3798 oldInvoke->getUnwindDest(), 3799 newArgs, newBundles, "", 3800 callSite.getInstruction()); 3801 } 3802 newArgs.clear(); // for the next iteration 3803 3804 if (!newCall->getType()->isVoidTy()) 3805 newCall->takeName(callSite.getInstruction()); 3806 newCall.setAttributes(llvm::AttributeList::get( 3807 newFn->getContext(), oldAttrs.getFnAttributes(), 3808 oldAttrs.getRetAttributes(), newArgAttrs)); 3809 newCall.setCallingConv(callSite.getCallingConv()); 3810 3811 // Finally, remove the old call, replacing any uses with the new one. 3812 if (!callSite->use_empty()) 3813 callSite->replaceAllUsesWith(newCall.getInstruction()); 3814 3815 // Copy debug location attached to CI. 3816 if (callSite->getDebugLoc()) 3817 newCall->setDebugLoc(callSite->getDebugLoc()); 3818 3819 callSite->eraseFromParent(); 3820 } 3821 } 3822 3823 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 3824 /// implement a function with no prototype, e.g. "int foo() {}". If there are 3825 /// existing call uses of the old function in the module, this adjusts them to 3826 /// call the new function directly. 3827 /// 3828 /// This is not just a cleanup: the always_inline pass requires direct calls to 3829 /// functions to be able to inline them. If there is a bitcast in the way, it 3830 /// won't inline them. Instcombine normally deletes these calls, but it isn't 3831 /// run at -O0. 3832 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 3833 llvm::Function *NewFn) { 3834 // If we're redefining a global as a function, don't transform it. 3835 if (!isa<llvm::Function>(Old)) return; 3836 3837 replaceUsesOfNonProtoConstant(Old, NewFn); 3838 } 3839 3840 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 3841 auto DK = VD->isThisDeclarationADefinition(); 3842 if (DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>()) 3843 return; 3844 3845 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind(); 3846 // If we have a definition, this might be a deferred decl. If the 3847 // instantiation is explicit, make sure we emit it at the end. 3848 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition) 3849 GetAddrOfGlobalVar(VD); 3850 3851 EmitTopLevelDecl(VD); 3852 } 3853 3854 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, 3855 llvm::GlobalValue *GV) { 3856 const auto *D = cast<FunctionDecl>(GD.getDecl()); 3857 3858 // Compute the function info and LLVM type. 3859 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 3860 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 3861 3862 // Get or create the prototype for the function. 3863 if (!GV || (GV->getType()->getElementType() != Ty)) 3864 GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, 3865 /*DontDefer=*/true, 3866 ForDefinition)); 3867 3868 // Already emitted. 3869 if (!GV->isDeclaration()) 3870 return; 3871 3872 // We need to set linkage and visibility on the function before 3873 // generating code for it because various parts of IR generation 3874 // want to propagate this information down (e.g. to local static 3875 // declarations). 3876 auto *Fn = cast<llvm::Function>(GV); 3877 setFunctionLinkage(GD, Fn); 3878 3879 // FIXME: this is redundant with part of setFunctionDefinitionAttributes 3880 setGVProperties(Fn, GD); 3881 3882 MaybeHandleStaticInExternC(D, Fn); 3883 3884 3885 maybeSetTrivialComdat(*D, *Fn); 3886 3887 CodeGenFunction(*this).GenerateCode(D, Fn, FI); 3888 3889 setNonAliasAttributes(GD, Fn); 3890 SetLLVMFunctionAttributesForDefinition(D, Fn); 3891 3892 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 3893 AddGlobalCtor(Fn, CA->getPriority()); 3894 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 3895 AddGlobalDtor(Fn, DA->getPriority()); 3896 if (D->hasAttr<AnnotateAttr>()) 3897 AddGlobalAnnotations(D, Fn); 3898 3899 if (D->isCPUSpecificMultiVersion()) { 3900 auto *Spec = D->getAttr<CPUSpecificAttr>(); 3901 // If there is another specific version we need to emit, do so here. 3902 if (Spec->ActiveArgIndex + 1 < Spec->cpus_size()) { 3903 ++Spec->ActiveArgIndex; 3904 EmitGlobalFunctionDefinition(GD, nullptr); 3905 } 3906 } 3907 } 3908 3909 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 3910 const auto *D = cast<ValueDecl>(GD.getDecl()); 3911 const AliasAttr *AA = D->getAttr<AliasAttr>(); 3912 assert(AA && "Not an alias?"); 3913 3914 StringRef MangledName = getMangledName(GD); 3915 3916 if (AA->getAliasee() == MangledName) { 3917 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0; 3918 return; 3919 } 3920 3921 // If there is a definition in the module, then it wins over the alias. 3922 // This is dubious, but allow it to be safe. Just ignore the alias. 3923 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 3924 if (Entry && !Entry->isDeclaration()) 3925 return; 3926 3927 Aliases.push_back(GD); 3928 3929 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 3930 3931 // Create a reference to the named value. This ensures that it is emitted 3932 // if a deferred decl. 3933 llvm::Constant *Aliasee; 3934 if (isa<llvm::FunctionType>(DeclTy)) 3935 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD, 3936 /*ForVTable=*/false); 3937 else 3938 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 3939 llvm::PointerType::getUnqual(DeclTy), 3940 /*D=*/nullptr); 3941 3942 // Create the new alias itself, but don't set a name yet. 3943 auto *GA = llvm::GlobalAlias::create( 3944 DeclTy, 0, llvm::Function::ExternalLinkage, "", Aliasee, &getModule()); 3945 3946 if (Entry) { 3947 if (GA->getAliasee() == Entry) { 3948 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0; 3949 return; 3950 } 3951 3952 assert(Entry->isDeclaration()); 3953 3954 // If there is a declaration in the module, then we had an extern followed 3955 // by the alias, as in: 3956 // extern int test6(); 3957 // ... 3958 // int test6() __attribute__((alias("test7"))); 3959 // 3960 // Remove it and replace uses of it with the alias. 3961 GA->takeName(Entry); 3962 3963 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 3964 Entry->getType())); 3965 Entry->eraseFromParent(); 3966 } else { 3967 GA->setName(MangledName); 3968 } 3969 3970 // Set attributes which are particular to an alias; this is a 3971 // specialization of the attributes which may be set on a global 3972 // variable/function. 3973 if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() || 3974 D->isWeakImported()) { 3975 GA->setLinkage(llvm::Function::WeakAnyLinkage); 3976 } 3977 3978 if (const auto *VD = dyn_cast<VarDecl>(D)) 3979 if (VD->getTLSKind()) 3980 setTLSMode(GA, *VD); 3981 3982 SetCommonAttributes(GD, GA); 3983 } 3984 3985 void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) { 3986 const auto *D = cast<ValueDecl>(GD.getDecl()); 3987 const IFuncAttr *IFA = D->getAttr<IFuncAttr>(); 3988 assert(IFA && "Not an ifunc?"); 3989 3990 StringRef MangledName = getMangledName(GD); 3991 3992 if (IFA->getResolver() == MangledName) { 3993 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1; 3994 return; 3995 } 3996 3997 // Report an error if some definition overrides ifunc. 3998 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 3999 if (Entry && !Entry->isDeclaration()) { 4000 GlobalDecl OtherGD; 4001 if (lookupRepresentativeDecl(MangledName, OtherGD) && 4002 DiagnosedConflictingDefinitions.insert(GD).second) { 4003 Diags.Report(D->getLocation(), diag::err_duplicate_mangled_name) 4004 << MangledName; 4005 Diags.Report(OtherGD.getDecl()->getLocation(), 4006 diag::note_previous_definition); 4007 } 4008 return; 4009 } 4010 4011 Aliases.push_back(GD); 4012 4013 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 4014 llvm::Constant *Resolver = 4015 GetOrCreateLLVMFunction(IFA->getResolver(), DeclTy, GD, 4016 /*ForVTable=*/false); 4017 llvm::GlobalIFunc *GIF = 4018 llvm::GlobalIFunc::create(DeclTy, 0, llvm::Function::ExternalLinkage, 4019 "", Resolver, &getModule()); 4020 if (Entry) { 4021 if (GIF->getResolver() == Entry) { 4022 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1; 4023 return; 4024 } 4025 assert(Entry->isDeclaration()); 4026 4027 // If there is a declaration in the module, then we had an extern followed 4028 // by the ifunc, as in: 4029 // extern int test(); 4030 // ... 4031 // int test() __attribute__((ifunc("resolver"))); 4032 // 4033 // Remove it and replace uses of it with the ifunc. 4034 GIF->takeName(Entry); 4035 4036 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GIF, 4037 Entry->getType())); 4038 Entry->eraseFromParent(); 4039 } else 4040 GIF->setName(MangledName); 4041 4042 SetCommonAttributes(GD, GIF); 4043 } 4044 4045 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID, 4046 ArrayRef<llvm::Type*> Tys) { 4047 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID, 4048 Tys); 4049 } 4050 4051 static llvm::StringMapEntry<llvm::GlobalVariable *> & 4052 GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map, 4053 const StringLiteral *Literal, bool TargetIsLSB, 4054 bool &IsUTF16, unsigned &StringLength) { 4055 StringRef String = Literal->getString(); 4056 unsigned NumBytes = String.size(); 4057 4058 // Check for simple case. 4059 if (!Literal->containsNonAsciiOrNull()) { 4060 StringLength = NumBytes; 4061 return *Map.insert(std::make_pair(String, nullptr)).first; 4062 } 4063 4064 // Otherwise, convert the UTF8 literals into a string of shorts. 4065 IsUTF16 = true; 4066 4067 SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls. 4068 const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data(); 4069 llvm::UTF16 *ToPtr = &ToBuf[0]; 4070 4071 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr, 4072 ToPtr + NumBytes, llvm::strictConversion); 4073 4074 // ConvertUTF8toUTF16 returns the length in ToPtr. 4075 StringLength = ToPtr - &ToBuf[0]; 4076 4077 // Add an explicit null. 4078 *ToPtr = 0; 4079 return *Map.insert(std::make_pair( 4080 StringRef(reinterpret_cast<const char *>(ToBuf.data()), 4081 (StringLength + 1) * 2), 4082 nullptr)).first; 4083 } 4084 4085 ConstantAddress 4086 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 4087 unsigned StringLength = 0; 4088 bool isUTF16 = false; 4089 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = 4090 GetConstantCFStringEntry(CFConstantStringMap, Literal, 4091 getDataLayout().isLittleEndian(), isUTF16, 4092 StringLength); 4093 4094 if (auto *C = Entry.second) 4095 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment())); 4096 4097 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 4098 llvm::Constant *Zeros[] = { Zero, Zero }; 4099 4100 // If we don't already have it, get __CFConstantStringClassReference. 4101 if (!CFConstantStringClassRef) { 4102 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 4103 Ty = llvm::ArrayType::get(Ty, 0); 4104 llvm::GlobalValue *GV = cast<llvm::GlobalValue>( 4105 CreateRuntimeVariable(Ty, "__CFConstantStringClassReference")); 4106 4107 if (getTriple().isOSBinFormatCOFF()) { 4108 IdentifierInfo &II = getContext().Idents.get(GV->getName()); 4109 TranslationUnitDecl *TUDecl = getContext().getTranslationUnitDecl(); 4110 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); 4111 4112 const VarDecl *VD = nullptr; 4113 for (const auto &Result : DC->lookup(&II)) 4114 if ((VD = dyn_cast<VarDecl>(Result))) 4115 break; 4116 4117 if (!VD || !VD->hasAttr<DLLExportAttr>()) { 4118 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 4119 GV->setLinkage(llvm::GlobalValue::ExternalLinkage); 4120 } else { 4121 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 4122 GV->setLinkage(llvm::GlobalValue::ExternalLinkage); 4123 } 4124 } 4125 setDSOLocal(GV); 4126 4127 // Decay array -> ptr 4128 CFConstantStringClassRef = 4129 llvm::ConstantExpr::getGetElementPtr(Ty, GV, Zeros); 4130 } 4131 4132 QualType CFTy = getContext().getCFConstantStringType(); 4133 4134 auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 4135 4136 ConstantInitBuilder Builder(*this); 4137 auto Fields = Builder.beginStruct(STy); 4138 4139 // Class pointer. 4140 Fields.add(cast<llvm::ConstantExpr>(CFConstantStringClassRef)); 4141 4142 // Flags. 4143 Fields.addInt(IntTy, isUTF16 ? 0x07d0 : 0x07C8); 4144 4145 // String pointer. 4146 llvm::Constant *C = nullptr; 4147 if (isUTF16) { 4148 auto Arr = llvm::makeArrayRef( 4149 reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())), 4150 Entry.first().size() / 2); 4151 C = llvm::ConstantDataArray::get(VMContext, Arr); 4152 } else { 4153 C = llvm::ConstantDataArray::getString(VMContext, Entry.first()); 4154 } 4155 4156 // Note: -fwritable-strings doesn't make the backing store strings of 4157 // CFStrings writable. (See <rdar://problem/10657500>) 4158 auto *GV = 4159 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, 4160 llvm::GlobalValue::PrivateLinkage, C, ".str"); 4161 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 4162 // Don't enforce the target's minimum global alignment, since the only use 4163 // of the string is via this class initializer. 4164 CharUnits Align = isUTF16 4165 ? getContext().getTypeAlignInChars(getContext().ShortTy) 4166 : getContext().getTypeAlignInChars(getContext().CharTy); 4167 GV->setAlignment(Align.getQuantity()); 4168 4169 // FIXME: We set the section explicitly to avoid a bug in ld64 224.1. 4170 // Without it LLVM can merge the string with a non unnamed_addr one during 4171 // LTO. Doing that changes the section it ends in, which surprises ld64. 4172 if (getTriple().isOSBinFormatMachO()) 4173 GV->setSection(isUTF16 ? "__TEXT,__ustring" 4174 : "__TEXT,__cstring,cstring_literals"); 4175 4176 // String. 4177 llvm::Constant *Str = 4178 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros); 4179 4180 if (isUTF16) 4181 // Cast the UTF16 string to the correct type. 4182 Str = llvm::ConstantExpr::getBitCast(Str, Int8PtrTy); 4183 Fields.add(Str); 4184 4185 // String length. 4186 auto Ty = getTypes().ConvertType(getContext().LongTy); 4187 Fields.addInt(cast<llvm::IntegerType>(Ty), StringLength); 4188 4189 CharUnits Alignment = getPointerAlign(); 4190 4191 // The struct. 4192 GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment, 4193 /*isConstant=*/false, 4194 llvm::GlobalVariable::PrivateLinkage); 4195 switch (getTriple().getObjectFormat()) { 4196 case llvm::Triple::UnknownObjectFormat: 4197 llvm_unreachable("unknown file format"); 4198 case llvm::Triple::COFF: 4199 case llvm::Triple::ELF: 4200 case llvm::Triple::Wasm: 4201 GV->setSection("cfstring"); 4202 break; 4203 case llvm::Triple::MachO: 4204 GV->setSection("__DATA,__cfstring"); 4205 break; 4206 } 4207 Entry.second = GV; 4208 4209 return ConstantAddress(GV, Alignment); 4210 } 4211 4212 bool CodeGenModule::getExpressionLocationsEnabled() const { 4213 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo; 4214 } 4215 4216 QualType CodeGenModule::getObjCFastEnumerationStateType() { 4217 if (ObjCFastEnumerationStateType.isNull()) { 4218 RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState"); 4219 D->startDefinition(); 4220 4221 QualType FieldTypes[] = { 4222 Context.UnsignedLongTy, 4223 Context.getPointerType(Context.getObjCIdType()), 4224 Context.getPointerType(Context.UnsignedLongTy), 4225 Context.getConstantArrayType(Context.UnsignedLongTy, 4226 llvm::APInt(32, 5), ArrayType::Normal, 0) 4227 }; 4228 4229 for (size_t i = 0; i < 4; ++i) { 4230 FieldDecl *Field = FieldDecl::Create(Context, 4231 D, 4232 SourceLocation(), 4233 SourceLocation(), nullptr, 4234 FieldTypes[i], /*TInfo=*/nullptr, 4235 /*BitWidth=*/nullptr, 4236 /*Mutable=*/false, 4237 ICIS_NoInit); 4238 Field->setAccess(AS_public); 4239 D->addDecl(Field); 4240 } 4241 4242 D->completeDefinition(); 4243 ObjCFastEnumerationStateType = Context.getTagDeclType(D); 4244 } 4245 4246 return ObjCFastEnumerationStateType; 4247 } 4248 4249 llvm::Constant * 4250 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { 4251 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 4252 4253 // Don't emit it as the address of the string, emit the string data itself 4254 // as an inline array. 4255 if (E->getCharByteWidth() == 1) { 4256 SmallString<64> Str(E->getString()); 4257 4258 // Resize the string to the right size, which is indicated by its type. 4259 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType()); 4260 Str.resize(CAT->getSize().getZExtValue()); 4261 return llvm::ConstantDataArray::getString(VMContext, Str, false); 4262 } 4263 4264 auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); 4265 llvm::Type *ElemTy = AType->getElementType(); 4266 unsigned NumElements = AType->getNumElements(); 4267 4268 // Wide strings have either 2-byte or 4-byte elements. 4269 if (ElemTy->getPrimitiveSizeInBits() == 16) { 4270 SmallVector<uint16_t, 32> Elements; 4271 Elements.reserve(NumElements); 4272 4273 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 4274 Elements.push_back(E->getCodeUnit(i)); 4275 Elements.resize(NumElements); 4276 return llvm::ConstantDataArray::get(VMContext, Elements); 4277 } 4278 4279 assert(ElemTy->getPrimitiveSizeInBits() == 32); 4280 SmallVector<uint32_t, 32> Elements; 4281 Elements.reserve(NumElements); 4282 4283 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 4284 Elements.push_back(E->getCodeUnit(i)); 4285 Elements.resize(NumElements); 4286 return llvm::ConstantDataArray::get(VMContext, Elements); 4287 } 4288 4289 static llvm::GlobalVariable * 4290 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, 4291 CodeGenModule &CGM, StringRef GlobalName, 4292 CharUnits Alignment) { 4293 unsigned AddrSpace = CGM.getContext().getTargetAddressSpace( 4294 CGM.getStringLiteralAddressSpace()); 4295 4296 llvm::Module &M = CGM.getModule(); 4297 // Create a global variable for this string 4298 auto *GV = new llvm::GlobalVariable( 4299 M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName, 4300 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace); 4301 GV->setAlignment(Alignment.getQuantity()); 4302 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 4303 if (GV->isWeakForLinker()) { 4304 assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals"); 4305 GV->setComdat(M.getOrInsertComdat(GV->getName())); 4306 } 4307 CGM.setDSOLocal(GV); 4308 4309 return GV; 4310 } 4311 4312 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a 4313 /// constant array for the given string literal. 4314 ConstantAddress 4315 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S, 4316 StringRef Name) { 4317 CharUnits Alignment = getContext().getAlignOfGlobalVarInChars(S->getType()); 4318 4319 llvm::Constant *C = GetConstantArrayFromStringLiteral(S); 4320 llvm::GlobalVariable **Entry = nullptr; 4321 if (!LangOpts.WritableStrings) { 4322 Entry = &ConstantStringMap[C]; 4323 if (auto GV = *Entry) { 4324 if (Alignment.getQuantity() > GV->getAlignment()) 4325 GV->setAlignment(Alignment.getQuantity()); 4326 return ConstantAddress(GV, Alignment); 4327 } 4328 } 4329 4330 SmallString<256> MangledNameBuffer; 4331 StringRef GlobalVariableName; 4332 llvm::GlobalValue::LinkageTypes LT; 4333 4334 // Mangle the string literal if that's how the ABI merges duplicate strings. 4335 // Don't do it if they are writable, since we don't want writes in one TU to 4336 // affect strings in another. 4337 if (getCXXABI().getMangleContext().shouldMangleStringLiteral(S) && 4338 !LangOpts.WritableStrings) { 4339 llvm::raw_svector_ostream Out(MangledNameBuffer); 4340 getCXXABI().getMangleContext().mangleStringLiteral(S, Out); 4341 LT = llvm::GlobalValue::LinkOnceODRLinkage; 4342 GlobalVariableName = MangledNameBuffer; 4343 } else { 4344 LT = llvm::GlobalValue::PrivateLinkage; 4345 GlobalVariableName = Name; 4346 } 4347 4348 auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment); 4349 if (Entry) 4350 *Entry = GV; 4351 4352 SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>", 4353 QualType()); 4354 4355 return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV), 4356 Alignment); 4357 } 4358 4359 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 4360 /// array for the given ObjCEncodeExpr node. 4361 ConstantAddress 4362 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 4363 std::string Str; 4364 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 4365 4366 return GetAddrOfConstantCString(Str); 4367 } 4368 4369 /// GetAddrOfConstantCString - Returns a pointer to a character array containing 4370 /// the literal and a terminating '\0' character. 4371 /// The result has pointer to array type. 4372 ConstantAddress CodeGenModule::GetAddrOfConstantCString( 4373 const std::string &Str, const char *GlobalName) { 4374 StringRef StrWithNull(Str.c_str(), Str.size() + 1); 4375 CharUnits Alignment = 4376 getContext().getAlignOfGlobalVarInChars(getContext().CharTy); 4377 4378 llvm::Constant *C = 4379 llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false); 4380 4381 // Don't share any string literals if strings aren't constant. 4382 llvm::GlobalVariable **Entry = nullptr; 4383 if (!LangOpts.WritableStrings) { 4384 Entry = &ConstantStringMap[C]; 4385 if (auto GV = *Entry) { 4386 if (Alignment.getQuantity() > GV->getAlignment()) 4387 GV->setAlignment(Alignment.getQuantity()); 4388 return ConstantAddress(GV, Alignment); 4389 } 4390 } 4391 4392 // Get the default prefix if a name wasn't specified. 4393 if (!GlobalName) 4394 GlobalName = ".str"; 4395 // Create a global variable for this. 4396 auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this, 4397 GlobalName, Alignment); 4398 if (Entry) 4399 *Entry = GV; 4400 4401 return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV), 4402 Alignment); 4403 } 4404 4405 ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary( 4406 const MaterializeTemporaryExpr *E, const Expr *Init) { 4407 assert((E->getStorageDuration() == SD_Static || 4408 E->getStorageDuration() == SD_Thread) && "not a global temporary"); 4409 const auto *VD = cast<VarDecl>(E->getExtendingDecl()); 4410 4411 // If we're not materializing a subobject of the temporary, keep the 4412 // cv-qualifiers from the type of the MaterializeTemporaryExpr. 4413 QualType MaterializedType = Init->getType(); 4414 if (Init == E->GetTemporaryExpr()) 4415 MaterializedType = E->getType(); 4416 4417 CharUnits Align = getContext().getTypeAlignInChars(MaterializedType); 4418 4419 if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E]) 4420 return ConstantAddress(Slot, Align); 4421 4422 // FIXME: If an externally-visible declaration extends multiple temporaries, 4423 // we need to give each temporary the same name in every translation unit (and 4424 // we also need to make the temporaries externally-visible). 4425 SmallString<256> Name; 4426 llvm::raw_svector_ostream Out(Name); 4427 getCXXABI().getMangleContext().mangleReferenceTemporary( 4428 VD, E->getManglingNumber(), Out); 4429 4430 APValue *Value = nullptr; 4431 if (E->getStorageDuration() == SD_Static) { 4432 // We might have a cached constant initializer for this temporary. Note 4433 // that this might have a different value from the value computed by 4434 // evaluating the initializer if the surrounding constant expression 4435 // modifies the temporary. 4436 Value = getContext().getMaterializedTemporaryValue(E, false); 4437 if (Value && Value->isUninit()) 4438 Value = nullptr; 4439 } 4440 4441 // Try evaluating it now, it might have a constant initializer. 4442 Expr::EvalResult EvalResult; 4443 if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) && 4444 !EvalResult.hasSideEffects()) 4445 Value = &EvalResult.Val; 4446 4447 LangAS AddrSpace = 4448 VD ? GetGlobalVarAddressSpace(VD) : MaterializedType.getAddressSpace(); 4449 4450 Optional<ConstantEmitter> emitter; 4451 llvm::Constant *InitialValue = nullptr; 4452 bool Constant = false; 4453 llvm::Type *Type; 4454 if (Value) { 4455 // The temporary has a constant initializer, use it. 4456 emitter.emplace(*this); 4457 InitialValue = emitter->emitForInitializer(*Value, AddrSpace, 4458 MaterializedType); 4459 Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value); 4460 Type = InitialValue->getType(); 4461 } else { 4462 // No initializer, the initialization will be provided when we 4463 // initialize the declaration which performed lifetime extension. 4464 Type = getTypes().ConvertTypeForMem(MaterializedType); 4465 } 4466 4467 // Create a global variable for this lifetime-extended temporary. 4468 llvm::GlobalValue::LinkageTypes Linkage = 4469 getLLVMLinkageVarDefinition(VD, Constant); 4470 if (Linkage == llvm::GlobalVariable::ExternalLinkage) { 4471 const VarDecl *InitVD; 4472 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) && 4473 isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) { 4474 // Temporaries defined inside a class get linkonce_odr linkage because the 4475 // class can be defined in multiple translation units. 4476 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage; 4477 } else { 4478 // There is no need for this temporary to have external linkage if the 4479 // VarDecl has external linkage. 4480 Linkage = llvm::GlobalVariable::InternalLinkage; 4481 } 4482 } 4483 auto TargetAS = getContext().getTargetAddressSpace(AddrSpace); 4484 auto *GV = new llvm::GlobalVariable( 4485 getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(), 4486 /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS); 4487 if (emitter) emitter->finalize(GV); 4488 setGVProperties(GV, VD); 4489 GV->setAlignment(Align.getQuantity()); 4490 if (supportsCOMDAT() && GV->isWeakForLinker()) 4491 GV->setComdat(TheModule.getOrInsertComdat(GV->getName())); 4492 if (VD->getTLSKind()) 4493 setTLSMode(GV, *VD); 4494 llvm::Constant *CV = GV; 4495 if (AddrSpace != LangAS::Default) 4496 CV = getTargetCodeGenInfo().performAddrSpaceCast( 4497 *this, GV, AddrSpace, LangAS::Default, 4498 Type->getPointerTo( 4499 getContext().getTargetAddressSpace(LangAS::Default))); 4500 MaterializedGlobalTemporaryMap[E] = CV; 4501 return ConstantAddress(CV, Align); 4502 } 4503 4504 /// EmitObjCPropertyImplementations - Emit information for synthesized 4505 /// properties for an implementation. 4506 void CodeGenModule::EmitObjCPropertyImplementations(const 4507 ObjCImplementationDecl *D) { 4508 for (const auto *PID : D->property_impls()) { 4509 // Dynamic is just for type-checking. 4510 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 4511 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 4512 4513 // Determine which methods need to be implemented, some may have 4514 // been overridden. Note that ::isPropertyAccessor is not the method 4515 // we want, that just indicates if the decl came from a 4516 // property. What we want to know is if the method is defined in 4517 // this implementation. 4518 if (!D->getInstanceMethod(PD->getGetterName())) 4519 CodeGenFunction(*this).GenerateObjCGetter( 4520 const_cast<ObjCImplementationDecl *>(D), PID); 4521 if (!PD->isReadOnly() && 4522 !D->getInstanceMethod(PD->getSetterName())) 4523 CodeGenFunction(*this).GenerateObjCSetter( 4524 const_cast<ObjCImplementationDecl *>(D), PID); 4525 } 4526 } 4527 } 4528 4529 static bool needsDestructMethod(ObjCImplementationDecl *impl) { 4530 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 4531 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 4532 ivar; ivar = ivar->getNextIvar()) 4533 if (ivar->getType().isDestructedType()) 4534 return true; 4535 4536 return false; 4537 } 4538 4539 static bool AllTrivialInitializers(CodeGenModule &CGM, 4540 ObjCImplementationDecl *D) { 4541 CodeGenFunction CGF(CGM); 4542 for (ObjCImplementationDecl::init_iterator B = D->init_begin(), 4543 E = D->init_end(); B != E; ++B) { 4544 CXXCtorInitializer *CtorInitExp = *B; 4545 Expr *Init = CtorInitExp->getInit(); 4546 if (!CGF.isTrivialInitializer(Init)) 4547 return false; 4548 } 4549 return true; 4550 } 4551 4552 /// EmitObjCIvarInitializations - Emit information for ivar initialization 4553 /// for an implementation. 4554 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 4555 // We might need a .cxx_destruct even if we don't have any ivar initializers. 4556 if (needsDestructMethod(D)) { 4557 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 4558 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 4559 ObjCMethodDecl *DTORMethod = 4560 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 4561 cxxSelector, getContext().VoidTy, nullptr, D, 4562 /*isInstance=*/true, /*isVariadic=*/false, 4563 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, 4564 /*isDefined=*/false, ObjCMethodDecl::Required); 4565 D->addInstanceMethod(DTORMethod); 4566 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 4567 D->setHasDestructors(true); 4568 } 4569 4570 // If the implementation doesn't have any ivar initializers, we don't need 4571 // a .cxx_construct. 4572 if (D->getNumIvarInitializers() == 0 || 4573 AllTrivialInitializers(*this, D)) 4574 return; 4575 4576 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 4577 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 4578 // The constructor returns 'self'. 4579 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 4580 D->getLocation(), 4581 D->getLocation(), 4582 cxxSelector, 4583 getContext().getObjCIdType(), 4584 nullptr, D, /*isInstance=*/true, 4585 /*isVariadic=*/false, 4586 /*isPropertyAccessor=*/true, 4587 /*isImplicitlyDeclared=*/true, 4588 /*isDefined=*/false, 4589 ObjCMethodDecl::Required); 4590 D->addInstanceMethod(CTORMethod); 4591 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 4592 D->setHasNonZeroConstructors(true); 4593 } 4594 4595 // EmitLinkageSpec - Emit all declarations in a linkage spec. 4596 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 4597 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 4598 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 4599 ErrorUnsupported(LSD, "linkage spec"); 4600 return; 4601 } 4602 4603 EmitDeclContext(LSD); 4604 } 4605 4606 void CodeGenModule::EmitDeclContext(const DeclContext *DC) { 4607 for (auto *I : DC->decls()) { 4608 // Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope 4609 // are themselves considered "top-level", so EmitTopLevelDecl on an 4610 // ObjCImplDecl does not recursively visit them. We need to do that in 4611 // case they're nested inside another construct (LinkageSpecDecl / 4612 // ExportDecl) that does stop them from being considered "top-level". 4613 if (auto *OID = dyn_cast<ObjCImplDecl>(I)) { 4614 for (auto *M : OID->methods()) 4615 EmitTopLevelDecl(M); 4616 } 4617 4618 EmitTopLevelDecl(I); 4619 } 4620 } 4621 4622 /// EmitTopLevelDecl - Emit code for a single top level declaration. 4623 void CodeGenModule::EmitTopLevelDecl(Decl *D) { 4624 // Ignore dependent declarations. 4625 if (D->isTemplated()) 4626 return; 4627 4628 switch (D->getKind()) { 4629 case Decl::CXXConversion: 4630 case Decl::CXXMethod: 4631 case Decl::Function: 4632 EmitGlobal(cast<FunctionDecl>(D)); 4633 // Always provide some coverage mapping 4634 // even for the functions that aren't emitted. 4635 AddDeferredUnusedCoverageMapping(D); 4636 break; 4637 4638 case Decl::CXXDeductionGuide: 4639 // Function-like, but does not result in code emission. 4640 break; 4641 4642 case Decl::Var: 4643 case Decl::Decomposition: 4644 case Decl::VarTemplateSpecialization: 4645 EmitGlobal(cast<VarDecl>(D)); 4646 if (auto *DD = dyn_cast<DecompositionDecl>(D)) 4647 for (auto *B : DD->bindings()) 4648 if (auto *HD = B->getHoldingVar()) 4649 EmitGlobal(HD); 4650 break; 4651 4652 // Indirect fields from global anonymous structs and unions can be 4653 // ignored; only the actual variable requires IR gen support. 4654 case Decl::IndirectField: 4655 break; 4656 4657 // C++ Decls 4658 case Decl::Namespace: 4659 EmitDeclContext(cast<NamespaceDecl>(D)); 4660 break; 4661 case Decl::ClassTemplateSpecialization: { 4662 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D); 4663 if (DebugInfo && 4664 Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition && 4665 Spec->hasDefinition()) 4666 DebugInfo->completeTemplateDefinition(*Spec); 4667 } LLVM_FALLTHROUGH; 4668 case Decl::CXXRecord: 4669 if (DebugInfo) { 4670 if (auto *ES = D->getASTContext().getExternalSource()) 4671 if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never) 4672 DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D)); 4673 } 4674 // Emit any static data members, they may be definitions. 4675 for (auto *I : cast<CXXRecordDecl>(D)->decls()) 4676 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I)) 4677 EmitTopLevelDecl(I); 4678 break; 4679 // No code generation needed. 4680 case Decl::UsingShadow: 4681 case Decl::ClassTemplate: 4682 case Decl::VarTemplate: 4683 case Decl::VarTemplatePartialSpecialization: 4684 case Decl::FunctionTemplate: 4685 case Decl::TypeAliasTemplate: 4686 case Decl::Block: 4687 case Decl::Empty: 4688 break; 4689 case Decl::Using: // using X; [C++] 4690 if (CGDebugInfo *DI = getModuleDebugInfo()) 4691 DI->EmitUsingDecl(cast<UsingDecl>(*D)); 4692 return; 4693 case Decl::NamespaceAlias: 4694 if (CGDebugInfo *DI = getModuleDebugInfo()) 4695 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D)); 4696 return; 4697 case Decl::UsingDirective: // using namespace X; [C++] 4698 if (CGDebugInfo *DI = getModuleDebugInfo()) 4699 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D)); 4700 return; 4701 case Decl::CXXConstructor: 4702 getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 4703 break; 4704 case Decl::CXXDestructor: 4705 getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 4706 break; 4707 4708 case Decl::StaticAssert: 4709 // Nothing to do. 4710 break; 4711 4712 // Objective-C Decls 4713 4714 // Forward declarations, no (immediate) code generation. 4715 case Decl::ObjCInterface: 4716 case Decl::ObjCCategory: 4717 break; 4718 4719 case Decl::ObjCProtocol: { 4720 auto *Proto = cast<ObjCProtocolDecl>(D); 4721 if (Proto->isThisDeclarationADefinition()) 4722 ObjCRuntime->GenerateProtocol(Proto); 4723 break; 4724 } 4725 4726 case Decl::ObjCCategoryImpl: 4727 // Categories have properties but don't support synthesize so we 4728 // can ignore them here. 4729 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 4730 break; 4731 4732 case Decl::ObjCImplementation: { 4733 auto *OMD = cast<ObjCImplementationDecl>(D); 4734 EmitObjCPropertyImplementations(OMD); 4735 EmitObjCIvarInitializations(OMD); 4736 ObjCRuntime->GenerateClass(OMD); 4737 // Emit global variable debug information. 4738 if (CGDebugInfo *DI = getModuleDebugInfo()) 4739 if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) 4740 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType( 4741 OMD->getClassInterface()), OMD->getLocation()); 4742 break; 4743 } 4744 case Decl::ObjCMethod: { 4745 auto *OMD = cast<ObjCMethodDecl>(D); 4746 // If this is not a prototype, emit the body. 4747 if (OMD->getBody()) 4748 CodeGenFunction(*this).GenerateObjCMethod(OMD); 4749 break; 4750 } 4751 case Decl::ObjCCompatibleAlias: 4752 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D)); 4753 break; 4754 4755 case Decl::PragmaComment: { 4756 const auto *PCD = cast<PragmaCommentDecl>(D); 4757 switch (PCD->getCommentKind()) { 4758 case PCK_Unknown: 4759 llvm_unreachable("unexpected pragma comment kind"); 4760 case PCK_Linker: 4761 AppendLinkerOptions(PCD->getArg()); 4762 break; 4763 case PCK_Lib: 4764 if (getTarget().getTriple().isOSBinFormatELF() && 4765 !getTarget().getTriple().isPS4()) 4766 AddELFLibDirective(PCD->getArg()); 4767 else 4768 AddDependentLib(PCD->getArg()); 4769 break; 4770 case PCK_Compiler: 4771 case PCK_ExeStr: 4772 case PCK_User: 4773 break; // We ignore all of these. 4774 } 4775 break; 4776 } 4777 4778 case Decl::PragmaDetectMismatch: { 4779 const auto *PDMD = cast<PragmaDetectMismatchDecl>(D); 4780 AddDetectMismatch(PDMD->getName(), PDMD->getValue()); 4781 break; 4782 } 4783 4784 case Decl::LinkageSpec: 4785 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 4786 break; 4787 4788 case Decl::FileScopeAsm: { 4789 // File-scope asm is ignored during device-side CUDA compilation. 4790 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) 4791 break; 4792 // File-scope asm is ignored during device-side OpenMP compilation. 4793 if (LangOpts.OpenMPIsDevice) 4794 break; 4795 auto *AD = cast<FileScopeAsmDecl>(D); 4796 getModule().appendModuleInlineAsm(AD->getAsmString()->getString()); 4797 break; 4798 } 4799 4800 case Decl::Import: { 4801 auto *Import = cast<ImportDecl>(D); 4802 4803 // If we've already imported this module, we're done. 4804 if (!ImportedModules.insert(Import->getImportedModule())) 4805 break; 4806 4807 // Emit debug information for direct imports. 4808 if (!Import->getImportedOwningModule()) { 4809 if (CGDebugInfo *DI = getModuleDebugInfo()) 4810 DI->EmitImportDecl(*Import); 4811 } 4812 4813 // Find all of the submodules and emit the module initializers. 4814 llvm::SmallPtrSet<clang::Module *, 16> Visited; 4815 SmallVector<clang::Module *, 16> Stack; 4816 Visited.insert(Import->getImportedModule()); 4817 Stack.push_back(Import->getImportedModule()); 4818 4819 while (!Stack.empty()) { 4820 clang::Module *Mod = Stack.pop_back_val(); 4821 if (!EmittedModuleInitializers.insert(Mod).second) 4822 continue; 4823 4824 for (auto *D : Context.getModuleInitializers(Mod)) 4825 EmitTopLevelDecl(D); 4826 4827 // Visit the submodules of this module. 4828 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(), 4829 SubEnd = Mod->submodule_end(); 4830 Sub != SubEnd; ++Sub) { 4831 // Skip explicit children; they need to be explicitly imported to emit 4832 // the initializers. 4833 if ((*Sub)->IsExplicit) 4834 continue; 4835 4836 if (Visited.insert(*Sub).second) 4837 Stack.push_back(*Sub); 4838 } 4839 } 4840 break; 4841 } 4842 4843 case Decl::Export: 4844 EmitDeclContext(cast<ExportDecl>(D)); 4845 break; 4846 4847 case Decl::OMPThreadPrivate: 4848 EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D)); 4849 break; 4850 4851 case Decl::OMPDeclareReduction: 4852 EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(D)); 4853 break; 4854 4855 default: 4856 // Make sure we handled everything we should, every other kind is a 4857 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 4858 // function. Need to recode Decl::Kind to do that easily. 4859 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 4860 break; 4861 } 4862 } 4863 4864 void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) { 4865 // Do we need to generate coverage mapping? 4866 if (!CodeGenOpts.CoverageMapping) 4867 return; 4868 switch (D->getKind()) { 4869 case Decl::CXXConversion: 4870 case Decl::CXXMethod: 4871 case Decl::Function: 4872 case Decl::ObjCMethod: 4873 case Decl::CXXConstructor: 4874 case Decl::CXXDestructor: { 4875 if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody()) 4876 return; 4877 SourceManager &SM = getContext().getSourceManager(); 4878 if (LimitedCoverage && SM.getMainFileID() != SM.getFileID(D->getBeginLoc())) 4879 return; 4880 auto I = DeferredEmptyCoverageMappingDecls.find(D); 4881 if (I == DeferredEmptyCoverageMappingDecls.end()) 4882 DeferredEmptyCoverageMappingDecls[D] = true; 4883 break; 4884 } 4885 default: 4886 break; 4887 }; 4888 } 4889 4890 void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) { 4891 // Do we need to generate coverage mapping? 4892 if (!CodeGenOpts.CoverageMapping) 4893 return; 4894 if (const auto *Fn = dyn_cast<FunctionDecl>(D)) { 4895 if (Fn->isTemplateInstantiation()) 4896 ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern()); 4897 } 4898 auto I = DeferredEmptyCoverageMappingDecls.find(D); 4899 if (I == DeferredEmptyCoverageMappingDecls.end()) 4900 DeferredEmptyCoverageMappingDecls[D] = false; 4901 else 4902 I->second = false; 4903 } 4904 4905 void CodeGenModule::EmitDeferredUnusedCoverageMappings() { 4906 // We call takeVector() here to avoid use-after-free. 4907 // FIXME: DeferredEmptyCoverageMappingDecls is getting mutated because 4908 // we deserialize function bodies to emit coverage info for them, and that 4909 // deserializes more declarations. How should we handle that case? 4910 for (const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) { 4911 if (!Entry.second) 4912 continue; 4913 const Decl *D = Entry.first; 4914 switch (D->getKind()) { 4915 case Decl::CXXConversion: 4916 case Decl::CXXMethod: 4917 case Decl::Function: 4918 case Decl::ObjCMethod: { 4919 CodeGenPGO PGO(*this); 4920 GlobalDecl GD(cast<FunctionDecl>(D)); 4921 PGO.emitEmptyCounterMapping(D, getMangledName(GD), 4922 getFunctionLinkage(GD)); 4923 break; 4924 } 4925 case Decl::CXXConstructor: { 4926 CodeGenPGO PGO(*this); 4927 GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base); 4928 PGO.emitEmptyCounterMapping(D, getMangledName(GD), 4929 getFunctionLinkage(GD)); 4930 break; 4931 } 4932 case Decl::CXXDestructor: { 4933 CodeGenPGO PGO(*this); 4934 GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base); 4935 PGO.emitEmptyCounterMapping(D, getMangledName(GD), 4936 getFunctionLinkage(GD)); 4937 break; 4938 } 4939 default: 4940 break; 4941 }; 4942 } 4943 } 4944 4945 /// Turns the given pointer into a constant. 4946 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 4947 const void *Ptr) { 4948 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 4949 llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 4950 return llvm::ConstantInt::get(i64, PtrInt); 4951 } 4952 4953 static void EmitGlobalDeclMetadata(CodeGenModule &CGM, 4954 llvm::NamedMDNode *&GlobalMetadata, 4955 GlobalDecl D, 4956 llvm::GlobalValue *Addr) { 4957 if (!GlobalMetadata) 4958 GlobalMetadata = 4959 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 4960 4961 // TODO: should we report variant information for ctors/dtors? 4962 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr), 4963 llvm::ConstantAsMetadata::get(GetPointerConstant( 4964 CGM.getLLVMContext(), D.getDecl()))}; 4965 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 4966 } 4967 4968 /// For each function which is declared within an extern "C" region and marked 4969 /// as 'used', but has internal linkage, create an alias from the unmangled 4970 /// name to the mangled name if possible. People expect to be able to refer 4971 /// to such functions with an unmangled name from inline assembly within the 4972 /// same translation unit. 4973 void CodeGenModule::EmitStaticExternCAliases() { 4974 if (!getTargetCodeGenInfo().shouldEmitStaticExternCAliases()) 4975 return; 4976 for (auto &I : StaticExternCValues) { 4977 IdentifierInfo *Name = I.first; 4978 llvm::GlobalValue *Val = I.second; 4979 if (Val && !getModule().getNamedValue(Name->getName())) 4980 addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val)); 4981 } 4982 } 4983 4984 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName, 4985 GlobalDecl &Result) const { 4986 auto Res = Manglings.find(MangledName); 4987 if (Res == Manglings.end()) 4988 return false; 4989 Result = Res->getValue(); 4990 return true; 4991 } 4992 4993 /// Emits metadata nodes associating all the global values in the 4994 /// current module with the Decls they came from. This is useful for 4995 /// projects using IR gen as a subroutine. 4996 /// 4997 /// Since there's currently no way to associate an MDNode directly 4998 /// with an llvm::GlobalValue, we create a global named metadata 4999 /// with the name 'clang.global.decl.ptrs'. 5000 void CodeGenModule::EmitDeclMetadata() { 5001 llvm::NamedMDNode *GlobalMetadata = nullptr; 5002 5003 for (auto &I : MangledDeclNames) { 5004 llvm::GlobalValue *Addr = getModule().getNamedValue(I.second); 5005 // Some mangled names don't necessarily have an associated GlobalValue 5006 // in this module, e.g. if we mangled it for DebugInfo. 5007 if (Addr) 5008 EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr); 5009 } 5010 } 5011 5012 /// Emits metadata nodes for all the local variables in the current 5013 /// function. 5014 void CodeGenFunction::EmitDeclMetadata() { 5015 if (LocalDeclMap.empty()) return; 5016 5017 llvm::LLVMContext &Context = getLLVMContext(); 5018 5019 // Find the unique metadata ID for this name. 5020 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 5021 5022 llvm::NamedMDNode *GlobalMetadata = nullptr; 5023 5024 for (auto &I : LocalDeclMap) { 5025 const Decl *D = I.first; 5026 llvm::Value *Addr = I.second.getPointer(); 5027 if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 5028 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 5029 Alloca->setMetadata( 5030 DeclPtrKind, llvm::MDNode::get( 5031 Context, llvm::ValueAsMetadata::getConstant(DAddr))); 5032 } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 5033 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 5034 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 5035 } 5036 } 5037 } 5038 5039 void CodeGenModule::EmitVersionIdentMetadata() { 5040 llvm::NamedMDNode *IdentMetadata = 5041 TheModule.getOrInsertNamedMetadata("llvm.ident"); 5042 std::string Version = getClangFullVersion(); 5043 llvm::LLVMContext &Ctx = TheModule.getContext(); 5044 5045 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)}; 5046 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode)); 5047 } 5048 5049 void CodeGenModule::EmitTargetMetadata() { 5050 // Warning, new MangledDeclNames may be appended within this loop. 5051 // We rely on MapVector insertions adding new elements to the end 5052 // of the container. 5053 // FIXME: Move this loop into the one target that needs it, and only 5054 // loop over those declarations for which we couldn't emit the target 5055 // metadata when we emitted the declaration. 5056 for (unsigned I = 0; I != MangledDeclNames.size(); ++I) { 5057 auto Val = *(MangledDeclNames.begin() + I); 5058 const Decl *D = Val.first.getDecl()->getMostRecentDecl(); 5059 llvm::GlobalValue *GV = GetGlobalValue(Val.second); 5060 getTargetCodeGenInfo().emitTargetMD(D, GV, *this); 5061 } 5062 } 5063 5064 void CodeGenModule::EmitCoverageFile() { 5065 if (getCodeGenOpts().CoverageDataFile.empty() && 5066 getCodeGenOpts().CoverageNotesFile.empty()) 5067 return; 5068 5069 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu"); 5070 if (!CUNode) 5071 return; 5072 5073 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 5074 llvm::LLVMContext &Ctx = TheModule.getContext(); 5075 auto *CoverageDataFile = 5076 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageDataFile); 5077 auto *CoverageNotesFile = 5078 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageNotesFile); 5079 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 5080 llvm::MDNode *CU = CUNode->getOperand(i); 5081 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU}; 5082 GCov->addOperand(llvm::MDNode::get(Ctx, Elts)); 5083 } 5084 } 5085 5086 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) { 5087 // Sema has checked that all uuid strings are of the form 5088 // "12345678-1234-1234-1234-1234567890ab". 5089 assert(Uuid.size() == 36); 5090 for (unsigned i = 0; i < 36; ++i) { 5091 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-'); 5092 else assert(isHexDigit(Uuid[i])); 5093 } 5094 5095 // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab". 5096 const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 }; 5097 5098 llvm::Constant *Field3[8]; 5099 for (unsigned Idx = 0; Idx < 8; ++Idx) 5100 Field3[Idx] = llvm::ConstantInt::get( 5101 Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16); 5102 5103 llvm::Constant *Fields[4] = { 5104 llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16), 5105 llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16), 5106 llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16), 5107 llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3) 5108 }; 5109 5110 return llvm::ConstantStruct::getAnon(Fields); 5111 } 5112 5113 llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty, 5114 bool ForEH) { 5115 // Return a bogus pointer if RTTI is disabled, unless it's for EH. 5116 // FIXME: should we even be calling this method if RTTI is disabled 5117 // and it's not for EH? 5118 if ((!ForEH && !getLangOpts().RTTI) || getLangOpts().CUDAIsDevice) 5119 return llvm::Constant::getNullValue(Int8PtrTy); 5120 5121 if (ForEH && Ty->isObjCObjectPointerType() && 5122 LangOpts.ObjCRuntime.isGNUFamily()) 5123 return ObjCRuntime->GetEHType(Ty); 5124 5125 return getCXXABI().getAddrOfRTTIDescriptor(Ty); 5126 } 5127 5128 void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { 5129 // Do not emit threadprivates in simd-only mode. 5130 if (LangOpts.OpenMP && LangOpts.OpenMPSimd) 5131 return; 5132 for (auto RefExpr : D->varlists()) { 5133 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl()); 5134 bool PerformInit = 5135 VD->getAnyInitializer() && 5136 !VD->getAnyInitializer()->isConstantInitializer(getContext(), 5137 /*ForRef=*/false); 5138 5139 Address Addr(GetAddrOfGlobalVar(VD), getContext().getDeclAlign(VD)); 5140 if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition( 5141 VD, Addr, RefExpr->getBeginLoc(), PerformInit)) 5142 CXXGlobalInits.push_back(InitFunction); 5143 } 5144 } 5145 5146 llvm::Metadata * 5147 CodeGenModule::CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map, 5148 StringRef Suffix) { 5149 llvm::Metadata *&InternalId = Map[T.getCanonicalType()]; 5150 if (InternalId) 5151 return InternalId; 5152 5153 if (isExternallyVisible(T->getLinkage())) { 5154 std::string OutName; 5155 llvm::raw_string_ostream Out(OutName); 5156 getCXXABI().getMangleContext().mangleTypeName(T, Out); 5157 Out << Suffix; 5158 5159 InternalId = llvm::MDString::get(getLLVMContext(), Out.str()); 5160 } else { 5161 InternalId = llvm::MDNode::getDistinct(getLLVMContext(), 5162 llvm::ArrayRef<llvm::Metadata *>()); 5163 } 5164 5165 return InternalId; 5166 } 5167 5168 llvm::Metadata *CodeGenModule::CreateMetadataIdentifierForType(QualType T) { 5169 return CreateMetadataIdentifierImpl(T, MetadataIdMap, ""); 5170 } 5171 5172 llvm::Metadata * 5173 CodeGenModule::CreateMetadataIdentifierForVirtualMemPtrType(QualType T) { 5174 return CreateMetadataIdentifierImpl(T, VirtualMetadataIdMap, ".virtual"); 5175 } 5176 5177 // Generalize pointer types to a void pointer with the qualifiers of the 5178 // originally pointed-to type, e.g. 'const char *' and 'char * const *' 5179 // generalize to 'const void *' while 'char *' and 'const char **' generalize to 5180 // 'void *'. 5181 static QualType GeneralizeType(ASTContext &Ctx, QualType Ty) { 5182 if (!Ty->isPointerType()) 5183 return Ty; 5184 5185 return Ctx.getPointerType( 5186 QualType(Ctx.VoidTy).withCVRQualifiers( 5187 Ty->getPointeeType().getCVRQualifiers())); 5188 } 5189 5190 // Apply type generalization to a FunctionType's return and argument types 5191 static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty) { 5192 if (auto *FnType = Ty->getAs<FunctionProtoType>()) { 5193 SmallVector<QualType, 8> GeneralizedParams; 5194 for (auto &Param : FnType->param_types()) 5195 GeneralizedParams.push_back(GeneralizeType(Ctx, Param)); 5196 5197 return Ctx.getFunctionType( 5198 GeneralizeType(Ctx, FnType->getReturnType()), 5199 GeneralizedParams, FnType->getExtProtoInfo()); 5200 } 5201 5202 if (auto *FnType = Ty->getAs<FunctionNoProtoType>()) 5203 return Ctx.getFunctionNoProtoType( 5204 GeneralizeType(Ctx, FnType->getReturnType())); 5205 5206 llvm_unreachable("Encountered unknown FunctionType"); 5207 } 5208 5209 llvm::Metadata *CodeGenModule::CreateMetadataIdentifierGeneralized(QualType T) { 5210 return CreateMetadataIdentifierImpl(GeneralizeFunctionType(getContext(), T), 5211 GeneralizedMetadataIdMap, ".generalized"); 5212 } 5213 5214 /// Returns whether this module needs the "all-vtables" type identifier. 5215 bool CodeGenModule::NeedAllVtablesTypeId() const { 5216 // Returns true if at least one of vtable-based CFI checkers is enabled and 5217 // is not in the trapping mode. 5218 return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) && 5219 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) || 5220 (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) && 5221 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) || 5222 (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) && 5223 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) || 5224 (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) && 5225 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast))); 5226 } 5227 5228 void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable, 5229 CharUnits Offset, 5230 const CXXRecordDecl *RD) { 5231 llvm::Metadata *MD = 5232 CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0)); 5233 VTable->addTypeMetadata(Offset.getQuantity(), MD); 5234 5235 if (CodeGenOpts.SanitizeCfiCrossDso) 5236 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD)) 5237 VTable->addTypeMetadata(Offset.getQuantity(), 5238 llvm::ConstantAsMetadata::get(CrossDsoTypeId)); 5239 5240 if (NeedAllVtablesTypeId()) { 5241 llvm::Metadata *MD = llvm::MDString::get(getLLVMContext(), "all-vtables"); 5242 VTable->addTypeMetadata(Offset.getQuantity(), MD); 5243 } 5244 } 5245 5246 TargetAttr::ParsedTargetAttr CodeGenModule::filterFunctionTargetAttrs(const TargetAttr *TD) { 5247 assert(TD != nullptr); 5248 TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse(); 5249 5250 ParsedAttr.Features.erase( 5251 llvm::remove_if(ParsedAttr.Features, 5252 [&](const std::string &Feat) { 5253 return !Target.isValidFeatureName( 5254 StringRef{Feat}.substr(1)); 5255 }), 5256 ParsedAttr.Features.end()); 5257 return ParsedAttr; 5258 } 5259 5260 5261 // Fills in the supplied string map with the set of target features for the 5262 // passed in function. 5263 void CodeGenModule::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap, 5264 const FunctionDecl *FD) { 5265 StringRef TargetCPU = Target.getTargetOpts().CPU; 5266 if (const auto *TD = FD->getAttr<TargetAttr>()) { 5267 TargetAttr::ParsedTargetAttr ParsedAttr = filterFunctionTargetAttrs(TD); 5268 5269 // Make a copy of the features as passed on the command line into the 5270 // beginning of the additional features from the function to override. 5271 ParsedAttr.Features.insert(ParsedAttr.Features.begin(), 5272 Target.getTargetOpts().FeaturesAsWritten.begin(), 5273 Target.getTargetOpts().FeaturesAsWritten.end()); 5274 5275 if (ParsedAttr.Architecture != "" && 5276 Target.isValidCPUName(ParsedAttr.Architecture)) 5277 TargetCPU = ParsedAttr.Architecture; 5278 5279 // Now populate the feature map, first with the TargetCPU which is either 5280 // the default or a new one from the target attribute string. Then we'll use 5281 // the passed in features (FeaturesAsWritten) along with the new ones from 5282 // the attribute. 5283 Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU, 5284 ParsedAttr.Features); 5285 } else if (const auto *SD = FD->getAttr<CPUSpecificAttr>()) { 5286 llvm::SmallVector<StringRef, 32> FeaturesTmp; 5287 Target.getCPUSpecificCPUDispatchFeatures(SD->getCurCPUName()->getName(), 5288 FeaturesTmp); 5289 std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end()); 5290 Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU, Features); 5291 } else { 5292 Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU, 5293 Target.getTargetOpts().Features); 5294 } 5295 } 5296 5297 llvm::SanitizerStatReport &CodeGenModule::getSanStats() { 5298 if (!SanStats) 5299 SanStats = llvm::make_unique<llvm::SanitizerStatReport>(&getModule()); 5300 5301 return *SanStats; 5302 } 5303 llvm::Value * 5304 CodeGenModule::createOpenCLIntToSamplerConversion(const Expr *E, 5305 CodeGenFunction &CGF) { 5306 llvm::Constant *C = ConstantEmitter(CGF).emitAbstract(E, E->getType()); 5307 auto SamplerT = getOpenCLRuntime().getSamplerType(E->getType().getTypePtr()); 5308 auto FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false); 5309 return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy, 5310 "__translate_sampler_initializer"), 5311 {C}); 5312 } 5313