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