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