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