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