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