CodeGenModule.cpp revision 3dc05418538c719fea48b906bfa4febe5296e126
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 "CGCXXABI.h" 20#include "CGObjCRuntime.h" 21#include "TargetInfo.h" 22#include "clang/Frontend/CodeGenOptions.h" 23#include "clang/AST/ASTContext.h" 24#include "clang/AST/CharUnits.h" 25#include "clang/AST/DeclObjC.h" 26#include "clang/AST/DeclCXX.h" 27#include "clang/AST/DeclTemplate.h" 28#include "clang/AST/Mangle.h" 29#include "clang/AST/RecordLayout.h" 30#include "clang/Basic/Builtins.h" 31#include "clang/Basic/Diagnostic.h" 32#include "clang/Basic/SourceManager.h" 33#include "clang/Basic/TargetInfo.h" 34#include "clang/Basic/ConvertUTF.h" 35#include "llvm/CallingConv.h" 36#include "llvm/Module.h" 37#include "llvm/Intrinsics.h" 38#include "llvm/LLVMContext.h" 39#include "llvm/ADT/Triple.h" 40#include "llvm/Target/Mangler.h" 41#include "llvm/Target/TargetData.h" 42#include "llvm/Support/CallSite.h" 43#include "llvm/Support/ErrorHandling.h" 44using namespace clang; 45using namespace CodeGen; 46 47static CGCXXABI &createCXXABI(CodeGenModule &CGM) { 48 switch (CGM.getContext().Target.getCXXABI()) { 49 case CXXABI_ARM: return *CreateARMCXXABI(CGM); 50 case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM); 51 case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM); 52 } 53 54 llvm_unreachable("invalid C++ ABI kind"); 55 return *CreateItaniumCXXABI(CGM); 56} 57 58 59CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 60 llvm::Module &M, const llvm::TargetData &TD, 61 Diagnostic &diags) 62 : Context(C), Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M), 63 TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags), 64 ABI(createCXXABI(*this)), 65 Types(C, M, TD, getTargetCodeGenInfo().getABIInfo(), ABI), 66 TBAA(0), 67 VTables(*this), Runtime(0), DebugInfo(0), 68 CFConstantStringClassRef(0), ConstantStringClassRef(0), 69 VMContext(M.getContext()), 70 NSConcreteGlobalBlockDecl(0), NSConcreteStackBlockDecl(0), 71 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), 72 BlockObjectAssignDecl(0), BlockObjectDisposeDecl(0), 73 BlockObjectAssign(0), BlockObjectDispose(0), 74 BlockDescriptorType(0), GenericBlockLiteralType(0) { 75 if (Features.ObjC1) 76 createObjCRuntime(); 77 78 // Enable TBAA unless it's suppressed. 79 if (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0) 80 TBAA = new CodeGenTBAA(Context, VMContext, getLangOptions(), 81 ABI.getMangleContext()); 82 83 // If debug info or coverage generation is enabled, create the CGDebugInfo 84 // object. 85 if (CodeGenOpts.DebugInfo || CodeGenOpts.EmitGcovArcs || 86 CodeGenOpts.EmitGcovNotes) 87 DebugInfo = new CGDebugInfo(*this); 88 89 Block.GlobalUniqueCount = 0; 90 91 // Initialize the type cache. 92 llvm::LLVMContext &LLVMContext = M.getContext(); 93 Int8Ty = llvm::Type::getInt8Ty(LLVMContext); 94 Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 95 Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 96 PointerWidthInBits = C.Target.getPointerWidth(0); 97 PointerAlignInBytes = 98 C.toCharUnitsFromBits(C.Target.getPointerAlign(0)).getQuantity(); 99 IntTy = llvm::IntegerType::get(LLVMContext, C.Target.getIntWidth()); 100 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits); 101 Int8PtrTy = Int8Ty->getPointerTo(0); 102 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); 103} 104 105CodeGenModule::~CodeGenModule() { 106 delete Runtime; 107 delete &ABI; 108 delete TBAA; 109 delete DebugInfo; 110} 111 112void CodeGenModule::createObjCRuntime() { 113 if (!Features.NeXTRuntime) 114 Runtime = CreateGNUObjCRuntime(*this); 115 else 116 Runtime = CreateMacObjCRuntime(*this); 117} 118 119void CodeGenModule::Release() { 120 EmitDeferred(); 121 EmitCXXGlobalInitFunc(); 122 EmitCXXGlobalDtorFunc(); 123 if (Runtime) 124 if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction()) 125 AddGlobalCtor(ObjCInitFunction); 126 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 127 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 128 EmitAnnotations(); 129 EmitLLVMUsed(); 130 131 SimplifyPersonality(); 132 133 if (getCodeGenOpts().EmitDeclMetadata) 134 EmitDeclMetadata(); 135 136 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes) 137 EmitCoverageFile(); 138} 139 140void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 141 // Make sure that this type is translated. 142 Types.UpdateCompletedType(TD); 143 if (DebugInfo) 144 DebugInfo->UpdateCompletedType(TD); 145} 146 147llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { 148 if (!TBAA) 149 return 0; 150 return TBAA->getTBAAInfo(QTy); 151} 152 153void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, 154 llvm::MDNode *TBAAInfo) { 155 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); 156} 157 158bool CodeGenModule::isTargetDarwin() const { 159 return getContext().Target.getTriple().isOSDarwin(); 160} 161 162void CodeGenModule::Error(SourceLocation loc, llvm::StringRef error) { 163 unsigned diagID = getDiags().getCustomDiagID(Diagnostic::Error, error); 164 getDiags().Report(Context.getFullLoc(loc), diagID); 165} 166 167/// ErrorUnsupported - Print out an error that codegen doesn't support the 168/// specified stmt yet. 169void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 170 bool OmitOnError) { 171 if (OmitOnError && getDiags().hasErrorOccurred()) 172 return; 173 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 174 "cannot compile this %0 yet"); 175 std::string Msg = Type; 176 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 177 << Msg << S->getSourceRange(); 178} 179 180/// ErrorUnsupported - Print out an error that codegen doesn't support the 181/// specified decl yet. 182void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 183 bool OmitOnError) { 184 if (OmitOnError && getDiags().hasErrorOccurred()) 185 return; 186 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 187 "cannot compile this %0 yet"); 188 std::string Msg = Type; 189 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 190} 191 192void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 193 const NamedDecl *D) const { 194 // Internal definitions always have default visibility. 195 if (GV->hasLocalLinkage()) { 196 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 197 return; 198 } 199 200 // Set visibility for definitions. 201 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 202 if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage()) 203 GV->setVisibility(GetLLVMVisibility(LV.visibility())); 204} 205 206/// Set the symbol visibility of type information (vtable and RTTI) 207/// associated with the given type. 208void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV, 209 const CXXRecordDecl *RD, 210 TypeVisibilityKind TVK) const { 211 setGlobalVisibility(GV, RD); 212 213 if (!CodeGenOpts.HiddenWeakVTables) 214 return; 215 216 // We never want to drop the visibility for RTTI names. 217 if (TVK == TVK_ForRTTIName) 218 return; 219 220 // We want to drop the visibility to hidden for weak type symbols. 221 // This isn't possible if there might be unresolved references 222 // elsewhere that rely on this symbol being visible. 223 224 // This should be kept roughly in sync with setThunkVisibility 225 // in CGVTables.cpp. 226 227 // Preconditions. 228 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage || 229 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility) 230 return; 231 232 // Don't override an explicit visibility attribute. 233 if (RD->getExplicitVisibility()) 234 return; 235 236 switch (RD->getTemplateSpecializationKind()) { 237 // We have to disable the optimization if this is an EI definition 238 // because there might be EI declarations in other shared objects. 239 case TSK_ExplicitInstantiationDefinition: 240 case TSK_ExplicitInstantiationDeclaration: 241 return; 242 243 // Every use of a non-template class's type information has to emit it. 244 case TSK_Undeclared: 245 break; 246 247 // In theory, implicit instantiations can ignore the possibility of 248 // an explicit instantiation declaration because there necessarily 249 // must be an EI definition somewhere with default visibility. In 250 // practice, it's possible to have an explicit instantiation for 251 // an arbitrary template class, and linkers aren't necessarily able 252 // to deal with mixed-visibility symbols. 253 case TSK_ExplicitSpecialization: 254 case TSK_ImplicitInstantiation: 255 if (!CodeGenOpts.HiddenWeakTemplateVTables) 256 return; 257 break; 258 } 259 260 // If there's a key function, there may be translation units 261 // that don't have the key function's definition. But ignore 262 // this if we're emitting RTTI under -fno-rtti. 263 if (!(TVK != TVK_ForRTTI) || Features.RTTI) { 264 if (Context.getKeyFunction(RD)) 265 return; 266 } 267 268 // Otherwise, drop the visibility to hidden. 269 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 270 GV->setUnnamedAddr(true); 271} 272 273llvm::StringRef CodeGenModule::getMangledName(GlobalDecl GD) { 274 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); 275 276 llvm::StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()]; 277 if (!Str.empty()) 278 return Str; 279 280 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { 281 IdentifierInfo *II = ND->getIdentifier(); 282 assert(II && "Attempt to mangle unnamed decl."); 283 284 Str = II->getName(); 285 return Str; 286 } 287 288 llvm::SmallString<256> Buffer; 289 llvm::raw_svector_ostream Out(Buffer); 290 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 291 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); 292 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 293 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); 294 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND)) 295 getCXXABI().getMangleContext().mangleBlock(BD, Out); 296 else 297 getCXXABI().getMangleContext().mangleName(ND, Out); 298 299 // Allocate space for the mangled name. 300 Out.flush(); 301 size_t Length = Buffer.size(); 302 char *Name = MangledNamesAllocator.Allocate<char>(Length); 303 std::copy(Buffer.begin(), Buffer.end(), Name); 304 305 Str = llvm::StringRef(Name, Length); 306 307 return Str; 308} 309 310void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, 311 const BlockDecl *BD) { 312 MangleContext &MangleCtx = getCXXABI().getMangleContext(); 313 const Decl *D = GD.getDecl(); 314 llvm::raw_svector_ostream Out(Buffer.getBuffer()); 315 if (D == 0) 316 MangleCtx.mangleGlobalBlock(BD, Out); 317 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 318 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); 319 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) 320 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); 321 else 322 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); 323} 324 325llvm::GlobalValue *CodeGenModule::GetGlobalValue(llvm::StringRef Name) { 326 return getModule().getNamedValue(Name); 327} 328 329/// AddGlobalCtor - Add a function to the list that will be called before 330/// main() runs. 331void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 332 // FIXME: Type coercion of void()* types. 333 GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 334} 335 336/// AddGlobalDtor - Add a function to the list that will be called 337/// when the module is unloaded. 338void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 339 // FIXME: Type coercion of void()* types. 340 GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 341} 342 343void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 344 // Ctor function type is void()*. 345 llvm::FunctionType* CtorFTy = 346 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false); 347 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 348 349 // Get the type of a ctor entry, { i32, void ()* }. 350 llvm::StructType* CtorStructTy = 351 llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext), 352 llvm::PointerType::getUnqual(CtorFTy), NULL); 353 354 // Construct the constructor and destructor arrays. 355 std::vector<llvm::Constant*> Ctors; 356 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 357 std::vector<llvm::Constant*> S; 358 S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 359 I->second, false)); 360 S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)); 361 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 362 } 363 364 if (!Ctors.empty()) { 365 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 366 new llvm::GlobalVariable(TheModule, AT, false, 367 llvm::GlobalValue::AppendingLinkage, 368 llvm::ConstantArray::get(AT, Ctors), 369 GlobalName); 370 } 371} 372 373void CodeGenModule::EmitAnnotations() { 374 if (Annotations.empty()) 375 return; 376 377 // Create a new global variable for the ConstantStruct in the Module. 378 llvm::Constant *Array = 379 llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(), 380 Annotations.size()), 381 Annotations); 382 llvm::GlobalValue *gv = 383 new llvm::GlobalVariable(TheModule, Array->getType(), false, 384 llvm::GlobalValue::AppendingLinkage, Array, 385 "llvm.global.annotations"); 386 gv->setSection("llvm.metadata"); 387} 388 389llvm::GlobalValue::LinkageTypes 390CodeGenModule::getFunctionLinkage(const FunctionDecl *D) { 391 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); 392 393 if (Linkage == GVA_Internal) 394 return llvm::Function::InternalLinkage; 395 396 if (D->hasAttr<DLLExportAttr>()) 397 return llvm::Function::DLLExportLinkage; 398 399 if (D->hasAttr<WeakAttr>()) 400 return llvm::Function::WeakAnyLinkage; 401 402 // In C99 mode, 'inline' functions are guaranteed to have a strong 403 // definition somewhere else, so we can use available_externally linkage. 404 if (Linkage == GVA_C99Inline) 405 return llvm::Function::AvailableExternallyLinkage; 406 407 // In C++, the compiler has to emit a definition in every translation unit 408 // that references the function. We should use linkonce_odr because 409 // a) if all references in this translation unit are optimized away, we 410 // don't need to codegen it. b) if the function persists, it needs to be 411 // merged with other definitions. c) C++ has the ODR, so we know the 412 // definition is dependable. 413 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 414 return !Context.getLangOptions().AppleKext 415 ? llvm::Function::LinkOnceODRLinkage 416 : llvm::Function::InternalLinkage; 417 418 // An explicit instantiation of a template has weak linkage, since 419 // explicit instantiations can occur in multiple translation units 420 // and must all be equivalent. However, we are not allowed to 421 // throw away these explicit instantiations. 422 if (Linkage == GVA_ExplicitTemplateInstantiation) 423 return !Context.getLangOptions().AppleKext 424 ? llvm::Function::WeakODRLinkage 425 : llvm::Function::InternalLinkage; 426 427 // Otherwise, we have strong external linkage. 428 assert(Linkage == GVA_StrongExternal); 429 return llvm::Function::ExternalLinkage; 430} 431 432 433/// SetFunctionDefinitionAttributes - Set attributes for a global. 434/// 435/// FIXME: This is currently only done for aliases and functions, but not for 436/// variables (these details are set in EmitGlobalVarDefinition for variables). 437void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 438 llvm::GlobalValue *GV) { 439 SetCommonAttributes(D, GV); 440} 441 442void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 443 const CGFunctionInfo &Info, 444 llvm::Function *F) { 445 unsigned CallingConv; 446 AttributeListType AttributeList; 447 ConstructAttributeList(Info, D, AttributeList, CallingConv); 448 F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(), 449 AttributeList.size())); 450 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 451} 452 453void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 454 llvm::Function *F) { 455 if (!Features.Exceptions && !Features.ObjCNonFragileABI) 456 F->addFnAttr(llvm::Attribute::NoUnwind); 457 458 if (D->hasAttr<AlwaysInlineAttr>()) 459 F->addFnAttr(llvm::Attribute::AlwaysInline); 460 461 if (D->hasAttr<NakedAttr>()) 462 F->addFnAttr(llvm::Attribute::Naked); 463 464 if (D->hasAttr<NoInlineAttr>()) 465 F->addFnAttr(llvm::Attribute::NoInline); 466 467 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D)) 468 F->setUnnamedAddr(true); 469 470 if (Features.getStackProtectorMode() == LangOptions::SSPOn) 471 F->addFnAttr(llvm::Attribute::StackProtect); 472 else if (Features.getStackProtectorMode() == LangOptions::SSPReq) 473 F->addFnAttr(llvm::Attribute::StackProtectReq); 474 475 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth(); 476 if (alignment) 477 F->setAlignment(alignment); 478 479 // C++ ABI requires 2-byte alignment for member functions. 480 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 481 F->setAlignment(2); 482} 483 484void CodeGenModule::SetCommonAttributes(const Decl *D, 485 llvm::GlobalValue *GV) { 486 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 487 setGlobalVisibility(GV, ND); 488 else 489 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 490 491 if (D->hasAttr<UsedAttr>()) 492 AddUsedGlobal(GV); 493 494 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 495 GV->setSection(SA->getName()); 496 497 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this); 498} 499 500void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 501 llvm::Function *F, 502 const CGFunctionInfo &FI) { 503 SetLLVMFunctionAttributes(D, FI, F); 504 SetLLVMFunctionAttributesForDefinition(D, F); 505 506 F->setLinkage(llvm::Function::InternalLinkage); 507 508 SetCommonAttributes(D, F); 509} 510 511void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, 512 llvm::Function *F, 513 bool IsIncompleteFunction) { 514 if (unsigned IID = F->getIntrinsicID()) { 515 // If this is an intrinsic function, set the function's attributes 516 // to the intrinsic's attributes. 517 F->setAttributes(llvm::Intrinsic::getAttributes((llvm::Intrinsic::ID)IID)); 518 return; 519 } 520 521 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 522 523 if (!IsIncompleteFunction) 524 SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F); 525 526 // Only a few attributes are set on declarations; these may later be 527 // overridden by a definition. 528 529 if (FD->hasAttr<DLLImportAttr>()) { 530 F->setLinkage(llvm::Function::DLLImportLinkage); 531 } else if (FD->hasAttr<WeakAttr>() || 532 FD->isWeakImported()) { 533 // "extern_weak" is overloaded in LLVM; we probably should have 534 // separate linkage types for this. 535 F->setLinkage(llvm::Function::ExternalWeakLinkage); 536 } else { 537 F->setLinkage(llvm::Function::ExternalLinkage); 538 539 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility(); 540 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) { 541 F->setVisibility(GetLLVMVisibility(LV.visibility())); 542 } 543 } 544 545 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 546 F->setSection(SA->getName()); 547} 548 549void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 550 assert(!GV->isDeclaration() && 551 "Only globals with definition can force usage."); 552 LLVMUsed.push_back(GV); 553} 554 555void CodeGenModule::EmitLLVMUsed() { 556 // Don't create llvm.used if there is no need. 557 if (LLVMUsed.empty()) 558 return; 559 560 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 561 562 // Convert LLVMUsed to what ConstantArray needs. 563 std::vector<llvm::Constant*> UsedArray; 564 UsedArray.resize(LLVMUsed.size()); 565 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 566 UsedArray[i] = 567 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 568 i8PTy); 569 } 570 571 if (UsedArray.empty()) 572 return; 573 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size()); 574 575 llvm::GlobalVariable *GV = 576 new llvm::GlobalVariable(getModule(), ATy, false, 577 llvm::GlobalValue::AppendingLinkage, 578 llvm::ConstantArray::get(ATy, UsedArray), 579 "llvm.used"); 580 581 GV->setSection("llvm.metadata"); 582} 583 584void CodeGenModule::EmitDeferred() { 585 // Emit code for any potentially referenced deferred decls. Since a 586 // previously unused static decl may become used during the generation of code 587 // for a static function, iterate until no changes are made. 588 589 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) { 590 if (!DeferredVTables.empty()) { 591 const CXXRecordDecl *RD = DeferredVTables.back(); 592 DeferredVTables.pop_back(); 593 getVTables().GenerateClassData(getVTableLinkage(RD), RD); 594 continue; 595 } 596 597 GlobalDecl D = DeferredDeclsToEmit.back(); 598 DeferredDeclsToEmit.pop_back(); 599 600 // Check to see if we've already emitted this. This is necessary 601 // for a couple of reasons: first, decls can end up in the 602 // deferred-decls queue multiple times, and second, decls can end 603 // up with definitions in unusual ways (e.g. by an extern inline 604 // function acquiring a strong function redefinition). Just 605 // ignore these cases. 606 // 607 // TODO: That said, looking this up multiple times is very wasteful. 608 llvm::StringRef Name = getMangledName(D); 609 llvm::GlobalValue *CGRef = GetGlobalValue(Name); 610 assert(CGRef && "Deferred decl wasn't referenced?"); 611 612 if (!CGRef->isDeclaration()) 613 continue; 614 615 // GlobalAlias::isDeclaration() defers to the aliasee, but for our 616 // purposes an alias counts as a definition. 617 if (isa<llvm::GlobalAlias>(CGRef)) 618 continue; 619 620 // Otherwise, emit the definition and move on to the next one. 621 EmitGlobalDefinition(D); 622 } 623} 624 625/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 626/// annotation information for a given GlobalValue. The annotation struct is 627/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 628/// GlobalValue being annotated. The second field is the constant string 629/// created from the AnnotateAttr's annotation. The third field is a constant 630/// string containing the name of the translation unit. The fourth field is 631/// the line number in the file of the annotated value declaration. 632/// 633/// FIXME: this does not unique the annotation string constants, as llvm-gcc 634/// appears to. 635/// 636llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 637 const AnnotateAttr *AA, 638 unsigned LineNo) { 639 llvm::Module *M = &getModule(); 640 641 // get [N x i8] constants for the annotation string, and the filename string 642 // which are the 2nd and 3rd elements of the global annotation structure. 643 const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext); 644 llvm::Constant *anno = llvm::ConstantArray::get(VMContext, 645 AA->getAnnotation(), true); 646 llvm::Constant *unit = llvm::ConstantArray::get(VMContext, 647 M->getModuleIdentifier(), 648 true); 649 650 // Get the two global values corresponding to the ConstantArrays we just 651 // created to hold the bytes of the strings. 652 llvm::GlobalValue *annoGV = 653 new llvm::GlobalVariable(*M, anno->getType(), false, 654 llvm::GlobalValue::PrivateLinkage, anno, 655 GV->getName()); 656 // translation unit name string, emitted into the llvm.metadata section. 657 llvm::GlobalValue *unitGV = 658 new llvm::GlobalVariable(*M, unit->getType(), false, 659 llvm::GlobalValue::PrivateLinkage, unit, 660 ".str"); 661 unitGV->setUnnamedAddr(true); 662 663 // Create the ConstantStruct for the global annotation. 664 llvm::Constant *Fields[4] = { 665 llvm::ConstantExpr::getBitCast(GV, SBP), 666 llvm::ConstantExpr::getBitCast(annoGV, SBP), 667 llvm::ConstantExpr::getBitCast(unitGV, SBP), 668 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo) 669 }; 670 return llvm::ConstantStruct::get(VMContext, Fields, 4, false); 671} 672 673bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 674 // Never defer when EmitAllDecls is specified. 675 if (Features.EmitAllDecls) 676 return false; 677 678 return !getContext().DeclMustBeEmitted(Global); 679} 680 681llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 682 const AliasAttr *AA = VD->getAttr<AliasAttr>(); 683 assert(AA && "No alias?"); 684 685 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 686 687 // See if there is already something with the target's name in the module. 688 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 689 690 llvm::Constant *Aliasee; 691 if (isa<llvm::FunctionType>(DeclTy)) 692 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(), 693 /*ForVTable=*/false); 694 else 695 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 696 llvm::PointerType::getUnqual(DeclTy), 0); 697 if (!Entry) { 698 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); 699 F->setLinkage(llvm::Function::ExternalWeakLinkage); 700 WeakRefReferences.insert(F); 701 } 702 703 return Aliasee; 704} 705 706void CodeGenModule::EmitGlobal(GlobalDecl GD) { 707 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); 708 709 // Weak references don't produce any output by themselves. 710 if (Global->hasAttr<WeakRefAttr>()) 711 return; 712 713 // If this is an alias definition (which otherwise looks like a declaration) 714 // emit it now. 715 if (Global->hasAttr<AliasAttr>()) 716 return EmitAliasDefinition(GD); 717 718 // Ignore declarations, they will be emitted on their first use. 719 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 720 if (FD->getIdentifier()) { 721 llvm::StringRef Name = FD->getName(); 722 if (Name == "_Block_object_assign") { 723 BlockObjectAssignDecl = FD; 724 } else if (Name == "_Block_object_dispose") { 725 BlockObjectDisposeDecl = FD; 726 } 727 } 728 729 // Forward declarations are emitted lazily on first use. 730 if (!FD->isThisDeclarationADefinition()) 731 return; 732 } else { 733 const VarDecl *VD = cast<VarDecl>(Global); 734 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 735 736 if (VD->getIdentifier()) { 737 llvm::StringRef Name = VD->getName(); 738 if (Name == "_NSConcreteGlobalBlock") { 739 NSConcreteGlobalBlockDecl = VD; 740 } else if (Name == "_NSConcreteStackBlock") { 741 NSConcreteStackBlockDecl = VD; 742 } 743 } 744 745 746 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) 747 return; 748 } 749 750 // Defer code generation when possible if this is a static definition, inline 751 // function etc. These we only want to emit if they are used. 752 if (!MayDeferGeneration(Global)) { 753 // Emit the definition if it can't be deferred. 754 EmitGlobalDefinition(GD); 755 return; 756 } 757 758 // If we're deferring emission of a C++ variable with an 759 // initializer, remember the order in which it appeared in the file. 760 if (getLangOptions().CPlusPlus && isa<VarDecl>(Global) && 761 cast<VarDecl>(Global)->hasInit()) { 762 DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 763 CXXGlobalInits.push_back(0); 764 } 765 766 // If the value has already been used, add it directly to the 767 // DeferredDeclsToEmit list. 768 llvm::StringRef MangledName = getMangledName(GD); 769 if (GetGlobalValue(MangledName)) 770 DeferredDeclsToEmit.push_back(GD); 771 else { 772 // Otherwise, remember that we saw a deferred decl with this name. The 773 // first use of the mangled name will cause it to move into 774 // DeferredDeclsToEmit. 775 DeferredDecls[MangledName] = GD; 776 } 777} 778 779void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 780 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 781 782 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 783 Context.getSourceManager(), 784 "Generating code for declaration"); 785 786 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 787 // At -O0, don't generate IR for functions with available_externally 788 // linkage. 789 if (CodeGenOpts.OptimizationLevel == 0 && 790 !Function->hasAttr<AlwaysInlineAttr>() && 791 getFunctionLinkage(Function) 792 == llvm::Function::AvailableExternallyLinkage) 793 return; 794 795 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 796 if (Method->isVirtual()) 797 getVTables().EmitThunks(GD); 798 799 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method)) 800 return EmitCXXConstructor(CD, GD.getCtorType()); 801 802 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Method)) 803 return EmitCXXDestructor(DD, GD.getDtorType()); 804 } 805 806 return EmitGlobalFunctionDefinition(GD); 807 } 808 809 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 810 return EmitGlobalVarDefinition(VD); 811 812 assert(0 && "Invalid argument to EmitGlobalDefinition()"); 813} 814 815/// GetOrCreateLLVMFunction - If the specified mangled name is not in the 816/// module, create and return an llvm Function with the specified type. If there 817/// is something in the module with the specified name, return it potentially 818/// bitcasted to the right type. 819/// 820/// If D is non-null, it specifies a decl that correspond to this. This is used 821/// to set the attributes on the function when it is first created. 822llvm::Constant * 823CodeGenModule::GetOrCreateLLVMFunction(llvm::StringRef MangledName, 824 const llvm::Type *Ty, 825 GlobalDecl D, bool ForVTable) { 826 // Lookup the entry, lazily creating it if necessary. 827 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 828 if (Entry) { 829 if (WeakRefReferences.count(Entry)) { 830 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl()); 831 if (FD && !FD->hasAttr<WeakAttr>()) 832 Entry->setLinkage(llvm::Function::ExternalLinkage); 833 834 WeakRefReferences.erase(Entry); 835 } 836 837 if (Entry->getType()->getElementType() == Ty) 838 return Entry; 839 840 // Make sure the result is of the correct type. 841 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 842 return llvm::ConstantExpr::getBitCast(Entry, PTy); 843 } 844 845 // This function doesn't have a complete type (for example, the return 846 // type is an incomplete struct). Use a fake type instead, and make 847 // sure not to try to set attributes. 848 bool IsIncompleteFunction = false; 849 850 const llvm::FunctionType *FTy; 851 if (isa<llvm::FunctionType>(Ty)) { 852 FTy = cast<llvm::FunctionType>(Ty); 853 } else { 854 FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false); 855 IsIncompleteFunction = true; 856 } 857 858 llvm::Function *F = llvm::Function::Create(FTy, 859 llvm::Function::ExternalLinkage, 860 MangledName, &getModule()); 861 assert(F->getName() == MangledName && "name was uniqued!"); 862 if (D.getDecl()) 863 SetFunctionAttributes(D, F, IsIncompleteFunction); 864 865 // This is the first use or definition of a mangled name. If there is a 866 // deferred decl with this name, remember that we need to emit it at the end 867 // of the file. 868 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 869 if (DDI != DeferredDecls.end()) { 870 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 871 // list, and remove it from DeferredDecls (since we don't need it anymore). 872 DeferredDeclsToEmit.push_back(DDI->second); 873 DeferredDecls.erase(DDI); 874 875 // Otherwise, there are cases we have to worry about where we're 876 // using a declaration for which we must emit a definition but where 877 // we might not find a top-level definition: 878 // - member functions defined inline in their classes 879 // - friend functions defined inline in some class 880 // - special member functions with implicit definitions 881 // If we ever change our AST traversal to walk into class methods, 882 // this will be unnecessary. 883 // 884 // We also don't emit a definition for a function if it's going to be an entry 885 // in a vtable, unless it's already marked as used. 886 } else if (getLangOptions().CPlusPlus && D.getDecl()) { 887 // Look for a declaration that's lexically in a record. 888 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl()); 889 do { 890 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 891 if (FD->isImplicit() && !ForVTable) { 892 assert(FD->isUsed() && "Sema didn't mark implicit function as used!"); 893 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 894 break; 895 } else if (FD->isThisDeclarationADefinition()) { 896 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 897 break; 898 } 899 } 900 FD = FD->getPreviousDeclaration(); 901 } while (FD); 902 } 903 904 // Make sure the result is of the requested type. 905 if (!IsIncompleteFunction) { 906 assert(F->getType()->getElementType() == Ty); 907 return F; 908 } 909 910 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 911 return llvm::ConstantExpr::getBitCast(F, PTy); 912} 913 914/// GetAddrOfFunction - Return the address of the given function. If Ty is 915/// non-null, then this function will use the specified type if it has to 916/// create it (this occurs when we see a definition of the function). 917llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 918 const llvm::Type *Ty, 919 bool ForVTable) { 920 // If there was no specific requested type, just convert it now. 921 if (!Ty) 922 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 923 924 llvm::StringRef MangledName = getMangledName(GD); 925 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable); 926} 927 928/// CreateRuntimeFunction - Create a new runtime function with the specified 929/// type and name. 930llvm::Constant * 931CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy, 932 llvm::StringRef Name) { 933 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false); 934} 935 936static bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D) { 937 if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType()) 938 return false; 939 if (Context.getLangOptions().CPlusPlus && 940 Context.getBaseElementType(D->getType())->getAs<RecordType>()) { 941 // FIXME: We should do something fancier here! 942 return false; 943 } 944 return true; 945} 946 947/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 948/// create and return an llvm GlobalVariable with the specified type. If there 949/// is something in the module with the specified name, return it potentially 950/// bitcasted to the right type. 951/// 952/// If D is non-null, it specifies a decl that correspond to this. This is used 953/// to set the attributes on the global when it is first created. 954llvm::Constant * 955CodeGenModule::GetOrCreateLLVMGlobal(llvm::StringRef MangledName, 956 const llvm::PointerType *Ty, 957 const VarDecl *D, 958 bool UnnamedAddr) { 959 // Lookup the entry, lazily creating it if necessary. 960 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 961 if (Entry) { 962 if (WeakRefReferences.count(Entry)) { 963 if (D && !D->hasAttr<WeakAttr>()) 964 Entry->setLinkage(llvm::Function::ExternalLinkage); 965 966 WeakRefReferences.erase(Entry); 967 } 968 969 if (UnnamedAddr) 970 Entry->setUnnamedAddr(true); 971 972 if (Entry->getType() == Ty) 973 return Entry; 974 975 // Make sure the result is of the correct type. 976 return llvm::ConstantExpr::getBitCast(Entry, Ty); 977 } 978 979 // This is the first use or definition of a mangled name. If there is a 980 // deferred decl with this name, remember that we need to emit it at the end 981 // of the file. 982 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 983 if (DDI != DeferredDecls.end()) { 984 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 985 // list, and remove it from DeferredDecls (since we don't need it anymore). 986 DeferredDeclsToEmit.push_back(DDI->second); 987 DeferredDecls.erase(DDI); 988 } 989 990 llvm::GlobalVariable *GV = 991 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 992 llvm::GlobalValue::ExternalLinkage, 993 0, MangledName, 0, 994 false, Ty->getAddressSpace()); 995 996 // Handle things which are present even on external declarations. 997 if (D) { 998 // FIXME: This code is overly simple and should be merged with other global 999 // handling. 1000 GV->setConstant(DeclIsConstantGlobal(Context, D)); 1001 1002 // Set linkage and visibility in case we never see a definition. 1003 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 1004 if (LV.linkage() != ExternalLinkage) { 1005 // Don't set internal linkage on declarations. 1006 } else { 1007 if (D->hasAttr<DLLImportAttr>()) 1008 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage); 1009 else if (D->hasAttr<WeakAttr>() || D->isWeakImported()) 1010 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 1011 1012 // Set visibility on a declaration only if it's explicit. 1013 if (LV.visibilityExplicit()) 1014 GV->setVisibility(GetLLVMVisibility(LV.visibility())); 1015 } 1016 1017 GV->setThreadLocal(D->isThreadSpecified()); 1018 } 1019 1020 return GV; 1021} 1022 1023 1024llvm::GlobalVariable * 1025CodeGenModule::CreateOrReplaceCXXRuntimeVariable(llvm::StringRef Name, 1026 const llvm::Type *Ty, 1027 llvm::GlobalValue::LinkageTypes Linkage) { 1028 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 1029 llvm::GlobalVariable *OldGV = 0; 1030 1031 1032 if (GV) { 1033 // Check if the variable has the right type. 1034 if (GV->getType()->getElementType() == Ty) 1035 return GV; 1036 1037 // Because C++ name mangling, the only way we can end up with an already 1038 // existing global with the same name is if it has been declared extern "C". 1039 assert(GV->isDeclaration() && "Declaration has wrong type!"); 1040 OldGV = GV; 1041 } 1042 1043 // Create a new variable. 1044 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 1045 Linkage, 0, Name); 1046 1047 if (OldGV) { 1048 // Replace occurrences of the old variable if needed. 1049 GV->takeName(OldGV); 1050 1051 if (!OldGV->use_empty()) { 1052 llvm::Constant *NewPtrForOldDecl = 1053 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 1054 OldGV->replaceAllUsesWith(NewPtrForOldDecl); 1055 } 1056 1057 OldGV->eraseFromParent(); 1058 } 1059 1060 return GV; 1061} 1062 1063/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 1064/// given global variable. If Ty is non-null and if the global doesn't exist, 1065/// then it will be greated with the specified type instead of whatever the 1066/// normal requested type would be. 1067llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 1068 const llvm::Type *Ty) { 1069 assert(D->hasGlobalStorage() && "Not a global variable"); 1070 QualType ASTTy = D->getType(); 1071 if (Ty == 0) 1072 Ty = getTypes().ConvertTypeForMem(ASTTy); 1073 1074 const llvm::PointerType *PTy = 1075 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 1076 1077 llvm::StringRef MangledName = getMangledName(D); 1078 return GetOrCreateLLVMGlobal(MangledName, PTy, D); 1079} 1080 1081/// CreateRuntimeVariable - Create a new runtime global variable with the 1082/// specified type and name. 1083llvm::Constant * 1084CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty, 1085 llvm::StringRef Name) { 1086 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, 1087 true); 1088} 1089 1090void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 1091 assert(!D->getInit() && "Cannot emit definite definitions here!"); 1092 1093 if (MayDeferGeneration(D)) { 1094 // If we have not seen a reference to this variable yet, place it 1095 // into the deferred declarations table to be emitted if needed 1096 // later. 1097 llvm::StringRef MangledName = getMangledName(D); 1098 if (!GetGlobalValue(MangledName)) { 1099 DeferredDecls[MangledName] = D; 1100 return; 1101 } 1102 } 1103 1104 // The tentative definition is the only definition. 1105 EmitGlobalVarDefinition(D); 1106} 1107 1108void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) { 1109 if (DefinitionRequired) 1110 getVTables().GenerateClassData(getVTableLinkage(Class), Class); 1111} 1112 1113llvm::GlobalVariable::LinkageTypes 1114CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { 1115 if (RD->isInAnonymousNamespace() || !RD->hasLinkage()) 1116 return llvm::GlobalVariable::InternalLinkage; 1117 1118 if (const CXXMethodDecl *KeyFunction 1119 = RD->getASTContext().getKeyFunction(RD)) { 1120 // If this class has a key function, use that to determine the linkage of 1121 // the vtable. 1122 const FunctionDecl *Def = 0; 1123 if (KeyFunction->hasBody(Def)) 1124 KeyFunction = cast<CXXMethodDecl>(Def); 1125 1126 switch (KeyFunction->getTemplateSpecializationKind()) { 1127 case TSK_Undeclared: 1128 case TSK_ExplicitSpecialization: 1129 // When compiling with optimizations turned on, we emit all vtables, 1130 // even if the key function is not defined in the current translation 1131 // unit. If this is the case, use available_externally linkage. 1132 if (!Def && CodeGenOpts.OptimizationLevel) 1133 return llvm::GlobalVariable::AvailableExternallyLinkage; 1134 1135 if (KeyFunction->isInlined()) 1136 return !Context.getLangOptions().AppleKext ? 1137 llvm::GlobalVariable::LinkOnceODRLinkage : 1138 llvm::Function::InternalLinkage; 1139 1140 return llvm::GlobalVariable::ExternalLinkage; 1141 1142 case TSK_ImplicitInstantiation: 1143 return !Context.getLangOptions().AppleKext ? 1144 llvm::GlobalVariable::LinkOnceODRLinkage : 1145 llvm::Function::InternalLinkage; 1146 1147 case TSK_ExplicitInstantiationDefinition: 1148 return !Context.getLangOptions().AppleKext ? 1149 llvm::GlobalVariable::WeakODRLinkage : 1150 llvm::Function::InternalLinkage; 1151 1152 case TSK_ExplicitInstantiationDeclaration: 1153 // FIXME: Use available_externally linkage. However, this currently 1154 // breaks LLVM's build due to undefined symbols. 1155 // return llvm::GlobalVariable::AvailableExternallyLinkage; 1156 return !Context.getLangOptions().AppleKext ? 1157 llvm::GlobalVariable::LinkOnceODRLinkage : 1158 llvm::Function::InternalLinkage; 1159 } 1160 } 1161 1162 if (Context.getLangOptions().AppleKext) 1163 return llvm::Function::InternalLinkage; 1164 1165 switch (RD->getTemplateSpecializationKind()) { 1166 case TSK_Undeclared: 1167 case TSK_ExplicitSpecialization: 1168 case TSK_ImplicitInstantiation: 1169 // FIXME: Use available_externally linkage. However, this currently 1170 // breaks LLVM's build due to undefined symbols. 1171 // return llvm::GlobalVariable::AvailableExternallyLinkage; 1172 case TSK_ExplicitInstantiationDeclaration: 1173 return llvm::GlobalVariable::LinkOnceODRLinkage; 1174 1175 case TSK_ExplicitInstantiationDefinition: 1176 return llvm::GlobalVariable::WeakODRLinkage; 1177 } 1178 1179 // Silence GCC warning. 1180 return llvm::GlobalVariable::LinkOnceODRLinkage; 1181} 1182 1183CharUnits CodeGenModule::GetTargetTypeStoreSize(const llvm::Type *Ty) const { 1184 return Context.toCharUnitsFromBits( 1185 TheTargetData.getTypeStoreSizeInBits(Ty)); 1186} 1187 1188void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 1189 llvm::Constant *Init = 0; 1190 QualType ASTTy = D->getType(); 1191 bool NonConstInit = false; 1192 1193 const Expr *InitExpr = D->getAnyInitializer(); 1194 1195 if (!InitExpr) { 1196 // This is a tentative definition; tentative definitions are 1197 // implicitly initialized with { 0 }. 1198 // 1199 // Note that tentative definitions are only emitted at the end of 1200 // a translation unit, so they should never have incomplete 1201 // type. In addition, EmitTentativeDefinition makes sure that we 1202 // never attempt to emit a tentative definition if a real one 1203 // exists. A use may still exists, however, so we still may need 1204 // to do a RAUW. 1205 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 1206 Init = EmitNullConstant(D->getType()); 1207 } else { 1208 Init = EmitConstantExpr(InitExpr, D->getType()); 1209 if (!Init) { 1210 QualType T = InitExpr->getType(); 1211 if (D->getType()->isReferenceType()) 1212 T = D->getType(); 1213 1214 if (getLangOptions().CPlusPlus) { 1215 Init = EmitNullConstant(T); 1216 NonConstInit = true; 1217 } else { 1218 ErrorUnsupported(D, "static initializer"); 1219 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 1220 } 1221 } else { 1222 // We don't need an initializer, so remove the entry for the delayed 1223 // initializer position (just in case this entry was delayed). 1224 if (getLangOptions().CPlusPlus) 1225 DelayedCXXInitPosition.erase(D); 1226 } 1227 } 1228 1229 const llvm::Type* InitType = Init->getType(); 1230 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 1231 1232 // Strip off a bitcast if we got one back. 1233 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1234 assert(CE->getOpcode() == llvm::Instruction::BitCast || 1235 // all zero index gep. 1236 CE->getOpcode() == llvm::Instruction::GetElementPtr); 1237 Entry = CE->getOperand(0); 1238 } 1239 1240 // Entry is now either a Function or GlobalVariable. 1241 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 1242 1243 // We have a definition after a declaration with the wrong type. 1244 // We must make a new GlobalVariable* and update everything that used OldGV 1245 // (a declaration or tentative definition) with the new GlobalVariable* 1246 // (which will be a definition). 1247 // 1248 // This happens if there is a prototype for a global (e.g. 1249 // "extern int x[];") and then a definition of a different type (e.g. 1250 // "int x[10];"). This also happens when an initializer has a different type 1251 // from the type of the global (this happens with unions). 1252 if (GV == 0 || 1253 GV->getType()->getElementType() != InitType || 1254 GV->getType()->getAddressSpace() != 1255 getContext().getTargetAddressSpace(ASTTy)) { 1256 1257 // Move the old entry aside so that we'll create a new one. 1258 Entry->setName(llvm::StringRef()); 1259 1260 // Make a new global with the correct type, this is now guaranteed to work. 1261 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 1262 1263 // Replace all uses of the old global with the new global 1264 llvm::Constant *NewPtrForOldDecl = 1265 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 1266 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1267 1268 // Erase the old global, since it is no longer used. 1269 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 1270 } 1271 1272 if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) { 1273 SourceManager &SM = Context.getSourceManager(); 1274 AddAnnotation(EmitAnnotateAttr(GV, AA, 1275 SM.getInstantiationLineNumber(D->getLocation()))); 1276 } 1277 1278 GV->setInitializer(Init); 1279 1280 // If it is safe to mark the global 'constant', do so now. 1281 GV->setConstant(false); 1282 if (!NonConstInit && DeclIsConstantGlobal(Context, D)) 1283 GV->setConstant(true); 1284 1285 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 1286 1287 // Set the llvm linkage type as appropriate. 1288 llvm::GlobalValue::LinkageTypes Linkage = 1289 GetLLVMLinkageVarDefinition(D, GV); 1290 GV->setLinkage(Linkage); 1291 if (Linkage == llvm::GlobalVariable::CommonLinkage) 1292 // common vars aren't constant even if declared const. 1293 GV->setConstant(false); 1294 1295 SetCommonAttributes(D, GV); 1296 1297 // Emit the initializer function if necessary. 1298 if (NonConstInit) 1299 EmitCXXGlobalVarDeclInitFunc(D, GV); 1300 1301 // Emit global variable debug information. 1302 if (CGDebugInfo *DI = getModuleDebugInfo()) { 1303 DI->setLocation(D->getLocation()); 1304 DI->EmitGlobalVariable(GV, D); 1305 } 1306} 1307 1308llvm::GlobalValue::LinkageTypes 1309CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, 1310 llvm::GlobalVariable *GV) { 1311 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D); 1312 if (Linkage == GVA_Internal) 1313 return llvm::Function::InternalLinkage; 1314 else if (D->hasAttr<DLLImportAttr>()) 1315 return llvm::Function::DLLImportLinkage; 1316 else if (D->hasAttr<DLLExportAttr>()) 1317 return llvm::Function::DLLExportLinkage; 1318 else if (D->hasAttr<WeakAttr>()) { 1319 if (GV->isConstant()) 1320 return llvm::GlobalVariable::WeakODRLinkage; 1321 else 1322 return llvm::GlobalVariable::WeakAnyLinkage; 1323 } else if (Linkage == GVA_TemplateInstantiation || 1324 Linkage == GVA_ExplicitTemplateInstantiation) 1325 return llvm::GlobalVariable::WeakODRLinkage; 1326 else if (!getLangOptions().CPlusPlus && 1327 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) || 1328 D->getAttr<CommonAttr>()) && 1329 !D->hasExternalStorage() && !D->getInit() && 1330 !D->getAttr<SectionAttr>() && !D->isThreadSpecified()) { 1331 // Thread local vars aren't considered common linkage. 1332 return llvm::GlobalVariable::CommonLinkage; 1333 } 1334 return llvm::GlobalVariable::ExternalLinkage; 1335} 1336 1337/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1338/// implement a function with no prototype, e.g. "int foo() {}". If there are 1339/// existing call uses of the old function in the module, this adjusts them to 1340/// call the new function directly. 1341/// 1342/// This is not just a cleanup: the always_inline pass requires direct calls to 1343/// functions to be able to inline them. If there is a bitcast in the way, it 1344/// won't inline them. Instcombine normally deletes these calls, but it isn't 1345/// run at -O0. 1346static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1347 llvm::Function *NewFn) { 1348 // If we're redefining a global as a function, don't transform it. 1349 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 1350 if (OldFn == 0) return; 1351 1352 const llvm::Type *NewRetTy = NewFn->getReturnType(); 1353 llvm::SmallVector<llvm::Value*, 4> ArgList; 1354 1355 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 1356 UI != E; ) { 1357 // TODO: Do invokes ever occur in C code? If so, we should handle them too. 1358 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased. 1359 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I); 1360 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I) 1361 llvm::CallSite CS(CI); 1362 if (!CI || !CS.isCallee(I)) continue; 1363 1364 // If the return types don't match exactly, and if the call isn't dead, then 1365 // we can't transform this call. 1366 if (CI->getType() != NewRetTy && !CI->use_empty()) 1367 continue; 1368 1369 // If the function was passed too few arguments, don't transform. If extra 1370 // arguments were passed, we silently drop them. If any of the types 1371 // mismatch, we don't transform. 1372 unsigned ArgNo = 0; 1373 bool DontTransform = false; 1374 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 1375 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 1376 if (CS.arg_size() == ArgNo || 1377 CS.getArgument(ArgNo)->getType() != AI->getType()) { 1378 DontTransform = true; 1379 break; 1380 } 1381 } 1382 if (DontTransform) 1383 continue; 1384 1385 // Okay, we can transform this. Create the new call instruction and copy 1386 // over the required information. 1387 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo); 1388 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(), 1389 ArgList.end(), "", CI); 1390 ArgList.clear(); 1391 if (!NewCall->getType()->isVoidTy()) 1392 NewCall->takeName(CI); 1393 NewCall->setAttributes(CI->getAttributes()); 1394 NewCall->setCallingConv(CI->getCallingConv()); 1395 1396 // Finally, remove the old call, replacing any uses with the new one. 1397 if (!CI->use_empty()) 1398 CI->replaceAllUsesWith(NewCall); 1399 1400 // Copy debug location attached to CI. 1401 if (!CI->getDebugLoc().isUnknown()) 1402 NewCall->setDebugLoc(CI->getDebugLoc()); 1403 CI->eraseFromParent(); 1404 } 1405} 1406 1407 1408void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 1409 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 1410 1411 // Compute the function info and LLVM type. 1412 const CGFunctionInfo &FI = getTypes().getFunctionInfo(GD); 1413 bool variadic = false; 1414 if (const FunctionProtoType *fpt = D->getType()->getAs<FunctionProtoType>()) 1415 variadic = fpt->isVariadic(); 1416 const llvm::FunctionType *Ty = getTypes().GetFunctionType(FI, variadic, false); 1417 1418 // Get or create the prototype for the function. 1419 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 1420 1421 // Strip off a bitcast if we got one back. 1422 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1423 assert(CE->getOpcode() == llvm::Instruction::BitCast); 1424 Entry = CE->getOperand(0); 1425 } 1426 1427 1428 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 1429 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 1430 1431 // If the types mismatch then we have to rewrite the definition. 1432 assert(OldFn->isDeclaration() && 1433 "Shouldn't replace non-declaration"); 1434 1435 // F is the Function* for the one with the wrong type, we must make a new 1436 // Function* and update everything that used F (a declaration) with the new 1437 // Function* (which will be a definition). 1438 // 1439 // This happens if there is a prototype for a function 1440 // (e.g. "int f()") and then a definition of a different type 1441 // (e.g. "int f(int x)"). Move the old function aside so that it 1442 // doesn't interfere with GetAddrOfFunction. 1443 OldFn->setName(llvm::StringRef()); 1444 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 1445 1446 // If this is an implementation of a function without a prototype, try to 1447 // replace any existing uses of the function (which may be calls) with uses 1448 // of the new function 1449 if (D->getType()->isFunctionNoProtoType()) { 1450 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 1451 OldFn->removeDeadConstantUsers(); 1452 } 1453 1454 // Replace uses of F with the Function we will endow with a body. 1455 if (!Entry->use_empty()) { 1456 llvm::Constant *NewPtrForOldDecl = 1457 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 1458 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1459 } 1460 1461 // Ok, delete the old function now, which is dead. 1462 OldFn->eraseFromParent(); 1463 1464 Entry = NewFn; 1465 } 1466 1467 // We need to set linkage and visibility on the function before 1468 // generating code for it because various parts of IR generation 1469 // want to propagate this information down (e.g. to local static 1470 // declarations). 1471 llvm::Function *Fn = cast<llvm::Function>(Entry); 1472 setFunctionLinkage(D, Fn); 1473 1474 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes 1475 setGlobalVisibility(Fn, D); 1476 1477 CodeGenFunction(*this).GenerateCode(D, Fn, FI); 1478 1479 SetFunctionDefinitionAttributes(D, Fn); 1480 SetLLVMFunctionAttributesForDefinition(D, Fn); 1481 1482 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 1483 AddGlobalCtor(Fn, CA->getPriority()); 1484 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 1485 AddGlobalDtor(Fn, DA->getPriority()); 1486} 1487 1488void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 1489 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1490 const AliasAttr *AA = D->getAttr<AliasAttr>(); 1491 assert(AA && "Not an alias?"); 1492 1493 llvm::StringRef MangledName = getMangledName(GD); 1494 1495 // If there is a definition in the module, then it wins over the alias. 1496 // This is dubious, but allow it to be safe. Just ignore the alias. 1497 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1498 if (Entry && !Entry->isDeclaration()) 1499 return; 1500 1501 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 1502 1503 // Create a reference to the named value. This ensures that it is emitted 1504 // if a deferred decl. 1505 llvm::Constant *Aliasee; 1506 if (isa<llvm::FunctionType>(DeclTy)) 1507 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(), 1508 /*ForVTable=*/false); 1509 else 1510 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 1511 llvm::PointerType::getUnqual(DeclTy), 0); 1512 1513 // Create the new alias itself, but don't set a name yet. 1514 llvm::GlobalValue *GA = 1515 new llvm::GlobalAlias(Aliasee->getType(), 1516 llvm::Function::ExternalLinkage, 1517 "", Aliasee, &getModule()); 1518 1519 if (Entry) { 1520 assert(Entry->isDeclaration()); 1521 1522 // If there is a declaration in the module, then we had an extern followed 1523 // by the alias, as in: 1524 // extern int test6(); 1525 // ... 1526 // int test6() __attribute__((alias("test7"))); 1527 // 1528 // Remove it and replace uses of it with the alias. 1529 GA->takeName(Entry); 1530 1531 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 1532 Entry->getType())); 1533 Entry->eraseFromParent(); 1534 } else { 1535 GA->setName(MangledName); 1536 } 1537 1538 // Set attributes which are particular to an alias; this is a 1539 // specialization of the attributes which may be set on a global 1540 // variable/function. 1541 if (D->hasAttr<DLLExportAttr>()) { 1542 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1543 // The dllexport attribute is ignored for undefined symbols. 1544 if (FD->hasBody()) 1545 GA->setLinkage(llvm::Function::DLLExportLinkage); 1546 } else { 1547 GA->setLinkage(llvm::Function::DLLExportLinkage); 1548 } 1549 } else if (D->hasAttr<WeakAttr>() || 1550 D->hasAttr<WeakRefAttr>() || 1551 D->isWeakImported()) { 1552 GA->setLinkage(llvm::Function::WeakAnyLinkage); 1553 } 1554 1555 SetCommonAttributes(D, GA); 1556} 1557 1558/// getBuiltinLibFunction - Given a builtin id for a function like 1559/// "__builtin_fabsf", return a Function* for "fabsf". 1560llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD, 1561 unsigned BuiltinID) { 1562 assert((Context.BuiltinInfo.isLibFunction(BuiltinID) || 1563 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) && 1564 "isn't a lib fn"); 1565 1566 // Get the name, skip over the __builtin_ prefix (if necessary). 1567 const char *Name = Context.BuiltinInfo.GetName(BuiltinID); 1568 if (Context.BuiltinInfo.isLibFunction(BuiltinID)) 1569 Name += 10; 1570 1571 const llvm::FunctionType *Ty = 1572 cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType())); 1573 1574 return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD), /*ForVTable=*/false); 1575} 1576 1577llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 1578 unsigned NumTys) { 1579 return llvm::Intrinsic::getDeclaration(&getModule(), 1580 (llvm::Intrinsic::ID)IID, Tys, NumTys); 1581} 1582 1583static llvm::StringMapEntry<llvm::Constant*> & 1584GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 1585 const StringLiteral *Literal, 1586 bool TargetIsLSB, 1587 bool &IsUTF16, 1588 unsigned &StringLength) { 1589 llvm::StringRef String = Literal->getString(); 1590 unsigned NumBytes = String.size(); 1591 1592 // Check for simple case. 1593 if (!Literal->containsNonAsciiOrNull()) { 1594 StringLength = NumBytes; 1595 return Map.GetOrCreateValue(String); 1596 } 1597 1598 // Otherwise, convert the UTF8 literals into a byte string. 1599 llvm::SmallVector<UTF16, 128> ToBuf(NumBytes); 1600 const UTF8 *FromPtr = (UTF8 *)String.data(); 1601 UTF16 *ToPtr = &ToBuf[0]; 1602 1603 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 1604 &ToPtr, ToPtr + NumBytes, 1605 strictConversion); 1606 1607 // ConvertUTF8toUTF16 returns the length in ToPtr. 1608 StringLength = ToPtr - &ToBuf[0]; 1609 1610 // Render the UTF-16 string into a byte array and convert to the target byte 1611 // order. 1612 // 1613 // FIXME: This isn't something we should need to do here. 1614 llvm::SmallString<128> AsBytes; 1615 AsBytes.reserve(StringLength * 2); 1616 for (unsigned i = 0; i != StringLength; ++i) { 1617 unsigned short Val = ToBuf[i]; 1618 if (TargetIsLSB) { 1619 AsBytes.push_back(Val & 0xFF); 1620 AsBytes.push_back(Val >> 8); 1621 } else { 1622 AsBytes.push_back(Val >> 8); 1623 AsBytes.push_back(Val & 0xFF); 1624 } 1625 } 1626 // Append one extra null character, the second is automatically added by our 1627 // caller. 1628 AsBytes.push_back(0); 1629 1630 IsUTF16 = true; 1631 return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size())); 1632} 1633 1634llvm::Constant * 1635CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 1636 unsigned StringLength = 0; 1637 bool isUTF16 = false; 1638 llvm::StringMapEntry<llvm::Constant*> &Entry = 1639 GetConstantCFStringEntry(CFConstantStringMap, Literal, 1640 getTargetData().isLittleEndian(), 1641 isUTF16, StringLength); 1642 1643 if (llvm::Constant *C = Entry.getValue()) 1644 return C; 1645 1646 llvm::Constant *Zero = 1647 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 1648 llvm::Constant *Zeros[] = { Zero, Zero }; 1649 1650 // If we don't already have it, get __CFConstantStringClassReference. 1651 if (!CFConstantStringClassRef) { 1652 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 1653 Ty = llvm::ArrayType::get(Ty, 0); 1654 llvm::Constant *GV = CreateRuntimeVariable(Ty, 1655 "__CFConstantStringClassReference"); 1656 // Decay array -> ptr 1657 CFConstantStringClassRef = 1658 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1659 } 1660 1661 QualType CFTy = getContext().getCFConstantStringType(); 1662 1663 const llvm::StructType *STy = 1664 cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 1665 1666 std::vector<llvm::Constant*> Fields(4); 1667 1668 // Class pointer. 1669 Fields[0] = CFConstantStringClassRef; 1670 1671 // Flags. 1672 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 1673 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 1674 llvm::ConstantInt::get(Ty, 0x07C8); 1675 1676 // String pointer. 1677 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 1678 1679 llvm::GlobalValue::LinkageTypes Linkage; 1680 bool isConstant; 1681 if (isUTF16) { 1682 // FIXME: why do utf strings get "_" labels instead of "L" labels? 1683 Linkage = llvm::GlobalValue::InternalLinkage; 1684 // Note: -fwritable-strings doesn't make unicode CFStrings writable, but 1685 // does make plain ascii ones writable. 1686 isConstant = true; 1687 } else { 1688 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error 1689 // when using private linkage. It is not clear if this is a bug in ld 1690 // or a reasonable new restriction. 1691 Linkage = llvm::GlobalValue::LinkerPrivateLinkage; 1692 isConstant = !Features.WritableStrings; 1693 } 1694 1695 llvm::GlobalVariable *GV = 1696 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 1697 ".str"); 1698 GV->setUnnamedAddr(true); 1699 if (isUTF16) { 1700 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 1701 GV->setAlignment(Align.getQuantity()); 1702 } else { 1703 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 1704 GV->setAlignment(Align.getQuantity()); 1705 } 1706 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1707 1708 // String length. 1709 Ty = getTypes().ConvertType(getContext().LongTy); 1710 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 1711 1712 // The struct. 1713 C = llvm::ConstantStruct::get(STy, Fields); 1714 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 1715 llvm::GlobalVariable::PrivateLinkage, C, 1716 "_unnamed_cfstring_"); 1717 if (const char *Sect = getContext().Target.getCFStringSection()) 1718 GV->setSection(Sect); 1719 Entry.setValue(GV); 1720 1721 return GV; 1722} 1723 1724llvm::Constant * 1725CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { 1726 unsigned StringLength = 0; 1727 bool isUTF16 = false; 1728 llvm::StringMapEntry<llvm::Constant*> &Entry = 1729 GetConstantCFStringEntry(CFConstantStringMap, Literal, 1730 getTargetData().isLittleEndian(), 1731 isUTF16, StringLength); 1732 1733 if (llvm::Constant *C = Entry.getValue()) 1734 return C; 1735 1736 llvm::Constant *Zero = 1737 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 1738 llvm::Constant *Zeros[] = { Zero, Zero }; 1739 1740 // If we don't already have it, get _NSConstantStringClassReference. 1741 if (!ConstantStringClassRef) { 1742 std::string StringClass(getLangOptions().ObjCConstantStringClass); 1743 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 1744 Ty = llvm::ArrayType::get(Ty, 0); 1745 llvm::Constant *GV; 1746 if (StringClass.empty()) 1747 GV = CreateRuntimeVariable(Ty, 1748 Features.ObjCNonFragileABI ? 1749 "OBJC_CLASS_$_NSConstantString" : 1750 "_NSConstantStringClassReference"); 1751 else { 1752 std::string str; 1753 if (Features.ObjCNonFragileABI) 1754 str = "OBJC_CLASS_$_" + StringClass; 1755 else 1756 str = "_" + StringClass + "ClassReference"; 1757 GV = CreateRuntimeVariable(Ty, str); 1758 } 1759 // Decay array -> ptr 1760 ConstantStringClassRef = 1761 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1762 } 1763 1764 QualType NSTy = getContext().getNSConstantStringType(); 1765 1766 const llvm::StructType *STy = 1767 cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 1768 1769 std::vector<llvm::Constant*> Fields(3); 1770 1771 // Class pointer. 1772 Fields[0] = ConstantStringClassRef; 1773 1774 // String pointer. 1775 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 1776 1777 llvm::GlobalValue::LinkageTypes Linkage; 1778 bool isConstant; 1779 if (isUTF16) { 1780 // FIXME: why do utf strings get "_" labels instead of "L" labels? 1781 Linkage = llvm::GlobalValue::InternalLinkage; 1782 // Note: -fwritable-strings doesn't make unicode NSStrings writable, but 1783 // does make plain ascii ones writable. 1784 isConstant = true; 1785 } else { 1786 Linkage = llvm::GlobalValue::PrivateLinkage; 1787 isConstant = !Features.WritableStrings; 1788 } 1789 1790 llvm::GlobalVariable *GV = 1791 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 1792 ".str"); 1793 GV->setUnnamedAddr(true); 1794 if (isUTF16) { 1795 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 1796 GV->setAlignment(Align.getQuantity()); 1797 } else { 1798 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 1799 GV->setAlignment(Align.getQuantity()); 1800 } 1801 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1802 1803 // String length. 1804 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 1805 Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 1806 1807 // The struct. 1808 C = llvm::ConstantStruct::get(STy, Fields); 1809 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 1810 llvm::GlobalVariable::PrivateLinkage, C, 1811 "_unnamed_nsstring_"); 1812 // FIXME. Fix section. 1813 if (const char *Sect = 1814 Features.ObjCNonFragileABI 1815 ? getContext().Target.getNSStringNonFragileABISection() 1816 : getContext().Target.getNSStringSection()) 1817 GV->setSection(Sect); 1818 Entry.setValue(GV); 1819 1820 return GV; 1821} 1822 1823/// GetStringForStringLiteral - Return the appropriate bytes for a 1824/// string literal, properly padded to match the literal type. 1825std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) { 1826 const ASTContext &Context = getContext(); 1827 const ConstantArrayType *CAT = 1828 Context.getAsConstantArrayType(E->getType()); 1829 assert(CAT && "String isn't pointer or array!"); 1830 1831 // Resize the string to the right size. 1832 uint64_t RealLen = CAT->getSize().getZExtValue(); 1833 1834 if (E->isWide()) 1835 RealLen *= Context.Target.getWCharWidth() / Context.getCharWidth(); 1836 1837 std::string Str = E->getString().str(); 1838 Str.resize(RealLen, '\0'); 1839 1840 return Str; 1841} 1842 1843/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 1844/// constant array for the given string literal. 1845llvm::Constant * 1846CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 1847 // FIXME: This can be more efficient. 1848 // FIXME: We shouldn't need to bitcast the constant in the wide string case. 1849 llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S)); 1850 if (S->isWide()) { 1851 llvm::Type *DestTy = 1852 llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType())); 1853 C = llvm::ConstantExpr::getBitCast(C, DestTy); 1854 } 1855 return C; 1856} 1857 1858/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 1859/// array for the given ObjCEncodeExpr node. 1860llvm::Constant * 1861CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 1862 std::string Str; 1863 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 1864 1865 return GetAddrOfConstantCString(Str); 1866} 1867 1868 1869/// GenerateWritableString -- Creates storage for a string literal. 1870static llvm::Constant *GenerateStringLiteral(llvm::StringRef str, 1871 bool constant, 1872 CodeGenModule &CGM, 1873 const char *GlobalName) { 1874 // Create Constant for this string literal. Don't add a '\0'. 1875 llvm::Constant *C = 1876 llvm::ConstantArray::get(CGM.getLLVMContext(), str, false); 1877 1878 // Create a global variable for this string 1879 llvm::GlobalVariable *GV = 1880 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 1881 llvm::GlobalValue::PrivateLinkage, 1882 C, GlobalName); 1883 GV->setUnnamedAddr(true); 1884 return GV; 1885} 1886 1887/// GetAddrOfConstantString - Returns a pointer to a character array 1888/// containing the literal. This contents are exactly that of the 1889/// given string, i.e. it will not be null terminated automatically; 1890/// see GetAddrOfConstantCString. Note that whether the result is 1891/// actually a pointer to an LLVM constant depends on 1892/// Feature.WriteableStrings. 1893/// 1894/// The result has pointer to array type. 1895llvm::Constant *CodeGenModule::GetAddrOfConstantString(llvm::StringRef Str, 1896 const char *GlobalName) { 1897 bool IsConstant = !Features.WritableStrings; 1898 1899 // Get the default prefix if a name wasn't specified. 1900 if (!GlobalName) 1901 GlobalName = ".str"; 1902 1903 // Don't share any string literals if strings aren't constant. 1904 if (!IsConstant) 1905 return GenerateStringLiteral(Str, false, *this, GlobalName); 1906 1907 llvm::StringMapEntry<llvm::Constant *> &Entry = 1908 ConstantStringMap.GetOrCreateValue(Str); 1909 1910 if (Entry.getValue()) 1911 return Entry.getValue(); 1912 1913 // Create a global variable for this. 1914 llvm::Constant *C = GenerateStringLiteral(Str, true, *this, GlobalName); 1915 Entry.setValue(C); 1916 return C; 1917} 1918 1919/// GetAddrOfConstantCString - Returns a pointer to a character 1920/// array containing the literal and a terminating '\0' 1921/// character. The result has pointer to array type. 1922llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str, 1923 const char *GlobalName){ 1924 llvm::StringRef StrWithNull(Str.c_str(), Str.size() + 1); 1925 return GetAddrOfConstantString(StrWithNull, GlobalName); 1926} 1927 1928/// EmitObjCPropertyImplementations - Emit information for synthesized 1929/// properties for an implementation. 1930void CodeGenModule::EmitObjCPropertyImplementations(const 1931 ObjCImplementationDecl *D) { 1932 for (ObjCImplementationDecl::propimpl_iterator 1933 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 1934 ObjCPropertyImplDecl *PID = *i; 1935 1936 // Dynamic is just for type-checking. 1937 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 1938 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 1939 1940 // Determine which methods need to be implemented, some may have 1941 // been overridden. Note that ::isSynthesized is not the method 1942 // we want, that just indicates if the decl came from a 1943 // property. What we want to know is if the method is defined in 1944 // this implementation. 1945 if (!D->getInstanceMethod(PD->getGetterName())) 1946 CodeGenFunction(*this).GenerateObjCGetter( 1947 const_cast<ObjCImplementationDecl *>(D), PID); 1948 if (!PD->isReadOnly() && 1949 !D->getInstanceMethod(PD->getSetterName())) 1950 CodeGenFunction(*this).GenerateObjCSetter( 1951 const_cast<ObjCImplementationDecl *>(D), PID); 1952 } 1953 } 1954} 1955 1956static bool needsDestructMethod(ObjCImplementationDecl *impl) { 1957 ObjCInterfaceDecl *iface 1958 = const_cast<ObjCInterfaceDecl*>(impl->getClassInterface()); 1959 for (ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 1960 ivar; ivar = ivar->getNextIvar()) 1961 if (ivar->getType().isDestructedType()) 1962 return true; 1963 1964 return false; 1965} 1966 1967/// EmitObjCIvarInitializations - Emit information for ivar initialization 1968/// for an implementation. 1969void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 1970 // We might need a .cxx_destruct even if we don't have any ivar initializers. 1971 if (needsDestructMethod(D)) { 1972 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 1973 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 1974 ObjCMethodDecl *DTORMethod = 1975 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 1976 cxxSelector, getContext().VoidTy, 0, D, true, 1977 false, true, false, ObjCMethodDecl::Required); 1978 D->addInstanceMethod(DTORMethod); 1979 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 1980 } 1981 1982 // If the implementation doesn't have any ivar initializers, we don't need 1983 // a .cxx_construct. 1984 if (D->getNumIvarInitializers() == 0) 1985 return; 1986 1987 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 1988 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 1989 // The constructor returns 'self'. 1990 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 1991 D->getLocation(), 1992 D->getLocation(), cxxSelector, 1993 getContext().getObjCIdType(), 0, 1994 D, true, false, true, false, 1995 ObjCMethodDecl::Required); 1996 D->addInstanceMethod(CTORMethod); 1997 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 1998} 1999 2000/// EmitNamespace - Emit all declarations in a namespace. 2001void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 2002 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 2003 I != E; ++I) 2004 EmitTopLevelDecl(*I); 2005} 2006 2007// EmitLinkageSpec - Emit all declarations in a linkage spec. 2008void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 2009 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 2010 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 2011 ErrorUnsupported(LSD, "linkage spec"); 2012 return; 2013 } 2014 2015 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 2016 I != E; ++I) 2017 EmitTopLevelDecl(*I); 2018} 2019 2020/// EmitTopLevelDecl - Emit code for a single top level declaration. 2021void CodeGenModule::EmitTopLevelDecl(Decl *D) { 2022 // If an error has occurred, stop code generation, but continue 2023 // parsing and semantic analysis (to ensure all warnings and errors 2024 // are emitted). 2025 if (Diags.hasErrorOccurred()) 2026 return; 2027 2028 // Ignore dependent declarations. 2029 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 2030 return; 2031 2032 switch (D->getKind()) { 2033 case Decl::CXXConversion: 2034 case Decl::CXXMethod: 2035 case Decl::Function: 2036 // Skip function templates 2037 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2038 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2039 return; 2040 2041 EmitGlobal(cast<FunctionDecl>(D)); 2042 break; 2043 2044 case Decl::Var: 2045 EmitGlobal(cast<VarDecl>(D)); 2046 break; 2047 2048 // Indirect fields from global anonymous structs and unions can be 2049 // ignored; only the actual variable requires IR gen support. 2050 case Decl::IndirectField: 2051 break; 2052 2053 // C++ Decls 2054 case Decl::Namespace: 2055 EmitNamespace(cast<NamespaceDecl>(D)); 2056 break; 2057 // No code generation needed. 2058 case Decl::UsingShadow: 2059 case Decl::Using: 2060 case Decl::UsingDirective: 2061 case Decl::ClassTemplate: 2062 case Decl::FunctionTemplate: 2063 case Decl::NamespaceAlias: 2064 break; 2065 case Decl::CXXConstructor: 2066 // Skip function templates 2067 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2068 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2069 return; 2070 2071 EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 2072 break; 2073 case Decl::CXXDestructor: 2074 if (cast<FunctionDecl>(D)->isLateTemplateParsed()) 2075 return; 2076 EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 2077 break; 2078 2079 case Decl::StaticAssert: 2080 // Nothing to do. 2081 break; 2082 2083 // Objective-C Decls 2084 2085 // Forward declarations, no (immediate) code generation. 2086 case Decl::ObjCClass: 2087 case Decl::ObjCForwardProtocol: 2088 case Decl::ObjCInterface: 2089 break; 2090 2091 case Decl::ObjCCategory: { 2092 ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D); 2093 if (CD->IsClassExtension() && CD->hasSynthBitfield()) 2094 Context.ResetObjCLayout(CD->getClassInterface()); 2095 break; 2096 } 2097 2098 case Decl::ObjCProtocol: 2099 Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D)); 2100 break; 2101 2102 case Decl::ObjCCategoryImpl: 2103 // Categories have properties but don't support synthesize so we 2104 // can ignore them here. 2105 Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 2106 break; 2107 2108 case Decl::ObjCImplementation: { 2109 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 2110 if (Features.ObjCNonFragileABI2 && OMD->hasSynthBitfield()) 2111 Context.ResetObjCLayout(OMD->getClassInterface()); 2112 EmitObjCPropertyImplementations(OMD); 2113 EmitObjCIvarInitializations(OMD); 2114 Runtime->GenerateClass(OMD); 2115 break; 2116 } 2117 case Decl::ObjCMethod: { 2118 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 2119 // If this is not a prototype, emit the body. 2120 if (OMD->getBody()) 2121 CodeGenFunction(*this).GenerateObjCMethod(OMD); 2122 break; 2123 } 2124 case Decl::ObjCCompatibleAlias: 2125 // compatibility-alias is a directive and has no code gen. 2126 break; 2127 2128 case Decl::LinkageSpec: 2129 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 2130 break; 2131 2132 case Decl::FileScopeAsm: { 2133 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 2134 llvm::StringRef AsmString = AD->getAsmString()->getString(); 2135 2136 const std::string &S = getModule().getModuleInlineAsm(); 2137 if (S.empty()) 2138 getModule().setModuleInlineAsm(AsmString); 2139 else 2140 getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 2141 break; 2142 } 2143 2144 default: 2145 // Make sure we handled everything we should, every other kind is a 2146 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 2147 // function. Need to recode Decl::Kind to do that easily. 2148 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 2149 } 2150} 2151 2152/// Turns the given pointer into a constant. 2153static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 2154 const void *Ptr) { 2155 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 2156 const llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 2157 return llvm::ConstantInt::get(i64, PtrInt); 2158} 2159 2160static void EmitGlobalDeclMetadata(CodeGenModule &CGM, 2161 llvm::NamedMDNode *&GlobalMetadata, 2162 GlobalDecl D, 2163 llvm::GlobalValue *Addr) { 2164 if (!GlobalMetadata) 2165 GlobalMetadata = 2166 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 2167 2168 // TODO: should we report variant information for ctors/dtors? 2169 llvm::Value *Ops[] = { 2170 Addr, 2171 GetPointerConstant(CGM.getLLVMContext(), D.getDecl()) 2172 }; 2173 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 2174} 2175 2176/// Emits metadata nodes associating all the global values in the 2177/// current module with the Decls they came from. This is useful for 2178/// projects using IR gen as a subroutine. 2179/// 2180/// Since there's currently no way to associate an MDNode directly 2181/// with an llvm::GlobalValue, we create a global named metadata 2182/// with the name 'clang.global.decl.ptrs'. 2183void CodeGenModule::EmitDeclMetadata() { 2184 llvm::NamedMDNode *GlobalMetadata = 0; 2185 2186 // StaticLocalDeclMap 2187 for (llvm::DenseMap<GlobalDecl,llvm::StringRef>::iterator 2188 I = MangledDeclNames.begin(), E = MangledDeclNames.end(); 2189 I != E; ++I) { 2190 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second); 2191 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr); 2192 } 2193} 2194 2195/// Emits metadata nodes for all the local variables in the current 2196/// function. 2197void CodeGenFunction::EmitDeclMetadata() { 2198 if (LocalDeclMap.empty()) return; 2199 2200 llvm::LLVMContext &Context = getLLVMContext(); 2201 2202 // Find the unique metadata ID for this name. 2203 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 2204 2205 llvm::NamedMDNode *GlobalMetadata = 0; 2206 2207 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator 2208 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) { 2209 const Decl *D = I->first; 2210 llvm::Value *Addr = I->second; 2211 2212 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 2213 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 2214 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); 2215 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 2216 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 2217 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 2218 } 2219 } 2220} 2221 2222void CodeGenModule::EmitCoverageFile() { 2223 if (!getCodeGenOpts().CoverageFile.empty()) { 2224 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { 2225 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 2226 llvm::LLVMContext &Ctx = TheModule.getContext(); 2227 llvm::MDString *CoverageFile = 2228 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile); 2229 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 2230 llvm::MDNode *CU = CUNode->getOperand(i); 2231 llvm::Value *node[] = { CoverageFile, CU }; 2232 llvm::MDNode *N = llvm::MDNode::get(Ctx, node); 2233 GCov->addOperand(N); 2234 } 2235 } 2236 } 2237} 2238 2239///@name Custom Runtime Function Interfaces 2240///@{ 2241// 2242// FIXME: These can be eliminated once we can have clients just get the required 2243// AST nodes from the builtin tables. 2244 2245llvm::Constant *CodeGenModule::getBlockObjectDispose() { 2246 if (BlockObjectDispose) 2247 return BlockObjectDispose; 2248 2249 // If we saw an explicit decl, use that. 2250 if (BlockObjectDisposeDecl) { 2251 return BlockObjectDispose = GetAddrOfFunction( 2252 BlockObjectDisposeDecl, 2253 getTypes().GetFunctionType(BlockObjectDisposeDecl)); 2254 } 2255 2256 // Otherwise construct the function by hand. 2257 const llvm::FunctionType *FTy; 2258 std::vector<const llvm::Type*> ArgTys; 2259 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext); 2260 ArgTys.push_back(Int8PtrTy); 2261 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext)); 2262 FTy = llvm::FunctionType::get(ResultType, ArgTys, false); 2263 return BlockObjectDispose = 2264 CreateRuntimeFunction(FTy, "_Block_object_dispose"); 2265} 2266 2267llvm::Constant *CodeGenModule::getBlockObjectAssign() { 2268 if (BlockObjectAssign) 2269 return BlockObjectAssign; 2270 2271 // If we saw an explicit decl, use that. 2272 if (BlockObjectAssignDecl) { 2273 return BlockObjectAssign = GetAddrOfFunction( 2274 BlockObjectAssignDecl, 2275 getTypes().GetFunctionType(BlockObjectAssignDecl)); 2276 } 2277 2278 // Otherwise construct the function by hand. 2279 const llvm::FunctionType *FTy; 2280 std::vector<const llvm::Type*> ArgTys; 2281 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext); 2282 ArgTys.push_back(Int8PtrTy); 2283 ArgTys.push_back(Int8PtrTy); 2284 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext)); 2285 FTy = llvm::FunctionType::get(ResultType, ArgTys, false); 2286 return BlockObjectAssign = 2287 CreateRuntimeFunction(FTy, "_Block_object_assign"); 2288} 2289 2290llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() { 2291 if (NSConcreteGlobalBlock) 2292 return NSConcreteGlobalBlock; 2293 2294 // If we saw an explicit decl, use that. 2295 if (NSConcreteGlobalBlockDecl) { 2296 return NSConcreteGlobalBlock = GetAddrOfGlobalVar( 2297 NSConcreteGlobalBlockDecl, 2298 getTypes().ConvertType(NSConcreteGlobalBlockDecl->getType())); 2299 } 2300 2301 // Otherwise construct the variable by hand. 2302 return NSConcreteGlobalBlock = 2303 CreateRuntimeVariable(Int8PtrTy, "_NSConcreteGlobalBlock"); 2304} 2305 2306llvm::Constant *CodeGenModule::getNSConcreteStackBlock() { 2307 if (NSConcreteStackBlock) 2308 return NSConcreteStackBlock; 2309 2310 // If we saw an explicit decl, use that. 2311 if (NSConcreteStackBlockDecl) { 2312 return NSConcreteStackBlock = GetAddrOfGlobalVar( 2313 NSConcreteStackBlockDecl, 2314 getTypes().ConvertType(NSConcreteStackBlockDecl->getType())); 2315 } 2316 2317 // Otherwise construct the variable by hand. 2318 return NSConcreteStackBlock = 2319 CreateRuntimeVariable(Int8PtrTy, "_NSConcreteStackBlock"); 2320} 2321 2322///@} 2323