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 "CGDebugInfo.h" 16 #include "CodeGenFunction.h" 17 #include "CodeGenTBAA.h" 18 #include "CGCall.h" 19 #include "CGCUDARuntime.h" 20 #include "CGCXXABI.h" 21 #include "CGObjCRuntime.h" 22 #include "CGOpenCLRuntime.h" 23 #include "TargetInfo.h" 24 #include "clang/Frontend/CodeGenOptions.h" 25 #include "clang/AST/ASTContext.h" 26 #include "clang/AST/CharUnits.h" 27 #include "clang/AST/DeclObjC.h" 28 #include "clang/AST/DeclCXX.h" 29 #include "clang/AST/DeclTemplate.h" 30 #include "clang/AST/Mangle.h" 31 #include "clang/AST/RecordLayout.h" 32 #include "clang/AST/RecursiveASTVisitor.h" 33 #include "clang/Basic/Builtins.h" 34 #include "clang/Basic/Diagnostic.h" 35 #include "clang/Basic/SourceManager.h" 36 #include "clang/Basic/TargetInfo.h" 37 #include "clang/Basic/ConvertUTF.h" 38 #include "llvm/CallingConv.h" 39 #include "llvm/Module.h" 40 #include "llvm/Intrinsics.h" 41 #include "llvm/LLVMContext.h" 42 #include "llvm/ADT/APSInt.h" 43 #include "llvm/ADT/Triple.h" 44 #include "llvm/Target/Mangler.h" 45 #include "llvm/DataLayout.h" 46 #include "llvm/Support/CallSite.h" 47 #include "llvm/Support/ErrorHandling.h" 48 using namespace clang; 49 using namespace CodeGen; 50 51 static const char AnnotationSection[] = "llvm.metadata"; 52 53 static CGCXXABI &createCXXABI(CodeGenModule &CGM) { 54 switch (CGM.getContext().getTargetInfo().getCXXABI()) { 55 case CXXABI_ARM: return *CreateARMCXXABI(CGM); 56 case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM); 57 case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM); 58 } 59 60 llvm_unreachable("invalid C++ ABI kind"); 61 } 62 63 64 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 65 llvm::Module &M, const llvm::DataLayout &TD, 66 DiagnosticsEngine &diags) 67 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M), 68 TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags), 69 ABI(createCXXABI(*this)), 70 Types(*this), 71 TBAA(0), 72 VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0), 73 DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0), 74 RRData(0), CFConstantStringClassRef(0), 75 ConstantStringClassRef(0), NSConstantStringType(0), 76 VMContext(M.getContext()), 77 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), 78 BlockObjectAssign(0), BlockObjectDispose(0), 79 BlockDescriptorType(0), GenericBlockLiteralType(0) { 80 81 // Initialize the type cache. 82 llvm::LLVMContext &LLVMContext = M.getContext(); 83 VoidTy = llvm::Type::getVoidTy(LLVMContext); 84 Int8Ty = llvm::Type::getInt8Ty(LLVMContext); 85 Int16Ty = llvm::Type::getInt16Ty(LLVMContext); 86 Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 87 Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 88 FloatTy = llvm::Type::getFloatTy(LLVMContext); 89 DoubleTy = llvm::Type::getDoubleTy(LLVMContext); 90 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0); 91 PointerAlignInBytes = 92 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity(); 93 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth()); 94 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits); 95 Int8PtrTy = Int8Ty->getPointerTo(0); 96 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); 97 98 if (LangOpts.ObjC1) 99 createObjCRuntime(); 100 if (LangOpts.OpenCL) 101 createOpenCLRuntime(); 102 if (LangOpts.CUDA) 103 createCUDARuntime(); 104 105 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0. 106 if (LangOpts.ThreadSanitizer || 107 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)) 108 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(), 109 ABI.getMangleContext()); 110 111 // If debug info or coverage generation is enabled, create the CGDebugInfo 112 // object. 113 if (CodeGenOpts.DebugInfo != CodeGenOptions::NoDebugInfo || 114 CodeGenOpts.EmitGcovArcs || 115 CodeGenOpts.EmitGcovNotes) 116 DebugInfo = new CGDebugInfo(*this); 117 118 Block.GlobalUniqueCount = 0; 119 120 if (C.getLangOpts().ObjCAutoRefCount) 121 ARCData = new ARCEntrypoints(); 122 RRData = new RREntrypoints(); 123 } 124 125 CodeGenModule::~CodeGenModule() { 126 delete ObjCRuntime; 127 delete OpenCLRuntime; 128 delete CUDARuntime; 129 delete TheTargetCodeGenInfo; 130 delete &ABI; 131 delete TBAA; 132 delete DebugInfo; 133 delete ARCData; 134 delete RRData; 135 } 136 137 void CodeGenModule::createObjCRuntime() { 138 // This is just isGNUFamily(), but we want to force implementors of 139 // new ABIs to decide how best to do this. 140 switch (LangOpts.ObjCRuntime.getKind()) { 141 case ObjCRuntime::GNUstep: 142 case ObjCRuntime::GCC: 143 case ObjCRuntime::ObjFW: 144 ObjCRuntime = CreateGNUObjCRuntime(*this); 145 return; 146 147 case ObjCRuntime::FragileMacOSX: 148 case ObjCRuntime::MacOSX: 149 case ObjCRuntime::iOS: 150 ObjCRuntime = CreateMacObjCRuntime(*this); 151 return; 152 } 153 llvm_unreachable("bad runtime kind"); 154 } 155 156 void CodeGenModule::createOpenCLRuntime() { 157 OpenCLRuntime = new CGOpenCLRuntime(*this); 158 } 159 160 void CodeGenModule::createCUDARuntime() { 161 CUDARuntime = CreateNVCUDARuntime(*this); 162 } 163 164 void CodeGenModule::Release() { 165 EmitDeferred(); 166 EmitCXXGlobalInitFunc(); 167 EmitCXXGlobalDtorFunc(); 168 if (ObjCRuntime) 169 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction()) 170 AddGlobalCtor(ObjCInitFunction); 171 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 172 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 173 EmitGlobalAnnotations(); 174 EmitLLVMUsed(); 175 176 SimplifyPersonality(); 177 178 if (getCodeGenOpts().EmitDeclMetadata) 179 EmitDeclMetadata(); 180 181 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes) 182 EmitCoverageFile(); 183 184 if (DebugInfo) 185 DebugInfo->finalize(); 186 } 187 188 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 189 // Make sure that this type is translated. 190 Types.UpdateCompletedType(TD); 191 } 192 193 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { 194 if (!TBAA) 195 return 0; 196 return TBAA->getTBAAInfo(QTy); 197 } 198 199 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() { 200 if (!TBAA) 201 return 0; 202 return TBAA->getTBAAInfoForVTablePtr(); 203 } 204 205 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { 206 if (!TBAA) 207 return 0; 208 return TBAA->getTBAAStructInfo(QTy); 209 } 210 211 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, 212 llvm::MDNode *TBAAInfo) { 213 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); 214 } 215 216 bool CodeGenModule::isTargetDarwin() const { 217 return getContext().getTargetInfo().getTriple().isOSDarwin(); 218 } 219 220 void CodeGenModule::Error(SourceLocation loc, StringRef error) { 221 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error); 222 getDiags().Report(Context.getFullLoc(loc), diagID); 223 } 224 225 /// ErrorUnsupported - Print out an error that codegen doesn't support the 226 /// specified stmt yet. 227 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 228 bool OmitOnError) { 229 if (OmitOnError && getDiags().hasErrorOccurred()) 230 return; 231 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 232 "cannot compile this %0 yet"); 233 std::string Msg = Type; 234 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 235 << Msg << S->getSourceRange(); 236 } 237 238 /// ErrorUnsupported - Print out an error that codegen doesn't support the 239 /// specified decl yet. 240 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 241 bool OmitOnError) { 242 if (OmitOnError && getDiags().hasErrorOccurred()) 243 return; 244 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 245 "cannot compile this %0 yet"); 246 std::string Msg = Type; 247 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 248 } 249 250 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { 251 return llvm::ConstantInt::get(SizeTy, size.getQuantity()); 252 } 253 254 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 255 const NamedDecl *D) const { 256 // Internal definitions always have default visibility. 257 if (GV->hasLocalLinkage()) { 258 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 259 return; 260 } 261 262 // Set visibility for definitions. 263 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 264 if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage()) 265 GV->setVisibility(GetLLVMVisibility(LV.visibility())); 266 } 267 268 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) { 269 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S) 270 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel) 271 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel) 272 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel) 273 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel); 274 } 275 276 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel( 277 CodeGenOptions::TLSModel M) { 278 switch (M) { 279 case CodeGenOptions::GeneralDynamicTLSModel: 280 return llvm::GlobalVariable::GeneralDynamicTLSModel; 281 case CodeGenOptions::LocalDynamicTLSModel: 282 return llvm::GlobalVariable::LocalDynamicTLSModel; 283 case CodeGenOptions::InitialExecTLSModel: 284 return llvm::GlobalVariable::InitialExecTLSModel; 285 case CodeGenOptions::LocalExecTLSModel: 286 return llvm::GlobalVariable::LocalExecTLSModel; 287 } 288 llvm_unreachable("Invalid TLS model!"); 289 } 290 291 void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV, 292 const VarDecl &D) const { 293 assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!"); 294 295 llvm::GlobalVariable::ThreadLocalMode TLM; 296 TLM = GetLLVMTLSModel(CodeGenOpts.DefaultTLSModel); 297 298 // Override the TLS model if it is explicitly specified. 299 if (D.hasAttr<TLSModelAttr>()) { 300 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>(); 301 TLM = GetLLVMTLSModel(Attr->getModel()); 302 } 303 304 GV->setThreadLocalMode(TLM); 305 } 306 307 /// Set the symbol visibility of type information (vtable and RTTI) 308 /// associated with the given type. 309 void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV, 310 const CXXRecordDecl *RD, 311 TypeVisibilityKind TVK) const { 312 setGlobalVisibility(GV, RD); 313 314 if (!CodeGenOpts.HiddenWeakVTables) 315 return; 316 317 // We never want to drop the visibility for RTTI names. 318 if (TVK == TVK_ForRTTIName) 319 return; 320 321 // We want to drop the visibility to hidden for weak type symbols. 322 // This isn't possible if there might be unresolved references 323 // elsewhere that rely on this symbol being visible. 324 325 // This should be kept roughly in sync with setThunkVisibility 326 // in CGVTables.cpp. 327 328 // Preconditions. 329 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage || 330 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility) 331 return; 332 333 // Don't override an explicit visibility attribute. 334 if (RD->getExplicitVisibility()) 335 return; 336 337 switch (RD->getTemplateSpecializationKind()) { 338 // We have to disable the optimization if this is an EI definition 339 // because there might be EI declarations in other shared objects. 340 case TSK_ExplicitInstantiationDefinition: 341 case TSK_ExplicitInstantiationDeclaration: 342 return; 343 344 // Every use of a non-template class's type information has to emit it. 345 case TSK_Undeclared: 346 break; 347 348 // In theory, implicit instantiations can ignore the possibility of 349 // an explicit instantiation declaration because there necessarily 350 // must be an EI definition somewhere with default visibility. In 351 // practice, it's possible to have an explicit instantiation for 352 // an arbitrary template class, and linkers aren't necessarily able 353 // to deal with mixed-visibility symbols. 354 case TSK_ExplicitSpecialization: 355 case TSK_ImplicitInstantiation: 356 if (!CodeGenOpts.HiddenWeakTemplateVTables) 357 return; 358 break; 359 } 360 361 // If there's a key function, there may be translation units 362 // that don't have the key function's definition. But ignore 363 // this if we're emitting RTTI under -fno-rtti. 364 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) { 365 if (Context.getKeyFunction(RD)) 366 return; 367 } 368 369 // Otherwise, drop the visibility to hidden. 370 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 371 GV->setUnnamedAddr(true); 372 } 373 374 StringRef CodeGenModule::getMangledName(GlobalDecl GD) { 375 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); 376 377 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()]; 378 if (!Str.empty()) 379 return Str; 380 381 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { 382 IdentifierInfo *II = ND->getIdentifier(); 383 assert(II && "Attempt to mangle unnamed decl."); 384 385 Str = II->getName(); 386 return Str; 387 } 388 389 SmallString<256> Buffer; 390 llvm::raw_svector_ostream Out(Buffer); 391 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 392 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); 393 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 394 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); 395 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND)) 396 getCXXABI().getMangleContext().mangleBlock(BD, Out, 397 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl())); 398 else 399 getCXXABI().getMangleContext().mangleName(ND, Out); 400 401 // Allocate space for the mangled name. 402 Out.flush(); 403 size_t Length = Buffer.size(); 404 char *Name = MangledNamesAllocator.Allocate<char>(Length); 405 std::copy(Buffer.begin(), Buffer.end(), Name); 406 407 Str = StringRef(Name, Length); 408 409 return Str; 410 } 411 412 void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, 413 const BlockDecl *BD) { 414 MangleContext &MangleCtx = getCXXABI().getMangleContext(); 415 const Decl *D = GD.getDecl(); 416 llvm::raw_svector_ostream Out(Buffer.getBuffer()); 417 if (D == 0) 418 MangleCtx.mangleGlobalBlock(BD, 419 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out); 420 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 421 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); 422 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) 423 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); 424 else 425 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); 426 } 427 428 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { 429 return getModule().getNamedValue(Name); 430 } 431 432 /// AddGlobalCtor - Add a function to the list that will be called before 433 /// main() runs. 434 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 435 // FIXME: Type coercion of void()* types. 436 GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 437 } 438 439 /// AddGlobalDtor - Add a function to the list that will be called 440 /// when the module is unloaded. 441 void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 442 // FIXME: Type coercion of void()* types. 443 GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 444 } 445 446 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 447 // Ctor function type is void()*. 448 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); 449 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 450 451 // Get the type of a ctor entry, { i32, void ()* }. 452 llvm::StructType *CtorStructTy = 453 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL); 454 455 // Construct the constructor and destructor arrays. 456 SmallVector<llvm::Constant*, 8> Ctors; 457 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 458 llvm::Constant *S[] = { 459 llvm::ConstantInt::get(Int32Ty, I->second, false), 460 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy) 461 }; 462 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 463 } 464 465 if (!Ctors.empty()) { 466 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 467 new llvm::GlobalVariable(TheModule, AT, false, 468 llvm::GlobalValue::AppendingLinkage, 469 llvm::ConstantArray::get(AT, Ctors), 470 GlobalName); 471 } 472 } 473 474 llvm::GlobalValue::LinkageTypes 475 CodeGenModule::getFunctionLinkage(const FunctionDecl *D) { 476 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); 477 478 if (Linkage == GVA_Internal) 479 return llvm::Function::InternalLinkage; 480 481 if (D->hasAttr<DLLExportAttr>()) 482 return llvm::Function::DLLExportLinkage; 483 484 if (D->hasAttr<WeakAttr>()) 485 return llvm::Function::WeakAnyLinkage; 486 487 // In C99 mode, 'inline' functions are guaranteed to have a strong 488 // definition somewhere else, so we can use available_externally linkage. 489 if (Linkage == GVA_C99Inline) 490 return llvm::Function::AvailableExternallyLinkage; 491 492 // Note that Apple's kernel linker doesn't support symbol 493 // coalescing, so we need to avoid linkonce and weak linkages there. 494 // Normally, this means we just map to internal, but for explicit 495 // instantiations we'll map to external. 496 497 // In C++, the compiler has to emit a definition in every translation unit 498 // that references the function. We should use linkonce_odr because 499 // a) if all references in this translation unit are optimized away, we 500 // don't need to codegen it. b) if the function persists, it needs to be 501 // merged with other definitions. c) C++ has the ODR, so we know the 502 // definition is dependable. 503 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 504 return !Context.getLangOpts().AppleKext 505 ? llvm::Function::LinkOnceODRLinkage 506 : llvm::Function::InternalLinkage; 507 508 // An explicit instantiation of a template has weak linkage, since 509 // explicit instantiations can occur in multiple translation units 510 // and must all be equivalent. However, we are not allowed to 511 // throw away these explicit instantiations. 512 if (Linkage == GVA_ExplicitTemplateInstantiation) 513 return !Context.getLangOpts().AppleKext 514 ? llvm::Function::WeakODRLinkage 515 : llvm::Function::ExternalLinkage; 516 517 // Otherwise, we have strong external linkage. 518 assert(Linkage == GVA_StrongExternal); 519 return llvm::Function::ExternalLinkage; 520 } 521 522 523 /// SetFunctionDefinitionAttributes - Set attributes for a global. 524 /// 525 /// FIXME: This is currently only done for aliases and functions, but not for 526 /// variables (these details are set in EmitGlobalVarDefinition for variables). 527 void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 528 llvm::GlobalValue *GV) { 529 SetCommonAttributes(D, GV); 530 } 531 532 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 533 const CGFunctionInfo &Info, 534 llvm::Function *F) { 535 unsigned CallingConv; 536 AttributeListType AttributeList; 537 ConstructAttributeList(Info, D, AttributeList, CallingConv); 538 F->setAttributes(llvm::AttrListPtr::get(AttributeList)); 539 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 540 } 541 542 /// Determines whether the language options require us to model 543 /// unwind exceptions. We treat -fexceptions as mandating this 544 /// except under the fragile ObjC ABI with only ObjC exceptions 545 /// enabled. This means, for example, that C with -fexceptions 546 /// enables this. 547 static bool hasUnwindExceptions(const LangOptions &LangOpts) { 548 // If exceptions are completely disabled, obviously this is false. 549 if (!LangOpts.Exceptions) return false; 550 551 // If C++ exceptions are enabled, this is true. 552 if (LangOpts.CXXExceptions) return true; 553 554 // If ObjC exceptions are enabled, this depends on the ABI. 555 if (LangOpts.ObjCExceptions) { 556 return LangOpts.ObjCRuntime.hasUnwindExceptions(); 557 } 558 559 return true; 560 } 561 562 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 563 llvm::Function *F) { 564 if (CodeGenOpts.UnwindTables) 565 F->setHasUWTable(); 566 567 if (!hasUnwindExceptions(LangOpts)) 568 F->addFnAttr(llvm::Attributes::NoUnwind); 569 570 if (D->hasAttr<NakedAttr>()) { 571 // Naked implies noinline: we should not be inlining such functions. 572 F->addFnAttr(llvm::Attributes::Naked); 573 F->addFnAttr(llvm::Attributes::NoInline); 574 } 575 576 if (D->hasAttr<NoInlineAttr>()) 577 F->addFnAttr(llvm::Attributes::NoInline); 578 579 // (noinline wins over always_inline, and we can't specify both in IR) 580 if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) && 581 !F->getFnAttributes().hasAttribute(llvm::Attributes::NoInline)) 582 F->addFnAttr(llvm::Attributes::AlwaysInline); 583 584 // FIXME: Communicate hot and cold attributes to LLVM more directly. 585 if (D->hasAttr<ColdAttr>()) 586 F->addFnAttr(llvm::Attributes::OptimizeForSize); 587 588 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D)) 589 F->setUnnamedAddr(true); 590 591 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) 592 if (MD->isVirtual()) 593 F->setUnnamedAddr(true); 594 595 if (LangOpts.getStackProtector() == LangOptions::SSPOn) 596 F->addFnAttr(llvm::Attributes::StackProtect); 597 else if (LangOpts.getStackProtector() == LangOptions::SSPReq) 598 F->addFnAttr(llvm::Attributes::StackProtectReq); 599 600 if (LangOpts.AddressSanitizer) { 601 // When AddressSanitizer is enabled, set AddressSafety attribute 602 // unless __attribute__((no_address_safety_analysis)) is used. 603 if (!D->hasAttr<NoAddressSafetyAnalysisAttr>()) 604 F->addFnAttr(llvm::Attributes::AddressSafety); 605 } 606 607 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth(); 608 if (alignment) 609 F->setAlignment(alignment); 610 611 // C++ ABI requires 2-byte alignment for member functions. 612 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 613 F->setAlignment(2); 614 } 615 616 void CodeGenModule::SetCommonAttributes(const Decl *D, 617 llvm::GlobalValue *GV) { 618 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 619 setGlobalVisibility(GV, ND); 620 else 621 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 622 623 if (D->hasAttr<UsedAttr>()) 624 AddUsedGlobal(GV); 625 626 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 627 GV->setSection(SA->getName()); 628 629 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this); 630 } 631 632 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 633 llvm::Function *F, 634 const CGFunctionInfo &FI) { 635 SetLLVMFunctionAttributes(D, FI, F); 636 SetLLVMFunctionAttributesForDefinition(D, F); 637 638 F->setLinkage(llvm::Function::InternalLinkage); 639 640 SetCommonAttributes(D, F); 641 } 642 643 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, 644 llvm::Function *F, 645 bool IsIncompleteFunction) { 646 if (unsigned IID = F->getIntrinsicID()) { 647 // If this is an intrinsic function, set the function's attributes 648 // to the intrinsic's attributes. 649 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), 650 (llvm::Intrinsic::ID)IID)); 651 return; 652 } 653 654 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 655 656 if (!IsIncompleteFunction) 657 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); 658 659 // Only a few attributes are set on declarations; these may later be 660 // overridden by a definition. 661 662 if (FD->hasAttr<DLLImportAttr>()) { 663 F->setLinkage(llvm::Function::DLLImportLinkage); 664 } else if (FD->hasAttr<WeakAttr>() || 665 FD->isWeakImported()) { 666 // "extern_weak" is overloaded in LLVM; we probably should have 667 // separate linkage types for this. 668 F->setLinkage(llvm::Function::ExternalWeakLinkage); 669 } else { 670 F->setLinkage(llvm::Function::ExternalLinkage); 671 672 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility(); 673 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) { 674 F->setVisibility(GetLLVMVisibility(LV.visibility())); 675 } 676 } 677 678 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 679 F->setSection(SA->getName()); 680 } 681 682 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 683 assert(!GV->isDeclaration() && 684 "Only globals with definition can force usage."); 685 LLVMUsed.push_back(GV); 686 } 687 688 void CodeGenModule::EmitLLVMUsed() { 689 // Don't create llvm.used if there is no need. 690 if (LLVMUsed.empty()) 691 return; 692 693 // Convert LLVMUsed to what ConstantArray needs. 694 SmallVector<llvm::Constant*, 8> UsedArray; 695 UsedArray.resize(LLVMUsed.size()); 696 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 697 UsedArray[i] = 698 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 699 Int8PtrTy); 700 } 701 702 if (UsedArray.empty()) 703 return; 704 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size()); 705 706 llvm::GlobalVariable *GV = 707 new llvm::GlobalVariable(getModule(), ATy, false, 708 llvm::GlobalValue::AppendingLinkage, 709 llvm::ConstantArray::get(ATy, UsedArray), 710 "llvm.used"); 711 712 GV->setSection("llvm.metadata"); 713 } 714 715 void CodeGenModule::EmitDeferred() { 716 // Emit code for any potentially referenced deferred decls. Since a 717 // previously unused static decl may become used during the generation of code 718 // for a static function, iterate until no changes are made. 719 720 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) { 721 if (!DeferredVTables.empty()) { 722 const CXXRecordDecl *RD = DeferredVTables.back(); 723 DeferredVTables.pop_back(); 724 getCXXABI().EmitVTables(RD); 725 continue; 726 } 727 728 GlobalDecl D = DeferredDeclsToEmit.back(); 729 DeferredDeclsToEmit.pop_back(); 730 731 // Check to see if we've already emitted this. This is necessary 732 // for a couple of reasons: first, decls can end up in the 733 // deferred-decls queue multiple times, and second, decls can end 734 // up with definitions in unusual ways (e.g. by an extern inline 735 // function acquiring a strong function redefinition). Just 736 // ignore these cases. 737 // 738 // TODO: That said, looking this up multiple times is very wasteful. 739 StringRef Name = getMangledName(D); 740 llvm::GlobalValue *CGRef = GetGlobalValue(Name); 741 assert(CGRef && "Deferred decl wasn't referenced?"); 742 743 if (!CGRef->isDeclaration()) 744 continue; 745 746 // GlobalAlias::isDeclaration() defers to the aliasee, but for our 747 // purposes an alias counts as a definition. 748 if (isa<llvm::GlobalAlias>(CGRef)) 749 continue; 750 751 // Otherwise, emit the definition and move on to the next one. 752 EmitGlobalDefinition(D); 753 } 754 } 755 756 void CodeGenModule::EmitGlobalAnnotations() { 757 if (Annotations.empty()) 758 return; 759 760 // Create a new global variable for the ConstantStruct in the Module. 761 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( 762 Annotations[0]->getType(), Annotations.size()), Annotations); 763 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), 764 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array, 765 "llvm.global.annotations"); 766 gv->setSection(AnnotationSection); 767 } 768 769 llvm::Constant *CodeGenModule::EmitAnnotationString(llvm::StringRef Str) { 770 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str); 771 if (i != AnnotationStrings.end()) 772 return i->second; 773 774 // Not found yet, create a new global. 775 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); 776 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(), 777 true, llvm::GlobalValue::PrivateLinkage, s, ".str"); 778 gv->setSection(AnnotationSection); 779 gv->setUnnamedAddr(true); 780 AnnotationStrings[Str] = gv; 781 return gv; 782 } 783 784 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { 785 SourceManager &SM = getContext().getSourceManager(); 786 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 787 if (PLoc.isValid()) 788 return EmitAnnotationString(PLoc.getFilename()); 789 return EmitAnnotationString(SM.getBufferName(Loc)); 790 } 791 792 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { 793 SourceManager &SM = getContext().getSourceManager(); 794 PresumedLoc PLoc = SM.getPresumedLoc(L); 795 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() : 796 SM.getExpansionLineNumber(L); 797 return llvm::ConstantInt::get(Int32Ty, LineNo); 798 } 799 800 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 801 const AnnotateAttr *AA, 802 SourceLocation L) { 803 // Get the globals for file name, annotation, and the line number. 804 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()), 805 *UnitGV = EmitAnnotationUnit(L), 806 *LineNoCst = EmitAnnotationLineNo(L); 807 808 // Create the ConstantStruct for the global annotation. 809 llvm::Constant *Fields[4] = { 810 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy), 811 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy), 812 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy), 813 LineNoCst 814 }; 815 return llvm::ConstantStruct::getAnon(Fields); 816 } 817 818 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, 819 llvm::GlobalValue *GV) { 820 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 821 // Get the struct elements for these annotations. 822 for (specific_attr_iterator<AnnotateAttr> 823 ai = D->specific_attr_begin<AnnotateAttr>(), 824 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 825 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation())); 826 } 827 828 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 829 // Never defer when EmitAllDecls is specified. 830 if (LangOpts.EmitAllDecls) 831 return false; 832 833 return !getContext().DeclMustBeEmitted(Global); 834 } 835 836 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor( 837 const CXXUuidofExpr* E) { 838 // Sema has verified that IIDSource has a __declspec(uuid()), and that its 839 // well-formed. 840 StringRef Uuid; 841 if (E->isTypeOperand()) 842 Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid(); 843 else { 844 // Special case: __uuidof(0) means an all-zero GUID. 845 Expr *Op = E->getExprOperand(); 846 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 847 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid(); 848 else 849 Uuid = "00000000-0000-0000-0000-000000000000"; 850 } 851 std::string Name = "__uuid_" + Uuid.str(); 852 853 // Look for an existing global. 854 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name)) 855 return GV; 856 857 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType()); 858 assert(Init && "failed to initialize as constant"); 859 860 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the 861 // first field is declared as "long", which for many targets is 8 bytes. 862 // Those architectures are not supported. (With the MS abi, long is always 4 863 // bytes.) 864 llvm::Type *GuidType = getTypes().ConvertType(E->getType()); 865 if (Init->getType() != GuidType) { 866 DiagnosticsEngine &Diags = getDiags(); 867 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 868 "__uuidof codegen is not supported on this architecture"); 869 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange(); 870 Init = llvm::UndefValue::get(GuidType); 871 } 872 873 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType, 874 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name); 875 GV->setUnnamedAddr(true); 876 return GV; 877 } 878 879 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 880 const AliasAttr *AA = VD->getAttr<AliasAttr>(); 881 assert(AA && "No alias?"); 882 883 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 884 885 // See if there is already something with the target's name in the module. 886 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 887 888 llvm::Constant *Aliasee; 889 if (isa<llvm::FunctionType>(DeclTy)) 890 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, 891 GlobalDecl(cast<FunctionDecl>(VD)), 892 /*ForVTable=*/false); 893 else 894 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 895 llvm::PointerType::getUnqual(DeclTy), 0); 896 if (!Entry) { 897 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); 898 F->setLinkage(llvm::Function::ExternalWeakLinkage); 899 WeakRefReferences.insert(F); 900 } 901 902 return Aliasee; 903 } 904 905 void CodeGenModule::EmitGlobal(GlobalDecl GD) { 906 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); 907 908 // Weak references don't produce any output by themselves. 909 if (Global->hasAttr<WeakRefAttr>()) 910 return; 911 912 // If this is an alias definition (which otherwise looks like a declaration) 913 // emit it now. 914 if (Global->hasAttr<AliasAttr>()) 915 return EmitAliasDefinition(GD); 916 917 // If this is CUDA, be selective about which declarations we emit. 918 if (LangOpts.CUDA) { 919 if (CodeGenOpts.CUDAIsDevice) { 920 if (!Global->hasAttr<CUDADeviceAttr>() && 921 !Global->hasAttr<CUDAGlobalAttr>() && 922 !Global->hasAttr<CUDAConstantAttr>() && 923 !Global->hasAttr<CUDASharedAttr>()) 924 return; 925 } else { 926 if (!Global->hasAttr<CUDAHostAttr>() && ( 927 Global->hasAttr<CUDADeviceAttr>() || 928 Global->hasAttr<CUDAConstantAttr>() || 929 Global->hasAttr<CUDASharedAttr>())) 930 return; 931 } 932 } 933 934 // Ignore declarations, they will be emitted on their first use. 935 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 936 // Forward declarations are emitted lazily on first use. 937 if (!FD->doesThisDeclarationHaveABody()) { 938 if (!FD->doesDeclarationForceExternallyVisibleDefinition()) 939 return; 940 941 const FunctionDecl *InlineDefinition = 0; 942 FD->getBody(InlineDefinition); 943 944 StringRef MangledName = getMangledName(GD); 945 DeferredDecls.erase(MangledName); 946 EmitGlobalDefinition(InlineDefinition); 947 return; 948 } 949 } else { 950 const VarDecl *VD = cast<VarDecl>(Global); 951 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 952 953 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) 954 return; 955 } 956 957 // Defer code generation when possible if this is a static definition, inline 958 // function etc. These we only want to emit if they are used. 959 if (!MayDeferGeneration(Global)) { 960 // Emit the definition if it can't be deferred. 961 EmitGlobalDefinition(GD); 962 return; 963 } 964 965 // If we're deferring emission of a C++ variable with an 966 // initializer, remember the order in which it appeared in the file. 967 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) && 968 cast<VarDecl>(Global)->hasInit()) { 969 DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 970 CXXGlobalInits.push_back(0); 971 } 972 973 // If the value has already been used, add it directly to the 974 // DeferredDeclsToEmit list. 975 StringRef MangledName = getMangledName(GD); 976 if (GetGlobalValue(MangledName)) 977 DeferredDeclsToEmit.push_back(GD); 978 else { 979 // Otherwise, remember that we saw a deferred decl with this name. The 980 // first use of the mangled name will cause it to move into 981 // DeferredDeclsToEmit. 982 DeferredDecls[MangledName] = GD; 983 } 984 } 985 986 namespace { 987 struct FunctionIsDirectlyRecursive : 988 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> { 989 const StringRef Name; 990 const Builtin::Context &BI; 991 bool Result; 992 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) : 993 Name(N), BI(C), Result(false) { 994 } 995 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base; 996 997 bool TraverseCallExpr(CallExpr *E) { 998 const FunctionDecl *FD = E->getDirectCallee(); 999 if (!FD) 1000 return true; 1001 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 1002 if (Attr && Name == Attr->getLabel()) { 1003 Result = true; 1004 return false; 1005 } 1006 unsigned BuiltinID = FD->getBuiltinID(); 1007 if (!BuiltinID) 1008 return true; 1009 StringRef BuiltinName = BI.GetName(BuiltinID); 1010 if (BuiltinName.startswith("__builtin_") && 1011 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) { 1012 Result = true; 1013 return false; 1014 } 1015 return true; 1016 } 1017 }; 1018 } 1019 1020 // isTriviallyRecursive - Check if this function calls another 1021 // decl that, because of the asm attribute or the other decl being a builtin, 1022 // ends up pointing to itself. 1023 bool 1024 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) { 1025 StringRef Name; 1026 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) { 1027 // asm labels are a special kind of mangling we have to support. 1028 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 1029 if (!Attr) 1030 return false; 1031 Name = Attr->getLabel(); 1032 } else { 1033 Name = FD->getName(); 1034 } 1035 1036 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo); 1037 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD)); 1038 return Walker.Result; 1039 } 1040 1041 bool 1042 CodeGenModule::shouldEmitFunction(const FunctionDecl *F) { 1043 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage) 1044 return true; 1045 if (CodeGenOpts.OptimizationLevel == 0 && 1046 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>()) 1047 return false; 1048 // PR9614. Avoid cases where the source code is lying to us. An available 1049 // externally function should have an equivalent function somewhere else, 1050 // but a function that calls itself is clearly not equivalent to the real 1051 // implementation. 1052 // This happens in glibc's btowc and in some configure checks. 1053 return !isTriviallyRecursive(F); 1054 } 1055 1056 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 1057 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1058 1059 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 1060 Context.getSourceManager(), 1061 "Generating code for declaration"); 1062 1063 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 1064 // At -O0, don't generate IR for functions with available_externally 1065 // linkage. 1066 if (!shouldEmitFunction(Function)) 1067 return; 1068 1069 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 1070 // Make sure to emit the definition(s) before we emit the thunks. 1071 // This is necessary for the generation of certain thunks. 1072 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method)) 1073 EmitCXXConstructor(CD, GD.getCtorType()); 1074 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method)) 1075 EmitCXXDestructor(DD, GD.getDtorType()); 1076 else 1077 EmitGlobalFunctionDefinition(GD); 1078 1079 if (Method->isVirtual()) 1080 getVTables().EmitThunks(GD); 1081 1082 return; 1083 } 1084 1085 return EmitGlobalFunctionDefinition(GD); 1086 } 1087 1088 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 1089 return EmitGlobalVarDefinition(VD); 1090 1091 llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); 1092 } 1093 1094 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the 1095 /// module, create and return an llvm Function with the specified type. If there 1096 /// is something in the module with the specified name, return it potentially 1097 /// bitcasted to the right type. 1098 /// 1099 /// If D is non-null, it specifies a decl that correspond to this. This is used 1100 /// to set the attributes on the function when it is first created. 1101 llvm::Constant * 1102 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, 1103 llvm::Type *Ty, 1104 GlobalDecl D, bool ForVTable, 1105 llvm::Attributes ExtraAttrs) { 1106 // Lookup the entry, lazily creating it if necessary. 1107 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1108 if (Entry) { 1109 if (WeakRefReferences.erase(Entry)) { 1110 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl()); 1111 if (FD && !FD->hasAttr<WeakAttr>()) 1112 Entry->setLinkage(llvm::Function::ExternalLinkage); 1113 } 1114 1115 if (Entry->getType()->getElementType() == Ty) 1116 return Entry; 1117 1118 // Make sure the result is of the correct type. 1119 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); 1120 } 1121 1122 // This function doesn't have a complete type (for example, the return 1123 // type is an incomplete struct). Use a fake type instead, and make 1124 // sure not to try to set attributes. 1125 bool IsIncompleteFunction = false; 1126 1127 llvm::FunctionType *FTy; 1128 if (isa<llvm::FunctionType>(Ty)) { 1129 FTy = cast<llvm::FunctionType>(Ty); 1130 } else { 1131 FTy = llvm::FunctionType::get(VoidTy, false); 1132 IsIncompleteFunction = true; 1133 } 1134 1135 llvm::Function *F = llvm::Function::Create(FTy, 1136 llvm::Function::ExternalLinkage, 1137 MangledName, &getModule()); 1138 assert(F->getName() == MangledName && "name was uniqued!"); 1139 if (D.getDecl()) 1140 SetFunctionAttributes(D, F, IsIncompleteFunction); 1141 if (ExtraAttrs.hasAttributes()) 1142 F->addAttribute(~0, ExtraAttrs); 1143 1144 // This is the first use or definition of a mangled name. If there is a 1145 // deferred decl with this name, remember that we need to emit it at the end 1146 // of the file. 1147 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 1148 if (DDI != DeferredDecls.end()) { 1149 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1150 // list, and remove it from DeferredDecls (since we don't need it anymore). 1151 DeferredDeclsToEmit.push_back(DDI->second); 1152 DeferredDecls.erase(DDI); 1153 1154 // Otherwise, there are cases we have to worry about where we're 1155 // using a declaration for which we must emit a definition but where 1156 // we might not find a top-level definition: 1157 // - member functions defined inline in their classes 1158 // - friend functions defined inline in some class 1159 // - special member functions with implicit definitions 1160 // If we ever change our AST traversal to walk into class methods, 1161 // this will be unnecessary. 1162 // 1163 // We also don't emit a definition for a function if it's going to be an entry 1164 // in a vtable, unless it's already marked as used. 1165 } else if (getLangOpts().CPlusPlus && D.getDecl()) { 1166 // Look for a declaration that's lexically in a record. 1167 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl()); 1168 FD = FD->getMostRecentDecl(); 1169 do { 1170 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 1171 if (FD->isImplicit() && !ForVTable) { 1172 assert(FD->isUsed() && "Sema didn't mark implicit function as used!"); 1173 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 1174 break; 1175 } else if (FD->doesThisDeclarationHaveABody()) { 1176 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 1177 break; 1178 } 1179 } 1180 FD = FD->getPreviousDecl(); 1181 } while (FD); 1182 } 1183 1184 // Make sure the result is of the requested type. 1185 if (!IsIncompleteFunction) { 1186 assert(F->getType()->getElementType() == Ty); 1187 return F; 1188 } 1189 1190 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 1191 return llvm::ConstantExpr::getBitCast(F, PTy); 1192 } 1193 1194 /// GetAddrOfFunction - Return the address of the given function. If Ty is 1195 /// non-null, then this function will use the specified type if it has to 1196 /// create it (this occurs when we see a definition of the function). 1197 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 1198 llvm::Type *Ty, 1199 bool ForVTable) { 1200 // If there was no specific requested type, just convert it now. 1201 if (!Ty) 1202 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 1203 1204 StringRef MangledName = getMangledName(GD); 1205 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable); 1206 } 1207 1208 /// CreateRuntimeFunction - Create a new runtime function with the specified 1209 /// type and name. 1210 llvm::Constant * 1211 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, 1212 StringRef Name, 1213 llvm::Attributes ExtraAttrs) { 1214 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 1215 ExtraAttrs); 1216 } 1217 1218 /// isTypeConstant - Determine whether an object of this type can be emitted 1219 /// as a constant. 1220 /// 1221 /// If ExcludeCtor is true, the duration when the object's constructor runs 1222 /// will not be considered. The caller will need to verify that the object is 1223 /// not written to during its construction. 1224 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) { 1225 if (!Ty.isConstant(Context) && !Ty->isReferenceType()) 1226 return false; 1227 1228 if (Context.getLangOpts().CPlusPlus) { 1229 if (const CXXRecordDecl *Record 1230 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl()) 1231 return ExcludeCtor && !Record->hasMutableFields() && 1232 Record->hasTrivialDestructor(); 1233 } 1234 1235 return true; 1236 } 1237 1238 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 1239 /// create and return an llvm GlobalVariable with the specified type. If there 1240 /// is something in the module with the specified name, return it potentially 1241 /// bitcasted to the right type. 1242 /// 1243 /// If D is non-null, it specifies a decl that correspond to this. This is used 1244 /// to set the attributes on the global when it is first created. 1245 llvm::Constant * 1246 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, 1247 llvm::PointerType *Ty, 1248 const VarDecl *D, 1249 bool UnnamedAddr) { 1250 // Lookup the entry, lazily creating it if necessary. 1251 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1252 if (Entry) { 1253 if (WeakRefReferences.erase(Entry)) { 1254 if (D && !D->hasAttr<WeakAttr>()) 1255 Entry->setLinkage(llvm::Function::ExternalLinkage); 1256 } 1257 1258 if (UnnamedAddr) 1259 Entry->setUnnamedAddr(true); 1260 1261 if (Entry->getType() == Ty) 1262 return Entry; 1263 1264 // Make sure the result is of the correct type. 1265 return llvm::ConstantExpr::getBitCast(Entry, Ty); 1266 } 1267 1268 // This is the first use or definition of a mangled name. If there is a 1269 // deferred decl with this name, remember that we need to emit it at the end 1270 // of the file. 1271 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 1272 if (DDI != DeferredDecls.end()) { 1273 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1274 // list, and remove it from DeferredDecls (since we don't need it anymore). 1275 DeferredDeclsToEmit.push_back(DDI->second); 1276 DeferredDecls.erase(DDI); 1277 } 1278 1279 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); 1280 llvm::GlobalVariable *GV = 1281 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 1282 llvm::GlobalValue::ExternalLinkage, 1283 0, MangledName, 0, 1284 llvm::GlobalVariable::NotThreadLocal, AddrSpace); 1285 1286 // Handle things which are present even on external declarations. 1287 if (D) { 1288 // FIXME: This code is overly simple and should be merged with other global 1289 // handling. 1290 GV->setConstant(isTypeConstant(D->getType(), false)); 1291 1292 // Set linkage and visibility in case we never see a definition. 1293 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 1294 if (LV.linkage() != ExternalLinkage) { 1295 // Don't set internal linkage on declarations. 1296 } else { 1297 if (D->hasAttr<DLLImportAttr>()) 1298 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage); 1299 else if (D->hasAttr<WeakAttr>() || D->isWeakImported()) 1300 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 1301 1302 // Set visibility on a declaration only if it's explicit. 1303 if (LV.visibilityExplicit()) 1304 GV->setVisibility(GetLLVMVisibility(LV.visibility())); 1305 } 1306 1307 if (D->isThreadSpecified()) 1308 setTLSMode(GV, *D); 1309 } 1310 1311 if (AddrSpace != Ty->getAddressSpace()) 1312 return llvm::ConstantExpr::getBitCast(GV, Ty); 1313 else 1314 return GV; 1315 } 1316 1317 1318 llvm::GlobalVariable * 1319 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, 1320 llvm::Type *Ty, 1321 llvm::GlobalValue::LinkageTypes Linkage) { 1322 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 1323 llvm::GlobalVariable *OldGV = 0; 1324 1325 1326 if (GV) { 1327 // Check if the variable has the right type. 1328 if (GV->getType()->getElementType() == Ty) 1329 return GV; 1330 1331 // Because C++ name mangling, the only way we can end up with an already 1332 // existing global with the same name is if it has been declared extern "C". 1333 assert(GV->isDeclaration() && "Declaration has wrong type!"); 1334 OldGV = GV; 1335 } 1336 1337 // Create a new variable. 1338 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 1339 Linkage, 0, Name); 1340 1341 if (OldGV) { 1342 // Replace occurrences of the old variable if needed. 1343 GV->takeName(OldGV); 1344 1345 if (!OldGV->use_empty()) { 1346 llvm::Constant *NewPtrForOldDecl = 1347 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 1348 OldGV->replaceAllUsesWith(NewPtrForOldDecl); 1349 } 1350 1351 OldGV->eraseFromParent(); 1352 } 1353 1354 return GV; 1355 } 1356 1357 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 1358 /// given global variable. If Ty is non-null and if the global doesn't exist, 1359 /// then it will be created with the specified type instead of whatever the 1360 /// normal requested type would be. 1361 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 1362 llvm::Type *Ty) { 1363 assert(D->hasGlobalStorage() && "Not a global variable"); 1364 QualType ASTTy = D->getType(); 1365 if (Ty == 0) 1366 Ty = getTypes().ConvertTypeForMem(ASTTy); 1367 1368 llvm::PointerType *PTy = 1369 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 1370 1371 StringRef MangledName = getMangledName(D); 1372 return GetOrCreateLLVMGlobal(MangledName, PTy, D); 1373 } 1374 1375 /// CreateRuntimeVariable - Create a new runtime global variable with the 1376 /// specified type and name. 1377 llvm::Constant * 1378 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, 1379 StringRef Name) { 1380 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, 1381 true); 1382 } 1383 1384 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 1385 assert(!D->getInit() && "Cannot emit definite definitions here!"); 1386 1387 if (MayDeferGeneration(D)) { 1388 // If we have not seen a reference to this variable yet, place it 1389 // into the deferred declarations table to be emitted if needed 1390 // later. 1391 StringRef MangledName = getMangledName(D); 1392 if (!GetGlobalValue(MangledName)) { 1393 DeferredDecls[MangledName] = D; 1394 return; 1395 } 1396 } 1397 1398 // The tentative definition is the only definition. 1399 EmitGlobalVarDefinition(D); 1400 } 1401 1402 void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) { 1403 if (DefinitionRequired) 1404 getCXXABI().EmitVTables(Class); 1405 } 1406 1407 llvm::GlobalVariable::LinkageTypes 1408 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { 1409 if (RD->getLinkage() != ExternalLinkage) 1410 return llvm::GlobalVariable::InternalLinkage; 1411 1412 if (const CXXMethodDecl *KeyFunction 1413 = RD->getASTContext().getKeyFunction(RD)) { 1414 // If this class has a key function, use that to determine the linkage of 1415 // the vtable. 1416 const FunctionDecl *Def = 0; 1417 if (KeyFunction->hasBody(Def)) 1418 KeyFunction = cast<CXXMethodDecl>(Def); 1419 1420 switch (KeyFunction->getTemplateSpecializationKind()) { 1421 case TSK_Undeclared: 1422 case TSK_ExplicitSpecialization: 1423 // When compiling with optimizations turned on, we emit all vtables, 1424 // even if the key function is not defined in the current translation 1425 // unit. If this is the case, use available_externally linkage. 1426 if (!Def && CodeGenOpts.OptimizationLevel) 1427 return llvm::GlobalVariable::AvailableExternallyLinkage; 1428 1429 if (KeyFunction->isInlined()) 1430 return !Context.getLangOpts().AppleKext ? 1431 llvm::GlobalVariable::LinkOnceODRLinkage : 1432 llvm::Function::InternalLinkage; 1433 1434 return llvm::GlobalVariable::ExternalLinkage; 1435 1436 case TSK_ImplicitInstantiation: 1437 return !Context.getLangOpts().AppleKext ? 1438 llvm::GlobalVariable::LinkOnceODRLinkage : 1439 llvm::Function::InternalLinkage; 1440 1441 case TSK_ExplicitInstantiationDefinition: 1442 return !Context.getLangOpts().AppleKext ? 1443 llvm::GlobalVariable::WeakODRLinkage : 1444 llvm::Function::InternalLinkage; 1445 1446 case TSK_ExplicitInstantiationDeclaration: 1447 // FIXME: Use available_externally linkage. However, this currently 1448 // breaks LLVM's build due to undefined symbols. 1449 // return llvm::GlobalVariable::AvailableExternallyLinkage; 1450 return !Context.getLangOpts().AppleKext ? 1451 llvm::GlobalVariable::LinkOnceODRLinkage : 1452 llvm::Function::InternalLinkage; 1453 } 1454 } 1455 1456 if (Context.getLangOpts().AppleKext) 1457 return llvm::Function::InternalLinkage; 1458 1459 switch (RD->getTemplateSpecializationKind()) { 1460 case TSK_Undeclared: 1461 case TSK_ExplicitSpecialization: 1462 case TSK_ImplicitInstantiation: 1463 // FIXME: Use available_externally linkage. However, this currently 1464 // breaks LLVM's build due to undefined symbols. 1465 // return llvm::GlobalVariable::AvailableExternallyLinkage; 1466 case TSK_ExplicitInstantiationDeclaration: 1467 return llvm::GlobalVariable::LinkOnceODRLinkage; 1468 1469 case TSK_ExplicitInstantiationDefinition: 1470 return llvm::GlobalVariable::WeakODRLinkage; 1471 } 1472 1473 llvm_unreachable("Invalid TemplateSpecializationKind!"); 1474 } 1475 1476 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { 1477 return Context.toCharUnitsFromBits( 1478 TheDataLayout.getTypeStoreSizeInBits(Ty)); 1479 } 1480 1481 llvm::Constant * 1482 CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D, 1483 const Expr *rawInit) { 1484 ArrayRef<ExprWithCleanups::CleanupObject> cleanups; 1485 if (const ExprWithCleanups *withCleanups = 1486 dyn_cast<ExprWithCleanups>(rawInit)) { 1487 cleanups = withCleanups->getObjects(); 1488 rawInit = withCleanups->getSubExpr(); 1489 } 1490 1491 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit); 1492 if (!init || !init->initializesStdInitializerList() || 1493 init->getNumInits() == 0) 1494 return 0; 1495 1496 ASTContext &ctx = getContext(); 1497 unsigned numInits = init->getNumInits(); 1498 // FIXME: This check is here because we would otherwise silently miscompile 1499 // nested global std::initializer_lists. Better would be to have a real 1500 // implementation. 1501 for (unsigned i = 0; i < numInits; ++i) { 1502 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i)); 1503 if (inner && inner->initializesStdInitializerList()) { 1504 ErrorUnsupported(inner, "nested global std::initializer_list"); 1505 return 0; 1506 } 1507 } 1508 1509 // Synthesize a fake VarDecl for the array and initialize that. 1510 QualType elementType = init->getInit(0)->getType(); 1511 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits); 1512 QualType arrayType = ctx.getConstantArrayType(elementType, numElements, 1513 ArrayType::Normal, 0); 1514 1515 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist"); 1516 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo( 1517 arrayType, D->getLocation()); 1518 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>( 1519 D->getDeclContext()), 1520 D->getLocStart(), D->getLocation(), 1521 name, arrayType, sourceInfo, 1522 SC_Static, SC_Static); 1523 1524 // Now clone the InitListExpr to initialize the array instead. 1525 // Incredible hack: we want to use the existing InitListExpr here, so we need 1526 // to tell it that it no longer initializes a std::initializer_list. 1527 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(), 1528 init->getNumInits()); 1529 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits, 1530 init->getRBraceLoc()); 1531 arrayInit->setType(arrayType); 1532 1533 if (!cleanups.empty()) 1534 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups); 1535 1536 backingArray->setInit(arrayInit); 1537 1538 // Emit the definition of the array. 1539 EmitGlobalVarDefinition(backingArray); 1540 1541 // Inspect the initializer list to validate it and determine its type. 1542 // FIXME: doing this every time is probably inefficient; caching would be nice 1543 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl(); 1544 RecordDecl::field_iterator field = record->field_begin(); 1545 if (field == record->field_end()) { 1546 ErrorUnsupported(D, "weird std::initializer_list"); 1547 return 0; 1548 } 1549 QualType elementPtr = ctx.getPointerType(elementType.withConst()); 1550 // Start pointer. 1551 if (!ctx.hasSameType(field->getType(), elementPtr)) { 1552 ErrorUnsupported(D, "weird std::initializer_list"); 1553 return 0; 1554 } 1555 ++field; 1556 if (field == record->field_end()) { 1557 ErrorUnsupported(D, "weird std::initializer_list"); 1558 return 0; 1559 } 1560 bool isStartEnd = false; 1561 if (ctx.hasSameType(field->getType(), elementPtr)) { 1562 // End pointer. 1563 isStartEnd = true; 1564 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) { 1565 ErrorUnsupported(D, "weird std::initializer_list"); 1566 return 0; 1567 } 1568 1569 // Now build an APValue representing the std::initializer_list. 1570 APValue initListValue(APValue::UninitStruct(), 0, 2); 1571 APValue &startField = initListValue.getStructField(0); 1572 APValue::LValuePathEntry startOffsetPathEntry; 1573 startOffsetPathEntry.ArrayIndex = 0; 1574 startField = APValue(APValue::LValueBase(backingArray), 1575 CharUnits::fromQuantity(0), 1576 llvm::makeArrayRef(startOffsetPathEntry), 1577 /*IsOnePastTheEnd=*/false, 0); 1578 1579 if (isStartEnd) { 1580 APValue &endField = initListValue.getStructField(1); 1581 APValue::LValuePathEntry endOffsetPathEntry; 1582 endOffsetPathEntry.ArrayIndex = numInits; 1583 endField = APValue(APValue::LValueBase(backingArray), 1584 ctx.getTypeSizeInChars(elementType) * numInits, 1585 llvm::makeArrayRef(endOffsetPathEntry), 1586 /*IsOnePastTheEnd=*/true, 0); 1587 } else { 1588 APValue &sizeField = initListValue.getStructField(1); 1589 sizeField = APValue(llvm::APSInt(numElements)); 1590 } 1591 1592 // Emit the constant for the initializer_list. 1593 llvm::Constant *llvmInit = 1594 EmitConstantValueForMemory(initListValue, D->getType()); 1595 assert(llvmInit && "failed to initialize as constant"); 1596 return llvmInit; 1597 } 1598 1599 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D, 1600 unsigned AddrSpace) { 1601 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) { 1602 if (D->hasAttr<CUDAConstantAttr>()) 1603 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant); 1604 else if (D->hasAttr<CUDASharedAttr>()) 1605 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared); 1606 else 1607 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device); 1608 } 1609 1610 return AddrSpace; 1611 } 1612 1613 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 1614 llvm::Constant *Init = 0; 1615 QualType ASTTy = D->getType(); 1616 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 1617 bool NeedsGlobalCtor = false; 1618 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor(); 1619 1620 const VarDecl *InitDecl; 1621 const Expr *InitExpr = D->getAnyInitializer(InitDecl); 1622 1623 if (!InitExpr) { 1624 // This is a tentative definition; tentative definitions are 1625 // implicitly initialized with { 0 }. 1626 // 1627 // Note that tentative definitions are only emitted at the end of 1628 // a translation unit, so they should never have incomplete 1629 // type. In addition, EmitTentativeDefinition makes sure that we 1630 // never attempt to emit a tentative definition if a real one 1631 // exists. A use may still exists, however, so we still may need 1632 // to do a RAUW. 1633 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 1634 Init = EmitNullConstant(D->getType()); 1635 } else { 1636 // If this is a std::initializer_list, emit the special initializer. 1637 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr); 1638 // An empty init list will perform zero-initialization, which happens 1639 // to be exactly what we want. 1640 // FIXME: It does so in a global constructor, which is *not* what we 1641 // want. 1642 1643 if (!Init) { 1644 initializedGlobalDecl = GlobalDecl(D); 1645 Init = EmitConstantInit(*InitDecl); 1646 } 1647 if (!Init) { 1648 QualType T = InitExpr->getType(); 1649 if (D->getType()->isReferenceType()) 1650 T = D->getType(); 1651 1652 if (getLangOpts().CPlusPlus) { 1653 Init = EmitNullConstant(T); 1654 NeedsGlobalCtor = true; 1655 } else { 1656 ErrorUnsupported(D, "static initializer"); 1657 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 1658 } 1659 } else { 1660 // We don't need an initializer, so remove the entry for the delayed 1661 // initializer position (just in case this entry was delayed) if we 1662 // also don't need to register a destructor. 1663 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor) 1664 DelayedCXXInitPosition.erase(D); 1665 } 1666 } 1667 1668 llvm::Type* InitType = Init->getType(); 1669 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 1670 1671 // Strip off a bitcast if we got one back. 1672 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1673 assert(CE->getOpcode() == llvm::Instruction::BitCast || 1674 // all zero index gep. 1675 CE->getOpcode() == llvm::Instruction::GetElementPtr); 1676 Entry = CE->getOperand(0); 1677 } 1678 1679 // Entry is now either a Function or GlobalVariable. 1680 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 1681 1682 // We have a definition after a declaration with the wrong type. 1683 // We must make a new GlobalVariable* and update everything that used OldGV 1684 // (a declaration or tentative definition) with the new GlobalVariable* 1685 // (which will be a definition). 1686 // 1687 // This happens if there is a prototype for a global (e.g. 1688 // "extern int x[];") and then a definition of a different type (e.g. 1689 // "int x[10];"). This also happens when an initializer has a different type 1690 // from the type of the global (this happens with unions). 1691 if (GV == 0 || 1692 GV->getType()->getElementType() != InitType || 1693 GV->getType()->getAddressSpace() != 1694 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) { 1695 1696 // Move the old entry aside so that we'll create a new one. 1697 Entry->setName(StringRef()); 1698 1699 // Make a new global with the correct type, this is now guaranteed to work. 1700 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 1701 1702 // Replace all uses of the old global with the new global 1703 llvm::Constant *NewPtrForOldDecl = 1704 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 1705 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1706 1707 // Erase the old global, since it is no longer used. 1708 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 1709 } 1710 1711 if (D->hasAttr<AnnotateAttr>()) 1712 AddGlobalAnnotations(D, GV); 1713 1714 GV->setInitializer(Init); 1715 1716 // If it is safe to mark the global 'constant', do so now. 1717 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor && 1718 isTypeConstant(D->getType(), true)); 1719 1720 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 1721 1722 // Set the llvm linkage type as appropriate. 1723 llvm::GlobalValue::LinkageTypes Linkage = 1724 GetLLVMLinkageVarDefinition(D, GV); 1725 GV->setLinkage(Linkage); 1726 if (Linkage == llvm::GlobalVariable::CommonLinkage) 1727 // common vars aren't constant even if declared const. 1728 GV->setConstant(false); 1729 1730 SetCommonAttributes(D, GV); 1731 1732 // Emit the initializer function if necessary. 1733 if (NeedsGlobalCtor || NeedsGlobalDtor) 1734 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor); 1735 1736 // If we are compiling with ASan, add metadata indicating dynamically 1737 // initialized globals. 1738 if (LangOpts.AddressSanitizer && NeedsGlobalCtor) { 1739 llvm::Module &M = getModule(); 1740 1741 llvm::NamedMDNode *DynamicInitializers = 1742 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals"); 1743 llvm::Value *GlobalToAdd[] = { GV }; 1744 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd); 1745 DynamicInitializers->addOperand(ThisGlobal); 1746 } 1747 1748 // Emit global variable debug information. 1749 if (CGDebugInfo *DI = getModuleDebugInfo()) 1750 if (getCodeGenOpts().DebugInfo >= CodeGenOptions::LimitedDebugInfo) 1751 DI->EmitGlobalVariable(GV, D); 1752 } 1753 1754 llvm::GlobalValue::LinkageTypes 1755 CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, 1756 llvm::GlobalVariable *GV) { 1757 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D); 1758 if (Linkage == GVA_Internal) 1759 return llvm::Function::InternalLinkage; 1760 else if (D->hasAttr<DLLImportAttr>()) 1761 return llvm::Function::DLLImportLinkage; 1762 else if (D->hasAttr<DLLExportAttr>()) 1763 return llvm::Function::DLLExportLinkage; 1764 else if (D->hasAttr<WeakAttr>()) { 1765 if (GV->isConstant()) 1766 return llvm::GlobalVariable::WeakODRLinkage; 1767 else 1768 return llvm::GlobalVariable::WeakAnyLinkage; 1769 } else if (Linkage == GVA_TemplateInstantiation || 1770 Linkage == GVA_ExplicitTemplateInstantiation) 1771 return llvm::GlobalVariable::WeakODRLinkage; 1772 else if (!getLangOpts().CPlusPlus && 1773 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) || 1774 D->getAttr<CommonAttr>()) && 1775 !D->hasExternalStorage() && !D->getInit() && 1776 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() && 1777 !D->getAttr<WeakImportAttr>()) { 1778 // Thread local vars aren't considered common linkage. 1779 return llvm::GlobalVariable::CommonLinkage; 1780 } 1781 return llvm::GlobalVariable::ExternalLinkage; 1782 } 1783 1784 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1785 /// implement a function with no prototype, e.g. "int foo() {}". If there are 1786 /// existing call uses of the old function in the module, this adjusts them to 1787 /// call the new function directly. 1788 /// 1789 /// This is not just a cleanup: the always_inline pass requires direct calls to 1790 /// functions to be able to inline them. If there is a bitcast in the way, it 1791 /// won't inline them. Instcombine normally deletes these calls, but it isn't 1792 /// run at -O0. 1793 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1794 llvm::Function *NewFn) { 1795 // If we're redefining a global as a function, don't transform it. 1796 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 1797 if (OldFn == 0) return; 1798 1799 llvm::Type *NewRetTy = NewFn->getReturnType(); 1800 SmallVector<llvm::Value*, 4> ArgList; 1801 1802 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 1803 UI != E; ) { 1804 // TODO: Do invokes ever occur in C code? If so, we should handle them too. 1805 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased. 1806 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I); 1807 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I) 1808 llvm::CallSite CS(CI); 1809 if (!CI || !CS.isCallee(I)) continue; 1810 1811 // If the return types don't match exactly, and if the call isn't dead, then 1812 // we can't transform this call. 1813 if (CI->getType() != NewRetTy && !CI->use_empty()) 1814 continue; 1815 1816 // Get the attribute list. 1817 llvm::SmallVector<llvm::AttributeWithIndex, 8> AttrVec; 1818 llvm::AttrListPtr AttrList = CI->getAttributes(); 1819 1820 // Get any return attributes. 1821 llvm::Attributes RAttrs = AttrList.getRetAttributes(); 1822 1823 // Add the return attributes. 1824 if (RAttrs.hasAttributes()) 1825 AttrVec.push_back(llvm::AttributeWithIndex::get(0, RAttrs)); 1826 1827 // If the function was passed too few arguments, don't transform. If extra 1828 // arguments were passed, we silently drop them. If any of the types 1829 // mismatch, we don't transform. 1830 unsigned ArgNo = 0; 1831 bool DontTransform = false; 1832 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 1833 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 1834 if (CS.arg_size() == ArgNo || 1835 CS.getArgument(ArgNo)->getType() != AI->getType()) { 1836 DontTransform = true; 1837 break; 1838 } 1839 1840 // Add any parameter attributes. 1841 llvm::Attributes PAttrs = AttrList.getParamAttributes(ArgNo + 1); 1842 if (PAttrs.hasAttributes()) 1843 AttrVec.push_back(llvm::AttributeWithIndex::get(ArgNo + 1, PAttrs)); 1844 } 1845 if (DontTransform) 1846 continue; 1847 1848 llvm::Attributes FnAttrs = AttrList.getFnAttributes(); 1849 if (FnAttrs.hasAttributes()) 1850 AttrVec.push_back(llvm::AttributeWithIndex::get(~0, FnAttrs)); 1851 1852 // Okay, we can transform this. Create the new call instruction and copy 1853 // over the required information. 1854 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo); 1855 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList, "", CI); 1856 ArgList.clear(); 1857 if (!NewCall->getType()->isVoidTy()) 1858 NewCall->takeName(CI); 1859 NewCall->setAttributes(llvm::AttrListPtr::get(AttrVec)); 1860 NewCall->setCallingConv(CI->getCallingConv()); 1861 1862 // Finally, remove the old call, replacing any uses with the new one. 1863 if (!CI->use_empty()) 1864 CI->replaceAllUsesWith(NewCall); 1865 1866 // Copy debug location attached to CI. 1867 if (!CI->getDebugLoc().isUnknown()) 1868 NewCall->setDebugLoc(CI->getDebugLoc()); 1869 CI->eraseFromParent(); 1870 } 1871 } 1872 1873 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 1874 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind(); 1875 // If we have a definition, this might be a deferred decl. If the 1876 // instantiation is explicit, make sure we emit it at the end. 1877 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition) 1878 GetAddrOfGlobalVar(VD); 1879 } 1880 1881 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 1882 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 1883 1884 // Compute the function info and LLVM type. 1885 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 1886 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 1887 1888 // Get or create the prototype for the function. 1889 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 1890 1891 // Strip off a bitcast if we got one back. 1892 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1893 assert(CE->getOpcode() == llvm::Instruction::BitCast); 1894 Entry = CE->getOperand(0); 1895 } 1896 1897 1898 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 1899 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 1900 1901 // If the types mismatch then we have to rewrite the definition. 1902 assert(OldFn->isDeclaration() && 1903 "Shouldn't replace non-declaration"); 1904 1905 // F is the Function* for the one with the wrong type, we must make a new 1906 // Function* and update everything that used F (a declaration) with the new 1907 // Function* (which will be a definition). 1908 // 1909 // This happens if there is a prototype for a function 1910 // (e.g. "int f()") and then a definition of a different type 1911 // (e.g. "int f(int x)"). Move the old function aside so that it 1912 // doesn't interfere with GetAddrOfFunction. 1913 OldFn->setName(StringRef()); 1914 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 1915 1916 // If this is an implementation of a function without a prototype, try to 1917 // replace any existing uses of the function (which may be calls) with uses 1918 // of the new function 1919 if (D->getType()->isFunctionNoProtoType()) { 1920 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 1921 OldFn->removeDeadConstantUsers(); 1922 } 1923 1924 // Replace uses of F with the Function we will endow with a body. 1925 if (!Entry->use_empty()) { 1926 llvm::Constant *NewPtrForOldDecl = 1927 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 1928 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1929 } 1930 1931 // Ok, delete the old function now, which is dead. 1932 OldFn->eraseFromParent(); 1933 1934 Entry = NewFn; 1935 } 1936 1937 // We need to set linkage and visibility on the function before 1938 // generating code for it because various parts of IR generation 1939 // want to propagate this information down (e.g. to local static 1940 // declarations). 1941 llvm::Function *Fn = cast<llvm::Function>(Entry); 1942 setFunctionLinkage(D, Fn); 1943 1944 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes 1945 setGlobalVisibility(Fn, D); 1946 1947 CodeGenFunction(*this).GenerateCode(D, Fn, FI); 1948 1949 SetFunctionDefinitionAttributes(D, Fn); 1950 SetLLVMFunctionAttributesForDefinition(D, Fn); 1951 1952 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 1953 AddGlobalCtor(Fn, CA->getPriority()); 1954 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 1955 AddGlobalDtor(Fn, DA->getPriority()); 1956 if (D->hasAttr<AnnotateAttr>()) 1957 AddGlobalAnnotations(D, Fn); 1958 } 1959 1960 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 1961 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1962 const AliasAttr *AA = D->getAttr<AliasAttr>(); 1963 assert(AA && "Not an alias?"); 1964 1965 StringRef MangledName = getMangledName(GD); 1966 1967 // If there is a definition in the module, then it wins over the alias. 1968 // This is dubious, but allow it to be safe. Just ignore the alias. 1969 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1970 if (Entry && !Entry->isDeclaration()) 1971 return; 1972 1973 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 1974 1975 // Create a reference to the named value. This ensures that it is emitted 1976 // if a deferred decl. 1977 llvm::Constant *Aliasee; 1978 if (isa<llvm::FunctionType>(DeclTy)) 1979 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD, 1980 /*ForVTable=*/false); 1981 else 1982 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 1983 llvm::PointerType::getUnqual(DeclTy), 0); 1984 1985 // Create the new alias itself, but don't set a name yet. 1986 llvm::GlobalValue *GA = 1987 new llvm::GlobalAlias(Aliasee->getType(), 1988 llvm::Function::ExternalLinkage, 1989 "", Aliasee, &getModule()); 1990 1991 if (Entry) { 1992 assert(Entry->isDeclaration()); 1993 1994 // If there is a declaration in the module, then we had an extern followed 1995 // by the alias, as in: 1996 // extern int test6(); 1997 // ... 1998 // int test6() __attribute__((alias("test7"))); 1999 // 2000 // Remove it and replace uses of it with the alias. 2001 GA->takeName(Entry); 2002 2003 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 2004 Entry->getType())); 2005 Entry->eraseFromParent(); 2006 } else { 2007 GA->setName(MangledName); 2008 } 2009 2010 // Set attributes which are particular to an alias; this is a 2011 // specialization of the attributes which may be set on a global 2012 // variable/function. 2013 if (D->hasAttr<DLLExportAttr>()) { 2014 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2015 // The dllexport attribute is ignored for undefined symbols. 2016 if (FD->hasBody()) 2017 GA->setLinkage(llvm::Function::DLLExportLinkage); 2018 } else { 2019 GA->setLinkage(llvm::Function::DLLExportLinkage); 2020 } 2021 } else if (D->hasAttr<WeakAttr>() || 2022 D->hasAttr<WeakRefAttr>() || 2023 D->isWeakImported()) { 2024 GA->setLinkage(llvm::Function::WeakAnyLinkage); 2025 } 2026 2027 SetCommonAttributes(D, GA); 2028 } 2029 2030 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID, 2031 ArrayRef<llvm::Type*> Tys) { 2032 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID, 2033 Tys); 2034 } 2035 2036 static llvm::StringMapEntry<llvm::Constant*> & 2037 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2038 const StringLiteral *Literal, 2039 bool TargetIsLSB, 2040 bool &IsUTF16, 2041 unsigned &StringLength) { 2042 StringRef String = Literal->getString(); 2043 unsigned NumBytes = String.size(); 2044 2045 // Check for simple case. 2046 if (!Literal->containsNonAsciiOrNull()) { 2047 StringLength = NumBytes; 2048 return Map.GetOrCreateValue(String); 2049 } 2050 2051 // Otherwise, convert the UTF8 literals into a string of shorts. 2052 IsUTF16 = true; 2053 2054 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls. 2055 const UTF8 *FromPtr = (const UTF8 *)String.data(); 2056 UTF16 *ToPtr = &ToBuf[0]; 2057 2058 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 2059 &ToPtr, ToPtr + NumBytes, 2060 strictConversion); 2061 2062 // ConvertUTF8toUTF16 returns the length in ToPtr. 2063 StringLength = ToPtr - &ToBuf[0]; 2064 2065 // Add an explicit null. 2066 *ToPtr = 0; 2067 return Map. 2068 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()), 2069 (StringLength + 1) * 2)); 2070 } 2071 2072 static llvm::StringMapEntry<llvm::Constant*> & 2073 GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2074 const StringLiteral *Literal, 2075 unsigned &StringLength) { 2076 StringRef String = Literal->getString(); 2077 StringLength = String.size(); 2078 return Map.GetOrCreateValue(String); 2079 } 2080 2081 llvm::Constant * 2082 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 2083 unsigned StringLength = 0; 2084 bool isUTF16 = false; 2085 llvm::StringMapEntry<llvm::Constant*> &Entry = 2086 GetConstantCFStringEntry(CFConstantStringMap, Literal, 2087 getDataLayout().isLittleEndian(), 2088 isUTF16, StringLength); 2089 2090 if (llvm::Constant *C = Entry.getValue()) 2091 return C; 2092 2093 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2094 llvm::Constant *Zeros[] = { Zero, Zero }; 2095 2096 // If we don't already have it, get __CFConstantStringClassReference. 2097 if (!CFConstantStringClassRef) { 2098 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2099 Ty = llvm::ArrayType::get(Ty, 0); 2100 llvm::Constant *GV = CreateRuntimeVariable(Ty, 2101 "__CFConstantStringClassReference"); 2102 // Decay array -> ptr 2103 CFConstantStringClassRef = 2104 llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2105 } 2106 2107 QualType CFTy = getContext().getCFConstantStringType(); 2108 2109 llvm::StructType *STy = 2110 cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 2111 2112 llvm::Constant *Fields[4]; 2113 2114 // Class pointer. 2115 Fields[0] = CFConstantStringClassRef; 2116 2117 // Flags. 2118 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2119 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 2120 llvm::ConstantInt::get(Ty, 0x07C8); 2121 2122 // String pointer. 2123 llvm::Constant *C = 0; 2124 if (isUTF16) { 2125 ArrayRef<uint16_t> Arr = 2126 llvm::makeArrayRef<uint16_t>((uint16_t*)Entry.getKey().data(), 2127 Entry.getKey().size() / 2); 2128 C = llvm::ConstantDataArray::get(VMContext, Arr); 2129 } else { 2130 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); 2131 } 2132 2133 llvm::GlobalValue::LinkageTypes Linkage; 2134 if (isUTF16) 2135 // FIXME: why do utf strings get "_" labels instead of "L" labels? 2136 Linkage = llvm::GlobalValue::InternalLinkage; 2137 else 2138 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error 2139 // when using private linkage. It is not clear if this is a bug in ld 2140 // or a reasonable new restriction. 2141 Linkage = llvm::GlobalValue::LinkerPrivateLinkage; 2142 2143 // Note: -fwritable-strings doesn't make the backing store strings of 2144 // CFStrings writable. (See <rdar://problem/10657500>) 2145 llvm::GlobalVariable *GV = 2146 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, 2147 Linkage, C, ".str"); 2148 GV->setUnnamedAddr(true); 2149 if (isUTF16) { 2150 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 2151 GV->setAlignment(Align.getQuantity()); 2152 } else { 2153 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2154 GV->setAlignment(Align.getQuantity()); 2155 } 2156 2157 // String. 2158 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2159 2160 if (isUTF16) 2161 // Cast the UTF16 string to the correct type. 2162 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy); 2163 2164 // String length. 2165 Ty = getTypes().ConvertType(getContext().LongTy); 2166 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 2167 2168 // The struct. 2169 C = llvm::ConstantStruct::get(STy, Fields); 2170 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2171 llvm::GlobalVariable::PrivateLinkage, C, 2172 "_unnamed_cfstring_"); 2173 if (const char *Sect = getContext().getTargetInfo().getCFStringSection()) 2174 GV->setSection(Sect); 2175 Entry.setValue(GV); 2176 2177 return GV; 2178 } 2179 2180 static RecordDecl * 2181 CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 2182 DeclContext *DC, IdentifierInfo *Id) { 2183 SourceLocation Loc; 2184 if (Ctx.getLangOpts().CPlusPlus) 2185 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 2186 else 2187 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 2188 } 2189 2190 llvm::Constant * 2191 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { 2192 unsigned StringLength = 0; 2193 llvm::StringMapEntry<llvm::Constant*> &Entry = 2194 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength); 2195 2196 if (llvm::Constant *C = Entry.getValue()) 2197 return C; 2198 2199 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2200 llvm::Constant *Zeros[] = { Zero, Zero }; 2201 2202 // If we don't already have it, get _NSConstantStringClassReference. 2203 if (!ConstantStringClassRef) { 2204 std::string StringClass(getLangOpts().ObjCConstantStringClass); 2205 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2206 llvm::Constant *GV; 2207 if (LangOpts.ObjCRuntime.isNonFragile()) { 2208 std::string str = 2209 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 2210 : "OBJC_CLASS_$_" + StringClass; 2211 GV = getObjCRuntime().GetClassGlobal(str); 2212 // Make sure the result is of the correct type. 2213 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 2214 ConstantStringClassRef = 2215 llvm::ConstantExpr::getBitCast(GV, PTy); 2216 } else { 2217 std::string str = 2218 StringClass.empty() ? "_NSConstantStringClassReference" 2219 : "_" + StringClass + "ClassReference"; 2220 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0); 2221 GV = CreateRuntimeVariable(PTy, str); 2222 // Decay array -> ptr 2223 ConstantStringClassRef = 2224 llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2225 } 2226 } 2227 2228 if (!NSConstantStringType) { 2229 // Construct the type for a constant NSString. 2230 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 2231 Context.getTranslationUnitDecl(), 2232 &Context.Idents.get("__builtin_NSString")); 2233 D->startDefinition(); 2234 2235 QualType FieldTypes[3]; 2236 2237 // const int *isa; 2238 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst()); 2239 // const char *str; 2240 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst()); 2241 // unsigned int length; 2242 FieldTypes[2] = Context.UnsignedIntTy; 2243 2244 // Create fields 2245 for (unsigned i = 0; i < 3; ++i) { 2246 FieldDecl *Field = FieldDecl::Create(Context, D, 2247 SourceLocation(), 2248 SourceLocation(), 0, 2249 FieldTypes[i], /*TInfo=*/0, 2250 /*BitWidth=*/0, 2251 /*Mutable=*/false, 2252 ICIS_NoInit); 2253 Field->setAccess(AS_public); 2254 D->addDecl(Field); 2255 } 2256 2257 D->completeDefinition(); 2258 QualType NSTy = Context.getTagDeclType(D); 2259 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 2260 } 2261 2262 llvm::Constant *Fields[3]; 2263 2264 // Class pointer. 2265 Fields[0] = ConstantStringClassRef; 2266 2267 // String pointer. 2268 llvm::Constant *C = 2269 llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); 2270 2271 llvm::GlobalValue::LinkageTypes Linkage; 2272 bool isConstant; 2273 Linkage = llvm::GlobalValue::PrivateLinkage; 2274 isConstant = !LangOpts.WritableStrings; 2275 2276 llvm::GlobalVariable *GV = 2277 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 2278 ".str"); 2279 GV->setUnnamedAddr(true); 2280 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2281 GV->setAlignment(Align.getQuantity()); 2282 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2283 2284 // String length. 2285 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2286 Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 2287 2288 // The struct. 2289 C = llvm::ConstantStruct::get(NSConstantStringType, Fields); 2290 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2291 llvm::GlobalVariable::PrivateLinkage, C, 2292 "_unnamed_nsstring_"); 2293 // FIXME. Fix section. 2294 if (const char *Sect = 2295 LangOpts.ObjCRuntime.isNonFragile() 2296 ? getContext().getTargetInfo().getNSStringNonFragileABISection() 2297 : getContext().getTargetInfo().getNSStringSection()) 2298 GV->setSection(Sect); 2299 Entry.setValue(GV); 2300 2301 return GV; 2302 } 2303 2304 QualType CodeGenModule::getObjCFastEnumerationStateType() { 2305 if (ObjCFastEnumerationStateType.isNull()) { 2306 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 2307 Context.getTranslationUnitDecl(), 2308 &Context.Idents.get("__objcFastEnumerationState")); 2309 D->startDefinition(); 2310 2311 QualType FieldTypes[] = { 2312 Context.UnsignedLongTy, 2313 Context.getPointerType(Context.getObjCIdType()), 2314 Context.getPointerType(Context.UnsignedLongTy), 2315 Context.getConstantArrayType(Context.UnsignedLongTy, 2316 llvm::APInt(32, 5), ArrayType::Normal, 0) 2317 }; 2318 2319 for (size_t i = 0; i < 4; ++i) { 2320 FieldDecl *Field = FieldDecl::Create(Context, 2321 D, 2322 SourceLocation(), 2323 SourceLocation(), 0, 2324 FieldTypes[i], /*TInfo=*/0, 2325 /*BitWidth=*/0, 2326 /*Mutable=*/false, 2327 ICIS_NoInit); 2328 Field->setAccess(AS_public); 2329 D->addDecl(Field); 2330 } 2331 2332 D->completeDefinition(); 2333 ObjCFastEnumerationStateType = Context.getTagDeclType(D); 2334 } 2335 2336 return ObjCFastEnumerationStateType; 2337 } 2338 2339 llvm::Constant * 2340 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { 2341 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 2342 2343 // Don't emit it as the address of the string, emit the string data itself 2344 // as an inline array. 2345 if (E->getCharByteWidth() == 1) { 2346 SmallString<64> Str(E->getString()); 2347 2348 // Resize the string to the right size, which is indicated by its type. 2349 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType()); 2350 Str.resize(CAT->getSize().getZExtValue()); 2351 return llvm::ConstantDataArray::getString(VMContext, Str, false); 2352 } 2353 2354 llvm::ArrayType *AType = 2355 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); 2356 llvm::Type *ElemTy = AType->getElementType(); 2357 unsigned NumElements = AType->getNumElements(); 2358 2359 // Wide strings have either 2-byte or 4-byte elements. 2360 if (ElemTy->getPrimitiveSizeInBits() == 16) { 2361 SmallVector<uint16_t, 32> Elements; 2362 Elements.reserve(NumElements); 2363 2364 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2365 Elements.push_back(E->getCodeUnit(i)); 2366 Elements.resize(NumElements); 2367 return llvm::ConstantDataArray::get(VMContext, Elements); 2368 } 2369 2370 assert(ElemTy->getPrimitiveSizeInBits() == 32); 2371 SmallVector<uint32_t, 32> Elements; 2372 Elements.reserve(NumElements); 2373 2374 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2375 Elements.push_back(E->getCodeUnit(i)); 2376 Elements.resize(NumElements); 2377 return llvm::ConstantDataArray::get(VMContext, Elements); 2378 } 2379 2380 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a 2381 /// constant array for the given string literal. 2382 llvm::Constant * 2383 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 2384 CharUnits Align = getContext().getTypeAlignInChars(S->getType()); 2385 if (S->isAscii() || S->isUTF8()) { 2386 SmallString<64> Str(S->getString()); 2387 2388 // Resize the string to the right size, which is indicated by its type. 2389 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType()); 2390 Str.resize(CAT->getSize().getZExtValue()); 2391 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity()); 2392 } 2393 2394 // FIXME: the following does not memoize wide strings. 2395 llvm::Constant *C = GetConstantArrayFromStringLiteral(S); 2396 llvm::GlobalVariable *GV = 2397 new llvm::GlobalVariable(getModule(),C->getType(), 2398 !LangOpts.WritableStrings, 2399 llvm::GlobalValue::PrivateLinkage, 2400 C,".str"); 2401 2402 GV->setAlignment(Align.getQuantity()); 2403 GV->setUnnamedAddr(true); 2404 return GV; 2405 } 2406 2407 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 2408 /// array for the given ObjCEncodeExpr node. 2409 llvm::Constant * 2410 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 2411 std::string Str; 2412 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 2413 2414 return GetAddrOfConstantCString(Str); 2415 } 2416 2417 2418 /// GenerateWritableString -- Creates storage for a string literal. 2419 static llvm::GlobalVariable *GenerateStringLiteral(StringRef str, 2420 bool constant, 2421 CodeGenModule &CGM, 2422 const char *GlobalName, 2423 unsigned Alignment) { 2424 // Create Constant for this string literal. Don't add a '\0'. 2425 llvm::Constant *C = 2426 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false); 2427 2428 // Create a global variable for this string 2429 llvm::GlobalVariable *GV = 2430 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 2431 llvm::GlobalValue::PrivateLinkage, 2432 C, GlobalName); 2433 GV->setAlignment(Alignment); 2434 GV->setUnnamedAddr(true); 2435 return GV; 2436 } 2437 2438 /// GetAddrOfConstantString - Returns a pointer to a character array 2439 /// containing the literal. This contents are exactly that of the 2440 /// given string, i.e. it will not be null terminated automatically; 2441 /// see GetAddrOfConstantCString. Note that whether the result is 2442 /// actually a pointer to an LLVM constant depends on 2443 /// Feature.WriteableStrings. 2444 /// 2445 /// The result has pointer to array type. 2446 llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str, 2447 const char *GlobalName, 2448 unsigned Alignment) { 2449 // Get the default prefix if a name wasn't specified. 2450 if (!GlobalName) 2451 GlobalName = ".str"; 2452 2453 // Don't share any string literals if strings aren't constant. 2454 if (LangOpts.WritableStrings) 2455 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment); 2456 2457 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = 2458 ConstantStringMap.GetOrCreateValue(Str); 2459 2460 if (llvm::GlobalVariable *GV = Entry.getValue()) { 2461 if (Alignment > GV->getAlignment()) { 2462 GV->setAlignment(Alignment); 2463 } 2464 return GV; 2465 } 2466 2467 // Create a global variable for this. 2468 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName, 2469 Alignment); 2470 Entry.setValue(GV); 2471 return GV; 2472 } 2473 2474 /// GetAddrOfConstantCString - Returns a pointer to a character 2475 /// array containing the literal and a terminating '\0' 2476 /// character. The result has pointer to array type. 2477 llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str, 2478 const char *GlobalName, 2479 unsigned Alignment) { 2480 StringRef StrWithNull(Str.c_str(), Str.size() + 1); 2481 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment); 2482 } 2483 2484 /// EmitObjCPropertyImplementations - Emit information for synthesized 2485 /// properties for an implementation. 2486 void CodeGenModule::EmitObjCPropertyImplementations(const 2487 ObjCImplementationDecl *D) { 2488 for (ObjCImplementationDecl::propimpl_iterator 2489 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 2490 ObjCPropertyImplDecl *PID = *i; 2491 2492 // Dynamic is just for type-checking. 2493 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 2494 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 2495 2496 // Determine which methods need to be implemented, some may have 2497 // been overridden. Note that ::isPropertyAccessor is not the method 2498 // we want, that just indicates if the decl came from a 2499 // property. What we want to know is if the method is defined in 2500 // this implementation. 2501 if (!D->getInstanceMethod(PD->getGetterName())) 2502 CodeGenFunction(*this).GenerateObjCGetter( 2503 const_cast<ObjCImplementationDecl *>(D), PID); 2504 if (!PD->isReadOnly() && 2505 !D->getInstanceMethod(PD->getSetterName())) 2506 CodeGenFunction(*this).GenerateObjCSetter( 2507 const_cast<ObjCImplementationDecl *>(D), PID); 2508 } 2509 } 2510 } 2511 2512 static bool needsDestructMethod(ObjCImplementationDecl *impl) { 2513 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 2514 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 2515 ivar; ivar = ivar->getNextIvar()) 2516 if (ivar->getType().isDestructedType()) 2517 return true; 2518 2519 return false; 2520 } 2521 2522 /// EmitObjCIvarInitializations - Emit information for ivar initialization 2523 /// for an implementation. 2524 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 2525 // We might need a .cxx_destruct even if we don't have any ivar initializers. 2526 if (needsDestructMethod(D)) { 2527 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 2528 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 2529 ObjCMethodDecl *DTORMethod = 2530 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 2531 cxxSelector, getContext().VoidTy, 0, D, 2532 /*isInstance=*/true, /*isVariadic=*/false, 2533 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, 2534 /*isDefined=*/false, ObjCMethodDecl::Required); 2535 D->addInstanceMethod(DTORMethod); 2536 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 2537 D->setHasCXXStructors(true); 2538 } 2539 2540 // If the implementation doesn't have any ivar initializers, we don't need 2541 // a .cxx_construct. 2542 if (D->getNumIvarInitializers() == 0) 2543 return; 2544 2545 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 2546 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 2547 // The constructor returns 'self'. 2548 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 2549 D->getLocation(), 2550 D->getLocation(), 2551 cxxSelector, 2552 getContext().getObjCIdType(), 0, 2553 D, /*isInstance=*/true, 2554 /*isVariadic=*/false, 2555 /*isPropertyAccessor=*/true, 2556 /*isImplicitlyDeclared=*/true, 2557 /*isDefined=*/false, 2558 ObjCMethodDecl::Required); 2559 D->addInstanceMethod(CTORMethod); 2560 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 2561 D->setHasCXXStructors(true); 2562 } 2563 2564 /// EmitNamespace - Emit all declarations in a namespace. 2565 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 2566 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 2567 I != E; ++I) 2568 EmitTopLevelDecl(*I); 2569 } 2570 2571 // EmitLinkageSpec - Emit all declarations in a linkage spec. 2572 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 2573 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 2574 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 2575 ErrorUnsupported(LSD, "linkage spec"); 2576 return; 2577 } 2578 2579 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 2580 I != E; ++I) 2581 EmitTopLevelDecl(*I); 2582 } 2583 2584 /// EmitTopLevelDecl - Emit code for a single top level declaration. 2585 void CodeGenModule::EmitTopLevelDecl(Decl *D) { 2586 // If an error has occurred, stop code generation, but continue 2587 // parsing and semantic analysis (to ensure all warnings and errors 2588 // are emitted). 2589 if (Diags.hasErrorOccurred()) 2590 return; 2591 2592 // Ignore dependent declarations. 2593 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 2594 return; 2595 2596 switch (D->getKind()) { 2597 case Decl::CXXConversion: 2598 case Decl::CXXMethod: 2599 case Decl::Function: 2600 // Skip function templates 2601 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2602 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2603 return; 2604 2605 EmitGlobal(cast<FunctionDecl>(D)); 2606 break; 2607 2608 case Decl::Var: 2609 EmitGlobal(cast<VarDecl>(D)); 2610 break; 2611 2612 // Indirect fields from global anonymous structs and unions can be 2613 // ignored; only the actual variable requires IR gen support. 2614 case Decl::IndirectField: 2615 break; 2616 2617 // C++ Decls 2618 case Decl::Namespace: 2619 EmitNamespace(cast<NamespaceDecl>(D)); 2620 break; 2621 // No code generation needed. 2622 case Decl::UsingShadow: 2623 case Decl::Using: 2624 case Decl::UsingDirective: 2625 case Decl::ClassTemplate: 2626 case Decl::FunctionTemplate: 2627 case Decl::TypeAliasTemplate: 2628 case Decl::NamespaceAlias: 2629 case Decl::Block: 2630 case Decl::Import: 2631 break; 2632 case Decl::CXXConstructor: 2633 // Skip function templates 2634 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2635 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2636 return; 2637 2638 EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 2639 break; 2640 case Decl::CXXDestructor: 2641 if (cast<FunctionDecl>(D)->isLateTemplateParsed()) 2642 return; 2643 EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 2644 break; 2645 2646 case Decl::StaticAssert: 2647 // Nothing to do. 2648 break; 2649 2650 // Objective-C Decls 2651 2652 // Forward declarations, no (immediate) code generation. 2653 case Decl::ObjCInterface: 2654 case Decl::ObjCCategory: 2655 break; 2656 2657 case Decl::ObjCProtocol: { 2658 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D); 2659 if (Proto->isThisDeclarationADefinition()) 2660 ObjCRuntime->GenerateProtocol(Proto); 2661 break; 2662 } 2663 2664 case Decl::ObjCCategoryImpl: 2665 // Categories have properties but don't support synthesize so we 2666 // can ignore them here. 2667 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 2668 break; 2669 2670 case Decl::ObjCImplementation: { 2671 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 2672 EmitObjCPropertyImplementations(OMD); 2673 EmitObjCIvarInitializations(OMD); 2674 ObjCRuntime->GenerateClass(OMD); 2675 // Emit global variable debug information. 2676 if (CGDebugInfo *DI = getModuleDebugInfo()) 2677 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(OMD->getClassInterface()), 2678 OMD->getLocation()); 2679 2680 break; 2681 } 2682 case Decl::ObjCMethod: { 2683 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 2684 // If this is not a prototype, emit the body. 2685 if (OMD->getBody()) 2686 CodeGenFunction(*this).GenerateObjCMethod(OMD); 2687 break; 2688 } 2689 case Decl::ObjCCompatibleAlias: 2690 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D)); 2691 break; 2692 2693 case Decl::LinkageSpec: 2694 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 2695 break; 2696 2697 case Decl::FileScopeAsm: { 2698 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 2699 StringRef AsmString = AD->getAsmString()->getString(); 2700 2701 const std::string &S = getModule().getModuleInlineAsm(); 2702 if (S.empty()) 2703 getModule().setModuleInlineAsm(AsmString); 2704 else if (S.end()[-1] == '\n') 2705 getModule().setModuleInlineAsm(S + AsmString.str()); 2706 else 2707 getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 2708 break; 2709 } 2710 2711 default: 2712 // Make sure we handled everything we should, every other kind is a 2713 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 2714 // function. Need to recode Decl::Kind to do that easily. 2715 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 2716 } 2717 } 2718 2719 /// Turns the given pointer into a constant. 2720 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 2721 const void *Ptr) { 2722 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 2723 llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 2724 return llvm::ConstantInt::get(i64, PtrInt); 2725 } 2726 2727 static void EmitGlobalDeclMetadata(CodeGenModule &CGM, 2728 llvm::NamedMDNode *&GlobalMetadata, 2729 GlobalDecl D, 2730 llvm::GlobalValue *Addr) { 2731 if (!GlobalMetadata) 2732 GlobalMetadata = 2733 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 2734 2735 // TODO: should we report variant information for ctors/dtors? 2736 llvm::Value *Ops[] = { 2737 Addr, 2738 GetPointerConstant(CGM.getLLVMContext(), D.getDecl()) 2739 }; 2740 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 2741 } 2742 2743 /// Emits metadata nodes associating all the global values in the 2744 /// current module with the Decls they came from. This is useful for 2745 /// projects using IR gen as a subroutine. 2746 /// 2747 /// Since there's currently no way to associate an MDNode directly 2748 /// with an llvm::GlobalValue, we create a global named metadata 2749 /// with the name 'clang.global.decl.ptrs'. 2750 void CodeGenModule::EmitDeclMetadata() { 2751 llvm::NamedMDNode *GlobalMetadata = 0; 2752 2753 // StaticLocalDeclMap 2754 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator 2755 I = MangledDeclNames.begin(), E = MangledDeclNames.end(); 2756 I != E; ++I) { 2757 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second); 2758 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr); 2759 } 2760 } 2761 2762 /// Emits metadata nodes for all the local variables in the current 2763 /// function. 2764 void CodeGenFunction::EmitDeclMetadata() { 2765 if (LocalDeclMap.empty()) return; 2766 2767 llvm::LLVMContext &Context = getLLVMContext(); 2768 2769 // Find the unique metadata ID for this name. 2770 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 2771 2772 llvm::NamedMDNode *GlobalMetadata = 0; 2773 2774 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator 2775 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) { 2776 const Decl *D = I->first; 2777 llvm::Value *Addr = I->second; 2778 2779 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 2780 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 2781 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); 2782 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 2783 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 2784 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 2785 } 2786 } 2787 } 2788 2789 void CodeGenModule::EmitCoverageFile() { 2790 if (!getCodeGenOpts().CoverageFile.empty()) { 2791 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { 2792 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 2793 llvm::LLVMContext &Ctx = TheModule.getContext(); 2794 llvm::MDString *CoverageFile = 2795 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile); 2796 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 2797 llvm::MDNode *CU = CUNode->getOperand(i); 2798 llvm::Value *node[] = { CoverageFile, CU }; 2799 llvm::MDNode *N = llvm::MDNode::get(Ctx, node); 2800 GCov->addOperand(N); 2801 } 2802 } 2803 } 2804 } 2805 2806 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid, 2807 QualType GuidType) { 2808 // Sema has checked that all uuid strings are of the form 2809 // "12345678-1234-1234-1234-1234567890ab". 2810 assert(Uuid.size() == 36); 2811 const char *Uuidstr = Uuid.data(); 2812 for (int i = 0; i < 36; ++i) { 2813 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-'); 2814 else assert(isxdigit(Uuidstr[i])); 2815 } 2816 2817 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16); 2818 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16); 2819 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16); 2820 int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 }; 2821 2822 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4); 2823 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0)); 2824 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1)); 2825 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2)); 2826 APValue& Arr = InitStruct.getStructField(3); 2827 Arr = APValue(APValue::UninitArray(), 8, 8); 2828 for (int t = 0; t < 8; ++t) 2829 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt( 2830 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16))); 2831 2832 return EmitConstantValue(InitStruct, GuidType); 2833 } 2834