CodeGenModule.cpp revision 226633
128415Speter//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===// 234768Speter// 328415Speter// The LLVM Compiler Infrastructure 428415Speter// 528415Speter// This file is distributed under the University of Illinois Open Source 628415Speter// License. See LICENSE.TXT for details. 728415Speter// 828415Speter//===----------------------------------------------------------------------===// 928415Speter// 1034768Speter// This coordinates the per-module state used while generating code. 1134768Speter// 1228415Speter//===----------------------------------------------------------------------===// 1350477Speter 1428415Speter#include "CodeGenModule.h" 1528415Speter#include "CGDebugInfo.h" 1628415Speter#include "CodeGenFunction.h" 1734768Speter#include "CodeGenTBAA.h" 1828415Speter#include "CGCall.h" 1928415Speter#include "CGCUDARuntime.h" 2028415Speter#include "CGCXXABI.h" 2128415Speter#include "CGObjCRuntime.h" 2228415Speter#include "CGOpenCLRuntime.h" 2334768Speter#include "TargetInfo.h" 2434768Speter#include "clang/Frontend/CodeGenOptions.h" 2534768Speter#include "clang/AST/ASTContext.h" 2634768Speter#include "clang/AST/CharUnits.h" 2755205Speter#include "clang/AST/DeclObjC.h" 2834768Speter#include "clang/AST/DeclCXX.h" 2934768Speter#include "clang/AST/DeclTemplate.h" 3034768Speter#include "clang/AST/Mangle.h" 3134768Speter#include "clang/AST/RecordLayout.h" 3234768Speter#include "clang/Basic/Diagnostic.h" 3328415Speter#include "clang/Basic/SourceManager.h" 3434768Speter#include "clang/Basic/TargetInfo.h" 3528415Speter#include "clang/Basic/ConvertUTF.h" 3628415Speter#include "llvm/CallingConv.h" 3728415Speter#include "llvm/Module.h" 3828415Speter#include "llvm/Intrinsics.h" 3928415Speter#include "llvm/LLVMContext.h" 4028415Speter#include "llvm/ADT/Triple.h" 4128415Speter#include "llvm/Target/Mangler.h" 4228415Speter#include "llvm/Target/TargetData.h" 4334768Speter#include "llvm/Support/CallSite.h" 4428415Speter#include "llvm/Support/ErrorHandling.h" 4534768Speterusing namespace clang; 4628415Speterusing namespace CodeGen; 4728415Speter 4855205Speterstatic const char AnnotationSection[] = "llvm.metadata"; 4928415Speter 5028415Speterstatic CGCXXABI &createCXXABI(CodeGenModule &CGM) { 5128415Speter switch (CGM.getContext().getTargetInfo().getCXXABI()) { 5228415Speter case CXXABI_ARM: return *CreateARMCXXABI(CGM); 5328415Speter case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM); 5455205Speter case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM); 5534768Speter } 5634768Speter 5734768Speter llvm_unreachable("invalid C++ ABI kind"); 5834768Speter return *CreateItaniumCXXABI(CGM); 5934768Speter} 6034768Speter 6134768Speter 6234768SpeterCodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 6334768Speter llvm::Module &M, const llvm::TargetData &TD, 6434768Speter DiagnosticsEngine &diags) 6534768Speter : Context(C), Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M), 6634768Speter TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags), 6734768Speter ABI(createCXXABI(*this)), 6834768Speter Types(C, M, TD, getTargetCodeGenInfo().getABIInfo(), ABI, CGO), 6934768Speter TBAA(0), 7034768Speter VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0), 7134768Speter DebugInfo(0), ARCData(0), RRData(0), CFConstantStringClassRef(0), 7234768Speter ConstantStringClassRef(0), NSConstantStringType(0), 7334768Speter VMContext(M.getContext()), 7434768Speter NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), 7534768Speter BlockObjectAssign(0), BlockObjectDispose(0), 7634768Speter BlockDescriptorType(0), GenericBlockLiteralType(0) { 7734768Speter if (Features.ObjC1) 7834768Speter createObjCRuntime(); 7934768Speter if (Features.OpenCL) 8034768Speter createOpenCLRuntime(); 8134768Speter if (Features.CUDA) 8234768Speter createCUDARuntime(); 8355205Speter 8434768Speter // Enable TBAA unless it's suppressed. 8528415Speter if (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0) 8628415Speter TBAA = new CodeGenTBAA(Context, VMContext, getLangOptions(), 8728415Speter ABI.getMangleContext()); 8828415Speter 8928415Speter // If debug info or coverage generation is enabled, create the CGDebugInfo 9028415Speter // object. 9128415Speter if (CodeGenOpts.DebugInfo || CodeGenOpts.EmitGcovArcs || 9228415Speter CodeGenOpts.EmitGcovNotes) 9328415Speter DebugInfo = new CGDebugInfo(*this); 9428415Speter 9528415Speter Block.GlobalUniqueCount = 0; 9634768Speter 9734768Speter if (C.getLangOptions().ObjCAutoRefCount) 9828415Speter ARCData = new ARCEntrypoints(); 9934768Speter RRData = new RREntrypoints(); 10034768Speter 10134768Speter // Initialize the type cache. 10243305Sdillon llvm::LLVMContext &LLVMContext = M.getContext(); 10328415Speter VoidTy = llvm::Type::getVoidTy(LLVMContext); 10428415Speter Int8Ty = llvm::Type::getInt8Ty(LLVMContext); 10528415Speter Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 10628415Speter Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 10728415Speter PointerWidthInBits = C.getTargetInfo().getPointerWidth(0); 10828415Speter PointerAlignInBytes = 10928415Speter C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity(); 11028415Speter IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth()); 11128415Speter IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits); 11228415Speter Int8PtrTy = Int8Ty->getPointerTo(0); 11328415Speter Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); 11428415Speter} 11528415Speter 11628415SpeterCodeGenModule::~CodeGenModule() { 11728415Speter delete ObjCRuntime; 11828415Speter delete OpenCLRuntime; 11928415Speter delete CUDARuntime; 12028415Speter delete TheTargetCodeGenInfo; 12128415Speter delete &ABI; 12228415Speter delete TBAA; 12328415Speter delete DebugInfo; 12428415Speter delete ARCData; 12528415Speter delete RRData; 12628415Speter} 12728415Speter 12834768Spetervoid CodeGenModule::createObjCRuntime() { 12934768Speter if (!Features.NeXTRuntime) 13034768Speter ObjCRuntime = CreateGNUObjCRuntime(*this); 13134768Speter else 13234768Speter ObjCRuntime = CreateMacObjCRuntime(*this); 13334768Speter} 13434768Speter 13534768Spetervoid CodeGenModule::createOpenCLRuntime() { 13634768Speter OpenCLRuntime = new CGOpenCLRuntime(*this); 13734768Speter} 13834768Speter 13934768Spetervoid CodeGenModule::createCUDARuntime() { 14034768Speter CUDARuntime = CreateNVCUDARuntime(*this); 14134768Speter} 14234768Speter 14334768Spetervoid CodeGenModule::Release() { 14434768Speter EmitDeferred(); 14534768Speter EmitCXXGlobalInitFunc(); 14634768Speter EmitCXXGlobalDtorFunc(); 14734768Speter if (ObjCRuntime) 14834768Speter if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction()) 14934768Speter AddGlobalCtor(ObjCInitFunction); 15034768Speter EmitCtorList(GlobalCtors, "llvm.global_ctors"); 15134768Speter EmitCtorList(GlobalDtors, "llvm.global_dtors"); 15234768Speter EmitGlobalAnnotations(); 15334768Speter EmitLLVMUsed(); 15434768Speter 15534768Speter SimplifyPersonality(); 15634768Speter 15734768Speter if (getCodeGenOpts().EmitDeclMetadata) 15834768Speter EmitDeclMetadata(); 15934768Speter 16034768Speter if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes) 16134768Speter EmitCoverageFile(); 16234768Speter 16334768Speter if (DebugInfo) 16434768Speter DebugInfo->finalize(); 16534768Speter} 16634768Speter 16734768Spetervoid CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 16834768Speter // Make sure that this type is translated. 16934768Speter Types.UpdateCompletedType(TD); 17034768Speter if (DebugInfo) 17134768Speter DebugInfo->UpdateCompletedType(TD); 17234768Speter} 17334768Speter 17434768Speterllvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { 17534768Speter if (!TBAA) 17634768Speter return 0; 17734768Speter return TBAA->getTBAAInfo(QTy); 17834768Speter} 17934768Speter 18034768Spetervoid CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, 18134768Speter llvm::MDNode *TBAAInfo) { 18234768Speter Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); 18334768Speter} 18434768Speter 18534768Speterbool CodeGenModule::isTargetDarwin() const { 18634768Speter return getContext().getTargetInfo().getTriple().isOSDarwin(); 18734768Speter} 18834768Speter 18928415Spetervoid CodeGenModule::Error(SourceLocation loc, StringRef error) { 19028415Speter unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error); 19134768Speter getDiags().Report(Context.getFullLoc(loc), diagID); 19234768Speter} 19334768Speter 19428415Speter/// ErrorUnsupported - Print out an error that codegen doesn't support the 19534768Speter/// specified stmt yet. 19634768Spetervoid CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 19728415Speter bool OmitOnError) { 19834768Speter if (OmitOnError && getDiags().hasErrorOccurred()) 19934768Speter return; 20034768Speter unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 20134768Speter "cannot compile this %0 yet"); 20234768Speter std::string Msg = Type; 20334768Speter getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 20434768Speter << Msg << S->getSourceRange(); 20534768Speter} 20634768Speter 20728415Speter/// ErrorUnsupported - Print out an error that codegen doesn't support the 20828415Speter/// specified decl yet. 20928415Spetervoid CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 21028415Speter bool OmitOnError) { 21134768Speter if (OmitOnError && getDiags().hasErrorOccurred()) 21234768Speter return; 21334768Speter unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 21434768Speter "cannot compile this %0 yet"); 21534768Speter std::string Msg = Type; 21628415Speter getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 21734768Speter} 21828415Speter 21934768Speterllvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { 22028415Speter return llvm::ConstantInt::get(SizeTy, size.getQuantity()); 22128415Speter} 22234768Speter 22328415Spetervoid CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 22428415Speter const NamedDecl *D) const { 22528415Speter // Internal definitions always have default visibility. 22628415Speter if (GV->hasLocalLinkage()) { 22728415Speter GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 22828415Speter return; 22928415Speter } 23028415Speter 23128415Speter // Set visibility for definitions. 23234768Speter NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 23328415Speter if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage()) 23428415Speter GV->setVisibility(GetLLVMVisibility(LV.visibility())); 23528415Speter} 23628415Speter 23728415Speter/// Set the symbol visibility of type information (vtable and RTTI) 23828415Speter/// associated with the given type. 23928415Spetervoid CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV, 24028415Speter const CXXRecordDecl *RD, 24128415Speter TypeVisibilityKind TVK) const { 24228415Speter setGlobalVisibility(GV, RD); 24328415Speter 24428415Speter if (!CodeGenOpts.HiddenWeakVTables) 24528415Speter return; 24628415Speter 24728415Speter // We never want to drop the visibility for RTTI names. 24828415Speter if (TVK == TVK_ForRTTIName) 24934768Speter return; 25028415Speter 25134768Speter // We want to drop the visibility to hidden for weak type symbols. 25234768Speter // This isn't possible if there might be unresolved references 25328415Speter // elsewhere that rely on this symbol being visible. 25428415Speter 25528415Speter // This should be kept roughly in sync with setThunkVisibility 25634768Speter // in CGVTables.cpp. 25734768Speter 25828415Speter // Preconditions. 25934768Speter if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage || 26034768Speter GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility) 26134768Speter return; 26234768Speter 26328415Speter // Don't override an explicit visibility attribute. 26434768Speter if (RD->getExplicitVisibility()) 26528415Speter return; 26628415Speter 26728415Speter switch (RD->getTemplateSpecializationKind()) { 26828415Speter // We have to disable the optimization if this is an EI definition 26928415Speter // because there might be EI declarations in other shared objects. 27028415Speter case TSK_ExplicitInstantiationDefinition: 27128415Speter case TSK_ExplicitInstantiationDeclaration: 27228415Speter return; 27334768Speter 27428415Speter // Every use of a non-template class's type information has to emit it. 27534768Speter case TSK_Undeclared: 27634768Speter break; 27728415Speter 27834768Speter // In theory, implicit instantiations can ignore the possibility of 27934768Speter // an explicit instantiation declaration because there necessarily 28028415Speter // must be an EI definition somewhere with default visibility. In 28128415Speter // practice, it's possible to have an explicit instantiation for 28228415Speter // an arbitrary template class, and linkers aren't necessarily able 28328415Speter // to deal with mixed-visibility symbols. 28428415Speter case TSK_ExplicitSpecialization: 28528415Speter case TSK_ImplicitInstantiation: 28628415Speter if (!CodeGenOpts.HiddenWeakTemplateVTables) 28728415Speter return; 28828415Speter break; 28928415Speter } 29028415Speter 29128415Speter // If there's a key function, there may be translation units 29228415Speter // that don't have the key function's definition. But ignore 29328415Speter // this if we're emitting RTTI under -fno-rtti. 29428415Speter if (!(TVK != TVK_ForRTTI) || Features.RTTI) { 29528415Speter if (Context.getKeyFunction(RD)) 29628415Speter return; 29728415Speter } 29828415Speter 29928415Speter // Otherwise, drop the visibility to hidden. 30028415Speter GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 30128415Speter GV->setUnnamedAddr(true); 30228415Speter} 30328415Speter 30428415SpeterStringRef CodeGenModule::getMangledName(GlobalDecl GD) { 30528415Speter const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); 30628415Speter 30728415Speter StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()]; 30828415Speter if (!Str.empty()) 30928415Speter return Str; 31028415Speter 31128415Speter if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { 31228415Speter IdentifierInfo *II = ND->getIdentifier(); 31328415Speter assert(II && "Attempt to mangle unnamed decl."); 31428415Speter 31528415Speter Str = II->getName(); 31628415Speter return Str; 31728415Speter } 31828415Speter 31928415Speter llvm::SmallString<256> Buffer; 32028415Speter llvm::raw_svector_ostream Out(Buffer); 32128415Speter if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 32228415Speter getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); 32328415Speter else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 32428415Speter getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); 32528415Speter else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND)) 32628415Speter getCXXABI().getMangleContext().mangleBlock(BD, Out); 32728415Speter else 32828415Speter getCXXABI().getMangleContext().mangleName(ND, Out); 32928415Speter 33028415Speter // Allocate space for the mangled name. 33128415Speter Out.flush(); 33228415Speter size_t Length = Buffer.size(); 33328415Speter char *Name = MangledNamesAllocator.Allocate<char>(Length); 33428415Speter std::copy(Buffer.begin(), Buffer.end(), Name); 33528415Speter 33628415Speter Str = StringRef(Name, Length); 33728415Speter 33828415Speter return Str; 33928415Speter} 34028415Speter 34128415Spetervoid CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, 34228415Speter const BlockDecl *BD) { 34328415Speter MangleContext &MangleCtx = getCXXABI().getMangleContext(); 34428415Speter const Decl *D = GD.getDecl(); 34534768Speter llvm::raw_svector_ostream Out(Buffer.getBuffer()); 34628415Speter if (D == 0) 34728415Speter MangleCtx.mangleGlobalBlock(BD, Out); 34834768Speter else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 34928415Speter MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); 35028415Speter else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) 35128415Speter MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); 35234768Speter else 35328415Speter MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); 35434768Speter} 35528415Speter 35628415Speterllvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { 35728415Speter return getModule().getNamedValue(Name); 35828415Speter} 35928415Speter 36028415Speter/// AddGlobalCtor - Add a function to the list that will be called before 36128415Speter/// main() runs. 36228415Spetervoid CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 36328415Speter // FIXME: Type coercion of void()* types. 36428415Speter GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 36528415Speter} 36628415Speter 36728415Speter/// AddGlobalDtor - Add a function to the list that will be called 36828415Speter/// when the module is unloaded. 36928415Spetervoid CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 37028415Speter // FIXME: Type coercion of void()* types. 37128415Speter GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 37228415Speter} 37328415Speter 37428415Spetervoid CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 37528415Speter // Ctor function type is void()*. 37628415Speter llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); 37728415Speter llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 37828415Speter 37928415Speter // Get the type of a ctor entry, { i32, void ()* }. 38028415Speter llvm::StructType *CtorStructTy = 38128415Speter llvm::StructType::get(llvm::Type::getInt32Ty(VMContext), 38228415Speter llvm::PointerType::getUnqual(CtorFTy), NULL); 38328415Speter 38428415Speter // Construct the constructor and destructor arrays. 38528415Speter std::vector<llvm::Constant*> Ctors; 38628415Speter for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 38728415Speter std::vector<llvm::Constant*> S; 38828415Speter S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 38928415Speter I->second, false)); 39028415Speter S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)); 39128415Speter Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 39228415Speter } 39328415Speter 39428415Speter if (!Ctors.empty()) { 39528415Speter llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 39628415Speter new llvm::GlobalVariable(TheModule, AT, false, 39728415Speter llvm::GlobalValue::AppendingLinkage, 39828415Speter llvm::ConstantArray::get(AT, Ctors), 39928415Speter GlobalName); 40028415Speter } 40128415Speter} 40228415Speter 40328415Speterllvm::GlobalValue::LinkageTypes 40428415SpeterCodeGenModule::getFunctionLinkage(const FunctionDecl *D) { 40528415Speter GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); 40628415Speter 40728415Speter if (Linkage == GVA_Internal) 40828415Speter return llvm::Function::InternalLinkage; 40928415Speter 41028415Speter if (D->hasAttr<DLLExportAttr>()) 41128415Speter return llvm::Function::DLLExportLinkage; 41228415Speter 41328415Speter if (D->hasAttr<WeakAttr>()) 41428415Speter return llvm::Function::WeakAnyLinkage; 41528415Speter 41628415Speter // In C99 mode, 'inline' functions are guaranteed to have a strong 41728415Speter // definition somewhere else, so we can use available_externally linkage. 41828415Speter if (Linkage == GVA_C99Inline) 41928415Speter return llvm::Function::AvailableExternallyLinkage; 42028415Speter 42128415Speter // Note that Apple's kernel linker doesn't support symbol 42228415Speter // coalescing, so we need to avoid linkonce and weak linkages there. 42328415Speter // Normally, this means we just map to internal, but for explicit 42428415Speter // instantiations we'll map to external. 42528415Speter 42628415Speter // In C++, the compiler has to emit a definition in every translation unit 42728415Speter // that references the function. We should use linkonce_odr because 42828415Speter // a) if all references in this translation unit are optimized away, we 42928415Speter // don't need to codegen it. b) if the function persists, it needs to be 43028415Speter // merged with other definitions. c) C++ has the ODR, so we know the 43128415Speter // definition is dependable. 43228415Speter if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 43328415Speter return !Context.getLangOptions().AppleKext 43428415Speter ? llvm::Function::LinkOnceODRLinkage 43528415Speter : llvm::Function::InternalLinkage; 43628415Speter 43734768Speter // An explicit instantiation of a template has weak linkage, since 43828415Speter // explicit instantiations can occur in multiple translation units 43928415Speter // and must all be equivalent. However, we are not allowed to 44028415Speter // throw away these explicit instantiations. 44128415Speter if (Linkage == GVA_ExplicitTemplateInstantiation) 44228415Speter return !Context.getLangOptions().AppleKext 44328415Speter ? llvm::Function::WeakODRLinkage 44428415Speter : llvm::Function::ExternalLinkage; 44528415Speter 44628415Speter // Otherwise, we have strong external linkage. 44728415Speter assert(Linkage == GVA_StrongExternal); 44828415Speter return llvm::Function::ExternalLinkage; 44928415Speter} 45028415Speter 45128415Speter 45228415Speter/// SetFunctionDefinitionAttributes - Set attributes for a global. 45328415Speter/// 45428415Speter/// FIXME: This is currently only done for aliases and functions, but not for 45528415Speter/// variables (these details are set in EmitGlobalVarDefinition for variables). 45628415Spetervoid CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 45728415Speter llvm::GlobalValue *GV) { 45828415Speter SetCommonAttributes(D, GV); 45928415Speter} 46028415Speter 46128415Spetervoid CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 46228415Speter const CGFunctionInfo &Info, 46328415Speter llvm::Function *F) { 46428415Speter unsigned CallingConv; 46528415Speter AttributeListType AttributeList; 46628415Speter ConstructAttributeList(Info, D, AttributeList, CallingConv); 46728415Speter F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(), 46828415Speter AttributeList.size())); 46928415Speter F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 47028415Speter} 47128415Speter 47228415Speter/// Determines whether the language options require us to model 47328415Speter/// unwind exceptions. We treat -fexceptions as mandating this 47428415Speter/// except under the fragile ObjC ABI with only ObjC exceptions 47528415Speter/// enabled. This means, for example, that C with -fexceptions 47628415Speter/// enables this. 47728415Speterstatic bool hasUnwindExceptions(const LangOptions &Features) { 47828415Speter // If exceptions are completely disabled, obviously this is false. 47928415Speter if (!Features.Exceptions) return false; 48028415Speter 48128415Speter // If C++ exceptions are enabled, this is true. 48228415Speter if (Features.CXXExceptions) return true; 48328415Speter 48428415Speter // If ObjC exceptions are enabled, this depends on the ABI. 48528415Speter if (Features.ObjCExceptions) { 48628415Speter if (!Features.ObjCNonFragileABI) return false; 48728415Speter } 48828415Speter 48928415Speter return true; 49028415Speter} 49128415Speter 49228415Spetervoid CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 49328415Speter llvm::Function *F) { 49428415Speter if (CodeGenOpts.UnwindTables) 49528415Speter F->setHasUWTable(); 49628415Speter 49728415Speter if (!hasUnwindExceptions(Features)) 49828415Speter F->addFnAttr(llvm::Attribute::NoUnwind); 49928415Speter 50028415Speter if (D->hasAttr<NakedAttr>()) { 50128415Speter // Naked implies noinline: we should not be inlining such functions. 50228415Speter F->addFnAttr(llvm::Attribute::Naked); 50328415Speter F->addFnAttr(llvm::Attribute::NoInline); 50428415Speter } 50528415Speter 50628415Speter if (D->hasAttr<NoInlineAttr>()) 50728415Speter F->addFnAttr(llvm::Attribute::NoInline); 50828415Speter 50928415Speter // (noinline wins over always_inline, and we can't specify both in IR) 51028415Speter if (D->hasAttr<AlwaysInlineAttr>() && 51128415Speter !F->hasFnAttr(llvm::Attribute::NoInline)) 51228415Speter F->addFnAttr(llvm::Attribute::AlwaysInline); 51328415Speter 51428415Speter if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D)) 51528415Speter F->setUnnamedAddr(true); 51628415Speter 51728415Speter if (Features.getStackProtector() == LangOptions::SSPOn) 51828415Speter F->addFnAttr(llvm::Attribute::StackProtect); 51928415Speter else if (Features.getStackProtector() == LangOptions::SSPReq) 52028415Speter F->addFnAttr(llvm::Attribute::StackProtectReq); 52128415Speter 52228415Speter unsigned alignment = D->getMaxAlignment() / Context.getCharWidth(); 52328415Speter if (alignment) 52428415Speter F->setAlignment(alignment); 52528415Speter 52628415Speter // C++ ABI requires 2-byte alignment for member functions. 52728415Speter if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 52828415Speter F->setAlignment(2); 52928415Speter} 53028415Speter 53134768Spetervoid CodeGenModule::SetCommonAttributes(const Decl *D, 53234768Speter llvm::GlobalValue *GV) { 53334768Speter if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 53434768Speter setGlobalVisibility(GV, ND); 53534768Speter else 53634768Speter GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 53728415Speter 53834768Speter if (D->hasAttr<UsedAttr>()) 53928415Speter AddUsedGlobal(GV); 54034768Speter 54134768Speter if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 54228415Speter GV->setSection(SA->getName()); 54334768Speter 54428415Speter getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this); 54534768Speter} 54628415Speter 54728415Spetervoid CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 54828415Speter llvm::Function *F, 54928415Speter const CGFunctionInfo &FI) { 55028415Speter SetLLVMFunctionAttributes(D, FI, F); 55128415Speter SetLLVMFunctionAttributesForDefinition(D, F); 55228415Speter 55328415Speter F->setLinkage(llvm::Function::InternalLinkage); 55428415Speter 55528415Speter SetCommonAttributes(D, F); 55628415Speter} 55728415Speter 55828415Spetervoid CodeGenModule::SetFunctionAttributes(GlobalDecl GD, 55928415Speter llvm::Function *F, 56028415Speter bool IsIncompleteFunction) { 56128415Speter if (unsigned IID = F->getIntrinsicID()) { 56228415Speter // If this is an intrinsic function, set the function's attributes 56328415Speter // to the intrinsic's attributes. 56428415Speter F->setAttributes(llvm::Intrinsic::getAttributes((llvm::Intrinsic::ID)IID)); 56528415Speter return; 56628415Speter } 56728415Speter 56828415Speter const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 56928415Speter 57028415Speter if (!IsIncompleteFunction) 57128415Speter SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F); 57228415Speter 57328415Speter // Only a few attributes are set on declarations; these may later be 57428415Speter // overridden by a definition. 57528415Speter 57628415Speter if (FD->hasAttr<DLLImportAttr>()) { 57728415Speter F->setLinkage(llvm::Function::DLLImportLinkage); 57828415Speter } else if (FD->hasAttr<WeakAttr>() || 57928415Speter FD->isWeakImported()) { 58028415Speter // "extern_weak" is overloaded in LLVM; we probably should have 58128415Speter // separate linkage types for this. 58234768Speter F->setLinkage(llvm::Function::ExternalWeakLinkage); 58334768Speter } else { 58428415Speter F->setLinkage(llvm::Function::ExternalLinkage); 58528415Speter 58628415Speter NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility(); 58728415Speter if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) { 58828415Speter F->setVisibility(GetLLVMVisibility(LV.visibility())); 58928415Speter } 59028415Speter } 59128415Speter 59228415Speter if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 59334768Speter F->setSection(SA->getName()); 59428415Speter} 59534768Speter 59634768Spetervoid CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 59734768Speter assert(!GV->isDeclaration() && 59828415Speter "Only globals with definition can force usage."); 59928415Speter LLVMUsed.push_back(GV); 60028415Speter} 60128415Speter 60228415Spetervoid CodeGenModule::EmitLLVMUsed() { 60328415Speter // Don't create llvm.used if there is no need. 60428415Speter if (LLVMUsed.empty()) 60534768Speter return; 60634768Speter 60734768Speter llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 60834768Speter 60934768Speter // Convert LLVMUsed to what ConstantArray needs. 61034768Speter std::vector<llvm::Constant*> UsedArray; 61134768Speter UsedArray.resize(LLVMUsed.size()); 61234768Speter for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 61334768Speter UsedArray[i] = 61434768Speter llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 61534768Speter i8PTy); 61634768Speter } 61734768Speter 61834768Speter if (UsedArray.empty()) 61934768Speter return; 62034768Speter llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size()); 62134768Speter 62234768Speter llvm::GlobalVariable *GV = 62334768Speter new llvm::GlobalVariable(getModule(), ATy, false, 62434768Speter llvm::GlobalValue::AppendingLinkage, 62534768Speter llvm::ConstantArray::get(ATy, UsedArray), 62634768Speter "llvm.used"); 62734768Speter 62834768Speter GV->setSection("llvm.metadata"); 62934768Speter} 63034768Speter 63134768Spetervoid CodeGenModule::EmitDeferred() { 63234768Speter // Emit code for any potentially referenced deferred decls. Since a 63334768Speter // previously unused static decl may become used during the generation of code 63434768Speter // for a static function, iterate until no changes are made. 63534768Speter 63634768Speter while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) { 63734768Speter if (!DeferredVTables.empty()) { 63834768Speter const CXXRecordDecl *RD = DeferredVTables.back(); 63934768Speter DeferredVTables.pop_back(); 64034768Speter getVTables().GenerateClassData(getVTableLinkage(RD), RD); 64134768Speter continue; 64228415Speter } 64328415Speter 64428415Speter GlobalDecl D = DeferredDeclsToEmit.back(); 64528415Speter DeferredDeclsToEmit.pop_back(); 64628415Speter 64728415Speter // Check to see if we've already emitted this. This is necessary 64828415Speter // for a couple of reasons: first, decls can end up in the 64928415Speter // deferred-decls queue multiple times, and second, decls can end 65028415Speter // up with definitions in unusual ways (e.g. by an extern inline 65128415Speter // function acquiring a strong function redefinition). Just 65228415Speter // ignore these cases. 65328415Speter // 65428415Speter // TODO: That said, looking this up multiple times is very wasteful. 65528415Speter StringRef Name = getMangledName(D); 65628415Speter llvm::GlobalValue *CGRef = GetGlobalValue(Name); 65728415Speter assert(CGRef && "Deferred decl wasn't referenced?"); 65828415Speter 65928415Speter if (!CGRef->isDeclaration()) 66028415Speter continue; 66128415Speter 66228415Speter // GlobalAlias::isDeclaration() defers to the aliasee, but for our 66328415Speter // purposes an alias counts as a definition. 66428415Speter if (isa<llvm::GlobalAlias>(CGRef)) 66534768Speter continue; 66628415Speter 66728415Speter // Otherwise, emit the definition and move on to the next one. 66828415Speter EmitGlobalDefinition(D); 66928415Speter } 67034768Speter} 67134768Speter 67234768Spetervoid CodeGenModule::EmitGlobalAnnotations() { 67334768Speter if (Annotations.empty()) 67428415Speter return; 67534768Speter 67634768Speter // Create a new global variable for the ConstantStruct in the Module. 67734768Speter llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( 67834768Speter Annotations[0]->getType(), Annotations.size()), Annotations); 67934768Speter llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), 68034768Speter Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array, 68128415Speter "llvm.global.annotations"); 68228415Speter gv->setSection(AnnotationSection); 68328415Speter} 68428415Speter 68528415Speterllvm::Constant *CodeGenModule::EmitAnnotationString(llvm::StringRef Str) { 68628415Speter llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str); 68728415Speter if (i != AnnotationStrings.end()) 68828415Speter return i->second; 68928415Speter 69034768Speter // Not found yet, create a new global. 69134768Speter llvm::Constant *s = llvm::ConstantArray::get(getLLVMContext(), Str, true); 69228415Speter llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(), 69328415Speter true, llvm::GlobalValue::PrivateLinkage, s, ".str"); 69428415Speter gv->setSection(AnnotationSection); 69528415Speter gv->setUnnamedAddr(true); 69628415Speter AnnotationStrings[Str] = gv; 69728415Speter return gv; 69828415Speter} 69928415Speter 70028415Speterllvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { 70128415Speter SourceManager &SM = getContext().getSourceManager(); 70228415Speter PresumedLoc PLoc = SM.getPresumedLoc(Loc); 70328415Speter if (PLoc.isValid()) 70428415Speter return EmitAnnotationString(PLoc.getFilename()); 70528415Speter return EmitAnnotationString(SM.getBufferName(Loc)); 70628415Speter} 70728415Speter 70828415Speterllvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { 70928415Speter SourceManager &SM = getContext().getSourceManager(); 71028415Speter PresumedLoc PLoc = SM.getPresumedLoc(L); 71128415Speter unsigned LineNo = PLoc.isValid() ? PLoc.getLine() : 71228415Speter SM.getExpansionLineNumber(L); 71328415Speter return llvm::ConstantInt::get(Int32Ty, LineNo); 71434768Speter} 71528415Speter 71628415Speterllvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 71728415Speter const AnnotateAttr *AA, 71828415Speter SourceLocation L) { 71928415Speter // Get the globals for file name, annotation, and the line number. 72028415Speter llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()), 72128415Speter *UnitGV = EmitAnnotationUnit(L), 72228415Speter *LineNoCst = EmitAnnotationLineNo(L); 72328415Speter 72428415Speter // Create the ConstantStruct for the global annotation. 72534768Speter llvm::Constant *Fields[4] = { 72634768Speter llvm::ConstantExpr::getBitCast(GV, Int8PtrTy), 72728415Speter llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy), 72834768Speter llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy), 72934768Speter LineNoCst 73028415Speter }; 73134768Speter return llvm::ConstantStruct::getAnon(Fields); 73234768Speter} 73328415Speter 73428415Spetervoid CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, 73528415Speter llvm::GlobalValue *GV) { 73628415Speter assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 73734768Speter // Get the struct elements for these annotations. 73834768Speter for (specific_attr_iterator<AnnotateAttr> 73934768Speter ai = D->specific_attr_begin<AnnotateAttr>(), 74028415Speter ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 74128415Speter Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation())); 74228415Speter} 74328415Speter 74428415Speterbool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 74534768Speter // Never defer when EmitAllDecls is specified. 74634768Speter if (Features.EmitAllDecls) 74728415Speter return false; 74828415Speter 74928415Speter return !getContext().DeclMustBeEmitted(Global); 75034768Speter} 75128415Speter 75234768Speterllvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 75334768Speter const AliasAttr *AA = VD->getAttr<AliasAttr>(); 75434768Speter assert(AA && "No alias?"); 75534768Speter 75634768Speter llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 75734768Speter 75834768Speter // See if there is already something with the target's name in the module. 75934768Speter llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 76034768Speter 76128415Speter llvm::Constant *Aliasee; 76228415Speter if (isa<llvm::FunctionType>(DeclTy)) 76328415Speter Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(), 76434768Speter /*ForVTable=*/false); 76534768Speter else 76634768Speter Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 76734768Speter llvm::PointerType::getUnqual(DeclTy), 0); 76834768Speter if (!Entry) { 76934768Speter llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); 77034768Speter F->setLinkage(llvm::Function::ExternalWeakLinkage); 77128415Speter WeakRefReferences.insert(F); 77228415Speter } 77328415Speter 77428415Speter return Aliasee; 77528415Speter} 77628415Speter 77728415Spetervoid CodeGenModule::EmitGlobal(GlobalDecl GD) { 77834768Speter const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); 77993013Sjedgar 78034768Speter // Weak references don't produce any output by themselves. 78128415Speter if (Global->hasAttr<WeakRefAttr>()) 78228415Speter return; 78334768Speter 78428415Speter // If this is an alias definition (which otherwise looks like a declaration) 78528415Speter // emit it now. 78628415Speter if (Global->hasAttr<AliasAttr>()) 78728415Speter return EmitAliasDefinition(GD); 78828415Speter 78928415Speter // If this is CUDA, be selective about which declarations we emit. 79028415Speter if (Features.CUDA) { 79128415Speter if (CodeGenOpts.CUDAIsDevice) { 79228415Speter if (!Global->hasAttr<CUDADeviceAttr>() && 79328415Speter !Global->hasAttr<CUDAGlobalAttr>() && 79428415Speter !Global->hasAttr<CUDAConstantAttr>() && 79528415Speter !Global->hasAttr<CUDASharedAttr>()) 79628415Speter return; 79728415Speter } else { 79834768Speter if (!Global->hasAttr<CUDAHostAttr>() && ( 79934768Speter Global->hasAttr<CUDADeviceAttr>() || 80034768Speter Global->hasAttr<CUDAConstantAttr>() || 80128415Speter Global->hasAttr<CUDASharedAttr>())) 80228415Speter return; 80328415Speter } 80434768Speter } 80534768Speter 80634768Speter // Ignore declarations, they will be emitted on their first use. 80728415Speter if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 80828415Speter // Forward declarations are emitted lazily on first use. 80928415Speter if (!FD->doesThisDeclarationHaveABody()) { 81043305Sdillon if (!FD->doesDeclarationForceExternallyVisibleDefinition()) 81128415Speter return; 81228415Speter 81328415Speter const FunctionDecl *InlineDefinition = 0; 81434768Speter FD->getBody(InlineDefinition); 81534768Speter 81628415Speter StringRef MangledName = getMangledName(GD); 81728415Speter llvm::StringMap<GlobalDecl>::iterator DDI = 81828415Speter DeferredDecls.find(MangledName); 81928415Speter if (DDI != DeferredDecls.end()) 82028415Speter DeferredDecls.erase(DDI); 82128415Speter EmitGlobalDefinition(InlineDefinition); 82228415Speter return; 82328415Speter } 82428415Speter } else { 82534768Speter const VarDecl *VD = cast<VarDecl>(Global); 82634768Speter assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 82734768Speter 82834768Speter if (VD->isThisDeclarationADefinition() != VarDecl::Definition) 82934768Speter return; 83034768Speter } 83134768Speter 83234768Speter // Defer code generation when possible if this is a static definition, inline 83334768Speter // function etc. These we only want to emit if they are used. 83434768Speter if (!MayDeferGeneration(Global)) { 83534768Speter // Emit the definition if it can't be deferred. 83634768Speter EmitGlobalDefinition(GD); 83734768Speter return; 83834768Speter } 83934768Speter 84034768Speter // If we're deferring emission of a C++ variable with an 84134768Speter // initializer, remember the order in which it appeared in the file. 84234768Speter if (getLangOptions().CPlusPlus && isa<VarDecl>(Global) && 84334768Speter cast<VarDecl>(Global)->hasInit()) { 84434768Speter DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 84534768Speter CXXGlobalInits.push_back(0); 84634768Speter } 84734768Speter 84834768Speter // If the value has already been used, add it directly to the 84934768Speter // DeferredDeclsToEmit list. 85034768Speter StringRef MangledName = getMangledName(GD); 85134768Speter if (GetGlobalValue(MangledName)) 85234768Speter DeferredDeclsToEmit.push_back(GD); 85334768Speter else { 85434768Speter // Otherwise, remember that we saw a deferred decl with this name. The 85534768Speter // first use of the mangled name will cause it to move into 85634768Speter // DeferredDeclsToEmit. 85734768Speter DeferredDecls[MangledName] = GD; 85834768Speter } 85934768Speter} 86034768Speter 86134768Spetervoid CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 86234768Speter const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 86334768Speter 86434768Speter PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 86534768Speter Context.getSourceManager(), 86634768Speter "Generating code for declaration"); 86734768Speter 86828415Speter if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 86934768Speter // At -O0, don't generate IR for functions with available_externally 87028415Speter // linkage. 87128415Speter if (CodeGenOpts.OptimizationLevel == 0 && 87228415Speter !Function->hasAttr<AlwaysInlineAttr>() && 87328415Speter getFunctionLinkage(Function) 87434768Speter == llvm::Function::AvailableExternallyLinkage) 87528415Speter return; 87628415Speter 87728415Speter if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 87828415Speter // Make sure to emit the definition(s) before we emit the thunks. 87928415Speter // This is necessary for the generation of certain thunks. 88028415Speter if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method)) 88128415Speter EmitCXXConstructor(CD, GD.getCtorType()); 88228415Speter else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method)) 88328415Speter EmitCXXDestructor(DD, GD.getDtorType()); 88428415Speter else 88528415Speter EmitGlobalFunctionDefinition(GD); 88628415Speter 88728415Speter if (Method->isVirtual()) 88834768Speter getVTables().EmitThunks(GD); 88934768Speter 89028415Speter return; 89134768Speter } 89228415Speter 89328415Speter return EmitGlobalFunctionDefinition(GD); 89428415Speter } 89528415Speter 89628415Speter if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 89734768Speter return EmitGlobalVarDefinition(VD); 89834768Speter 89934768Speter llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); 90034768Speter} 90134768Speter 90234768Speter/// GetOrCreateLLVMFunction - If the specified mangled name is not in the 90334768Speter/// module, create and return an llvm Function with the specified type. If there 90434768Speter/// is something in the module with the specified name, return it potentially 90534768Speter/// bitcasted to the right type. 90634768Speter/// 90734768Speter/// If D is non-null, it specifies a decl that correspond to this. This is used 90834768Speter/// to set the attributes on the function when it is first created. 90934768Speterllvm::Constant * 91034768SpeterCodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, 91134768Speter llvm::Type *Ty, 91234768Speter GlobalDecl D, bool ForVTable, 91334768Speter llvm::Attributes ExtraAttrs) { 91434768Speter // Lookup the entry, lazily creating it if necessary. 91534768Speter llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 91634768Speter if (Entry) { 91734768Speter if (WeakRefReferences.count(Entry)) { 91834768Speter const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl()); 91934768Speter if (FD && !FD->hasAttr<WeakAttr>()) 92034768Speter Entry->setLinkage(llvm::Function::ExternalLinkage); 92134768Speter 92234768Speter WeakRefReferences.erase(Entry); 92334768Speter } 92434768Speter 92534768Speter if (Entry->getType()->getElementType() == Ty) 92634768Speter return Entry; 92734768Speter 92834768Speter // Make sure the result is of the correct type. 92934768Speter return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); 93034768Speter } 93134768Speter 93234768Speter // This function doesn't have a complete type (for example, the return 93328415Speter // type is an incomplete struct). Use a fake type instead, and make 93428415Speter // sure not to try to set attributes. 93528415Speter bool IsIncompleteFunction = false; 93628415Speter 93728415Speter llvm::FunctionType *FTy; 93828415Speter if (isa<llvm::FunctionType>(Ty)) { 93928415Speter FTy = cast<llvm::FunctionType>(Ty); 94028415Speter } else { 94128415Speter FTy = llvm::FunctionType::get(VoidTy, false); 94228415Speter IsIncompleteFunction = true; 94328415Speter } 94428415Speter 94528415Speter llvm::Function *F = llvm::Function::Create(FTy, 94628415Speter llvm::Function::ExternalLinkage, 94734768Speter MangledName, &getModule()); 94834768Speter assert(F->getName() == MangledName && "name was uniqued!"); 94934768Speter if (D.getDecl()) 95034768Speter SetFunctionAttributes(D, F, IsIncompleteFunction); 95128415Speter if (ExtraAttrs != llvm::Attribute::None) 95228415Speter F->addFnAttr(ExtraAttrs); 95334768Speter 95428415Speter // This is the first use or definition of a mangled name. If there is a 95534768Speter // deferred decl with this name, remember that we need to emit it at the end 95634768Speter // of the file. 95728415Speter llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 95828415Speter if (DDI != DeferredDecls.end()) { 95928415Speter // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 96028415Speter // list, and remove it from DeferredDecls (since we don't need it anymore). 96134768Speter DeferredDeclsToEmit.push_back(DDI->second); 96234768Speter DeferredDecls.erase(DDI); 96328415Speter 96428415Speter // Otherwise, there are cases we have to worry about where we're 96534768Speter // using a declaration for which we must emit a definition but where 96628415Speter // we might not find a top-level definition: 96734768Speter // - member functions defined inline in their classes 96834768Speter // - friend functions defined inline in some class 96934768Speter // - special member functions with implicit definitions 97034768Speter // If we ever change our AST traversal to walk into class methods, 97128415Speter // this will be unnecessary. 97228415Speter // 97328415Speter // We also don't emit a definition for a function if it's going to be an entry 97428415Speter // in a vtable, unless it's already marked as used. 97528415Speter } else if (getLangOptions().CPlusPlus && D.getDecl()) { 97634768Speter // Look for a declaration that's lexically in a record. 97728415Speter const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl()); 97828415Speter do { 97934768Speter if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 98034768Speter if (FD->isImplicit() && !ForVTable) { 98128415Speter assert(FD->isUsed() && "Sema didn't mark implicit function as used!"); 98234768Speter DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 98334768Speter break; 98434768Speter } else if (FD->doesThisDeclarationHaveABody()) { 98534768Speter DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 98634768Speter break; 98734768Speter } 98834768Speter } 98934768Speter FD = FD->getPreviousDeclaration(); 99028415Speter } while (FD); 99128415Speter } 99228415Speter 99328415Speter // Make sure the result is of the requested type. 99434768Speter if (!IsIncompleteFunction) { 99534768Speter assert(F->getType()->getElementType() == Ty); 99634768Speter return F; 99728415Speter } 99828415Speter 99934768Speter llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 100028415Speter return llvm::ConstantExpr::getBitCast(F, PTy); 100134768Speter} 100234768Speter 100328415Speter/// GetAddrOfFunction - Return the address of the given function. If Ty is 100428415Speter/// non-null, then this function will use the specified type if it has to 100528415Speter/// create it (this occurs when we see a definition of the function). 100634768Speterllvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 100728415Speter llvm::Type *Ty, 100828415Speter bool ForVTable) { 100934768Speter // If there was no specific requested type, just convert it now. 101034768Speter if (!Ty) 101134768Speter Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 101234768Speter 101334768Speter StringRef MangledName = getMangledName(GD); 101434768Speter return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable); 101534768Speter} 101634768Speter 101734768Speter/// CreateRuntimeFunction - Create a new runtime function with the specified 101828415Speter/// type and name. 101928415Speterllvm::Constant * 102028415SpeterCodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, 102134768Speter StringRef Name, 102228415Speter llvm::Attributes ExtraAttrs) { 102334768Speter return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 102434768Speter ExtraAttrs); 102534768Speter} 102634768Speter 102734768Speterstatic bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D, 102834768Speter bool ConstantInit) { 102934768Speter if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType()) 103034768Speter return false; 103134768Speter 103234768Speter if (Context.getLangOptions().CPlusPlus) { 103328415Speter if (const RecordType *Record 103434768Speter = Context.getBaseElementType(D->getType())->getAs<RecordType>()) 103534768Speter return ConstantInit && 103634768Speter cast<CXXRecordDecl>(Record->getDecl())->isPOD() && 103728415Speter !cast<CXXRecordDecl>(Record->getDecl())->hasMutableFields(); 103834768Speter } 103934768Speter 104034768Speter return true; 104128415Speter} 104228415Speter 104328415Speter/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 104434768Speter/// create and return an llvm GlobalVariable with the specified type. If there 104528415Speter/// is something in the module with the specified name, return it potentially 104628415Speter/// bitcasted to the right type. 104728415Speter/// 104828415Speter/// If D is non-null, it specifies a decl that correspond to this. This is used 104928415Speter/// to set the attributes on the global when it is first created. 105034768Speterllvm::Constant * 105134768SpeterCodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, 105234768Speter llvm::PointerType *Ty, 105328415Speter const VarDecl *D, 105434768Speter bool UnnamedAddr) { 105534768Speter // Lookup the entry, lazily creating it if necessary. 105634768Speter llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 105734768Speter if (Entry) { 105828415Speter if (WeakRefReferences.count(Entry)) { 105934768Speter if (D && !D->hasAttr<WeakAttr>()) 106034768Speter Entry->setLinkage(llvm::Function::ExternalLinkage); 106134768Speter 106234768Speter WeakRefReferences.erase(Entry); 106328415Speter } 106434768Speter 106534768Speter if (UnnamedAddr) 106634768Speter Entry->setUnnamedAddr(true); 106734768Speter 106834768Speter if (Entry->getType() == Ty) 106934768Speter return Entry; 107028415Speter 107134768Speter // Make sure the result is of the correct type. 107234768Speter return llvm::ConstantExpr::getBitCast(Entry, Ty); 107334768Speter } 107434768Speter 107534768Speter // This is the first use or definition of a mangled name. If there is a 107634768Speter // deferred decl with this name, remember that we need to emit it at the end 107734768Speter // of the file. 107834768Speter llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 107934768Speter if (DDI != DeferredDecls.end()) { 108034768Speter // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 108134768Speter // list, and remove it from DeferredDecls (since we don't need it anymore). 108234768Speter DeferredDeclsToEmit.push_back(DDI->second); 108334768Speter DeferredDecls.erase(DDI); 108434768Speter } 108534768Speter 108634768Speter llvm::GlobalVariable *GV = 108734768Speter new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 108834768Speter llvm::GlobalValue::ExternalLinkage, 108934768Speter 0, MangledName, 0, 109034768Speter false, Ty->getAddressSpace()); 109134768Speter 109228415Speter // Handle things which are present even on external declarations. 109334768Speter if (D) { 109428415Speter // FIXME: This code is overly simple and should be merged with other global 109528415Speter // handling. 109628415Speter GV->setConstant(DeclIsConstantGlobal(Context, D, false)); 109728415Speter 109834768Speter // Set linkage and visibility in case we never see a definition. 109928415Speter NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility(); 110028415Speter if (LV.linkage() != ExternalLinkage) { 110134768Speter // Don't set internal linkage on declarations. 110234768Speter } else { 110328415Speter if (D->hasAttr<DLLImportAttr>()) 110428415Speter GV->setLinkage(llvm::GlobalValue::DLLImportLinkage); 110528415Speter else if (D->hasAttr<WeakAttr>() || D->isWeakImported()) 110628415Speter GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 110734768Speter 110834768Speter // Set visibility on a declaration only if it's explicit. 110928415Speter if (LV.visibilityExplicit()) 111028415Speter GV->setVisibility(GetLLVMVisibility(LV.visibility())); 111128415Speter } 111228415Speter 111334768Speter GV->setThreadLocal(D->isThreadSpecified()); 111428415Speter } 111534768Speter 111634768Speter return GV; 111728415Speter} 111834768Speter 111934768Speter 112028415Speterllvm::GlobalVariable * 112134768SpeterCodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, 112234768Speter llvm::Type *Ty, 112334768Speter llvm::GlobalValue::LinkageTypes Linkage) { 112434768Speter llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 112534768Speter llvm::GlobalVariable *OldGV = 0; 112628415Speter 112734768Speter 112834768Speter if (GV) { 112934768Speter // Check if the variable has the right type. 113034768Speter if (GV->getType()->getElementType() == Ty) 113134768Speter return GV; 113234768Speter 113334768Speter // Because C++ name mangling, the only way we can end up with an already 113428415Speter // existing global with the same name is if it has been declared extern "C". 113528415Speter assert(GV->isDeclaration() && "Declaration has wrong type!"); 113634768Speter OldGV = GV; 113734768Speter } 113834768Speter 113934768Speter // Create a new variable. 114034768Speter GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 114134768Speter Linkage, 0, Name); 114234768Speter 114334768Speter if (OldGV) { 114434768Speter // Replace occurrences of the old variable if needed. 114534768Speter GV->takeName(OldGV); 114634768Speter 114734768Speter if (!OldGV->use_empty()) { 114834768Speter llvm::Constant *NewPtrForOldDecl = 114934768Speter llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 115034768Speter OldGV->replaceAllUsesWith(NewPtrForOldDecl); 115134768Speter } 115234768Speter 115334768Speter OldGV->eraseFromParent(); 115437065Speter } 115534768Speter 115634768Speter return GV; 115734768Speter} 115834768Speter 115937065Speter/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 116034768Speter/// given global variable. If Ty is non-null and if the global doesn't exist, 116134768Speter/// then it will be greated with the specified type instead of whatever the 116234768Speter/// normal requested type would be. 116334768Speterllvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 116434768Speter llvm::Type *Ty) { 116534768Speter assert(D->hasGlobalStorage() && "Not a global variable"); 116634768Speter QualType ASTTy = D->getType(); 116734768Speter if (Ty == 0) 116834768Speter Ty = getTypes().ConvertTypeForMem(ASTTy); 116934768Speter 117034768Speter llvm::PointerType *PTy = 117134768Speter llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 117234768Speter 117334768Speter StringRef MangledName = getMangledName(D); 117434768Speter return GetOrCreateLLVMGlobal(MangledName, PTy, D); 117534768Speter} 117634768Speter 117734768Speter/// CreateRuntimeVariable - Create a new runtime global variable with the 117834768Speter/// specified type and name. 117934768Speterllvm::Constant * 118034768SpeterCodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, 118134768Speter StringRef Name) { 118234768Speter return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, 118334768Speter true); 118434768Speter} 118534768Speter 118634768Spetervoid CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 118728415Speter assert(!D->getInit() && "Cannot emit definite definitions here!"); 118828415Speter 118928415Speter if (MayDeferGeneration(D)) { 119028415Speter // If we have not seen a reference to this variable yet, place it 119134768Speter // into the deferred declarations table to be emitted if needed 119234768Speter // later. 119334768Speter StringRef MangledName = getMangledName(D); 119434768Speter if (!GetGlobalValue(MangledName)) { 119534768Speter DeferredDecls[MangledName] = D; 119634768Speter return; 119734768Speter } 119834768Speter } 119934768Speter 120034768Speter // The tentative definition is the only definition. 120134768Speter EmitGlobalVarDefinition(D); 120234768Speter} 120328415Speter 120434768Spetervoid CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) { 120534768Speter if (DefinitionRequired) 120634768Speter getVTables().GenerateClassData(getVTableLinkage(Class), Class); 120734768Speter} 120828415Speter 120928415Speterllvm::GlobalVariable::LinkageTypes 121034768SpeterCodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { 121128415Speter if (RD->getLinkage() != ExternalLinkage) 121228415Speter return llvm::GlobalVariable::InternalLinkage; 121328415Speter 121428415Speter if (const CXXMethodDecl *KeyFunction 121528415Speter = RD->getASTContext().getKeyFunction(RD)) { 121628415Speter // If this class has a key function, use that to determine the linkage of 121728415Speter // the vtable. 121828415Speter const FunctionDecl *Def = 0; 121928415Speter if (KeyFunction->hasBody(Def)) 122028415Speter KeyFunction = cast<CXXMethodDecl>(Def); 122134768Speter 122234768Speter switch (KeyFunction->getTemplateSpecializationKind()) { 122328415Speter case TSK_Undeclared: 122428415Speter case TSK_ExplicitSpecialization: 122528415Speter // When compiling with optimizations turned on, we emit all vtables, 122628415Speter // even if the key function is not defined in the current translation 122728415Speter // unit. If this is the case, use available_externally linkage. 122828415Speter if (!Def && CodeGenOpts.OptimizationLevel) 122928415Speter return llvm::GlobalVariable::AvailableExternallyLinkage; 123028415Speter 123128415Speter if (KeyFunction->isInlined()) 123228415Speter return !Context.getLangOptions().AppleKext ? 123328415Speter llvm::GlobalVariable::LinkOnceODRLinkage : 123428415Speter llvm::Function::InternalLinkage; 123528415Speter 123628415Speter return llvm::GlobalVariable::ExternalLinkage; 123728415Speter 123828415Speter case TSK_ImplicitInstantiation: 123928415Speter return !Context.getLangOptions().AppleKext ? 124028415Speter llvm::GlobalVariable::LinkOnceODRLinkage : 124128415Speter llvm::Function::InternalLinkage; 124228415Speter 124328415Speter case TSK_ExplicitInstantiationDefinition: 124428415Speter return !Context.getLangOptions().AppleKext ? 124528415Speter llvm::GlobalVariable::WeakODRLinkage : 124628415Speter llvm::Function::InternalLinkage; 124728415Speter 124828415Speter case TSK_ExplicitInstantiationDeclaration: 124928415Speter // FIXME: Use available_externally linkage. However, this currently 125028415Speter // breaks LLVM's build due to undefined symbols. 125134768Speter // return llvm::GlobalVariable::AvailableExternallyLinkage; 125228415Speter return !Context.getLangOptions().AppleKext ? 125328415Speter llvm::GlobalVariable::LinkOnceODRLinkage : 125428415Speter llvm::Function::InternalLinkage; 125528415Speter } 125628415Speter } 125728415Speter 125828415Speter if (Context.getLangOptions().AppleKext) 125928415Speter return llvm::Function::InternalLinkage; 126028415Speter 126128415Speter switch (RD->getTemplateSpecializationKind()) { 126228415Speter case TSK_Undeclared: 126328415Speter case TSK_ExplicitSpecialization: 126428415Speter case TSK_ImplicitInstantiation: 126528415Speter // FIXME: Use available_externally linkage. However, this currently 126634768Speter // breaks LLVM's build due to undefined symbols. 126728415Speter // return llvm::GlobalVariable::AvailableExternallyLinkage; 126828415Speter case TSK_ExplicitInstantiationDeclaration: 126928415Speter return llvm::GlobalVariable::LinkOnceODRLinkage; 127028415Speter 127128415Speter case TSK_ExplicitInstantiationDefinition: 127234768Speter return llvm::GlobalVariable::WeakODRLinkage; 127328415Speter } 127428415Speter 127528415Speter // Silence GCC warning. 127628415Speter return llvm::GlobalVariable::LinkOnceODRLinkage; 127728415Speter} 127828415Speter 127928415SpeterCharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { 128028415Speter return Context.toCharUnitsFromBits( 128134768Speter TheTargetData.getTypeStoreSizeInBits(Ty)); 128228415Speter} 128328415Speter 128428415Spetervoid CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 128528415Speter llvm::Constant *Init = 0; 128628415Speter QualType ASTTy = D->getType(); 128728415Speter bool NonConstInit = false; 128828415Speter 128928415Speter const Expr *InitExpr = D->getAnyInitializer(); 129028415Speter 129128415Speter if (!InitExpr) { 129228415Speter // This is a tentative definition; tentative definitions are 129328415Speter // implicitly initialized with { 0 }. 129428415Speter // 129528415Speter // Note that tentative definitions are only emitted at the end of 129628415Speter // a translation unit, so they should never have incomplete 129728415Speter // type. In addition, EmitTentativeDefinition makes sure that we 129828415Speter // never attempt to emit a tentative definition if a real one 129928415Speter // exists. A use may still exists, however, so we still may need 130028415Speter // to do a RAUW. 130128415Speter assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 130228415Speter Init = EmitNullConstant(D->getType()); 130328415Speter } else { 130428415Speter Init = EmitConstantExpr(InitExpr, D->getType()); 130528415Speter if (!Init) { 130628415Speter QualType T = InitExpr->getType(); 130728415Speter if (D->getType()->isReferenceType()) 130828415Speter T = D->getType(); 130928415Speter 131028415Speter if (getLangOptions().CPlusPlus) { 131128415Speter Init = EmitNullConstant(T); 131234768Speter NonConstInit = true; 131334768Speter } else { 131434768Speter ErrorUnsupported(D, "static initializer"); 131534768Speter Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 131634768Speter } 131728415Speter } else { 131828415Speter // We don't need an initializer, so remove the entry for the delayed 131928415Speter // initializer position (just in case this entry was delayed). 132028415Speter if (getLangOptions().CPlusPlus) 132128415Speter DelayedCXXInitPosition.erase(D); 132228415Speter } 132328415Speter } 132428415Speter 132528415Speter llvm::Type* InitType = Init->getType(); 132628415Speter llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 132728415Speter 132828415Speter // Strip off a bitcast if we got one back. 132928415Speter if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 133028415Speter assert(CE->getOpcode() == llvm::Instruction::BitCast || 133128415Speter // all zero index gep. 133228415Speter CE->getOpcode() == llvm::Instruction::GetElementPtr); 133328415Speter Entry = CE->getOperand(0); 133428415Speter } 133528415Speter 133628415Speter // Entry is now either a Function or GlobalVariable. 133728415Speter llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 133828415Speter 133928415Speter // We have a definition after a declaration with the wrong type. 134028415Speter // We must make a new GlobalVariable* and update everything that used OldGV 134128415Speter // (a declaration or tentative definition) with the new GlobalVariable* 134228415Speter // (which will be a definition). 134328415Speter // 134428415Speter // This happens if there is a prototype for a global (e.g. 134528415Speter // "extern int x[];") and then a definition of a different type (e.g. 134628415Speter // "int x[10];"). This also happens when an initializer has a different type 134728415Speter // from the type of the global (this happens with unions). 134828415Speter if (GV == 0 || 134928415Speter GV->getType()->getElementType() != InitType || 135028415Speter GV->getType()->getAddressSpace() != 135128415Speter getContext().getTargetAddressSpace(ASTTy)) { 135228415Speter 135328415Speter // Move the old entry aside so that we'll create a new one. 135428415Speter Entry->setName(StringRef()); 135528415Speter 135628415Speter // Make a new global with the correct type, this is now guaranteed to work. 135728415Speter GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 135828415Speter 135928415Speter // Replace all uses of the old global with the new global 136028415Speter llvm::Constant *NewPtrForOldDecl = 136128415Speter llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 136228415Speter Entry->replaceAllUsesWith(NewPtrForOldDecl); 136328415Speter 136428415Speter // Erase the old global, since it is no longer used. 136528415Speter cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 136628415Speter } 136728415Speter 136828415Speter if (D->hasAttr<AnnotateAttr>()) 136928415Speter AddGlobalAnnotations(D, GV); 137028415Speter 137128415Speter GV->setInitializer(Init); 137228415Speter 137328415Speter // If it is safe to mark the global 'constant', do so now. 137428415Speter GV->setConstant(false); 137528415Speter if (!NonConstInit && DeclIsConstantGlobal(Context, D, true)) 137628415Speter GV->setConstant(true); 137728415Speter 137828415Speter GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 137928415Speter 138028415Speter // Set the llvm linkage type as appropriate. 138128415Speter llvm::GlobalValue::LinkageTypes Linkage = 138228415Speter GetLLVMLinkageVarDefinition(D, GV); 138328415Speter GV->setLinkage(Linkage); 138428415Speter if (Linkage == llvm::GlobalVariable::CommonLinkage) 138528415Speter // common vars aren't constant even if declared const. 138628415Speter GV->setConstant(false); 138728415Speter 138828415Speter SetCommonAttributes(D, GV); 138928415Speter 139028415Speter // Emit the initializer function if necessary. 139128415Speter if (NonConstInit) 139228415Speter EmitCXXGlobalVarDeclInitFunc(D, GV); 139328415Speter 139428415Speter // Emit global variable debug information. 139534768Speter if (CGDebugInfo *DI = getModuleDebugInfo()) 139628415Speter DI->EmitGlobalVariable(GV, D); 139728415Speter} 139828415Speter 139928415Speterllvm::GlobalValue::LinkageTypes 140028415SpeterCodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, 140128415Speter llvm::GlobalVariable *GV) { 140228415Speter GVALinkage Linkage = getContext().GetGVALinkageForVariable(D); 140328415Speter if (Linkage == GVA_Internal) 140428415Speter return llvm::Function::InternalLinkage; 140528415Speter else if (D->hasAttr<DLLImportAttr>()) 140634768Speter return llvm::Function::DLLImportLinkage; 140734768Speter else if (D->hasAttr<DLLExportAttr>()) 140828415Speter return llvm::Function::DLLExportLinkage; 140928415Speter else if (D->hasAttr<WeakAttr>()) { 141028415Speter if (GV->isConstant()) 141128415Speter return llvm::GlobalVariable::WeakODRLinkage; 141228415Speter else 141328415Speter return llvm::GlobalVariable::WeakAnyLinkage; 141428415Speter } else if (Linkage == GVA_TemplateInstantiation || 141528415Speter Linkage == GVA_ExplicitTemplateInstantiation) 141628415Speter return llvm::GlobalVariable::WeakODRLinkage; 141728415Speter else if (!getLangOptions().CPlusPlus && 141828415Speter ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) || 141928415Speter D->getAttr<CommonAttr>()) && 142028415Speter !D->hasExternalStorage() && !D->getInit() && 142134768Speter !D->getAttr<SectionAttr>() && !D->isThreadSpecified() && 142228415Speter !D->getAttr<WeakImportAttr>()) { 142334768Speter // Thread local vars aren't considered common linkage. 142434768Speter return llvm::GlobalVariable::CommonLinkage; 142534768Speter } 142634768Speter return llvm::GlobalVariable::ExternalLinkage; 142734768Speter} 142828415Speter 142928415Speter/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 143034768Speter/// implement a function with no prototype, e.g. "int foo() {}". If there are 143128415Speter/// existing call uses of the old function in the module, this adjusts them to 143228415Speter/// call the new function directly. 143328415Speter/// 143428415Speter/// This is not just a cleanup: the always_inline pass requires direct calls to 143528415Speter/// functions to be able to inline them. If there is a bitcast in the way, it 143628415Speter/// won't inline them. Instcombine normally deletes these calls, but it isn't 143728415Speter/// run at -O0. 143828415Speterstatic void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 143928415Speter llvm::Function *NewFn) { 144028415Speter // If we're redefining a global as a function, don't transform it. 144128415Speter llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 144228415Speter if (OldFn == 0) return; 144328415Speter 144428415Speter llvm::Type *NewRetTy = NewFn->getReturnType(); 144528415Speter SmallVector<llvm::Value*, 4> ArgList; 144628415Speter 144728415Speter for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 144828415Speter UI != E; ) { 144928415Speter // TODO: Do invokes ever occur in C code? If so, we should handle them too. 145028415Speter llvm::Value::use_iterator I = UI++; // Increment before the CI is erased. 145128415Speter llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I); 145228415Speter if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I) 145328415Speter llvm::CallSite CS(CI); 145428415Speter if (!CI || !CS.isCallee(I)) continue; 145528415Speter 145628415Speter // If the return types don't match exactly, and if the call isn't dead, then 145728415Speter // we can't transform this call. 145828415Speter if (CI->getType() != NewRetTy && !CI->use_empty()) 145928415Speter continue; 146028415Speter 146128415Speter // Get the attribute list. 146228415Speter llvm::SmallVector<llvm::AttributeWithIndex, 8> AttrVec; 146334768Speter llvm::AttrListPtr AttrList = CI->getAttributes(); 146428415Speter 146528415Speter // Get any return attributes. 146628415Speter llvm::Attributes RAttrs = AttrList.getRetAttributes(); 146728415Speter 146828415Speter // Add the return attributes. 146928415Speter if (RAttrs) 147028415Speter AttrVec.push_back(llvm::AttributeWithIndex::get(0, RAttrs)); 147128415Speter 147228415Speter // If the function was passed too few arguments, don't transform. If extra 147328415Speter // arguments were passed, we silently drop them. If any of the types 147428415Speter // mismatch, we don't transform. 147528415Speter unsigned ArgNo = 0; 147628415Speter bool DontTransform = false; 147728415Speter for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 147828415Speter E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 147928415Speter if (CS.arg_size() == ArgNo || 148028415Speter CS.getArgument(ArgNo)->getType() != AI->getType()) { 148128415Speter DontTransform = true; 148234768Speter break; 148334768Speter } 148434768Speter 148534768Speter // Add any parameter attributes. 148628415Speter if (llvm::Attributes PAttrs = AttrList.getParamAttributes(ArgNo + 1)) 148728415Speter AttrVec.push_back(llvm::AttributeWithIndex::get(ArgNo + 1, PAttrs)); 148828415Speter } 148928415Speter if (DontTransform) 149028415Speter continue; 149128415Speter 149228415Speter if (llvm::Attributes FnAttrs = AttrList.getFnAttributes()) 149328415Speter AttrVec.push_back(llvm::AttributeWithIndex::get(~0, FnAttrs)); 149428415Speter 149528415Speter // Okay, we can transform this. Create the new call instruction and copy 149628415Speter // over the required information. 149728415Speter ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo); 149828415Speter llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList, "", CI); 149928415Speter ArgList.clear(); 150028415Speter if (!NewCall->getType()->isVoidTy()) 150128415Speter NewCall->takeName(CI); 150228415Speter NewCall->setAttributes(llvm::AttrListPtr::get(AttrVec.begin(), 150328415Speter AttrVec.end())); 150428415Speter NewCall->setCallingConv(CI->getCallingConv()); 150528415Speter 150628415Speter // Finally, remove the old call, replacing any uses with the new one. 150728415Speter if (!CI->use_empty()) 150828415Speter CI->replaceAllUsesWith(NewCall); 150928415Speter 151028415Speter // Copy debug location attached to CI. 151128415Speter if (!CI->getDebugLoc().isUnknown()) 151228415Speter NewCall->setDebugLoc(CI->getDebugLoc()); 151328415Speter CI->eraseFromParent(); 151428415Speter } 151528415Speter} 151628415Speter 151728415Speter 151828415Spetervoid CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 151928415Speter const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 152028415Speter 152128415Speter // Compute the function info and LLVM type. 152228415Speter const CGFunctionInfo &FI = getTypes().getFunctionInfo(GD); 152328415Speter bool variadic = false; 152428415Speter if (const FunctionProtoType *fpt = D->getType()->getAs<FunctionProtoType>()) 152528415Speter variadic = fpt->isVariadic(); 152628415Speter llvm::FunctionType *Ty = getTypes().GetFunctionType(FI, variadic); 152728415Speter 152828415Speter // Get or create the prototype for the function. 152928415Speter llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 153028415Speter 153128415Speter // Strip off a bitcast if we got one back. 153228415Speter if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 153328415Speter assert(CE->getOpcode() == llvm::Instruction::BitCast); 153428415Speter Entry = CE->getOperand(0); 153528415Speter } 153628415Speter 153728415Speter 153828415Speter if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 153928415Speter llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 154028415Speter 154128415Speter // If the types mismatch then we have to rewrite the definition. 154228415Speter assert(OldFn->isDeclaration() && 154334768Speter "Shouldn't replace non-declaration"); 154434768Speter 154534768Speter // F is the Function* for the one with the wrong type, we must make a new 154634768Speter // Function* and update everything that used F (a declaration) with the new 154734768Speter // Function* (which will be a definition). 154834768Speter // 154928415Speter // This happens if there is a prototype for a function 155028415Speter // (e.g. "int f()") and then a definition of a different type 155128415Speter // (e.g. "int f(int x)"). Move the old function aside so that it 155228415Speter // doesn't interfere with GetAddrOfFunction. 155328415Speter OldFn->setName(StringRef()); 155428415Speter llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 155534768Speter 155634768Speter // If this is an implementation of a function without a prototype, try to 155734768Speter // replace any existing uses of the function (which may be calls) with uses 155828415Speter // of the new function 155928415Speter if (D->getType()->isFunctionNoProtoType()) { 156028415Speter ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 156134768Speter OldFn->removeDeadConstantUsers(); 156234768Speter } 156334768Speter 156434768Speter // Replace uses of F with the Function we will endow with a body. 156534768Speter if (!Entry->use_empty()) { 156634768Speter llvm::Constant *NewPtrForOldDecl = 156734768Speter llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 156834768Speter Entry->replaceAllUsesWith(NewPtrForOldDecl); 156934768Speter } 157034768Speter 157134768Speter // Ok, delete the old function now, which is dead. 157234768Speter OldFn->eraseFromParent(); 157334768Speter 157434768Speter Entry = NewFn; 157534768Speter } 157634768Speter 157734768Speter // We need to set linkage and visibility on the function before 157834768Speter // generating code for it because various parts of IR generation 157934768Speter // want to propagate this information down (e.g. to local static 158034768Speter // declarations). 158134768Speter llvm::Function *Fn = cast<llvm::Function>(Entry); 158234768Speter setFunctionLinkage(D, Fn); 158334768Speter 158434768Speter // FIXME: this is redundant with part of SetFunctionDefinitionAttributes 158534768Speter setGlobalVisibility(Fn, D); 158634768Speter 158734768Speter CodeGenFunction(*this).GenerateCode(D, Fn, FI); 158834768Speter 158934768Speter SetFunctionDefinitionAttributes(D, Fn); 159034768Speter SetLLVMFunctionAttributesForDefinition(D, Fn); 159134768Speter 159234768Speter if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 159334768Speter AddGlobalCtor(Fn, CA->getPriority()); 159434768Speter if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 159534768Speter AddGlobalDtor(Fn, DA->getPriority()); 159634768Speter if (D->hasAttr<AnnotateAttr>()) 159734768Speter AddGlobalAnnotations(D, Fn); 159834768Speter} 159934768Speter 160034768Spetervoid CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 160134768Speter const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 160234768Speter const AliasAttr *AA = D->getAttr<AliasAttr>(); 160334768Speter assert(AA && "Not an alias?"); 160434768Speter 160534768Speter StringRef MangledName = getMangledName(GD); 160634768Speter 160734768Speter // If there is a definition in the module, then it wins over the alias. 160834768Speter // This is dubious, but allow it to be safe. Just ignore the alias. 160934768Speter llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 161034768Speter if (Entry && !Entry->isDeclaration()) 161134768Speter return; 161234768Speter 161334768Speter llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 161434768Speter 161534768Speter // Create a reference to the named value. This ensures that it is emitted 161634768Speter // if a deferred decl. 161734768Speter llvm::Constant *Aliasee; 161834768Speter if (isa<llvm::FunctionType>(DeclTy)) 161934768Speter Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(), 162034768Speter /*ForVTable=*/false); 162134768Speter else 162234768Speter Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 162334768Speter llvm::PointerType::getUnqual(DeclTy), 0); 162428415Speter 162528415Speter // Create the new alias itself, but don't set a name yet. 162628415Speter llvm::GlobalValue *GA = 162734768Speter new llvm::GlobalAlias(Aliasee->getType(), 162828415Speter llvm::Function::ExternalLinkage, 162928415Speter "", Aliasee, &getModule()); 163028415Speter 163128415Speter if (Entry) { 163234768Speter assert(Entry->isDeclaration()); 163328415Speter 163428415Speter // If there is a declaration in the module, then we had an extern followed 163528415Speter // by the alias, as in: 163628415Speter // extern int test6(); 163728415Speter // ... 163828415Speter // int test6() __attribute__((alias("test7"))); 163928415Speter // 164028415Speter // Remove it and replace uses of it with the alias. 164128415Speter GA->takeName(Entry); 164234768Speter 164334768Speter Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 164434768Speter Entry->getType())); 164528415Speter Entry->eraseFromParent(); 164628415Speter } else { 164728415Speter GA->setName(MangledName); 164828415Speter } 164928415Speter 165028415Speter // Set attributes which are particular to an alias; this is a 165128415Speter // specialization of the attributes which may be set on a global 165228415Speter // variable/function. 165328415Speter if (D->hasAttr<DLLExportAttr>()) { 165428415Speter if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 165528415Speter // The dllexport attribute is ignored for undefined symbols. 165628415Speter if (FD->hasBody()) 165728415Speter GA->setLinkage(llvm::Function::DLLExportLinkage); 165828415Speter } else { 165928415Speter GA->setLinkage(llvm::Function::DLLExportLinkage); 166028415Speter } 166128415Speter } else if (D->hasAttr<WeakAttr>() || 166228415Speter D->hasAttr<WeakRefAttr>() || 166328415Speter D->isWeakImported()) { 166428415Speter GA->setLinkage(llvm::Function::WeakAnyLinkage); 166528415Speter } 166628415Speter 166728415Speter SetCommonAttributes(D, GA); 166828415Speter} 166928415Speter 167028415Speterllvm::Function *CodeGenModule::getIntrinsic(unsigned IID, 167134768Speter ArrayRef<llvm::Type*> Tys) { 167234768Speter return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID, 167328415Speter Tys); 167428415Speter} 167528415Speter 167628415Speterstatic llvm::StringMapEntry<llvm::Constant*> & 167728415SpeterGetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 167828415Speter const StringLiteral *Literal, 167928415Speter bool TargetIsLSB, 168028415Speter bool &IsUTF16, 168128415Speter unsigned &StringLength) { 168228415Speter StringRef String = Literal->getString(); 168328415Speter unsigned NumBytes = String.size(); 168428415Speter 168528415Speter // Check for simple case. 168628415Speter if (!Literal->containsNonAsciiOrNull()) { 168728415Speter StringLength = NumBytes; 168828415Speter return Map.GetOrCreateValue(String); 168928415Speter } 169028415Speter 169128415Speter // Otherwise, convert the UTF8 literals into a byte string. 169228415Speter SmallVector<UTF16, 128> ToBuf(NumBytes); 169328415Speter const UTF8 *FromPtr = (UTF8 *)String.data(); 169428415Speter UTF16 *ToPtr = &ToBuf[0]; 169528415Speter 169628415Speter (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 169728415Speter &ToPtr, ToPtr + NumBytes, 169828415Speter strictConversion); 169928415Speter 170028415Speter // ConvertUTF8toUTF16 returns the length in ToPtr. 170128415Speter StringLength = ToPtr - &ToBuf[0]; 170228415Speter 170328415Speter // Render the UTF-16 string into a byte array and convert to the target byte 170428415Speter // order. 170534768Speter // 170628415Speter // FIXME: This isn't something we should need to do here. 170728415Speter llvm::SmallString<128> AsBytes; 170828415Speter AsBytes.reserve(StringLength * 2); 170934768Speter for (unsigned i = 0; i != StringLength; ++i) { 171028415Speter unsigned short Val = ToBuf[i]; 171134768Speter if (TargetIsLSB) { 171234768Speter AsBytes.push_back(Val & 0xFF); 171328415Speter AsBytes.push_back(Val >> 8); 171428415Speter } else { 171528415Speter AsBytes.push_back(Val >> 8); 171628415Speter AsBytes.push_back(Val & 0xFF); 171728415Speter } 171828415Speter } 171928415Speter // Append one extra null character, the second is automatically added by our 172034768Speter // caller. 172128415Speter AsBytes.push_back(0); 172228415Speter 172328415Speter IsUTF16 = true; 172428415Speter return Map.GetOrCreateValue(StringRef(AsBytes.data(), AsBytes.size())); 172528415Speter} 172628415Speter 172728415Speterstatic llvm::StringMapEntry<llvm::Constant*> & 172828415SpeterGetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map, 172928415Speter const StringLiteral *Literal, 173028415Speter unsigned &StringLength) 173128415Speter{ 173228415Speter StringRef String = Literal->getString(); 173328415Speter StringLength = String.size(); 173428415Speter return Map.GetOrCreateValue(String); 173528415Speter} 173634768Speter 173734768Speterllvm::Constant * 173834768SpeterCodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 173928415Speter unsigned StringLength = 0; 174028415Speter bool isUTF16 = false; 174128415Speter llvm::StringMapEntry<llvm::Constant*> &Entry = 174228415Speter GetConstantCFStringEntry(CFConstantStringMap, Literal, 174328415Speter getTargetData().isLittleEndian(), 174428415Speter isUTF16, StringLength); 174528415Speter 174628415Speter if (llvm::Constant *C = Entry.getValue()) 174728415Speter return C; 174828415Speter 174928415Speter llvm::Constant *Zero = 175028415Speter llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 175128415Speter llvm::Constant *Zeros[] = { Zero, Zero }; 175228415Speter 175328415Speter // If we don't already have it, get __CFConstantStringClassReference. 175428415Speter if (!CFConstantStringClassRef) { 175528415Speter llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 175628415Speter Ty = llvm::ArrayType::get(Ty, 0); 175728415Speter llvm::Constant *GV = CreateRuntimeVariable(Ty, 175828415Speter "__CFConstantStringClassReference"); 175928415Speter // Decay array -> ptr 176028415Speter CFConstantStringClassRef = 176128415Speter llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 176228415Speter } 176328415Speter 176428415Speter QualType CFTy = getContext().getCFConstantStringType(); 176528415Speter 176628415Speter llvm::StructType *STy = 176728415Speter cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 176828415Speter 176928415Speter std::vector<llvm::Constant*> Fields(4); 177028415Speter 177128415Speter // Class pointer. 177228415Speter Fields[0] = CFConstantStringClassRef; 177328415Speter 177428415Speter // Flags. 177528415Speter llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 177628415Speter Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 177728415Speter llvm::ConstantInt::get(Ty, 0x07C8); 177828415Speter 177928415Speter // String pointer. 178028415Speter llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 178128415Speter 178228415Speter llvm::GlobalValue::LinkageTypes Linkage; 178328415Speter bool isConstant; 178434768Speter if (isUTF16) { 178534768Speter // FIXME: why do utf strings get "_" labels instead of "L" labels? 178628415Speter Linkage = llvm::GlobalValue::InternalLinkage; 178728415Speter // Note: -fwritable-strings doesn't make unicode CFStrings writable, but 178828415Speter // does make plain ascii ones writable. 178928415Speter isConstant = true; 179028415Speter } else { 179128415Speter // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error 179228415Speter // when using private linkage. It is not clear if this is a bug in ld 179328415Speter // or a reasonable new restriction. 179428415Speter Linkage = llvm::GlobalValue::LinkerPrivateLinkage; 179528415Speter isConstant = !Features.WritableStrings; 179628415Speter } 179728415Speter 179828415Speter llvm::GlobalVariable *GV = 179928415Speter new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 180028415Speter ".str"); 180128415Speter GV->setUnnamedAddr(true); 180228415Speter if (isUTF16) { 180334768Speter CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 180428415Speter GV->setAlignment(Align.getQuantity()); 180528415Speter } else { 180628415Speter CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 180728415Speter GV->setAlignment(Align.getQuantity()); 180828415Speter } 180928415Speter Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 181028415Speter 181134768Speter // String length. 181234768Speter Ty = getTypes().ConvertType(getContext().LongTy); 181328415Speter Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 181428415Speter 181528415Speter // The struct. 181634768Speter C = llvm::ConstantStruct::get(STy, Fields); 181728415Speter GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 181828415Speter llvm::GlobalVariable::PrivateLinkage, C, 181928415Speter "_unnamed_cfstring_"); 182028415Speter if (const char *Sect = getContext().getTargetInfo().getCFStringSection()) 182128415Speter GV->setSection(Sect); 182228415Speter Entry.setValue(GV); 182328415Speter 182428415Speter return GV; 182528415Speter} 182628415Speter 182728415Speterstatic RecordDecl * 182828415SpeterCreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 182934768Speter DeclContext *DC, IdentifierInfo *Id) { 183028415Speter SourceLocation Loc; 183128415Speter if (Ctx.getLangOptions().CPlusPlus) 183234768Speter return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 183334768Speter else 183428415Speter return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 183534768Speter} 183628415Speter 183734768Speterllvm::Constant * 183828415SpeterCodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { 183934768Speter unsigned StringLength = 0; 184028415Speter llvm::StringMapEntry<llvm::Constant*> &Entry = 184128415Speter GetConstantStringEntry(CFConstantStringMap, Literal, StringLength); 184228415Speter 184328415Speter if (llvm::Constant *C = Entry.getValue()) 184428415Speter return C; 184528415Speter 184628415Speter llvm::Constant *Zero = 184728415Speter llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 184828415Speter llvm::Constant *Zeros[] = { Zero, Zero }; 184928415Speter 185028415Speter // If we don't already have it, get _NSConstantStringClassReference. 185128415Speter if (!ConstantStringClassRef) { 185228415Speter std::string StringClass(getLangOptions().ObjCConstantStringClass); 185328415Speter llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 185428415Speter llvm::Constant *GV; 185528415Speter if (Features.ObjCNonFragileABI) { 185628415Speter std::string str = 185728415Speter StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 185828415Speter : "OBJC_CLASS_$_" + StringClass; 185928415Speter GV = getObjCRuntime().GetClassGlobal(str); 186028415Speter // Make sure the result is of the correct type. 186128415Speter llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 186228415Speter ConstantStringClassRef = 186328415Speter llvm::ConstantExpr::getBitCast(GV, PTy); 186428415Speter } else { 186528415Speter std::string str = 186628415Speter StringClass.empty() ? "_NSConstantStringClassReference" 186728415Speter : "_" + StringClass + "ClassReference"; 186828415Speter llvm::Type *PTy = llvm::ArrayType::get(Ty, 0); 186934768Speter GV = CreateRuntimeVariable(PTy, str); 187028415Speter // Decay array -> ptr 187134768Speter ConstantStringClassRef = 187234768Speter llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 187328415Speter } 187428415Speter } 187528415Speter 187628415Speter if (!NSConstantStringType) { 187728415Speter // Construct the type for a constant NSString. 187828415Speter RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 187928415Speter Context.getTranslationUnitDecl(), 188028415Speter &Context.Idents.get("__builtin_NSString")); 188128415Speter D->startDefinition(); 188228415Speter 188328415Speter QualType FieldTypes[3]; 188428415Speter 188528415Speter // const int *isa; 188628415Speter FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst()); 188728415Speter // const char *str; 188828415Speter FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst()); 188928415Speter // unsigned int length; 189028415Speter FieldTypes[2] = Context.UnsignedIntTy; 189128415Speter 189228415Speter // Create fields 189328415Speter for (unsigned i = 0; i < 3; ++i) { 189428415Speter FieldDecl *Field = FieldDecl::Create(Context, D, 189528415Speter SourceLocation(), 189628415Speter SourceLocation(), 0, 189728415Speter FieldTypes[i], /*TInfo=*/0, 189828415Speter /*BitWidth=*/0, 189928415Speter /*Mutable=*/false, 190028415Speter /*HasInit=*/false); 190128415Speter Field->setAccess(AS_public); 190228415Speter D->addDecl(Field); 190328415Speter } 190428415Speter 190528415Speter D->completeDefinition(); 190628415Speter QualType NSTy = Context.getTagDeclType(D); 190728415Speter NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 190828415Speter } 190928415Speter 191028415Speter std::vector<llvm::Constant*> Fields(3); 191128415Speter 191228415Speter // Class pointer. 191328415Speter Fields[0] = ConstantStringClassRef; 191428415Speter 191528415Speter // String pointer. 191628415Speter llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 191728415Speter 191828415Speter llvm::GlobalValue::LinkageTypes Linkage; 191928415Speter bool isConstant; 192028415Speter Linkage = llvm::GlobalValue::PrivateLinkage; 192128415Speter isConstant = !Features.WritableStrings; 192228415Speter 192334768Speter llvm::GlobalVariable *GV = 192428415Speter new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 192528415Speter ".str"); 192628415Speter GV->setUnnamedAddr(true); 192728415Speter CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 192828415Speter GV->setAlignment(Align.getQuantity()); 192928415Speter Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 193028415Speter 193128415Speter // String length. 193228415Speter llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 193328415Speter Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 193428415Speter 193528415Speter // The struct. 193628415Speter C = llvm::ConstantStruct::get(NSConstantStringType, Fields); 193728415Speter GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 193828415Speter llvm::GlobalVariable::PrivateLinkage, C, 193928415Speter "_unnamed_nsstring_"); 194028415Speter // FIXME. Fix section. 194128415Speter if (const char *Sect = 194228415Speter Features.ObjCNonFragileABI 194328415Speter ? getContext().getTargetInfo().getNSStringNonFragileABISection() 194428415Speter : getContext().getTargetInfo().getNSStringSection()) 194528415Speter GV->setSection(Sect); 194628415Speter Entry.setValue(GV); 194728415Speter 194828415Speter return GV; 194928415Speter} 195028415Speter 195128415SpeterQualType CodeGenModule::getObjCFastEnumerationStateType() { 195228415Speter if (ObjCFastEnumerationStateType.isNull()) { 195328415Speter RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 195428415Speter Context.getTranslationUnitDecl(), 195528415Speter &Context.Idents.get("__objcFastEnumerationState")); 195628415Speter D->startDefinition(); 195728415Speter 195828415Speter QualType FieldTypes[] = { 195928415Speter Context.UnsignedLongTy, 196028415Speter Context.getPointerType(Context.getObjCIdType()), 196128415Speter Context.getPointerType(Context.UnsignedLongTy), 196228415Speter Context.getConstantArrayType(Context.UnsignedLongTy, 196328415Speter llvm::APInt(32, 5), ArrayType::Normal, 0) 196428415Speter }; 196528415Speter 196628415Speter for (size_t i = 0; i < 4; ++i) { 196728415Speter FieldDecl *Field = FieldDecl::Create(Context, 196834768Speter D, 196928415Speter SourceLocation(), 197028415Speter SourceLocation(), 0, 197128415Speter FieldTypes[i], /*TInfo=*/0, 197228415Speter /*BitWidth=*/0, 197328415Speter /*Mutable=*/false, 197428415Speter /*HasInit=*/false); 197528415Speter Field->setAccess(AS_public); 197628415Speter D->addDecl(Field); 197728415Speter } 197828415Speter 197928415Speter D->completeDefinition(); 198028415Speter ObjCFastEnumerationStateType = Context.getTagDeclType(D); 198128415Speter } 198228415Speter 198328415Speter return ObjCFastEnumerationStateType; 198428415Speter} 198528415Speter 198628415Speter/// GetStringForStringLiteral - Return the appropriate bytes for a 198728415Speter/// string literal, properly padded to match the literal type. 198828415Speterstd::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) { 198928415Speter const ASTContext &Context = getContext(); 199028415Speter const ConstantArrayType *CAT = 199128415Speter Context.getAsConstantArrayType(E->getType()); 199228415Speter assert(CAT && "String isn't pointer or array!"); 199328415Speter 199434768Speter // Resize the string to the right size. 199528415Speter uint64_t RealLen = CAT->getSize().getZExtValue(); 199628415Speter 199728415Speter switch (E->getKind()) { 199828415Speter case StringLiteral::Ascii: 199928415Speter case StringLiteral::UTF8: 200028415Speter break; 200128415Speter case StringLiteral::Wide: 200228415Speter RealLen *= Context.getTargetInfo().getWCharWidth() / Context.getCharWidth(); 200328415Speter break; 200428415Speter case StringLiteral::UTF16: 200528415Speter RealLen *= Context.getTargetInfo().getChar16Width() / Context.getCharWidth(); 200628415Speter break; 200728415Speter case StringLiteral::UTF32: 200828415Speter RealLen *= Context.getTargetInfo().getChar32Width() / Context.getCharWidth(); 200928415Speter break; 201028415Speter } 201128415Speter 201228415Speter std::string Str = E->getString().str(); 201328415Speter Str.resize(RealLen, '\0'); 201428415Speter 201528415Speter return Str; 201628415Speter} 201728415Speter 201828415Speter/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 201928415Speter/// constant array for the given string literal. 202028415Speterllvm::Constant * 202128415SpeterCodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 202228415Speter // FIXME: This can be more efficient. 202328415Speter // FIXME: We shouldn't need to bitcast the constant in the wide string case. 202428415Speter CharUnits Align = getContext().getTypeAlignInChars(S->getType()); 202528415Speter llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S), 202634768Speter /* GlobalName */ 0, 202728415Speter Align.getQuantity()); 202828415Speter if (S->isWide() || S->isUTF16() || S->isUTF32()) { 202928415Speter llvm::Type *DestTy = 203028415Speter llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType())); 203128415Speter C = llvm::ConstantExpr::getBitCast(C, DestTy); 203228415Speter } 203328415Speter return C; 203428415Speter} 203528415Speter 203628415Speter/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 203728415Speter/// array for the given ObjCEncodeExpr node. 203828415Speterllvm::Constant * 203928415SpeterCodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 204028415Speter std::string Str; 204128415Speter getContext().getObjCEncodingForType(E->getEncodedType(), Str); 204228415Speter 204328415Speter return GetAddrOfConstantCString(Str); 204428415Speter} 204528415Speter 204628415Speter 204728415Speter/// GenerateWritableString -- Creates storage for a string literal. 204828415Speterstatic llvm::GlobalVariable *GenerateStringLiteral(StringRef str, 204928415Speter bool constant, 205028415Speter CodeGenModule &CGM, 205128415Speter const char *GlobalName, 205228415Speter unsigned Alignment) { 205328415Speter // Create Constant for this string literal. Don't add a '\0'. 205428415Speter llvm::Constant *C = 205528415Speter llvm::ConstantArray::get(CGM.getLLVMContext(), str, false); 205628415Speter 205728415Speter // Create a global variable for this string 205828415Speter llvm::GlobalVariable *GV = 205928415Speter new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 206028415Speter llvm::GlobalValue::PrivateLinkage, 206128415Speter C, GlobalName); 206228415Speter GV->setAlignment(Alignment); 206328415Speter GV->setUnnamedAddr(true); 206428415Speter return GV; 206528415Speter} 206634768Speter 206734768Speter/// GetAddrOfConstantString - Returns a pointer to a character array 206834768Speter/// containing the literal. This contents are exactly that of the 206928415Speter/// given string, i.e. it will not be null terminated automatically; 207034768Speter/// see GetAddrOfConstantCString. Note that whether the result is 207128415Speter/// actually a pointer to an LLVM constant depends on 207234768Speter/// Feature.WriteableStrings. 207328415Speter/// 207428415Speter/// The result has pointer to array type. 207528415Speterllvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str, 207628415Speter const char *GlobalName, 207728415Speter unsigned Alignment) { 207828415Speter bool IsConstant = !Features.WritableStrings; 207928415Speter 208028415Speter // Get the default prefix if a name wasn't specified. 208134768Speter if (!GlobalName) 208234768Speter GlobalName = ".str"; 208328415Speter 208428415Speter // Don't share any string literals if strings aren't constant. 208528415Speter if (!IsConstant) 208628415Speter return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment); 208728415Speter 208828415Speter llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = 208928415Speter ConstantStringMap.GetOrCreateValue(Str); 209028415Speter 209134768Speter if (llvm::GlobalVariable *GV = Entry.getValue()) { 209228415Speter if (Alignment > GV->getAlignment()) { 209328415Speter GV->setAlignment(Alignment); 209428415Speter } 209528415Speter return GV; 209628415Speter } 209728415Speter 209828415Speter // Create a global variable for this. 209928415Speter llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName, Alignment); 210028415Speter Entry.setValue(GV); 210128415Speter return GV; 210228415Speter} 210328415Speter 210428415Speter/// GetAddrOfConstantCString - Returns a pointer to a character 210528415Speter/// array containing the literal and a terminating '\0' 210634768Speter/// character. The result has pointer to array type. 210728415Speterllvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str, 210828415Speter const char *GlobalName, 210928415Speter unsigned Alignment) { 211028415Speter StringRef StrWithNull(Str.c_str(), Str.size() + 1); 211128415Speter return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment); 211228415Speter} 211328415Speter 211434768Speter/// EmitObjCPropertyImplementations - Emit information for synthesized 211528415Speter/// properties for an implementation. 211628415Spetervoid CodeGenModule::EmitObjCPropertyImplementations(const 211728415Speter ObjCImplementationDecl *D) { 211828415Speter for (ObjCImplementationDecl::propimpl_iterator 211928415Speter i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 212028415Speter ObjCPropertyImplDecl *PID = *i; 212128415Speter 212228415Speter // Dynamic is just for type-checking. 212328415Speter if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 212428415Speter ObjCPropertyDecl *PD = PID->getPropertyDecl(); 212528415Speter 212628415Speter // Determine which methods need to be implemented, some may have 212728415Speter // been overridden. Note that ::isSynthesized is not the method 212828415Speter // we want, that just indicates if the decl came from a 212928415Speter // property. What we want to know is if the method is defined in 213028415Speter // this implementation. 213128415Speter if (!D->getInstanceMethod(PD->getGetterName())) 213234768Speter CodeGenFunction(*this).GenerateObjCGetter( 213328415Speter const_cast<ObjCImplementationDecl *>(D), PID); 213434768Speter if (!PD->isReadOnly() && 213528415Speter !D->getInstanceMethod(PD->getSetterName())) 213628415Speter CodeGenFunction(*this).GenerateObjCSetter( 213728415Speter const_cast<ObjCImplementationDecl *>(D), PID); 213828415Speter } 213928415Speter } 214034768Speter} 214128415Speter 214228415Speterstatic bool needsDestructMethod(ObjCImplementationDecl *impl) { 214334768Speter const ObjCInterfaceDecl *iface = impl->getClassInterface(); 214428415Speter for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 214528415Speter ivar; ivar = ivar->getNextIvar()) 214628415Speter if (ivar->getType().isDestructedType()) 214728415Speter return true; 214828415Speter 214928415Speter return false; 215028415Speter} 215128415Speter 215228415Speter/// EmitObjCIvarInitializations - Emit information for ivar initialization 215328415Speter/// for an implementation. 215428415Spetervoid CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 215528415Speter // We might need a .cxx_destruct even if we don't have any ivar initializers. 215628415Speter if (needsDestructMethod(D)) { 215728415Speter IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 215828415Speter Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 215928415Speter ObjCMethodDecl *DTORMethod = 216028415Speter ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 216128415Speter cxxSelector, getContext().VoidTy, 0, D, 216228415Speter /*isInstance=*/true, /*isVariadic=*/false, 216328415Speter /*isSynthesized=*/true, /*isImplicitlyDeclared=*/true, 216428415Speter /*isDefined=*/false, ObjCMethodDecl::Required); 216528415Speter D->addInstanceMethod(DTORMethod); 216628415Speter CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 216728415Speter D->setHasCXXStructors(true); 216828415Speter } 216928415Speter 217028415Speter // If the implementation doesn't have any ivar initializers, we don't need 217128415Speter // a .cxx_construct. 217228415Speter if (D->getNumIvarInitializers() == 0) 217328415Speter return; 217428415Speter 217528415Speter IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 217628415Speter Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 217728415Speter // The constructor returns 'self'. 217828415Speter ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 217928415Speter D->getLocation(), 218028415Speter D->getLocation(), 218128415Speter cxxSelector, 218228415Speter getContext().getObjCIdType(), 0, 218328415Speter D, /*isInstance=*/true, 218428415Speter /*isVariadic=*/false, 218528415Speter /*isSynthesized=*/true, 218628415Speter /*isImplicitlyDeclared=*/true, 218728415Speter /*isDefined=*/false, 218828415Speter ObjCMethodDecl::Required); 218928415Speter D->addInstanceMethod(CTORMethod); 219028415Speter CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 219128415Speter D->setHasCXXStructors(true); 219228415Speter} 219328415Speter 219428415Speter/// EmitNamespace - Emit all declarations in a namespace. 219528415Spetervoid CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 219628415Speter for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 219728415Speter I != E; ++I) 219828415Speter EmitTopLevelDecl(*I); 219928415Speter} 220028415Speter 220128415Speter// EmitLinkageSpec - Emit all declarations in a linkage spec. 220228415Spetervoid CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 220328415Speter if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 220428415Speter LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 220528415Speter ErrorUnsupported(LSD, "linkage spec"); 220628415Speter return; 220728415Speter } 220828415Speter 220928415Speter for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 221028415Speter I != E; ++I) 221128415Speter EmitTopLevelDecl(*I); 221228415Speter} 221328415Speter 221428415Speter/// EmitTopLevelDecl - Emit code for a single top level declaration. 221528415Spetervoid CodeGenModule::EmitTopLevelDecl(Decl *D) { 221628415Speter // If an error has occurred, stop code generation, but continue 221728415Speter // parsing and semantic analysis (to ensure all warnings and errors 221828415Speter // are emitted). 221928415Speter if (Diags.hasErrorOccurred()) 222028415Speter return; 222128415Speter 222228415Speter // Ignore dependent declarations. 222328415Speter if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 222428415Speter return; 222528415Speter 222628415Speter switch (D->getKind()) { 222728415Speter case Decl::CXXConversion: 222828415Speter case Decl::CXXMethod: 222928415Speter case Decl::Function: 223028415Speter // Skip function templates 223128415Speter if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 223228415Speter cast<FunctionDecl>(D)->isLateTemplateParsed()) 223328415Speter return; 223428415Speter 223528415Speter EmitGlobal(cast<FunctionDecl>(D)); 223628415Speter break; 223728415Speter 223828415Speter case Decl::Var: 223928415Speter EmitGlobal(cast<VarDecl>(D)); 224028415Speter break; 224128415Speter 224228415Speter // Indirect fields from global anonymous structs and unions can be 224328415Speter // ignored; only the actual variable requires IR gen support. 224428415Speter case Decl::IndirectField: 224528415Speter break; 224628415Speter 224728415Speter // C++ Decls 224828415Speter case Decl::Namespace: 224928415Speter EmitNamespace(cast<NamespaceDecl>(D)); 225028415Speter break; 225128415Speter // No code generation needed. 225228415Speter case Decl::UsingShadow: 225328415Speter case Decl::Using: 225428415Speter case Decl::UsingDirective: 225528415Speter case Decl::ClassTemplate: 225628415Speter case Decl::FunctionTemplate: 225728415Speter case Decl::TypeAliasTemplate: 225828415Speter case Decl::NamespaceAlias: 225928415Speter case Decl::Block: 226028415Speter break; 226128415Speter case Decl::CXXConstructor: 226228415Speter // Skip function templates 226328415Speter if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 226428415Speter cast<FunctionDecl>(D)->isLateTemplateParsed()) 226528415Speter return; 226628415Speter 226728415Speter EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 226828415Speter break; 226928415Speter case Decl::CXXDestructor: 227028415Speter if (cast<FunctionDecl>(D)->isLateTemplateParsed()) 227128415Speter return; 227228415Speter EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 227328415Speter break; 227428415Speter 227528415Speter case Decl::StaticAssert: 227628415Speter // Nothing to do. 227728415Speter break; 227828415Speter 227928415Speter // Objective-C Decls 228028415Speter 228128415Speter // Forward declarations, no (immediate) code generation. 228228415Speter case Decl::ObjCClass: 228328415Speter case Decl::ObjCForwardProtocol: 228428415Speter case Decl::ObjCInterface: 228528415Speter break; 228628415Speter 228728415Speter case Decl::ObjCCategory: { 228828415Speter ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D); 228928415Speter if (CD->IsClassExtension() && CD->hasSynthBitfield()) 229028415Speter Context.ResetObjCLayout(CD->getClassInterface()); 229128415Speter break; 229228415Speter } 229328415Speter 229428415Speter case Decl::ObjCProtocol: 229528415Speter ObjCRuntime->GenerateProtocol(cast<ObjCProtocolDecl>(D)); 229628415Speter break; 229728415Speter 229828415Speter case Decl::ObjCCategoryImpl: 229928415Speter // Categories have properties but don't support synthesize so we 230028415Speter // can ignore them here. 230128415Speter ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 230228415Speter break; 230328415Speter 230428415Speter case Decl::ObjCImplementation: { 230528415Speter ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 230628415Speter if (Features.ObjCNonFragileABI2 && OMD->hasSynthBitfield()) 230728415Speter Context.ResetObjCLayout(OMD->getClassInterface()); 230828415Speter EmitObjCPropertyImplementations(OMD); 230928415Speter EmitObjCIvarInitializations(OMD); 231028415Speter ObjCRuntime->GenerateClass(OMD); 231128415Speter break; 231228415Speter } 231328415Speter case Decl::ObjCMethod: { 231428415Speter ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 231528415Speter // If this is not a prototype, emit the body. 231628415Speter if (OMD->getBody()) 231728415Speter CodeGenFunction(*this).GenerateObjCMethod(OMD); 231828415Speter break; 231928415Speter } 232028415Speter case Decl::ObjCCompatibleAlias: 232128415Speter // compatibility-alias is a directive and has no code gen. 232228415Speter break; 232328415Speter 232428415Speter case Decl::LinkageSpec: 232528415Speter EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 232628415Speter break; 232728415Speter 232828415Speter case Decl::FileScopeAsm: { 232928415Speter FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 233028415Speter StringRef AsmString = AD->getAsmString()->getString(); 233128415Speter 233228415Speter const std::string &S = getModule().getModuleInlineAsm(); 233328415Speter if (S.empty()) 233428415Speter getModule().setModuleInlineAsm(AsmString); 233528415Speter else if (*--S.end() == '\n') 233628415Speter getModule().setModuleInlineAsm(S + AsmString.str()); 233728415Speter else 233828415Speter getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 233928415Speter break; 234028415Speter } 234128415Speter 234228415Speter default: 234328415Speter // Make sure we handled everything we should, every other kind is a 234428415Speter // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 234528415Speter // function. Need to recode Decl::Kind to do that easily. 234628415Speter assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 234728415Speter } 234828415Speter} 234928415Speter 235028415Speter/// Turns the given pointer into a constant. 235128415Speterstatic llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 235228415Speter const void *Ptr) { 235328415Speter uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 235428415Speter llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 235528415Speter return llvm::ConstantInt::get(i64, PtrInt); 235628415Speter} 235728415Speter 235828415Speterstatic void EmitGlobalDeclMetadata(CodeGenModule &CGM, 235928415Speter llvm::NamedMDNode *&GlobalMetadata, 236028415Speter GlobalDecl D, 236128415Speter llvm::GlobalValue *Addr) { 236228415Speter if (!GlobalMetadata) 236328415Speter GlobalMetadata = 236428415Speter CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 236534768Speter 236628415Speter // TODO: should we report variant information for ctors/dtors? 236728415Speter llvm::Value *Ops[] = { 236828415Speter Addr, 236928415Speter GetPointerConstant(CGM.getLLVMContext(), D.getDecl()) 237028415Speter }; 237128415Speter GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 237228415Speter} 237328415Speter 237428415Speter/// Emits metadata nodes associating all the global values in the 237528415Speter/// current module with the Decls they came from. This is useful for 237628415Speter/// projects using IR gen as a subroutine. 237728415Speter/// 237828415Speter/// Since there's currently no way to associate an MDNode directly 237928415Speter/// with an llvm::GlobalValue, we create a global named metadata 238028415Speter/// with the name 'clang.global.decl.ptrs'. 238128415Spetervoid CodeGenModule::EmitDeclMetadata() { 238228415Speter llvm::NamedMDNode *GlobalMetadata = 0; 238328415Speter 238428415Speter // StaticLocalDeclMap 238528415Speter for (llvm::DenseMap<GlobalDecl,StringRef>::iterator 238628415Speter I = MangledDeclNames.begin(), E = MangledDeclNames.end(); 238728415Speter I != E; ++I) { 238828415Speter llvm::GlobalValue *Addr = getModule().getNamedValue(I->second); 238928415Speter EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr); 239028415Speter } 239128415Speter} 239228415Speter 239328415Speter/// Emits metadata nodes for all the local variables in the current 239428415Speter/// function. 239528415Spetervoid CodeGenFunction::EmitDeclMetadata() { 239628415Speter if (LocalDeclMap.empty()) return; 239728415Speter 239828415Speter llvm::LLVMContext &Context = getLLVMContext(); 239928415Speter 240028415Speter // Find the unique metadata ID for this name. 240128415Speter unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 240228415Speter 240328415Speter llvm::NamedMDNode *GlobalMetadata = 0; 240428415Speter 240528415Speter for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator 240628415Speter I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) { 240728415Speter const Decl *D = I->first; 240828415Speter llvm::Value *Addr = I->second; 240928415Speter 241028415Speter if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 241128415Speter llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 241228415Speter Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); 241328415Speter } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 241428415Speter GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 241528415Speter EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 241628415Speter } 241728415Speter } 241828415Speter} 241928415Speter 242028415Spetervoid CodeGenModule::EmitCoverageFile() { 242128415Speter if (!getCodeGenOpts().CoverageFile.empty()) { 242228415Speter if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { 242328415Speter llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 242428415Speter llvm::LLVMContext &Ctx = TheModule.getContext(); 242528415Speter llvm::MDString *CoverageFile = 242628415Speter llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile); 242728415Speter for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 242828415Speter llvm::MDNode *CU = CUNode->getOperand(i); 242928415Speter llvm::Value *node[] = { CoverageFile, CU }; 243028415Speter llvm::MDNode *N = llvm::MDNode::get(Ctx, node); 243128415Speter GCov->addOperand(N); 243228415Speter } 243328415Speter } 243428415Speter } 243528415Speter} 243628415Speter