CodeGenModule.cpp revision c857ce8b08397ed778928b8a000732ca90da2a8c
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/Target/TargetData.h" 46#include "llvm/Support/CallSite.h" 47#include "llvm/Support/ErrorHandling.h" 48using namespace clang; 49using namespace CodeGen; 50 51static const char AnnotationSection[] = "llvm.metadata"; 52 53static 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 64CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 65 llvm::Module &M, const llvm::TargetData &TD, 66 DiagnosticsEngine &diags) 67 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M), 68 TheTargetData(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 125CodeGenModule::~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 137void 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 156void CodeGenModule::createOpenCLRuntime() { 157 OpenCLRuntime = new CGOpenCLRuntime(*this); 158} 159 160void CodeGenModule::createCUDARuntime() { 161 CUDARuntime = CreateNVCUDARuntime(*this); 162} 163 164void 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 188void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 189 // Make sure that this type is translated. 190 Types.UpdateCompletedType(TD); 191} 192 193llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { 194 if (!TBAA) 195 return 0; 196 return TBAA->getTBAAInfo(QTy); 197} 198 199llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() { 200 if (!TBAA) 201 return 0; 202 return TBAA->getTBAAInfoForVTablePtr(); 203} 204 205llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { 206 if (!TBAA) 207 return 0; 208 return TBAA->getTBAAStructInfo(QTy); 209} 210 211void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, 212 llvm::MDNode *TBAAInfo) { 213 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); 214} 215 216bool CodeGenModule::isTargetDarwin() const { 217 return getContext().getTargetInfo().getTriple().isOSDarwin(); 218} 219 220void 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. 227void 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. 240void 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 250llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { 251 return llvm::ConstantInt::get(SizeTy, size.getQuantity()); 252} 253 254void 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 268static 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 276static 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 291void 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. 309void 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 374StringRef 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 412void 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 428llvm::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. 434void 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. 441void 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 446void 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 474llvm::GlobalValue::LinkageTypes 475CodeGenModule::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). 527void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 528 llvm::GlobalValue *GV) { 529 SetCommonAttributes(D, GV); 530} 531 532void 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. 547static 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 562void 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::Attribute::NoUnwind); 569 570 if (D->hasAttr<NakedAttr>()) { 571 // Naked implies noinline: we should not be inlining such functions. 572 F->addFnAttr(llvm::Attribute::Naked); 573 F->addFnAttr(llvm::Attribute::NoInline); 574 } 575 576 if (D->hasAttr<NoInlineAttr>()) 577 F->addFnAttr(llvm::Attribute::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().hasNoInlineAttr()) 582 F->addFnAttr(llvm::Attribute::AlwaysInline); 583 584 // FIXME: Communicate hot and cold attributes to LLVM more directly. 585 if (D->hasAttr<ColdAttr>()) 586 F->addFnAttr(llvm::Attribute::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::Attribute::StackProtect); 597 else if (LangOpts.getStackProtector() == LangOptions::SSPReq) 598 F->addFnAttr(llvm::Attribute::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::Attribute::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 616void 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 632void 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 643void 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((llvm::Intrinsic::ID)IID)); 650 return; 651 } 652 653 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 654 655 if (!IsIncompleteFunction) 656 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); 657 658 // Only a few attributes are set on declarations; these may later be 659 // overridden by a definition. 660 661 if (FD->hasAttr<DLLImportAttr>()) { 662 F->setLinkage(llvm::Function::DLLImportLinkage); 663 } else if (FD->hasAttr<WeakAttr>() || 664 FD->isWeakImported()) { 665 // "extern_weak" is overloaded in LLVM; we probably should have 666 // separate linkage types for this. 667 F->setLinkage(llvm::Function::ExternalWeakLinkage); 668 } else { 669 F->setLinkage(llvm::Function::ExternalLinkage); 670 671 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility(); 672 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) { 673 F->setVisibility(GetLLVMVisibility(LV.visibility())); 674 } 675 } 676 677 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 678 F->setSection(SA->getName()); 679} 680 681void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 682 assert(!GV->isDeclaration() && 683 "Only globals with definition can force usage."); 684 LLVMUsed.push_back(GV); 685} 686 687void CodeGenModule::EmitLLVMUsed() { 688 // Don't create llvm.used if there is no need. 689 if (LLVMUsed.empty()) 690 return; 691 692 // Convert LLVMUsed to what ConstantArray needs. 693 SmallVector<llvm::Constant*, 8> UsedArray; 694 UsedArray.resize(LLVMUsed.size()); 695 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 696 UsedArray[i] = 697 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 698 Int8PtrTy); 699 } 700 701 if (UsedArray.empty()) 702 return; 703 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size()); 704 705 llvm::GlobalVariable *GV = 706 new llvm::GlobalVariable(getModule(), ATy, false, 707 llvm::GlobalValue::AppendingLinkage, 708 llvm::ConstantArray::get(ATy, UsedArray), 709 "llvm.used"); 710 711 GV->setSection("llvm.metadata"); 712} 713 714void CodeGenModule::EmitDeferred() { 715 // Emit code for any potentially referenced deferred decls. Since a 716 // previously unused static decl may become used during the generation of code 717 // for a static function, iterate until no changes are made. 718 719 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) { 720 if (!DeferredVTables.empty()) { 721 const CXXRecordDecl *RD = DeferredVTables.back(); 722 DeferredVTables.pop_back(); 723 getCXXABI().EmitVTables(RD); 724 continue; 725 } 726 727 GlobalDecl D = DeferredDeclsToEmit.back(); 728 DeferredDeclsToEmit.pop_back(); 729 730 // Check to see if we've already emitted this. This is necessary 731 // for a couple of reasons: first, decls can end up in the 732 // deferred-decls queue multiple times, and second, decls can end 733 // up with definitions in unusual ways (e.g. by an extern inline 734 // function acquiring a strong function redefinition). Just 735 // ignore these cases. 736 // 737 // TODO: That said, looking this up multiple times is very wasteful. 738 StringRef Name = getMangledName(D); 739 llvm::GlobalValue *CGRef = GetGlobalValue(Name); 740 assert(CGRef && "Deferred decl wasn't referenced?"); 741 742 if (!CGRef->isDeclaration()) 743 continue; 744 745 // GlobalAlias::isDeclaration() defers to the aliasee, but for our 746 // purposes an alias counts as a definition. 747 if (isa<llvm::GlobalAlias>(CGRef)) 748 continue; 749 750 // Otherwise, emit the definition and move on to the next one. 751 EmitGlobalDefinition(D); 752 } 753} 754 755void CodeGenModule::EmitGlobalAnnotations() { 756 if (Annotations.empty()) 757 return; 758 759 // Create a new global variable for the ConstantStruct in the Module. 760 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( 761 Annotations[0]->getType(), Annotations.size()), Annotations); 762 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), 763 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array, 764 "llvm.global.annotations"); 765 gv->setSection(AnnotationSection); 766} 767 768llvm::Constant *CodeGenModule::EmitAnnotationString(llvm::StringRef Str) { 769 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str); 770 if (i != AnnotationStrings.end()) 771 return i->second; 772 773 // Not found yet, create a new global. 774 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); 775 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(), 776 true, llvm::GlobalValue::PrivateLinkage, s, ".str"); 777 gv->setSection(AnnotationSection); 778 gv->setUnnamedAddr(true); 779 AnnotationStrings[Str] = gv; 780 return gv; 781} 782 783llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { 784 SourceManager &SM = getContext().getSourceManager(); 785 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 786 if (PLoc.isValid()) 787 return EmitAnnotationString(PLoc.getFilename()); 788 return EmitAnnotationString(SM.getBufferName(Loc)); 789} 790 791llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { 792 SourceManager &SM = getContext().getSourceManager(); 793 PresumedLoc PLoc = SM.getPresumedLoc(L); 794 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() : 795 SM.getExpansionLineNumber(L); 796 return llvm::ConstantInt::get(Int32Ty, LineNo); 797} 798 799llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 800 const AnnotateAttr *AA, 801 SourceLocation L) { 802 // Get the globals for file name, annotation, and the line number. 803 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()), 804 *UnitGV = EmitAnnotationUnit(L), 805 *LineNoCst = EmitAnnotationLineNo(L); 806 807 // Create the ConstantStruct for the global annotation. 808 llvm::Constant *Fields[4] = { 809 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy), 810 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy), 811 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy), 812 LineNoCst 813 }; 814 return llvm::ConstantStruct::getAnon(Fields); 815} 816 817void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, 818 llvm::GlobalValue *GV) { 819 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 820 // Get the struct elements for these annotations. 821 for (specific_attr_iterator<AnnotateAttr> 822 ai = D->specific_attr_begin<AnnotateAttr>(), 823 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 824 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation())); 825} 826 827bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 828 // Never defer when EmitAllDecls is specified. 829 if (LangOpts.EmitAllDecls) 830 return false; 831 832 return !getContext().DeclMustBeEmitted(Global); 833} 834 835llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 836 const AliasAttr *AA = VD->getAttr<AliasAttr>(); 837 assert(AA && "No alias?"); 838 839 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 840 841 // See if there is already something with the target's name in the module. 842 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 843 844 llvm::Constant *Aliasee; 845 if (isa<llvm::FunctionType>(DeclTy)) 846 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, 847 GlobalDecl(cast<FunctionDecl>(VD)), 848 /*ForVTable=*/false); 849 else 850 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 851 llvm::PointerType::getUnqual(DeclTy), 0); 852 if (!Entry) { 853 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); 854 F->setLinkage(llvm::Function::ExternalWeakLinkage); 855 WeakRefReferences.insert(F); 856 } 857 858 return Aliasee; 859} 860 861void CodeGenModule::EmitGlobal(GlobalDecl GD) { 862 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); 863 864 // Weak references don't produce any output by themselves. 865 if (Global->hasAttr<WeakRefAttr>()) 866 return; 867 868 // If this is an alias definition (which otherwise looks like a declaration) 869 // emit it now. 870 if (Global->hasAttr<AliasAttr>()) 871 return EmitAliasDefinition(GD); 872 873 // If this is CUDA, be selective about which declarations we emit. 874 if (LangOpts.CUDA) { 875 if (CodeGenOpts.CUDAIsDevice) { 876 if (!Global->hasAttr<CUDADeviceAttr>() && 877 !Global->hasAttr<CUDAGlobalAttr>() && 878 !Global->hasAttr<CUDAConstantAttr>() && 879 !Global->hasAttr<CUDASharedAttr>()) 880 return; 881 } else { 882 if (!Global->hasAttr<CUDAHostAttr>() && ( 883 Global->hasAttr<CUDADeviceAttr>() || 884 Global->hasAttr<CUDAConstantAttr>() || 885 Global->hasAttr<CUDASharedAttr>())) 886 return; 887 } 888 } 889 890 // Ignore declarations, they will be emitted on their first use. 891 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 892 // Forward declarations are emitted lazily on first use. 893 if (!FD->doesThisDeclarationHaveABody()) { 894 if (!FD->doesDeclarationForceExternallyVisibleDefinition()) 895 return; 896 897 const FunctionDecl *InlineDefinition = 0; 898 FD->getBody(InlineDefinition); 899 900 StringRef MangledName = getMangledName(GD); 901 DeferredDecls.erase(MangledName); 902 EmitGlobalDefinition(InlineDefinition); 903 return; 904 } 905 } else { 906 const VarDecl *VD = cast<VarDecl>(Global); 907 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 908 909 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) 910 return; 911 } 912 913 // Defer code generation when possible if this is a static definition, inline 914 // function etc. These we only want to emit if they are used. 915 if (!MayDeferGeneration(Global)) { 916 // Emit the definition if it can't be deferred. 917 EmitGlobalDefinition(GD); 918 return; 919 } 920 921 // If we're deferring emission of a C++ variable with an 922 // initializer, remember the order in which it appeared in the file. 923 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) && 924 cast<VarDecl>(Global)->hasInit()) { 925 DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 926 CXXGlobalInits.push_back(0); 927 } 928 929 // If the value has already been used, add it directly to the 930 // DeferredDeclsToEmit list. 931 StringRef MangledName = getMangledName(GD); 932 if (GetGlobalValue(MangledName)) 933 DeferredDeclsToEmit.push_back(GD); 934 else { 935 // Otherwise, remember that we saw a deferred decl with this name. The 936 // first use of the mangled name will cause it to move into 937 // DeferredDeclsToEmit. 938 DeferredDecls[MangledName] = GD; 939 } 940} 941 942namespace { 943 struct FunctionIsDirectlyRecursive : 944 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> { 945 const StringRef Name; 946 const Builtin::Context &BI; 947 bool Result; 948 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) : 949 Name(N), BI(C), Result(false) { 950 } 951 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base; 952 953 bool TraverseCallExpr(CallExpr *E) { 954 const FunctionDecl *FD = E->getDirectCallee(); 955 if (!FD) 956 return true; 957 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 958 if (Attr && Name == Attr->getLabel()) { 959 Result = true; 960 return false; 961 } 962 unsigned BuiltinID = FD->getBuiltinID(); 963 if (!BuiltinID) 964 return true; 965 StringRef BuiltinName = BI.GetName(BuiltinID); 966 if (BuiltinName.startswith("__builtin_") && 967 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) { 968 Result = true; 969 return false; 970 } 971 return true; 972 } 973 }; 974} 975 976// isTriviallyRecursive - Check if this function calls another 977// decl that, because of the asm attribute or the other decl being a builtin, 978// ends up pointing to itself. 979bool 980CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) { 981 StringRef Name; 982 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) { 983 // asm labels are a special kind of mangling we have to support. 984 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 985 if (!Attr) 986 return false; 987 Name = Attr->getLabel(); 988 } else { 989 Name = FD->getName(); 990 } 991 992 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo); 993 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD)); 994 return Walker.Result; 995} 996 997bool 998CodeGenModule::shouldEmitFunction(const FunctionDecl *F) { 999 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage) 1000 return true; 1001 if (CodeGenOpts.OptimizationLevel == 0 && 1002 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>()) 1003 return false; 1004 // PR9614. Avoid cases where the source code is lying to us. An available 1005 // externally function should have an equivalent function somewhere else, 1006 // but a function that calls itself is clearly not equivalent to the real 1007 // implementation. 1008 // This happens in glibc's btowc and in some configure checks. 1009 return !isTriviallyRecursive(F); 1010} 1011 1012void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 1013 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1014 1015 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 1016 Context.getSourceManager(), 1017 "Generating code for declaration"); 1018 1019 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 1020 // At -O0, don't generate IR for functions with available_externally 1021 // linkage. 1022 if (!shouldEmitFunction(Function)) 1023 return; 1024 1025 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 1026 // Make sure to emit the definition(s) before we emit the thunks. 1027 // This is necessary for the generation of certain thunks. 1028 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method)) 1029 EmitCXXConstructor(CD, GD.getCtorType()); 1030 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method)) 1031 EmitCXXDestructor(DD, GD.getDtorType()); 1032 else 1033 EmitGlobalFunctionDefinition(GD); 1034 1035 if (Method->isVirtual()) 1036 getVTables().EmitThunks(GD); 1037 1038 return; 1039 } 1040 1041 return EmitGlobalFunctionDefinition(GD); 1042 } 1043 1044 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 1045 return EmitGlobalVarDefinition(VD); 1046 1047 llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); 1048} 1049 1050/// GetOrCreateLLVMFunction - If the specified mangled name is not in the 1051/// module, create and return an llvm Function with the specified type. If there 1052/// is something in the module with the specified name, return it potentially 1053/// bitcasted to the right type. 1054/// 1055/// If D is non-null, it specifies a decl that correspond to this. This is used 1056/// to set the attributes on the function when it is first created. 1057llvm::Constant * 1058CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, 1059 llvm::Type *Ty, 1060 GlobalDecl D, bool ForVTable, 1061 llvm::Attributes ExtraAttrs) { 1062 // Lookup the entry, lazily creating it if necessary. 1063 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1064 if (Entry) { 1065 if (WeakRefReferences.erase(Entry)) { 1066 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl()); 1067 if (FD && !FD->hasAttr<WeakAttr>()) 1068 Entry->setLinkage(llvm::Function::ExternalLinkage); 1069 } 1070 1071 if (Entry->getType()->getElementType() == Ty) 1072 return Entry; 1073 1074 // Make sure the result is of the correct type. 1075 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); 1076 } 1077 1078 // This function doesn't have a complete type (for example, the return 1079 // type is an incomplete struct). Use a fake type instead, and make 1080 // sure not to try to set attributes. 1081 bool IsIncompleteFunction = false; 1082 1083 llvm::FunctionType *FTy; 1084 if (isa<llvm::FunctionType>(Ty)) { 1085 FTy = cast<llvm::FunctionType>(Ty); 1086 } else { 1087 FTy = llvm::FunctionType::get(VoidTy, false); 1088 IsIncompleteFunction = true; 1089 } 1090 1091 llvm::Function *F = llvm::Function::Create(FTy, 1092 llvm::Function::ExternalLinkage, 1093 MangledName, &getModule()); 1094 assert(F->getName() == MangledName && "name was uniqued!"); 1095 if (D.getDecl()) 1096 SetFunctionAttributes(D, F, IsIncompleteFunction); 1097 if (ExtraAttrs != llvm::Attribute::None) 1098 F->addFnAttr(ExtraAttrs); 1099 1100 // This is the first use or definition of a mangled name. If there is a 1101 // deferred decl with this name, remember that we need to emit it at the end 1102 // of the file. 1103 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 1104 if (DDI != DeferredDecls.end()) { 1105 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1106 // list, and remove it from DeferredDecls (since we don't need it anymore). 1107 DeferredDeclsToEmit.push_back(DDI->second); 1108 DeferredDecls.erase(DDI); 1109 1110 // Otherwise, there are cases we have to worry about where we're 1111 // using a declaration for which we must emit a definition but where 1112 // we might not find a top-level definition: 1113 // - member functions defined inline in their classes 1114 // - friend functions defined inline in some class 1115 // - special member functions with implicit definitions 1116 // If we ever change our AST traversal to walk into class methods, 1117 // this will be unnecessary. 1118 // 1119 // We also don't emit a definition for a function if it's going to be an entry 1120 // in a vtable, unless it's already marked as used. 1121 } else if (getLangOpts().CPlusPlus && D.getDecl()) { 1122 // Look for a declaration that's lexically in a record. 1123 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl()); 1124 FD = FD->getMostRecentDecl(); 1125 do { 1126 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 1127 if (FD->isImplicit() && !ForVTable) { 1128 assert(FD->isUsed() && "Sema didn't mark implicit function as used!"); 1129 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 1130 break; 1131 } else if (FD->doesThisDeclarationHaveABody()) { 1132 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 1133 break; 1134 } 1135 } 1136 FD = FD->getPreviousDecl(); 1137 } while (FD); 1138 } 1139 1140 // Make sure the result is of the requested type. 1141 if (!IsIncompleteFunction) { 1142 assert(F->getType()->getElementType() == Ty); 1143 return F; 1144 } 1145 1146 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 1147 return llvm::ConstantExpr::getBitCast(F, PTy); 1148} 1149 1150/// GetAddrOfFunction - Return the address of the given function. If Ty is 1151/// non-null, then this function will use the specified type if it has to 1152/// create it (this occurs when we see a definition of the function). 1153llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 1154 llvm::Type *Ty, 1155 bool ForVTable) { 1156 // If there was no specific requested type, just convert it now. 1157 if (!Ty) 1158 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 1159 1160 StringRef MangledName = getMangledName(GD); 1161 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable); 1162} 1163 1164/// CreateRuntimeFunction - Create a new runtime function with the specified 1165/// type and name. 1166llvm::Constant * 1167CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, 1168 StringRef Name, 1169 llvm::Attributes ExtraAttrs) { 1170 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 1171 ExtraAttrs); 1172} 1173 1174/// isTypeConstant - Determine whether an object of this type can be emitted 1175/// as a constant. 1176/// 1177/// If ExcludeCtor is true, the duration when the object's constructor runs 1178/// will not be considered. The caller will need to verify that the object is 1179/// not written to during its construction. 1180bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) { 1181 if (!Ty.isConstant(Context) && !Ty->isReferenceType()) 1182 return false; 1183 1184 if (Context.getLangOpts().CPlusPlus) { 1185 if (const CXXRecordDecl *Record 1186 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl()) 1187 return ExcludeCtor && !Record->hasMutableFields() && 1188 Record->hasTrivialDestructor(); 1189 } 1190 1191 return true; 1192} 1193 1194/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 1195/// create and return an llvm GlobalVariable with the specified type. If there 1196/// is something in the module with the specified name, return it potentially 1197/// bitcasted to the right type. 1198/// 1199/// If D is non-null, it specifies a decl that correspond to this. This is used 1200/// to set the attributes on the global when it is first created. 1201llvm::Constant * 1202CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, 1203 llvm::PointerType *Ty, 1204 const VarDecl *D, 1205 bool UnnamedAddr) { 1206 // Lookup the entry, lazily creating it if necessary. 1207 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1208 if (Entry) { 1209 if (WeakRefReferences.erase(Entry)) { 1210 if (D && !D->hasAttr<WeakAttr>()) 1211 Entry->setLinkage(llvm::Function::ExternalLinkage); 1212 } 1213 1214 if (UnnamedAddr) 1215 Entry->setUnnamedAddr(true); 1216 1217 if (Entry->getType() == Ty) 1218 return Entry; 1219 1220 // Make sure the result is of the correct type. 1221 return llvm::ConstantExpr::getBitCast(Entry, Ty); 1222 } 1223 1224 // This is the first use or definition of a mangled name. If there is a 1225 // deferred decl with this name, remember that we need to emit it at the end 1226 // of the file. 1227 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 1228 if (DDI != DeferredDecls.end()) { 1229 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1230 // list, and remove it from DeferredDecls (since we don't need it anymore). 1231 DeferredDeclsToEmit.push_back(DDI->second); 1232 DeferredDecls.erase(DDI); 1233 } 1234 1235 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); 1236 llvm::GlobalVariable *GV = 1237 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 1238 llvm::GlobalValue::ExternalLinkage, 1239 0, MangledName, 0, 1240 llvm::GlobalVariable::NotThreadLocal, AddrSpace); 1241 1242 // Handle things which are present even on external declarations. 1243 if (D) { 1244 // FIXME: This code is overly simple and should be merged with other global 1245 // handling. 1246 GV->setConstant(isTypeConstant(D->getType(), false)); 1247 1248 // Set linkage and visibility in case we never see a definition. 1249 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 1250 if (LV.linkage() != ExternalLinkage) { 1251 // Don't set internal linkage on declarations. 1252 } else { 1253 if (D->hasAttr<DLLImportAttr>()) 1254 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage); 1255 else if (D->hasAttr<WeakAttr>() || D->isWeakImported()) 1256 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 1257 1258 // Set visibility on a declaration only if it's explicit. 1259 if (LV.visibilityExplicit()) 1260 GV->setVisibility(GetLLVMVisibility(LV.visibility())); 1261 } 1262 1263 if (D->isThreadSpecified()) 1264 setTLSMode(GV, *D); 1265 } 1266 1267 if (AddrSpace != Ty->getAddressSpace()) 1268 return llvm::ConstantExpr::getBitCast(GV, Ty); 1269 else 1270 return GV; 1271} 1272 1273 1274llvm::GlobalVariable * 1275CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, 1276 llvm::Type *Ty, 1277 llvm::GlobalValue::LinkageTypes Linkage) { 1278 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 1279 llvm::GlobalVariable *OldGV = 0; 1280 1281 1282 if (GV) { 1283 // Check if the variable has the right type. 1284 if (GV->getType()->getElementType() == Ty) 1285 return GV; 1286 1287 // Because C++ name mangling, the only way we can end up with an already 1288 // existing global with the same name is if it has been declared extern "C". 1289 assert(GV->isDeclaration() && "Declaration has wrong type!"); 1290 OldGV = GV; 1291 } 1292 1293 // Create a new variable. 1294 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 1295 Linkage, 0, Name); 1296 1297 if (OldGV) { 1298 // Replace occurrences of the old variable if needed. 1299 GV->takeName(OldGV); 1300 1301 if (!OldGV->use_empty()) { 1302 llvm::Constant *NewPtrForOldDecl = 1303 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 1304 OldGV->replaceAllUsesWith(NewPtrForOldDecl); 1305 } 1306 1307 OldGV->eraseFromParent(); 1308 } 1309 1310 return GV; 1311} 1312 1313/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 1314/// given global variable. If Ty is non-null and if the global doesn't exist, 1315/// then it will be created with the specified type instead of whatever the 1316/// normal requested type would be. 1317llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 1318 llvm::Type *Ty) { 1319 assert(D->hasGlobalStorage() && "Not a global variable"); 1320 QualType ASTTy = D->getType(); 1321 if (Ty == 0) 1322 Ty = getTypes().ConvertTypeForMem(ASTTy); 1323 1324 llvm::PointerType *PTy = 1325 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 1326 1327 StringRef MangledName = getMangledName(D); 1328 return GetOrCreateLLVMGlobal(MangledName, PTy, D); 1329} 1330 1331/// CreateRuntimeVariable - Create a new runtime global variable with the 1332/// specified type and name. 1333llvm::Constant * 1334CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, 1335 StringRef Name) { 1336 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, 1337 true); 1338} 1339 1340void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 1341 assert(!D->getInit() && "Cannot emit definite definitions here!"); 1342 1343 if (MayDeferGeneration(D)) { 1344 // If we have not seen a reference to this variable yet, place it 1345 // into the deferred declarations table to be emitted if needed 1346 // later. 1347 StringRef MangledName = getMangledName(D); 1348 if (!GetGlobalValue(MangledName)) { 1349 DeferredDecls[MangledName] = D; 1350 return; 1351 } 1352 } 1353 1354 // The tentative definition is the only definition. 1355 EmitGlobalVarDefinition(D); 1356} 1357 1358void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) { 1359 if (DefinitionRequired) 1360 getCXXABI().EmitVTables(Class); 1361} 1362 1363llvm::GlobalVariable::LinkageTypes 1364CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { 1365 if (RD->getLinkage() != ExternalLinkage) 1366 return llvm::GlobalVariable::InternalLinkage; 1367 1368 if (const CXXMethodDecl *KeyFunction 1369 = RD->getASTContext().getKeyFunction(RD)) { 1370 // If this class has a key function, use that to determine the linkage of 1371 // the vtable. 1372 const FunctionDecl *Def = 0; 1373 if (KeyFunction->hasBody(Def)) 1374 KeyFunction = cast<CXXMethodDecl>(Def); 1375 1376 switch (KeyFunction->getTemplateSpecializationKind()) { 1377 case TSK_Undeclared: 1378 case TSK_ExplicitSpecialization: 1379 // When compiling with optimizations turned on, we emit all vtables, 1380 // even if the key function is not defined in the current translation 1381 // unit. If this is the case, use available_externally linkage. 1382 if (!Def && CodeGenOpts.OptimizationLevel) 1383 return llvm::GlobalVariable::AvailableExternallyLinkage; 1384 1385 if (KeyFunction->isInlined()) 1386 return !Context.getLangOpts().AppleKext ? 1387 llvm::GlobalVariable::LinkOnceODRLinkage : 1388 llvm::Function::InternalLinkage; 1389 1390 return llvm::GlobalVariable::ExternalLinkage; 1391 1392 case TSK_ImplicitInstantiation: 1393 return !Context.getLangOpts().AppleKext ? 1394 llvm::GlobalVariable::LinkOnceODRLinkage : 1395 llvm::Function::InternalLinkage; 1396 1397 case TSK_ExplicitInstantiationDefinition: 1398 return !Context.getLangOpts().AppleKext ? 1399 llvm::GlobalVariable::WeakODRLinkage : 1400 llvm::Function::InternalLinkage; 1401 1402 case TSK_ExplicitInstantiationDeclaration: 1403 // FIXME: Use available_externally linkage. However, this currently 1404 // breaks LLVM's build due to undefined symbols. 1405 // return llvm::GlobalVariable::AvailableExternallyLinkage; 1406 return !Context.getLangOpts().AppleKext ? 1407 llvm::GlobalVariable::LinkOnceODRLinkage : 1408 llvm::Function::InternalLinkage; 1409 } 1410 } 1411 1412 if (Context.getLangOpts().AppleKext) 1413 return llvm::Function::InternalLinkage; 1414 1415 switch (RD->getTemplateSpecializationKind()) { 1416 case TSK_Undeclared: 1417 case TSK_ExplicitSpecialization: 1418 case TSK_ImplicitInstantiation: 1419 // FIXME: Use available_externally linkage. However, this currently 1420 // breaks LLVM's build due to undefined symbols. 1421 // return llvm::GlobalVariable::AvailableExternallyLinkage; 1422 case TSK_ExplicitInstantiationDeclaration: 1423 return llvm::GlobalVariable::LinkOnceODRLinkage; 1424 1425 case TSK_ExplicitInstantiationDefinition: 1426 return llvm::GlobalVariable::WeakODRLinkage; 1427 } 1428 1429 llvm_unreachable("Invalid TemplateSpecializationKind!"); 1430} 1431 1432CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { 1433 return Context.toCharUnitsFromBits( 1434 TheTargetData.getTypeStoreSizeInBits(Ty)); 1435} 1436 1437llvm::Constant * 1438CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D, 1439 const Expr *rawInit) { 1440 ArrayRef<ExprWithCleanups::CleanupObject> cleanups; 1441 if (const ExprWithCleanups *withCleanups = 1442 dyn_cast<ExprWithCleanups>(rawInit)) { 1443 cleanups = withCleanups->getObjects(); 1444 rawInit = withCleanups->getSubExpr(); 1445 } 1446 1447 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit); 1448 if (!init || !init->initializesStdInitializerList() || 1449 init->getNumInits() == 0) 1450 return 0; 1451 1452 ASTContext &ctx = getContext(); 1453 unsigned numInits = init->getNumInits(); 1454 // FIXME: This check is here because we would otherwise silently miscompile 1455 // nested global std::initializer_lists. Better would be to have a real 1456 // implementation. 1457 for (unsigned i = 0; i < numInits; ++i) { 1458 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i)); 1459 if (inner && inner->initializesStdInitializerList()) { 1460 ErrorUnsupported(inner, "nested global std::initializer_list"); 1461 return 0; 1462 } 1463 } 1464 1465 // Synthesize a fake VarDecl for the array and initialize that. 1466 QualType elementType = init->getInit(0)->getType(); 1467 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits); 1468 QualType arrayType = ctx.getConstantArrayType(elementType, numElements, 1469 ArrayType::Normal, 0); 1470 1471 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist"); 1472 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo( 1473 arrayType, D->getLocation()); 1474 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>( 1475 D->getDeclContext()), 1476 D->getLocStart(), D->getLocation(), 1477 name, arrayType, sourceInfo, 1478 SC_Static, SC_Static); 1479 1480 // Now clone the InitListExpr to initialize the array instead. 1481 // Incredible hack: we want to use the existing InitListExpr here, so we need 1482 // to tell it that it no longer initializes a std::initializer_list. 1483 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(), 1484 init->getNumInits()); 1485 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits, 1486 init->getRBraceLoc()); 1487 arrayInit->setType(arrayType); 1488 1489 if (!cleanups.empty()) 1490 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups); 1491 1492 backingArray->setInit(arrayInit); 1493 1494 // Emit the definition of the array. 1495 EmitGlobalVarDefinition(backingArray); 1496 1497 // Inspect the initializer list to validate it and determine its type. 1498 // FIXME: doing this every time is probably inefficient; caching would be nice 1499 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl(); 1500 RecordDecl::field_iterator field = record->field_begin(); 1501 if (field == record->field_end()) { 1502 ErrorUnsupported(D, "weird std::initializer_list"); 1503 return 0; 1504 } 1505 QualType elementPtr = ctx.getPointerType(elementType.withConst()); 1506 // Start pointer. 1507 if (!ctx.hasSameType(field->getType(), elementPtr)) { 1508 ErrorUnsupported(D, "weird std::initializer_list"); 1509 return 0; 1510 } 1511 ++field; 1512 if (field == record->field_end()) { 1513 ErrorUnsupported(D, "weird std::initializer_list"); 1514 return 0; 1515 } 1516 bool isStartEnd = false; 1517 if (ctx.hasSameType(field->getType(), elementPtr)) { 1518 // End pointer. 1519 isStartEnd = true; 1520 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) { 1521 ErrorUnsupported(D, "weird std::initializer_list"); 1522 return 0; 1523 } 1524 1525 // Now build an APValue representing the std::initializer_list. 1526 APValue initListValue(APValue::UninitStruct(), 0, 2); 1527 APValue &startField = initListValue.getStructField(0); 1528 APValue::LValuePathEntry startOffsetPathEntry; 1529 startOffsetPathEntry.ArrayIndex = 0; 1530 startField = APValue(APValue::LValueBase(backingArray), 1531 CharUnits::fromQuantity(0), 1532 llvm::makeArrayRef(startOffsetPathEntry), 1533 /*IsOnePastTheEnd=*/false, 0); 1534 1535 if (isStartEnd) { 1536 APValue &endField = initListValue.getStructField(1); 1537 APValue::LValuePathEntry endOffsetPathEntry; 1538 endOffsetPathEntry.ArrayIndex = numInits; 1539 endField = APValue(APValue::LValueBase(backingArray), 1540 ctx.getTypeSizeInChars(elementType) * numInits, 1541 llvm::makeArrayRef(endOffsetPathEntry), 1542 /*IsOnePastTheEnd=*/true, 0); 1543 } else { 1544 APValue &sizeField = initListValue.getStructField(1); 1545 sizeField = APValue(llvm::APSInt(numElements)); 1546 } 1547 1548 // Emit the constant for the initializer_list. 1549 llvm::Constant *llvmInit = 1550 EmitConstantValueForMemory(initListValue, D->getType()); 1551 assert(llvmInit && "failed to initialize as constant"); 1552 return llvmInit; 1553} 1554 1555unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D, 1556 unsigned AddrSpace) { 1557 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) { 1558 if (D->hasAttr<CUDAConstantAttr>()) 1559 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant); 1560 else if (D->hasAttr<CUDASharedAttr>()) 1561 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared); 1562 else 1563 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device); 1564 } 1565 1566 return AddrSpace; 1567} 1568 1569void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 1570 llvm::Constant *Init = 0; 1571 QualType ASTTy = D->getType(); 1572 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 1573 bool NeedsGlobalCtor = false; 1574 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor(); 1575 1576 const VarDecl *InitDecl; 1577 const Expr *InitExpr = D->getAnyInitializer(InitDecl); 1578 1579 if (!InitExpr) { 1580 // This is a tentative definition; tentative definitions are 1581 // implicitly initialized with { 0 }. 1582 // 1583 // Note that tentative definitions are only emitted at the end of 1584 // a translation unit, so they should never have incomplete 1585 // type. In addition, EmitTentativeDefinition makes sure that we 1586 // never attempt to emit a tentative definition if a real one 1587 // exists. A use may still exists, however, so we still may need 1588 // to do a RAUW. 1589 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 1590 Init = EmitNullConstant(D->getType()); 1591 } else { 1592 // If this is a std::initializer_list, emit the special initializer. 1593 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr); 1594 // An empty init list will perform zero-initialization, which happens 1595 // to be exactly what we want. 1596 // FIXME: It does so in a global constructor, which is *not* what we 1597 // want. 1598 1599 if (!Init) { 1600 initializedGlobalDecl = GlobalDecl(D); 1601 Init = EmitConstantInit(*InitDecl); 1602 } 1603 if (!Init) { 1604 QualType T = InitExpr->getType(); 1605 if (D->getType()->isReferenceType()) 1606 T = D->getType(); 1607 1608 if (getLangOpts().CPlusPlus) { 1609 Init = EmitNullConstant(T); 1610 NeedsGlobalCtor = true; 1611 } else { 1612 ErrorUnsupported(D, "static initializer"); 1613 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 1614 } 1615 } else { 1616 // We don't need an initializer, so remove the entry for the delayed 1617 // initializer position (just in case this entry was delayed) if we 1618 // also don't need to register a destructor. 1619 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor) 1620 DelayedCXXInitPosition.erase(D); 1621 } 1622 } 1623 1624 llvm::Type* InitType = Init->getType(); 1625 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 1626 1627 // Strip off a bitcast if we got one back. 1628 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1629 assert(CE->getOpcode() == llvm::Instruction::BitCast || 1630 // all zero index gep. 1631 CE->getOpcode() == llvm::Instruction::GetElementPtr); 1632 Entry = CE->getOperand(0); 1633 } 1634 1635 // Entry is now either a Function or GlobalVariable. 1636 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 1637 1638 // We have a definition after a declaration with the wrong type. 1639 // We must make a new GlobalVariable* and update everything that used OldGV 1640 // (a declaration or tentative definition) with the new GlobalVariable* 1641 // (which will be a definition). 1642 // 1643 // This happens if there is a prototype for a global (e.g. 1644 // "extern int x[];") and then a definition of a different type (e.g. 1645 // "int x[10];"). This also happens when an initializer has a different type 1646 // from the type of the global (this happens with unions). 1647 if (GV == 0 || 1648 GV->getType()->getElementType() != InitType || 1649 GV->getType()->getAddressSpace() != 1650 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) { 1651 1652 // Move the old entry aside so that we'll create a new one. 1653 Entry->setName(StringRef()); 1654 1655 // Make a new global with the correct type, this is now guaranteed to work. 1656 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 1657 1658 // Replace all uses of the old global with the new global 1659 llvm::Constant *NewPtrForOldDecl = 1660 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 1661 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1662 1663 // Erase the old global, since it is no longer used. 1664 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 1665 } 1666 1667 if (D->hasAttr<AnnotateAttr>()) 1668 AddGlobalAnnotations(D, GV); 1669 1670 GV->setInitializer(Init); 1671 1672 // If it is safe to mark the global 'constant', do so now. 1673 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor && 1674 isTypeConstant(D->getType(), true)); 1675 1676 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 1677 1678 // Set the llvm linkage type as appropriate. 1679 llvm::GlobalValue::LinkageTypes Linkage = 1680 GetLLVMLinkageVarDefinition(D, GV); 1681 GV->setLinkage(Linkage); 1682 if (Linkage == llvm::GlobalVariable::CommonLinkage) 1683 // common vars aren't constant even if declared const. 1684 GV->setConstant(false); 1685 1686 SetCommonAttributes(D, GV); 1687 1688 // Emit the initializer function if necessary. 1689 if (NeedsGlobalCtor || NeedsGlobalDtor) 1690 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor); 1691 1692 // If we are compiling with ASan, add metadata indicating dynamically 1693 // initialized globals. 1694 if (LangOpts.AddressSanitizer && NeedsGlobalCtor) { 1695 llvm::Module &M = getModule(); 1696 1697 llvm::NamedMDNode *DynamicInitializers = 1698 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals"); 1699 llvm::Value *GlobalToAdd[] = { GV }; 1700 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd); 1701 DynamicInitializers->addOperand(ThisGlobal); 1702 } 1703 1704 // Emit global variable debug information. 1705 if (CGDebugInfo *DI = getModuleDebugInfo()) 1706 if (getCodeGenOpts().DebugInfo >= CodeGenOptions::LimitedDebugInfo) 1707 DI->EmitGlobalVariable(GV, D); 1708} 1709 1710llvm::GlobalValue::LinkageTypes 1711CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, 1712 llvm::GlobalVariable *GV) { 1713 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D); 1714 if (Linkage == GVA_Internal) 1715 return llvm::Function::InternalLinkage; 1716 else if (D->hasAttr<DLLImportAttr>()) 1717 return llvm::Function::DLLImportLinkage; 1718 else if (D->hasAttr<DLLExportAttr>()) 1719 return llvm::Function::DLLExportLinkage; 1720 else if (D->hasAttr<WeakAttr>()) { 1721 if (GV->isConstant()) 1722 return llvm::GlobalVariable::WeakODRLinkage; 1723 else 1724 return llvm::GlobalVariable::WeakAnyLinkage; 1725 } else if (Linkage == GVA_TemplateInstantiation || 1726 Linkage == GVA_ExplicitTemplateInstantiation) 1727 return llvm::GlobalVariable::WeakODRLinkage; 1728 else if (!getLangOpts().CPlusPlus && 1729 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) || 1730 D->getAttr<CommonAttr>()) && 1731 !D->hasExternalStorage() && !D->getInit() && 1732 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() && 1733 !D->getAttr<WeakImportAttr>()) { 1734 // Thread local vars aren't considered common linkage. 1735 return llvm::GlobalVariable::CommonLinkage; 1736 } 1737 return llvm::GlobalVariable::ExternalLinkage; 1738} 1739 1740/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1741/// implement a function with no prototype, e.g. "int foo() {}". If there are 1742/// existing call uses of the old function in the module, this adjusts them to 1743/// call the new function directly. 1744/// 1745/// This is not just a cleanup: the always_inline pass requires direct calls to 1746/// functions to be able to inline them. If there is a bitcast in the way, it 1747/// won't inline them. Instcombine normally deletes these calls, but it isn't 1748/// run at -O0. 1749static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1750 llvm::Function *NewFn) { 1751 // If we're redefining a global as a function, don't transform it. 1752 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 1753 if (OldFn == 0) return; 1754 1755 llvm::Type *NewRetTy = NewFn->getReturnType(); 1756 SmallVector<llvm::Value*, 4> ArgList; 1757 1758 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 1759 UI != E; ) { 1760 // TODO: Do invokes ever occur in C code? If so, we should handle them too. 1761 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased. 1762 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I); 1763 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I) 1764 llvm::CallSite CS(CI); 1765 if (!CI || !CS.isCallee(I)) continue; 1766 1767 // If the return types don't match exactly, and if the call isn't dead, then 1768 // we can't transform this call. 1769 if (CI->getType() != NewRetTy && !CI->use_empty()) 1770 continue; 1771 1772 // Get the attribute list. 1773 llvm::SmallVector<llvm::AttributeWithIndex, 8> AttrVec; 1774 llvm::AttrListPtr AttrList = CI->getAttributes(); 1775 1776 // Get any return attributes. 1777 llvm::Attributes RAttrs = AttrList.getRetAttributes(); 1778 1779 // Add the return attributes. 1780 if (RAttrs) 1781 AttrVec.push_back(llvm::AttributeWithIndex::get(0, RAttrs)); 1782 1783 // If the function was passed too few arguments, don't transform. If extra 1784 // arguments were passed, we silently drop them. If any of the types 1785 // mismatch, we don't transform. 1786 unsigned ArgNo = 0; 1787 bool DontTransform = false; 1788 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 1789 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 1790 if (CS.arg_size() == ArgNo || 1791 CS.getArgument(ArgNo)->getType() != AI->getType()) { 1792 DontTransform = true; 1793 break; 1794 } 1795 1796 // Add any parameter attributes. 1797 if (llvm::Attributes PAttrs = AttrList.getParamAttributes(ArgNo + 1)) 1798 AttrVec.push_back(llvm::AttributeWithIndex::get(ArgNo + 1, PAttrs)); 1799 } 1800 if (DontTransform) 1801 continue; 1802 1803 if (llvm::Attributes FnAttrs = AttrList.getFnAttributes()) 1804 AttrVec.push_back(llvm::AttributeWithIndex::get(~0, FnAttrs)); 1805 1806 // Okay, we can transform this. Create the new call instruction and copy 1807 // over the required information. 1808 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo); 1809 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList, "", CI); 1810 ArgList.clear(); 1811 if (!NewCall->getType()->isVoidTy()) 1812 NewCall->takeName(CI); 1813 NewCall->setAttributes(llvm::AttrListPtr::get(AttrVec)); 1814 NewCall->setCallingConv(CI->getCallingConv()); 1815 1816 // Finally, remove the old call, replacing any uses with the new one. 1817 if (!CI->use_empty()) 1818 CI->replaceAllUsesWith(NewCall); 1819 1820 // Copy debug location attached to CI. 1821 if (!CI->getDebugLoc().isUnknown()) 1822 NewCall->setDebugLoc(CI->getDebugLoc()); 1823 CI->eraseFromParent(); 1824 } 1825} 1826 1827void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 1828 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind(); 1829 // If we have a definition, this might be a deferred decl. If the 1830 // instantiation is explicit, make sure we emit it at the end. 1831 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition) 1832 GetAddrOfGlobalVar(VD); 1833} 1834 1835void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 1836 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 1837 1838 // Compute the function info and LLVM type. 1839 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 1840 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 1841 1842 // Get or create the prototype for the function. 1843 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 1844 1845 // Strip off a bitcast if we got one back. 1846 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1847 assert(CE->getOpcode() == llvm::Instruction::BitCast); 1848 Entry = CE->getOperand(0); 1849 } 1850 1851 1852 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 1853 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 1854 1855 // If the types mismatch then we have to rewrite the definition. 1856 assert(OldFn->isDeclaration() && 1857 "Shouldn't replace non-declaration"); 1858 1859 // F is the Function* for the one with the wrong type, we must make a new 1860 // Function* and update everything that used F (a declaration) with the new 1861 // Function* (which will be a definition). 1862 // 1863 // This happens if there is a prototype for a function 1864 // (e.g. "int f()") and then a definition of a different type 1865 // (e.g. "int f(int x)"). Move the old function aside so that it 1866 // doesn't interfere with GetAddrOfFunction. 1867 OldFn->setName(StringRef()); 1868 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 1869 1870 // If this is an implementation of a function without a prototype, try to 1871 // replace any existing uses of the function (which may be calls) with uses 1872 // of the new function 1873 if (D->getType()->isFunctionNoProtoType()) { 1874 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 1875 OldFn->removeDeadConstantUsers(); 1876 } 1877 1878 // Replace uses of F with the Function we will endow with a body. 1879 if (!Entry->use_empty()) { 1880 llvm::Constant *NewPtrForOldDecl = 1881 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 1882 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1883 } 1884 1885 // Ok, delete the old function now, which is dead. 1886 OldFn->eraseFromParent(); 1887 1888 Entry = NewFn; 1889 } 1890 1891 // We need to set linkage and visibility on the function before 1892 // generating code for it because various parts of IR generation 1893 // want to propagate this information down (e.g. to local static 1894 // declarations). 1895 llvm::Function *Fn = cast<llvm::Function>(Entry); 1896 setFunctionLinkage(D, Fn); 1897 1898 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes 1899 setGlobalVisibility(Fn, D); 1900 1901 CodeGenFunction(*this).GenerateCode(D, Fn, FI); 1902 1903 SetFunctionDefinitionAttributes(D, Fn); 1904 SetLLVMFunctionAttributesForDefinition(D, Fn); 1905 1906 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 1907 AddGlobalCtor(Fn, CA->getPriority()); 1908 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 1909 AddGlobalDtor(Fn, DA->getPriority()); 1910 if (D->hasAttr<AnnotateAttr>()) 1911 AddGlobalAnnotations(D, Fn); 1912} 1913 1914void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 1915 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1916 const AliasAttr *AA = D->getAttr<AliasAttr>(); 1917 assert(AA && "Not an alias?"); 1918 1919 StringRef MangledName = getMangledName(GD); 1920 1921 // If there is a definition in the module, then it wins over the alias. 1922 // This is dubious, but allow it to be safe. Just ignore the alias. 1923 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1924 if (Entry && !Entry->isDeclaration()) 1925 return; 1926 1927 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 1928 1929 // Create a reference to the named value. This ensures that it is emitted 1930 // if a deferred decl. 1931 llvm::Constant *Aliasee; 1932 if (isa<llvm::FunctionType>(DeclTy)) 1933 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD, 1934 /*ForVTable=*/false); 1935 else 1936 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 1937 llvm::PointerType::getUnqual(DeclTy), 0); 1938 1939 // Create the new alias itself, but don't set a name yet. 1940 llvm::GlobalValue *GA = 1941 new llvm::GlobalAlias(Aliasee->getType(), 1942 llvm::Function::ExternalLinkage, 1943 "", Aliasee, &getModule()); 1944 1945 if (Entry) { 1946 assert(Entry->isDeclaration()); 1947 1948 // If there is a declaration in the module, then we had an extern followed 1949 // by the alias, as in: 1950 // extern int test6(); 1951 // ... 1952 // int test6() __attribute__((alias("test7"))); 1953 // 1954 // Remove it and replace uses of it with the alias. 1955 GA->takeName(Entry); 1956 1957 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 1958 Entry->getType())); 1959 Entry->eraseFromParent(); 1960 } else { 1961 GA->setName(MangledName); 1962 } 1963 1964 // Set attributes which are particular to an alias; this is a 1965 // specialization of the attributes which may be set on a global 1966 // variable/function. 1967 if (D->hasAttr<DLLExportAttr>()) { 1968 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1969 // The dllexport attribute is ignored for undefined symbols. 1970 if (FD->hasBody()) 1971 GA->setLinkage(llvm::Function::DLLExportLinkage); 1972 } else { 1973 GA->setLinkage(llvm::Function::DLLExportLinkage); 1974 } 1975 } else if (D->hasAttr<WeakAttr>() || 1976 D->hasAttr<WeakRefAttr>() || 1977 D->isWeakImported()) { 1978 GA->setLinkage(llvm::Function::WeakAnyLinkage); 1979 } 1980 1981 SetCommonAttributes(D, GA); 1982} 1983 1984llvm::Function *CodeGenModule::getIntrinsic(unsigned IID, 1985 ArrayRef<llvm::Type*> Tys) { 1986 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID, 1987 Tys); 1988} 1989 1990static llvm::StringMapEntry<llvm::Constant*> & 1991GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 1992 const StringLiteral *Literal, 1993 bool TargetIsLSB, 1994 bool &IsUTF16, 1995 unsigned &StringLength) { 1996 StringRef String = Literal->getString(); 1997 unsigned NumBytes = String.size(); 1998 1999 // Check for simple case. 2000 if (!Literal->containsNonAsciiOrNull()) { 2001 StringLength = NumBytes; 2002 return Map.GetOrCreateValue(String); 2003 } 2004 2005 // Otherwise, convert the UTF8 literals into a string of shorts. 2006 IsUTF16 = true; 2007 2008 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls. 2009 const UTF8 *FromPtr = (const UTF8 *)String.data(); 2010 UTF16 *ToPtr = &ToBuf[0]; 2011 2012 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 2013 &ToPtr, ToPtr + NumBytes, 2014 strictConversion); 2015 2016 // ConvertUTF8toUTF16 returns the length in ToPtr. 2017 StringLength = ToPtr - &ToBuf[0]; 2018 2019 // Add an explicit null. 2020 *ToPtr = 0; 2021 return Map. 2022 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()), 2023 (StringLength + 1) * 2)); 2024} 2025 2026static llvm::StringMapEntry<llvm::Constant*> & 2027GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2028 const StringLiteral *Literal, 2029 unsigned &StringLength) { 2030 StringRef String = Literal->getString(); 2031 StringLength = String.size(); 2032 return Map.GetOrCreateValue(String); 2033} 2034 2035llvm::Constant * 2036CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 2037 unsigned StringLength = 0; 2038 bool isUTF16 = false; 2039 llvm::StringMapEntry<llvm::Constant*> &Entry = 2040 GetConstantCFStringEntry(CFConstantStringMap, Literal, 2041 getTargetData().isLittleEndian(), 2042 isUTF16, StringLength); 2043 2044 if (llvm::Constant *C = Entry.getValue()) 2045 return C; 2046 2047 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2048 llvm::Constant *Zeros[] = { Zero, Zero }; 2049 2050 // If we don't already have it, get __CFConstantStringClassReference. 2051 if (!CFConstantStringClassRef) { 2052 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2053 Ty = llvm::ArrayType::get(Ty, 0); 2054 llvm::Constant *GV = CreateRuntimeVariable(Ty, 2055 "__CFConstantStringClassReference"); 2056 // Decay array -> ptr 2057 CFConstantStringClassRef = 2058 llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2059 } 2060 2061 QualType CFTy = getContext().getCFConstantStringType(); 2062 2063 llvm::StructType *STy = 2064 cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 2065 2066 llvm::Constant *Fields[4]; 2067 2068 // Class pointer. 2069 Fields[0] = CFConstantStringClassRef; 2070 2071 // Flags. 2072 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2073 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 2074 llvm::ConstantInt::get(Ty, 0x07C8); 2075 2076 // String pointer. 2077 llvm::Constant *C = 0; 2078 if (isUTF16) { 2079 ArrayRef<uint16_t> Arr = 2080 llvm::makeArrayRef<uint16_t>((uint16_t*)Entry.getKey().data(), 2081 Entry.getKey().size() / 2); 2082 C = llvm::ConstantDataArray::get(VMContext, Arr); 2083 } else { 2084 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); 2085 } 2086 2087 llvm::GlobalValue::LinkageTypes Linkage; 2088 if (isUTF16) 2089 // FIXME: why do utf strings get "_" labels instead of "L" labels? 2090 Linkage = llvm::GlobalValue::InternalLinkage; 2091 else 2092 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error 2093 // when using private linkage. It is not clear if this is a bug in ld 2094 // or a reasonable new restriction. 2095 Linkage = llvm::GlobalValue::LinkerPrivateLinkage; 2096 2097 // Note: -fwritable-strings doesn't make the backing store strings of 2098 // CFStrings writable. (See <rdar://problem/10657500>) 2099 llvm::GlobalVariable *GV = 2100 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, 2101 Linkage, C, ".str"); 2102 GV->setUnnamedAddr(true); 2103 if (isUTF16) { 2104 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 2105 GV->setAlignment(Align.getQuantity()); 2106 } else { 2107 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2108 GV->setAlignment(Align.getQuantity()); 2109 } 2110 2111 // String. 2112 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2113 2114 if (isUTF16) 2115 // Cast the UTF16 string to the correct type. 2116 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy); 2117 2118 // String length. 2119 Ty = getTypes().ConvertType(getContext().LongTy); 2120 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 2121 2122 // The struct. 2123 C = llvm::ConstantStruct::get(STy, Fields); 2124 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2125 llvm::GlobalVariable::PrivateLinkage, C, 2126 "_unnamed_cfstring_"); 2127 if (const char *Sect = getContext().getTargetInfo().getCFStringSection()) 2128 GV->setSection(Sect); 2129 Entry.setValue(GV); 2130 2131 return GV; 2132} 2133 2134static RecordDecl * 2135CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 2136 DeclContext *DC, IdentifierInfo *Id) { 2137 SourceLocation Loc; 2138 if (Ctx.getLangOpts().CPlusPlus) 2139 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 2140 else 2141 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 2142} 2143 2144llvm::Constant * 2145CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { 2146 unsigned StringLength = 0; 2147 llvm::StringMapEntry<llvm::Constant*> &Entry = 2148 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength); 2149 2150 if (llvm::Constant *C = Entry.getValue()) 2151 return C; 2152 2153 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2154 llvm::Constant *Zeros[] = { Zero, Zero }; 2155 2156 // If we don't already have it, get _NSConstantStringClassReference. 2157 if (!ConstantStringClassRef) { 2158 std::string StringClass(getLangOpts().ObjCConstantStringClass); 2159 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2160 llvm::Constant *GV; 2161 if (LangOpts.ObjCRuntime.isNonFragile()) { 2162 std::string str = 2163 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 2164 : "OBJC_CLASS_$_" + StringClass; 2165 GV = getObjCRuntime().GetClassGlobal(str); 2166 // Make sure the result is of the correct type. 2167 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 2168 ConstantStringClassRef = 2169 llvm::ConstantExpr::getBitCast(GV, PTy); 2170 } else { 2171 std::string str = 2172 StringClass.empty() ? "_NSConstantStringClassReference" 2173 : "_" + StringClass + "ClassReference"; 2174 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0); 2175 GV = CreateRuntimeVariable(PTy, str); 2176 // Decay array -> ptr 2177 ConstantStringClassRef = 2178 llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2179 } 2180 } 2181 2182 if (!NSConstantStringType) { 2183 // Construct the type for a constant NSString. 2184 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 2185 Context.getTranslationUnitDecl(), 2186 &Context.Idents.get("__builtin_NSString")); 2187 D->startDefinition(); 2188 2189 QualType FieldTypes[3]; 2190 2191 // const int *isa; 2192 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst()); 2193 // const char *str; 2194 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst()); 2195 // unsigned int length; 2196 FieldTypes[2] = Context.UnsignedIntTy; 2197 2198 // Create fields 2199 for (unsigned i = 0; i < 3; ++i) { 2200 FieldDecl *Field = FieldDecl::Create(Context, D, 2201 SourceLocation(), 2202 SourceLocation(), 0, 2203 FieldTypes[i], /*TInfo=*/0, 2204 /*BitWidth=*/0, 2205 /*Mutable=*/false, 2206 ICIS_NoInit); 2207 Field->setAccess(AS_public); 2208 D->addDecl(Field); 2209 } 2210 2211 D->completeDefinition(); 2212 QualType NSTy = Context.getTagDeclType(D); 2213 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 2214 } 2215 2216 llvm::Constant *Fields[3]; 2217 2218 // Class pointer. 2219 Fields[0] = ConstantStringClassRef; 2220 2221 // String pointer. 2222 llvm::Constant *C = 2223 llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); 2224 2225 llvm::GlobalValue::LinkageTypes Linkage; 2226 bool isConstant; 2227 Linkage = llvm::GlobalValue::PrivateLinkage; 2228 isConstant = !LangOpts.WritableStrings; 2229 2230 llvm::GlobalVariable *GV = 2231 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 2232 ".str"); 2233 GV->setUnnamedAddr(true); 2234 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2235 GV->setAlignment(Align.getQuantity()); 2236 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2237 2238 // String length. 2239 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2240 Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 2241 2242 // The struct. 2243 C = llvm::ConstantStruct::get(NSConstantStringType, Fields); 2244 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2245 llvm::GlobalVariable::PrivateLinkage, C, 2246 "_unnamed_nsstring_"); 2247 // FIXME. Fix section. 2248 if (const char *Sect = 2249 LangOpts.ObjCRuntime.isNonFragile() 2250 ? getContext().getTargetInfo().getNSStringNonFragileABISection() 2251 : getContext().getTargetInfo().getNSStringSection()) 2252 GV->setSection(Sect); 2253 Entry.setValue(GV); 2254 2255 return GV; 2256} 2257 2258QualType CodeGenModule::getObjCFastEnumerationStateType() { 2259 if (ObjCFastEnumerationStateType.isNull()) { 2260 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 2261 Context.getTranslationUnitDecl(), 2262 &Context.Idents.get("__objcFastEnumerationState")); 2263 D->startDefinition(); 2264 2265 QualType FieldTypes[] = { 2266 Context.UnsignedLongTy, 2267 Context.getPointerType(Context.getObjCIdType()), 2268 Context.getPointerType(Context.UnsignedLongTy), 2269 Context.getConstantArrayType(Context.UnsignedLongTy, 2270 llvm::APInt(32, 5), ArrayType::Normal, 0) 2271 }; 2272 2273 for (size_t i = 0; i < 4; ++i) { 2274 FieldDecl *Field = FieldDecl::Create(Context, 2275 D, 2276 SourceLocation(), 2277 SourceLocation(), 0, 2278 FieldTypes[i], /*TInfo=*/0, 2279 /*BitWidth=*/0, 2280 /*Mutable=*/false, 2281 ICIS_NoInit); 2282 Field->setAccess(AS_public); 2283 D->addDecl(Field); 2284 } 2285 2286 D->completeDefinition(); 2287 ObjCFastEnumerationStateType = Context.getTagDeclType(D); 2288 } 2289 2290 return ObjCFastEnumerationStateType; 2291} 2292 2293llvm::Constant * 2294CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { 2295 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 2296 2297 // Don't emit it as the address of the string, emit the string data itself 2298 // as an inline array. 2299 if (E->getCharByteWidth() == 1) { 2300 SmallString<64> Str(E->getString()); 2301 2302 // Resize the string to the right size, which is indicated by its type. 2303 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType()); 2304 Str.resize(CAT->getSize().getZExtValue()); 2305 return llvm::ConstantDataArray::getString(VMContext, Str, false); 2306 } 2307 2308 llvm::ArrayType *AType = 2309 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); 2310 llvm::Type *ElemTy = AType->getElementType(); 2311 unsigned NumElements = AType->getNumElements(); 2312 2313 // Wide strings have either 2-byte or 4-byte elements. 2314 if (ElemTy->getPrimitiveSizeInBits() == 16) { 2315 SmallVector<uint16_t, 32> Elements; 2316 Elements.reserve(NumElements); 2317 2318 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2319 Elements.push_back(E->getCodeUnit(i)); 2320 Elements.resize(NumElements); 2321 return llvm::ConstantDataArray::get(VMContext, Elements); 2322 } 2323 2324 assert(ElemTy->getPrimitiveSizeInBits() == 32); 2325 SmallVector<uint32_t, 32> Elements; 2326 Elements.reserve(NumElements); 2327 2328 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2329 Elements.push_back(E->getCodeUnit(i)); 2330 Elements.resize(NumElements); 2331 return llvm::ConstantDataArray::get(VMContext, Elements); 2332} 2333 2334/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 2335/// constant array for the given string literal. 2336llvm::Constant * 2337CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 2338 CharUnits Align = getContext().getTypeAlignInChars(S->getType()); 2339 if (S->isAscii() || S->isUTF8()) { 2340 SmallString<64> Str(S->getString()); 2341 2342 // Resize the string to the right size, which is indicated by its type. 2343 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType()); 2344 Str.resize(CAT->getSize().getZExtValue()); 2345 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity()); 2346 } 2347 2348 // FIXME: the following does not memoize wide strings. 2349 llvm::Constant *C = GetConstantArrayFromStringLiteral(S); 2350 llvm::GlobalVariable *GV = 2351 new llvm::GlobalVariable(getModule(),C->getType(), 2352 !LangOpts.WritableStrings, 2353 llvm::GlobalValue::PrivateLinkage, 2354 C,".str"); 2355 2356 GV->setAlignment(Align.getQuantity()); 2357 GV->setUnnamedAddr(true); 2358 return GV; 2359} 2360 2361/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 2362/// array for the given ObjCEncodeExpr node. 2363llvm::Constant * 2364CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 2365 std::string Str; 2366 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 2367 2368 return GetAddrOfConstantCString(Str); 2369} 2370 2371 2372/// GenerateWritableString -- Creates storage for a string literal. 2373static llvm::GlobalVariable *GenerateStringLiteral(StringRef str, 2374 bool constant, 2375 CodeGenModule &CGM, 2376 const char *GlobalName, 2377 unsigned Alignment) { 2378 // Create Constant for this string literal. Don't add a '\0'. 2379 llvm::Constant *C = 2380 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false); 2381 2382 // Create a global variable for this string 2383 llvm::GlobalVariable *GV = 2384 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 2385 llvm::GlobalValue::PrivateLinkage, 2386 C, GlobalName); 2387 GV->setAlignment(Alignment); 2388 GV->setUnnamedAddr(true); 2389 return GV; 2390} 2391 2392/// GetAddrOfConstantString - Returns a pointer to a character array 2393/// containing the literal. This contents are exactly that of the 2394/// given string, i.e. it will not be null terminated automatically; 2395/// see GetAddrOfConstantCString. Note that whether the result is 2396/// actually a pointer to an LLVM constant depends on 2397/// Feature.WriteableStrings. 2398/// 2399/// The result has pointer to array type. 2400llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str, 2401 const char *GlobalName, 2402 unsigned Alignment) { 2403 // Get the default prefix if a name wasn't specified. 2404 if (!GlobalName) 2405 GlobalName = ".str"; 2406 2407 // Don't share any string literals if strings aren't constant. 2408 if (LangOpts.WritableStrings) 2409 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment); 2410 2411 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = 2412 ConstantStringMap.GetOrCreateValue(Str); 2413 2414 if (llvm::GlobalVariable *GV = Entry.getValue()) { 2415 if (Alignment > GV->getAlignment()) { 2416 GV->setAlignment(Alignment); 2417 } 2418 return GV; 2419 } 2420 2421 // Create a global variable for this. 2422 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName, 2423 Alignment); 2424 Entry.setValue(GV); 2425 return GV; 2426} 2427 2428/// GetAddrOfConstantCString - Returns a pointer to a character 2429/// array containing the literal and a terminating '\0' 2430/// character. The result has pointer to array type. 2431llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str, 2432 const char *GlobalName, 2433 unsigned Alignment) { 2434 StringRef StrWithNull(Str.c_str(), Str.size() + 1); 2435 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment); 2436} 2437 2438/// EmitObjCPropertyImplementations - Emit information for synthesized 2439/// properties for an implementation. 2440void CodeGenModule::EmitObjCPropertyImplementations(const 2441 ObjCImplementationDecl *D) { 2442 for (ObjCImplementationDecl::propimpl_iterator 2443 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 2444 ObjCPropertyImplDecl *PID = *i; 2445 2446 // Dynamic is just for type-checking. 2447 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 2448 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 2449 2450 // Determine which methods need to be implemented, some may have 2451 // been overridden. Note that ::isSynthesized is not the method 2452 // we want, that just indicates if the decl came from a 2453 // property. What we want to know is if the method is defined in 2454 // this implementation. 2455 if (!D->getInstanceMethod(PD->getGetterName())) 2456 CodeGenFunction(*this).GenerateObjCGetter( 2457 const_cast<ObjCImplementationDecl *>(D), PID); 2458 if (!PD->isReadOnly() && 2459 !D->getInstanceMethod(PD->getSetterName())) 2460 CodeGenFunction(*this).GenerateObjCSetter( 2461 const_cast<ObjCImplementationDecl *>(D), PID); 2462 } 2463 } 2464} 2465 2466static bool needsDestructMethod(ObjCImplementationDecl *impl) { 2467 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 2468 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 2469 ivar; ivar = ivar->getNextIvar()) 2470 if (ivar->getType().isDestructedType()) 2471 return true; 2472 2473 return false; 2474} 2475 2476/// EmitObjCIvarInitializations - Emit information for ivar initialization 2477/// for an implementation. 2478void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 2479 // We might need a .cxx_destruct even if we don't have any ivar initializers. 2480 if (needsDestructMethod(D)) { 2481 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 2482 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 2483 ObjCMethodDecl *DTORMethod = 2484 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 2485 cxxSelector, getContext().VoidTy, 0, D, 2486 /*isInstance=*/true, /*isVariadic=*/false, 2487 /*isSynthesized=*/true, /*isImplicitlyDeclared=*/true, 2488 /*isDefined=*/false, ObjCMethodDecl::Required); 2489 D->addInstanceMethod(DTORMethod); 2490 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 2491 D->setHasCXXStructors(true); 2492 } 2493 2494 // If the implementation doesn't have any ivar initializers, we don't need 2495 // a .cxx_construct. 2496 if (D->getNumIvarInitializers() == 0) 2497 return; 2498 2499 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 2500 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 2501 // The constructor returns 'self'. 2502 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 2503 D->getLocation(), 2504 D->getLocation(), 2505 cxxSelector, 2506 getContext().getObjCIdType(), 0, 2507 D, /*isInstance=*/true, 2508 /*isVariadic=*/false, 2509 /*isSynthesized=*/true, 2510 /*isImplicitlyDeclared=*/true, 2511 /*isDefined=*/false, 2512 ObjCMethodDecl::Required); 2513 D->addInstanceMethod(CTORMethod); 2514 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 2515 D->setHasCXXStructors(true); 2516} 2517 2518/// EmitNamespace - Emit all declarations in a namespace. 2519void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 2520 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 2521 I != E; ++I) 2522 EmitTopLevelDecl(*I); 2523} 2524 2525// EmitLinkageSpec - Emit all declarations in a linkage spec. 2526void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 2527 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 2528 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 2529 ErrorUnsupported(LSD, "linkage spec"); 2530 return; 2531 } 2532 2533 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 2534 I != E; ++I) 2535 EmitTopLevelDecl(*I); 2536} 2537 2538/// EmitTopLevelDecl - Emit code for a single top level declaration. 2539void CodeGenModule::EmitTopLevelDecl(Decl *D) { 2540 // If an error has occurred, stop code generation, but continue 2541 // parsing and semantic analysis (to ensure all warnings and errors 2542 // are emitted). 2543 if (Diags.hasErrorOccurred()) 2544 return; 2545 2546 // Ignore dependent declarations. 2547 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 2548 return; 2549 2550 switch (D->getKind()) { 2551 case Decl::CXXConversion: 2552 case Decl::CXXMethod: 2553 case Decl::Function: 2554 // Skip function templates 2555 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2556 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2557 return; 2558 2559 EmitGlobal(cast<FunctionDecl>(D)); 2560 break; 2561 2562 case Decl::Var: 2563 EmitGlobal(cast<VarDecl>(D)); 2564 break; 2565 2566 // Indirect fields from global anonymous structs and unions can be 2567 // ignored; only the actual variable requires IR gen support. 2568 case Decl::IndirectField: 2569 break; 2570 2571 // C++ Decls 2572 case Decl::Namespace: 2573 EmitNamespace(cast<NamespaceDecl>(D)); 2574 break; 2575 // No code generation needed. 2576 case Decl::UsingShadow: 2577 case Decl::Using: 2578 case Decl::UsingDirective: 2579 case Decl::ClassTemplate: 2580 case Decl::FunctionTemplate: 2581 case Decl::TypeAliasTemplate: 2582 case Decl::NamespaceAlias: 2583 case Decl::Block: 2584 case Decl::Import: 2585 break; 2586 case Decl::CXXConstructor: 2587 // Skip function templates 2588 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2589 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2590 return; 2591 2592 EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 2593 break; 2594 case Decl::CXXDestructor: 2595 if (cast<FunctionDecl>(D)->isLateTemplateParsed()) 2596 return; 2597 EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 2598 break; 2599 2600 case Decl::StaticAssert: 2601 // Nothing to do. 2602 break; 2603 2604 // Objective-C Decls 2605 2606 // Forward declarations, no (immediate) code generation. 2607 case Decl::ObjCInterface: 2608 case Decl::ObjCCategory: 2609 break; 2610 2611 case Decl::ObjCProtocol: { 2612 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D); 2613 if (Proto->isThisDeclarationADefinition()) 2614 ObjCRuntime->GenerateProtocol(Proto); 2615 break; 2616 } 2617 2618 case Decl::ObjCCategoryImpl: 2619 // Categories have properties but don't support synthesize so we 2620 // can ignore them here. 2621 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 2622 break; 2623 2624 case Decl::ObjCImplementation: { 2625 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 2626 EmitObjCPropertyImplementations(OMD); 2627 EmitObjCIvarInitializations(OMD); 2628 ObjCRuntime->GenerateClass(OMD); 2629 // Emit global variable debug information. 2630 if (CGDebugInfo *DI = getModuleDebugInfo()) 2631 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(OMD->getClassInterface()), 2632 OMD->getLocation()); 2633 2634 break; 2635 } 2636 case Decl::ObjCMethod: { 2637 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 2638 // If this is not a prototype, emit the body. 2639 if (OMD->getBody()) 2640 CodeGenFunction(*this).GenerateObjCMethod(OMD); 2641 break; 2642 } 2643 case Decl::ObjCCompatibleAlias: 2644 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D)); 2645 break; 2646 2647 case Decl::LinkageSpec: 2648 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 2649 break; 2650 2651 case Decl::FileScopeAsm: { 2652 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 2653 StringRef AsmString = AD->getAsmString()->getString(); 2654 2655 const std::string &S = getModule().getModuleInlineAsm(); 2656 if (S.empty()) 2657 getModule().setModuleInlineAsm(AsmString); 2658 else if (S.end()[-1] == '\n') 2659 getModule().setModuleInlineAsm(S + AsmString.str()); 2660 else 2661 getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 2662 break; 2663 } 2664 2665 default: 2666 // Make sure we handled everything we should, every other kind is a 2667 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 2668 // function. Need to recode Decl::Kind to do that easily. 2669 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 2670 } 2671} 2672 2673/// Turns the given pointer into a constant. 2674static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 2675 const void *Ptr) { 2676 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 2677 llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 2678 return llvm::ConstantInt::get(i64, PtrInt); 2679} 2680 2681static void EmitGlobalDeclMetadata(CodeGenModule &CGM, 2682 llvm::NamedMDNode *&GlobalMetadata, 2683 GlobalDecl D, 2684 llvm::GlobalValue *Addr) { 2685 if (!GlobalMetadata) 2686 GlobalMetadata = 2687 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 2688 2689 // TODO: should we report variant information for ctors/dtors? 2690 llvm::Value *Ops[] = { 2691 Addr, 2692 GetPointerConstant(CGM.getLLVMContext(), D.getDecl()) 2693 }; 2694 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 2695} 2696 2697/// Emits metadata nodes associating all the global values in the 2698/// current module with the Decls they came from. This is useful for 2699/// projects using IR gen as a subroutine. 2700/// 2701/// Since there's currently no way to associate an MDNode directly 2702/// with an llvm::GlobalValue, we create a global named metadata 2703/// with the name 'clang.global.decl.ptrs'. 2704void CodeGenModule::EmitDeclMetadata() { 2705 llvm::NamedMDNode *GlobalMetadata = 0; 2706 2707 // StaticLocalDeclMap 2708 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator 2709 I = MangledDeclNames.begin(), E = MangledDeclNames.end(); 2710 I != E; ++I) { 2711 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second); 2712 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr); 2713 } 2714} 2715 2716/// Emits metadata nodes for all the local variables in the current 2717/// function. 2718void CodeGenFunction::EmitDeclMetadata() { 2719 if (LocalDeclMap.empty()) return; 2720 2721 llvm::LLVMContext &Context = getLLVMContext(); 2722 2723 // Find the unique metadata ID for this name. 2724 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 2725 2726 llvm::NamedMDNode *GlobalMetadata = 0; 2727 2728 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator 2729 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) { 2730 const Decl *D = I->first; 2731 llvm::Value *Addr = I->second; 2732 2733 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 2734 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 2735 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); 2736 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 2737 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 2738 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 2739 } 2740 } 2741} 2742 2743void CodeGenModule::EmitCoverageFile() { 2744 if (!getCodeGenOpts().CoverageFile.empty()) { 2745 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { 2746 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 2747 llvm::LLVMContext &Ctx = TheModule.getContext(); 2748 llvm::MDString *CoverageFile = 2749 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile); 2750 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 2751 llvm::MDNode *CU = CUNode->getOperand(i); 2752 llvm::Value *node[] = { CoverageFile, CU }; 2753 llvm::MDNode *N = llvm::MDNode::get(Ctx, node); 2754 GCov->addOperand(N); 2755 } 2756 } 2757 } 2758} 2759