CodeGenModule.cpp revision 109dfc6ca6652f60c55ed0f2631aebf323d0200d
1ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===// 2ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// 3ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// The LLVM Compiler Infrastructure 4ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// 5ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// This file is distributed under the University of Illinois Open Source 6ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// License. See LICENSE.TXT for details. 7ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// 8ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown//===----------------------------------------------------------------------===// 9ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// 10ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// This coordinates the per-module state used while generating code. 11ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// 12ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown//===----------------------------------------------------------------------===// 13ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 14ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "CodeGenModule.h" 15ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "CGDebugInfo.h" 16ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "CodeGenFunction.h" 17ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "CGCall.h" 18ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "CGObjCRuntime.h" 19ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "Mangle.h" 20ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "TargetInfo.h" 21ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/CodeGen/CodeGenOptions.h" 22ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/AST/ASTContext.h" 23ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/AST/CharUnits.h" 24ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/AST/DeclObjC.h" 25ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/AST/DeclCXX.h" 26ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/AST/RecordLayout.h" 27ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/Basic/Builtins.h" 28ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/Basic/Diagnostic.h" 29ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/Basic/SourceManager.h" 30ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/Basic/TargetInfo.h" 31ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "clang/Basic/ConvertUTF.h" 32ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/CallingConv.h" 33ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/Module.h" 34ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/Intrinsics.h" 35ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/LLVMContext.h" 36ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/ADT/Triple.h" 37ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/Target/TargetData.h" 38ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/Support/CallSite.h" 39ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "llvm/Support/ErrorHandling.h" 40ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownusing namespace clang; 41ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownusing namespace CodeGen; 42ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 43ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 44ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 45ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Module &M, const llvm::TargetData &TD, 46ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Diagnostic &diags) 47ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown : BlockModule(C, M, TD, Types, *this), Context(C), 48ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M), 49ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags), 50ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Types(C, M, TD, getTargetCodeGenInfo().getABIInfo()), 51ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleCtx(C, diags), VTables(*this), Runtime(0), 52ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CFConstantStringClassRef(0), 53ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NSConstantStringClassRef(0), 54ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VMContext(M.getContext()) { 55ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 56ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Features.ObjC1) 57ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = 0; 58ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (!Features.NeXTRuntime) 59ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = CreateGNUObjCRuntime(*this); 60ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (Features.ObjCNonFragileABI) 61ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = CreateMacNonFragileABIObjCRuntime(*this); 62ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 63ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = CreateMacObjCRuntime(*this); 64ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 65ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If debug info generation is enabled, create the CGDebugInfo object. 66ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DebugInfo = CodeGenOpts.DebugInfo ? new CGDebugInfo(*this) : 0; 67ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 68ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 69ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::~CodeGenModule() { 70ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown delete Runtime; 71ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown delete DebugInfo; 72ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 73ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 74ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::createObjCRuntime() { 75ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Features.NeXTRuntime) 76ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = CreateGNUObjCRuntime(*this); 77ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (Features.ObjCNonFragileABI) 78ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = CreateMacNonFragileABIObjCRuntime(*this); 79ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 80ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime = CreateMacObjCRuntime(*this); 81ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 82ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 83ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::Release() { 84ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitDeferred(); 85ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCXXGlobalInitFunc(); 86ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCXXGlobalDtorFunc(); 87ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Runtime) 88ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction()) 89ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AddGlobalCtor(ObjCInitFunction); 90ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCtorList(GlobalCtors, "llvm.global_ctors"); 91ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCtorList(GlobalDtors, "llvm.global_dtors"); 92ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitAnnotations(); 93ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitLLVMUsed(); 94ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 95ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 96ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownbool CodeGenModule::isTargetDarwin() const { 97ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getContext().Target.getTriple().getOS() == llvm::Triple::Darwin; 98ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 99ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 100ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// ErrorUnsupported - Print out an error that codegen doesn't support the 101ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// specified stmt yet. 102ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 103ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool OmitOnError) { 104ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (OmitOnError && getDiags().hasErrorOccurred()) 105ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 106ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 107ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "cannot compile this %0 yet"); 108ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::string Msg = Type; 109ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 110ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown << Msg << S->getSourceRange(); 111ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 112ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 113ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// ErrorUnsupported - Print out an error that codegen doesn't support the 114ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// specified decl yet. 115ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 116ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool OmitOnError) { 117ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (OmitOnError && getDiags().hasErrorOccurred()) 118ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 119ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 120ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "cannot compile this %0 yet"); 121ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::string Msg = Type; 122ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 123ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 124ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 125ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownLangOptions::VisibilityMode 126ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::getDeclVisibilityMode(const Decl *D) const { 127ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 128ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (VD->getStorageClass() == VarDecl::PrivateExtern) 129ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return LangOptions::Hidden; 130ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 131ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) { 132ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (attr->getVisibility()) { 133ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown default: assert(0 && "Unknown visibility!"); 134ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case VisibilityAttr::DefaultVisibility: 135ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return LangOptions::Default; 136ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case VisibilityAttr::HiddenVisibility: 137ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return LangOptions::Hidden; 138ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case VisibilityAttr::ProtectedVisibility: 139ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return LangOptions::Protected; 140ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 141ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 142ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 143ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This decl should have the same visibility as its parent. 144ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const DeclContext *DC = D->getDeclContext()) 145ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getDeclVisibilityMode(cast<Decl>(DC)); 146ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 147ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getLangOptions().getVisibilityMode(); 148ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 149ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 150ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 151ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const Decl *D) const { 152ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Internal definitions always have default visibility. 153ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (GV->hasLocalLinkage()) { 154ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 155ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 156ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 157ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 158ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (getDeclVisibilityMode(D)) { 159ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown default: assert(0 && "Unknown visibility!"); 160ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case LangOptions::Default: 161ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 162ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case LangOptions::Hidden: 163ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 164ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case LangOptions::Protected: 165ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GV->setVisibility(llvm::GlobalValue::ProtectedVisibility); 166ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 167ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 168ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 169ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::getMangledName(MangleBuffer &Buffer, GlobalDecl GD) { 170ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); 171ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 172ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 173ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getMangledCXXCtorName(Buffer, D, GD.getCtorType()); 174ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 175ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getMangledCXXDtorName(Buffer, D, GD.getDtorType()); 176ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 177ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getMangledName(Buffer, ND); 178ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 179ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 180ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// \brief Retrieves the mangled name for the given declaration. 181ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 182ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// If the given declaration requires a mangled name, returns an 183ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// const char* containing the mangled name. Otherwise, returns 184ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// the unmangled name. 185ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 186ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::getMangledName(MangleBuffer &Buffer, 187ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const NamedDecl *ND) { 188ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!getMangleContext().shouldMangleDeclName(ND)) { 189ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(ND->getIdentifier() && "Attempt to mangle unnamed decl."); 190ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Buffer.setString(ND->getNameAsCString()); 191ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 192ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 193ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 194ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangleContext().mangleName(ND, Buffer.getBuffer()); 195ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 196ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 197ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::GlobalValue *CodeGenModule::GetGlobalValue(llvm::StringRef Name) { 198ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getModule().getNamedValue(Name); 199ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 200ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 201ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// AddGlobalCtor - Add a function to the list that will be called before 202ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// main() runs. 203ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 204ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Type coercion of void()* types. 205ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 206ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 207ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 208ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// AddGlobalDtor - Add a function to the list that will be called 209ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// when the module is unloaded. 210ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 211ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Type coercion of void()* types. 212ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 213ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 214ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 215ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 216ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Ctor function type is void()*. 217ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::FunctionType* CtorFTy = 218ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 219ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<const llvm::Type*>(), 220ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown false); 221ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 222ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 223ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Get the type of a ctor entry, { i32, void ()* }. 224ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StructType* CtorStructTy = 225ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext), 226ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::PointerType::getUnqual(CtorFTy), NULL); 227ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 228ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Construct the constructor and destructor arrays. 229ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<llvm::Constant*> Ctors; 230ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 231ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<llvm::Constant*> S; 232ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 233ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown I->second, false)); 234ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)); 235ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 236ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 237ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 238ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Ctors.empty()) { 239ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 240ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(TheModule, AT, false, 241ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::AppendingLinkage, 242ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantArray::get(AT, Ctors), 243ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GlobalName); 244ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 245ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 246ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 247ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitAnnotations() { 248ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Annotations.empty()) 249ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 250ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 251ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create a new global variable for the ConstantStruct in the Module. 252ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Array = 253ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(), 254ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Annotations.size()), 255ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Annotations); 256ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *gv = 257ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(TheModule, Array->getType(), false, 258ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::AppendingLinkage, Array, 259ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "llvm.global.annotations"); 260ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown gv->setSection("llvm.metadata"); 261ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 262ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 263ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic CodeGenModule::GVALinkage 264ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownGetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD, 265ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const LangOptions &Features) { 266ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenModule::GVALinkage External = CodeGenModule::GVA_StrongExternal; 267ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 268ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage L = FD->getLinkage(); 269ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (L == ExternalLinkage && Context.getLangOptions().CPlusPlus && 270ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FD->getType()->getLinkage() == UniqueExternalLinkage) 271ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown L = UniqueExternalLinkage; 272ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 273ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (L) { 274ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case NoLinkage: 275ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case InternalLinkage: 276ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case UniqueExternalLinkage: 277ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_Internal; 278ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 279ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case ExternalLinkage: 280ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (FD->getTemplateSpecializationKind()) { 281ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_Undeclared: 282ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitSpecialization: 283ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown External = CodeGenModule::GVA_StrongExternal; 284ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 285ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 286ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDefinition: 287ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_ExplicitTemplateInstantiation; 288ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 289ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDeclaration: 290ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ImplicitInstantiation: 291ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown External = CodeGenModule::GVA_TemplateInstantiation; 292ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 293ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 294ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 295ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 296ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!FD->isInlined()) 297ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return External; 298ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 299ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Features.CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 300ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // GNU or C99 inline semantics. Determine whether this symbol should be 301ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // externally visible. 302ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD->isInlineDefinitionExternallyVisible()) 303ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return External; 304ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 305ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // C99 inline semantics, where the symbol is not externally visible. 306ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_C99Inline; 307ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 308ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 309ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // C++0x [temp.explicit]p9: 310ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // [ Note: The intent is that an inline function that is the subject of 311ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // an explicit instantiation declaration will still be implicitly 312ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // instantiated when used so that the body can be considered for 313ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // inlining, but that no out-of-line copy of the inline function would be 314ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // generated in the translation unit. -- end note ] 315ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD->getTemplateSpecializationKind() 316ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown == TSK_ExplicitInstantiationDeclaration) 317ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_C99Inline; 318ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 319ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this is a virtual method and its class has a key method in another 320ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // translation unit, we know that this method will be present in that 321ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // translation unit. In this translation unit we will use this method 322ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // only for inlining and analysis. This is the semantics of c99 inline. 323ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 324ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const CXXRecordDecl *RD = MD->getParent(); 325ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (MD->isVirtual() && 326ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenVTables::isKeyFunctionInAnotherTU(Context, RD)) 327ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_C99Inline; 328ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 329ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 330ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_CXXInline; 331ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 332ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 333ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::GlobalValue::LinkageTypes 334ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::getFunctionLinkage(const FunctionDecl *D) { 335ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features); 336ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 337ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Linkage == GVA_Internal) { 338ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::InternalLinkage; 339ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (D->hasAttr<DLLExportAttr>()) { 340ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::DLLExportLinkage; 341ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (D->hasAttr<WeakAttr>()) { 342ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::WeakAnyLinkage; 343ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (Linkage == GVA_C99Inline) { 344ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // In C99 mode, 'inline' functions are guaranteed to have a strong 345ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // definition somewhere else, so we can use available_externally linkage. 346ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::AvailableExternallyLinkage; 347ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) { 348ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // In C++, the compiler has to emit a definition in every translation unit 349ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // that references the function. We should use linkonce_odr because 350ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // a) if all references in this translation unit are optimized away, we 351ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // don't need to codegen it. b) if the function persists, it needs to be 352ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // merged with other definitions. c) C++ has the ODR, so we know the 353ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // definition is dependable. 354ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::LinkOnceODRLinkage; 355ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (Linkage == GVA_ExplicitTemplateInstantiation) { 356ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // An explicit instantiation of a template has weak linkage, since 357ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // explicit instantiations can occur in multiple translation units 358ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // and must all be equivalent. However, we are not allowed to 359ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // throw away these explicit instantiations. 360ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::WeakODRLinkage; 361ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 362ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(Linkage == GVA_StrongExternal); 363ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Otherwise, we have strong external linkage. 364ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Function::ExternalLinkage; 365ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 366ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 367ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 368ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 369ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// SetFunctionDefinitionAttributes - Set attributes for a global. 370ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 371ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// FIXME: This is currently only done for aliases and functions, but not for 372ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// variables (these details are set in EmitGlobalVarDefinition for variables). 373ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 374ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *GV) { 375ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(getFunctionLinkage(D)); 376ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetCommonAttributes(D, GV); 377ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 378ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 379ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 380ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const CGFunctionInfo &Info, 381ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *F) { 382ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned CallingConv; 383ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AttributeListType AttributeList; 384ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ConstructAttributeList(Info, D, AttributeList, CallingConv); 385ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(), 386ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AttributeList.size())); 387ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 388ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 389ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 390ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 391ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *F) { 392ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Features.Exceptions && !Features.ObjCNonFragileABI) 393ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->addFnAttr(llvm::Attribute::NoUnwind); 394ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 395ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->hasAttr<AlwaysInlineAttr>()) 396ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->addFnAttr(llvm::Attribute::AlwaysInline); 397ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 398ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->hasAttr<NoInlineAttr>()) 399ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->addFnAttr(llvm::Attribute::NoInline); 400ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 401ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Features.getStackProtectorMode() == LangOptions::SSPOn) 402ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->addFnAttr(llvm::Attribute::StackProtect); 403ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (Features.getStackProtectorMode() == LangOptions::SSPReq) 404ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->addFnAttr(llvm::Attribute::StackProtectReq); 405ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 406ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const AlignedAttr *AA = D->getAttr<AlignedAttr>()) { 407ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned width = Context.Target.getCharWidth(); 408ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setAlignment(AA->getAlignment() / width); 409ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown while ((AA = AA->getNext<AlignedAttr>())) 410ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setAlignment(std::max(F->getAlignment(), AA->getAlignment() / width)); 411ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 412ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // C++ ABI requires 2-byte alignment for member functions. 413ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 414ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setAlignment(2); 415ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 416ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 417ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::SetCommonAttributes(const Decl *D, 418ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *GV) { 419ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown setGlobalVisibility(GV, D); 420ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 421ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->hasAttr<UsedAttr>()) 422ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AddUsedGlobal(GV); 423ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 424ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 425ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setSection(SA->getName()); 426ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 427ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this); 428ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 429ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 430ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 431ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *F, 432ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const CGFunctionInfo &FI) { 433ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetLLVMFunctionAttributes(D, FI, F); 434ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetLLVMFunctionAttributesForDefinition(D, F); 435ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 436ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setLinkage(llvm::Function::InternalLinkage); 437ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 438ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetCommonAttributes(D, F); 439ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 440ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 441ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::SetFunctionAttributes(GlobalDecl GD, 442ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *F, 443ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool IsIncompleteFunction) { 444ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 445ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 446ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!IsIncompleteFunction) 447ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F); 448ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 449ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Only a few attributes are set on declarations; these may later be 450ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // overridden by a definition. 451ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 452ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD->hasAttr<DLLImportAttr>()) { 453ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setLinkage(llvm::Function::DLLImportLinkage); 454ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (FD->hasAttr<WeakAttr>() || 455ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FD->hasAttr<WeakImportAttr>()) { 456ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // "extern_weak" is overloaded in LLVM; we probably should have 457ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // separate linkage types for this. 458ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setLinkage(llvm::Function::ExternalWeakLinkage); 459ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 460ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setLinkage(llvm::Function::ExternalLinkage); 461ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 462ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 463ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 464ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setSection(SA->getName()); 465ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 466ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 467ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 468ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(!GV->isDeclaration() && 469ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "Only globals with definition can force usage."); 470ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown LLVMUsed.push_back(GV); 471ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 472ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 473ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitLLVMUsed() { 474ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Don't create llvm.used if there is no need. 475ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (LLVMUsed.empty()) 476ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 477ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 478ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 479ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 480ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Convert LLVMUsed to what ConstantArray needs. 481ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<llvm::Constant*> UsedArray; 482ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UsedArray.resize(LLVMUsed.size()); 483ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 484ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UsedArray[i] = 485ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 486ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown i8PTy); 487ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 488ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 489ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (UsedArray.empty()) 490ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 491ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size()); 492ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 493ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable *GV = 494ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(getModule(), ATy, false, 495ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::AppendingLinkage, 496ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantArray::get(ATy, UsedArray), 497ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "llvm.used"); 498ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 499ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setSection("llvm.metadata"); 500ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 501ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 502ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitDeferred() { 503ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Emit code for any potentially referenced deferred decls. Since a 504ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // previously unused static decl may become used during the generation of code 505ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // for a static function, iterate until no changes are made. 506ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 507ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) { 508ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!DeferredVTables.empty()) { 509ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const CXXRecordDecl *RD = DeferredVTables.back(); 510ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredVTables.pop_back(); 511ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getVTables().GenerateClassData(getVTableLinkage(RD), RD); 512ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown continue; 513ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 514ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 515ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GlobalDecl D = DeferredDeclsToEmit.back(); 516ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.pop_back(); 517ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 518ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Look it up to see if it was defined with a stronger definition (e.g. an 519ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // extern inline function with a strong function redefinition). If so, 520ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // just ignore the deferred decl. 521ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleBuffer Name; 522ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangledName(Name, D); 523ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *CGRef = GetGlobalValue(Name); 524ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(CGRef && "Deferred decl wasn't referenced?"); 525ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 526ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!CGRef->isDeclaration()) 527ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown continue; 528ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 529ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Otherwise, emit the definition and move on to the next one. 530ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitGlobalDefinition(D); 531ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 532ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 533ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 534ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 535ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// annotation information for a given GlobalValue. The annotation struct is 536ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 537ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GlobalValue being annotated. The second field is the constant string 538ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// created from the AnnotateAttr's annotation. The third field is a constant 539ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// string containing the name of the translation unit. The fourth field is 540ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// the line number in the file of the annotated value declaration. 541ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 542ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// FIXME: this does not unique the annotation string constants, as llvm-gcc 543ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// appears to. 544ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 545ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 546ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const AnnotateAttr *AA, 547ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned LineNo) { 548ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Module *M = &getModule(); 549ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 550ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // get [N x i8] constants for the annotation string, and the filename string 551ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // which are the 2nd and 3rd elements of the global annotation structure. 552ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext); 553ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *anno = llvm::ConstantArray::get(VMContext, 554ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AA->getAnnotation(), true); 555ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *unit = llvm::ConstantArray::get(VMContext, 556ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown M->getModuleIdentifier(), 557ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown true); 558ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 559ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Get the two global values corresponding to the ConstantArrays we just 560ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // created to hold the bytes of the strings. 561ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *annoGV = 562ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(*M, anno->getType(), false, 563ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::PrivateLinkage, anno, 564ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->getName()); 565ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // translation unit name string, emitted into the llvm.metadata section. 566ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *unitGV = 567ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(*M, unit->getType(), false, 568ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::PrivateLinkage, unit, 569ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ".str"); 570ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 571ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create the ConstantStruct for the global annotation. 572ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Fields[4] = { 573ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getBitCast(GV, SBP), 574ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getBitCast(annoGV, SBP), 575ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getBitCast(unitGV, SBP), 576ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo) 577ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown }; 578ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::ConstantStruct::get(VMContext, Fields, 4, false); 579ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 580ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 581ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownbool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 582ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Never defer when EmitAllDecls is specified or the decl has 583ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // attribute used. 584ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Features.EmitAllDecls || Global->hasAttr<UsedAttr>()) 585ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 586ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 587ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 588ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Constructors and destructors should never be deferred. 589ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD->hasAttr<ConstructorAttr>() || 590ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FD->hasAttr<DestructorAttr>()) 591ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 592ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 593ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // The key function for a class must never be deferred. 594ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Global)) { 595ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const CXXRecordDecl *RD = MD->getParent(); 596ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (MD->isOutOfLine() && RD->isDynamicClass()) { 597ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const CXXMethodDecl *KeyFunction = getContext().getKeyFunction(RD); 598ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (KeyFunction && 599ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown KeyFunction->getCanonicalDecl() == MD->getCanonicalDecl()) 600ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 601ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 602ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 603ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 604ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features); 605ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 606ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // static, static inline, always_inline, and extern inline functions can 607ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // always be deferred. Normal inline functions can be deferred in C99/C++. 608ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Implicit template instantiations can also be deferred in C++. 609ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 610ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 611ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return true; 612ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 613ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 614ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 615ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const VarDecl *VD = cast<VarDecl>(Global); 616ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(VD->isFileVarDecl() && "Invalid decl"); 617ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 618ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // We never want to defer structs that have non-trivial constructors or 619ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // destructors. 620ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 621ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Handle references. 622ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 623ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 624ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor()) 625ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 626ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 627ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 628ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 629ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Static data may be deferred, but out-of-line static data members 630ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // cannot be. 631ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage L = VD->getLinkage(); 632ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (L == ExternalLinkage && getContext().getLangOptions().CPlusPlus && 633ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VD->getType()->getLinkage() == UniqueExternalLinkage) 634ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown L = UniqueExternalLinkage; 635ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 636ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (L) { 637ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case NoLinkage: 638ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case InternalLinkage: 639ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case UniqueExternalLinkage: 640ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Initializer has side effects? 641ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (VD->getInit() && VD->getInit()->HasSideEffects(Context)) 642ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 643ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return !(VD->isStaticDataMember() && VD->isOutOfLine()); 644ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 645ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case ExternalLinkage: 646ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 647ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 648ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 649ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 650ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 651ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 652ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 653ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const AliasAttr *AA = VD->getAttr<AliasAttr>(); 654ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(AA && "No alias?"); 655ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 656ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 657ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 658ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // See if there is already something with the target's name in the module. 659ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 660ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 661ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Aliasee; 662ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isa<llvm::FunctionType>(DeclTy)) 663ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl()); 664ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 665ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 666ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::PointerType::getUnqual(DeclTy), 0); 667ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Entry) { 668ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); 669ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown F->setLinkage(llvm::Function::ExternalWeakLinkage); 670ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown WeakRefReferences.insert(F); 671ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 672ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 673ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Aliasee; 674ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 675ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 676ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitGlobal(GlobalDecl GD) { 677ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); 678ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 679ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Weak references don't produce any output by themselves. 680ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Global->hasAttr<WeakRefAttr>()) 681ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 682ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 683ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this is an alias definition (which otherwise looks like a declaration) 684ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // emit it now. 685ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Global->hasAttr<AliasAttr>()) 686ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return EmitAliasDefinition(GD); 687ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 688ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Ignore declarations, they will be emitted on their first use. 689ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 690ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Forward declarations are emitted lazily on first use. 691ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!FD->isThisDeclarationADefinition()) 692ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 693ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 694ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const VarDecl *VD = cast<VarDecl>(Global); 695ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 696ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 697ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (VD->isThisDeclarationADefinition() != VarDecl::Definition) 698ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 699ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 700ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 701ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Defer code generation when possible if this is a static definition, inline 702ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // function etc. These we only want to emit if they are used. 703ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!MayDeferGeneration(Global)) { 704ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Emit the definition if it can't be deferred. 705ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitGlobalDefinition(GD); 706ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 707ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 708ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 709ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If the value has already been used, add it directly to the 710ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // DeferredDeclsToEmit list. 711ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleBuffer MangledName; 712ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangledName(MangledName, GD); 713ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (GetGlobalValue(MangledName)) 714ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(GD); 715ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else { 716ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Otherwise, remember that we saw a deferred decl with this name. The 717ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // first use of the mangled name will cause it to move into 718ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // DeferredDeclsToEmit. 719ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDecls[MangledName] = GD; 720ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 721ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 722ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 723ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 724ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 725ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 726ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 727ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Context.getSourceManager(), 728ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "Generating code for declaration"); 729ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 730ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isa<CXXMethodDecl>(D)) 731ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getVTables().EmitVTableRelatedData(GD); 732ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 733ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 734ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return EmitCXXConstructor(CD, GD.getCtorType()); 735ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 736ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) 737ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return EmitCXXDestructor(DD, GD.getDtorType()); 738ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 739ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isa<FunctionDecl>(D)) 740ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return EmitGlobalFunctionDefinition(GD); 741ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 742ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 743ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return EmitGlobalVarDefinition(VD); 744ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 745ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(0 && "Invalid argument to EmitGlobalDefinition()"); 746ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 747ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 748ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetOrCreateLLVMFunction - If the specified mangled name is not in the 749ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// module, create and return an llvm Function with the specified type. If there 750ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// is something in the module with the specified name, return it potentially 751ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// bitcasted to the right type. 752ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 753ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// If D is non-null, it specifies a decl that correspond to this. This is used 754ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// to set the attributes on the function when it is first created. 755ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 756ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::GetOrCreateLLVMFunction(llvm::StringRef MangledName, 757ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty, 758ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GlobalDecl D) { 759ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Lookup the entry, lazily creating it if necessary. 760ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 761ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry) { 762ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (WeakRefReferences.count(Entry)) { 763ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl()); 764ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD && !FD->hasAttr<WeakAttr>()) 765ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->setLinkage(llvm::Function::ExternalLinkage); 766ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 767ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown WeakRefReferences.erase(Entry); 768ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 769ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 770ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry->getType()->getElementType() == Ty) 771ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Entry; 772ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 773ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Make sure the result is of the correct type. 774ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 775ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::ConstantExpr::getBitCast(Entry, PTy); 776ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 777ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 778ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This function doesn't have a complete type (for example, the return 779ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // type is an incomplete struct). Use a fake type instead, and make 780ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // sure not to try to set attributes. 781ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool IsIncompleteFunction = false; 782ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 783ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::FunctionType *FTy; 784ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isa<llvm::FunctionType>(Ty)) { 785ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FTy = cast<llvm::FunctionType>(Ty); 786ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 787ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 788ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<const llvm::Type*>(), false); 789ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown IsIncompleteFunction = true; 790ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 791ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *F = llvm::Function::Create(FTy, 792ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function::ExternalLinkage, 793ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangledName, &getModule()); 794ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(F->getName() == MangledName && "name was uniqued!"); 795ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D.getDecl()) 796ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetFunctionAttributes(D, F, IsIncompleteFunction); 797ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 798ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This is the first use or definition of a mangled name. If there is a 799ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // deferred decl with this name, remember that we need to emit it at the end 800ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // of the file. 801ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 802ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (DDI != DeferredDecls.end()) { 803ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 804ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // list, and remove it from DeferredDecls (since we don't need it anymore). 805ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(DDI->second); 806ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDecls.erase(DDI); 807ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl())) { 808ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this the first reference to a C++ inline function in a class, queue up 809ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // the deferred function body for emission. These are not seen as 810ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // top-level declarations. 811ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD->isThisDeclarationADefinition() && MayDeferGeneration(FD)) 812ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(D); 813ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // A called constructor which has no definition or declaration need be 814ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // synthesized. 815ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) { 816ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (CD->isImplicit()) { 817ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(CD->isUsed() && "Sema doesn't consider constructor as used."); 818ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(D); 819ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 820ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD)) { 821ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (DD->isImplicit()) { 822ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(DD->isUsed() && "Sema doesn't consider destructor as used."); 823ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(D); 824ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 825ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 826ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (MD->isCopyAssignment() && MD->isImplicit()) { 827ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(MD->isUsed() && "Sema doesn't consider CopyAssignment as used."); 828ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(D); 829ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 830ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 831ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 832ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 833ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Make sure the result is of the requested type. 834ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!IsIncompleteFunction) { 835ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(F->getType()->getElementType() == Ty); 836ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return F; 837ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 838ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 839ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 840ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::ConstantExpr::getBitCast(F, PTy); 841ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 842ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 843ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetAddrOfFunction - Return the address of the given function. If Ty is 844ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// non-null, then this function will use the specified type if it has to 845ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// create it (this occurs when we see a definition of the function). 846ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 847ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty) { 848ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If there was no specific requested type, just convert it now. 849ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Ty) 850ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 851ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleBuffer MangledName; 852ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangledName(MangledName, GD); 853ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetOrCreateLLVMFunction(MangledName, Ty, GD); 854ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 855ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 856ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// CreateRuntimeFunction - Create a new runtime function with the specified 857ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// type and name. 858ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 859ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy, 860ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringRef Name) { 861ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl()); 862ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 863ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 864ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D) { 865ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType()) 866ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 867ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Context.getLangOptions().CPlusPlus && 868ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Context.getBaseElementType(D->getType())->getAs<RecordType>()) { 869ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: We should do something fancier here! 870ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return false; 871ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 872ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return true; 873ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 874ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 875ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 876ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// create and return an llvm GlobalVariable with the specified type. If there 877ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// is something in the module with the specified name, return it potentially 878ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// bitcasted to the right type. 879ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 880ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// If D is non-null, it specifies a decl that correspond to this. This is used 881ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// to set the attributes on the global when it is first created. 882ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 883ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::GetOrCreateLLVMGlobal(llvm::StringRef MangledName, 884ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::PointerType *Ty, 885ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const VarDecl *D) { 886ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Lookup the entry, lazily creating it if necessary. 887ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 888ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry) { 889ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (WeakRefReferences.count(Entry)) { 890ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D && !D->hasAttr<WeakAttr>()) 891ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->setLinkage(llvm::Function::ExternalLinkage); 892ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 893ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown WeakRefReferences.erase(Entry); 894ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 895ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 896ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry->getType() == Ty) 897ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Entry; 898ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 899ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Make sure the result is of the correct type. 900ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::ConstantExpr::getBitCast(Entry, Ty); 901ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 902ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 903ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This is the first use or definition of a mangled name. If there is a 904ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // deferred decl with this name, remember that we need to emit it at the end 905ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // of the file. 906ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 907ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (DDI != DeferredDecls.end()) { 908ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 909ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // list, and remove it from DeferredDecls (since we don't need it anymore). 910ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDeclsToEmit.push_back(DDI->second); 911ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDecls.erase(DDI); 912ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 913ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 914ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable *GV = 915ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 916ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::ExternalLinkage, 917ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 0, MangledName, 0, 918ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown false, Ty->getAddressSpace()); 919ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 920ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Handle things which are present even on external declarations. 921ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D) { 922ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: This code is overly simple and should be merged with other global 923ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // handling. 924ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setConstant(DeclIsConstantGlobal(Context, D)); 925ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 926ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Merge with other attribute handling code. 927ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->getStorageClass() == VarDecl::PrivateExtern) 928ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 929ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 930ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->hasAttr<WeakAttr>() || 931ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->hasAttr<WeakImportAttr>()) 932ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 933ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 934ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setThreadLocal(D->isThreadSpecified()); 935ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 936ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 937ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GV; 938ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 939ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 940ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 941ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 942ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// given global variable. If Ty is non-null and if the global doesn't exist, 943ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// then it will be greated with the specified type instead of whatever the 944ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// normal requested type would be. 945ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 946ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty) { 947ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(D->hasGlobalStorage() && "Not a global variable"); 948ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown QualType ASTTy = D->getType(); 949ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Ty == 0) 950ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ty = getTypes().ConvertTypeForMem(ASTTy); 951ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 952ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::PointerType *PTy = 953ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::PointerType::get(Ty, ASTTy.getAddressSpace()); 954ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 955ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleBuffer MangledName; 956ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangledName(MangledName, D); 957ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetOrCreateLLVMGlobal(MangledName, PTy, D); 958ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 959ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 960ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// CreateRuntimeVariable - Create a new runtime global variable with the 961ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// specified type and name. 962ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 963ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty, 964ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringRef Name) { 965ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0); 966ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 967ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 968ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 969ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(!D->getInit() && "Cannot emit definite definitions here!"); 970ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 971ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (MayDeferGeneration(D)) { 972ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If we have not seen a reference to this variable yet, place it 973ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // into the deferred declarations table to be emitted if needed 974ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // later. 975ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleBuffer MangledName; 976ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangledName(MangledName, D); 977ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!GetGlobalValue(MangledName)) { 978ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeferredDecls[MangledName] = D; 979ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 980ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 981ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 982ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 983ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // The tentative definition is the only definition. 984ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitGlobalVarDefinition(D); 985ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 986ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 987ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::GlobalVariable::LinkageTypes 988ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { 989ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (RD->isInAnonymousNamespace() || !RD->hasLinkage()) 990ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::InternalLinkage; 991ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 992ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const CXXMethodDecl *KeyFunction 993ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown = RD->getASTContext().getKeyFunction(RD)) { 994ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this class has a key function, use that to determine the linkage of 995ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // the vtable. 996ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const FunctionDecl *Def = 0; 997ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (KeyFunction->getBody(Def)) 998ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown KeyFunction = cast<CXXMethodDecl>(Def); 999ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1000ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (KeyFunction->getTemplateSpecializationKind()) { 1001ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_Undeclared: 1002ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitSpecialization: 1003ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (KeyFunction->isInlined()) 1004ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::WeakODRLinkage; 1005ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1006ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::ExternalLinkage; 1007ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1008ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ImplicitInstantiation: 1009ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDefinition: 1010ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::WeakODRLinkage; 1011ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1012ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDeclaration: 1013ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Use available_externally linkage. However, this currently 1014ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // breaks LLVM's build due to undefined symbols. 1015ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // return llvm::GlobalVariable::AvailableExternallyLinkage; 1016ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::WeakODRLinkage; 1017ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1018ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1019ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1020ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (RD->getTemplateSpecializationKind()) { 1021ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_Undeclared: 1022ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitSpecialization: 1023ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ImplicitInstantiation: 1024ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDefinition: 1025ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::WeakODRLinkage; 1026ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1027ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDeclaration: 1028ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Use available_externally linkage. However, this currently 1029ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // breaks LLVM's build due to undefined symbols. 1030ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // return llvm::GlobalVariable::AvailableExternallyLinkage; 1031ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::WeakODRLinkage; 1032ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1033ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1034ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Silence GCC warning. 1035ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::GlobalVariable::WeakODRLinkage; 1036ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1037ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1038ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic CodeGenModule::GVALinkage 1039ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownGetLinkageForVariable(ASTContext &Context, const VarDecl *VD) { 1040ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this is a static data member, compute the kind of template 1041ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // specialization. Otherwise, this variable is not part of a 1042ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // template. 1043ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown TemplateSpecializationKind TSK = TSK_Undeclared; 1044ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (VD->isStaticDataMember()) 1045ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown TSK = VD->getTemplateSpecializationKind(); 1046ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1047ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage L = VD->getLinkage(); 1048ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (L == ExternalLinkage && Context.getLangOptions().CPlusPlus && 1049ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VD->getType()->getLinkage() == UniqueExternalLinkage) 1050ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown L = UniqueExternalLinkage; 1051ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1052ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (L) { 1053ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case NoLinkage: 1054ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case InternalLinkage: 1055ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case UniqueExternalLinkage: 1056ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_Internal; 1057ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1058ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case ExternalLinkage: 1059ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (TSK) { 1060ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_Undeclared: 1061ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitSpecialization: 1062ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_StrongExternal; 1063ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1064ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDeclaration: 1065ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm_unreachable("Variable should not be instantiated"); 1066ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Fall through to treat this like any other instantiation. 1067ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1068ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ExplicitInstantiationDefinition: 1069ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_ExplicitTemplateInstantiation; 1070ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1071ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case TSK_ImplicitInstantiation: 1072ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_TemplateInstantiation; 1073ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1074ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1075ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1076ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CodeGenModule::GVA_StrongExternal; 1077ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1078ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1079ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCharUnits CodeGenModule::GetTargetTypeStoreSize(const llvm::Type *Ty) const { 1080ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return CharUnits::fromQuantity( 1081ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown TheTargetData.getTypeStoreSizeInBits(Ty) / Context.getCharWidth()); 1082ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1083ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1084ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 1085ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Init = 0; 1086ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown QualType ASTTy = D->getType(); 1087ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool NonConstInit = false; 1088ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1089ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const Expr *InitExpr = D->getAnyInitializer(); 1090ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1091ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!InitExpr) { 1092ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This is a tentative definition; tentative definitions are 1093ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // implicitly initialized with { 0 }. 1094ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // 1095ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Note that tentative definitions are only emitted at the end of 1096ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // a translation unit, so they should never have incomplete 1097ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // type. In addition, EmitTentativeDefinition makes sure that we 1098ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // never attempt to emit a tentative definition if a real one 1099ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // exists. A use may still exists, however, so we still may need 1100ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // to do a RAUW. 1101ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 1102ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Init = EmitNullConstant(D->getType()); 1103ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1104ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Init = EmitConstantExpr(InitExpr, D->getType()); 1105ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1106ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Init) { 1107ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown QualType T = InitExpr->getType(); 1108ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (getLangOptions().CPlusPlus) { 1109ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCXXGlobalVarDeclInitFunc(D); 1110ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Init = EmitNullConstant(T); 1111ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NonConstInit = true; 1112ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1113ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ErrorUnsupported(D, "static initializer"); 1114ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 1115ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1116ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1117ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1118ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1119ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type* InitType = Init->getType(); 1120ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 1121ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1122ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Strip off a bitcast if we got one back. 1123ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1124ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(CE->getOpcode() == llvm::Instruction::BitCast || 1125ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // all zero index gep. 1126ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CE->getOpcode() == llvm::Instruction::GetElementPtr); 1127ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry = CE->getOperand(0); 1128ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1129ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1130ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Entry is now either a Function or GlobalVariable. 1131ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 1132ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1133ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // We have a definition after a declaration with the wrong type. 1134ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // We must make a new GlobalVariable* and update everything that used OldGV 1135ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // (a declaration or tentative definition) with the new GlobalVariable* 1136ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // (which will be a definition). 1137ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // 1138ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This happens if there is a prototype for a global (e.g. 1139ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // "extern int x[];") and then a definition of a different type (e.g. 1140ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // "int x[10];"). This also happens when an initializer has a different type 1141ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // from the type of the global (this happens with unions). 1142ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (GV == 0 || 1143ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->getType()->getElementType() != InitType || 1144ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) { 1145ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1146ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Move the old entry aside so that we'll create a new one. 1147ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->setName(llvm::StringRef()); 1148ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1149ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Make a new global with the correct type, this is now guaranteed to work. 1150ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 1151ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1152ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Replace all uses of the old global with the new global 1153ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *NewPtrForOldDecl = 1154ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 1155ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->replaceAllUsesWith(NewPtrForOldDecl); 1156ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1157ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Erase the old global, since it is no longer used. 1158ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 1159ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1160ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1161ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) { 1162ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SourceManager &SM = Context.getSourceManager(); 1163ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AddAnnotation(EmitAnnotateAttr(GV, AA, 1164ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SM.getInstantiationLineNumber(D->getLocation()))); 1165ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1166ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1167ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setInitializer(Init); 1168ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1169ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If it is safe to mark the global 'constant', do so now. 1170ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setConstant(false); 1171ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!NonConstInit && DeclIsConstantGlobal(Context, D)) 1172ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setConstant(true); 1173ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1174ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 1175ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1176ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Set the llvm linkage type as appropriate. 1177ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GVALinkage Linkage = GetLinkageForVariable(getContext(), D); 1178ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Linkage == GVA_Internal) 1179ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::Function::InternalLinkage); 1180ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (D->hasAttr<DLLImportAttr>()) 1181ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::Function::DLLImportLinkage); 1182ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (D->hasAttr<DLLExportAttr>()) 1183ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::Function::DLLExportLinkage); 1184ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (D->hasAttr<WeakAttr>()) { 1185ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (GV->isConstant()) 1186ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::GlobalVariable::WeakODRLinkage); 1187ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 1188ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage); 1189ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (Linkage == GVA_TemplateInstantiation || 1190ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage == GVA_ExplicitTemplateInstantiation) 1191ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: It seems like we can provide more specific linkage here 1192ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // (LinkOnceODR, WeakODR). 1193ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage); 1194ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (!getLangOptions().CPlusPlus && !CodeGenOpts.NoCommon && 1195ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown !D->hasExternalStorage() && !D->getInit() && 1196ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown !D->getAttr<SectionAttr>()) { 1197ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::GlobalVariable::CommonLinkage); 1198ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // common vars aren't constant even if declared const. 1199ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setConstant(false); 1200ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else 1201ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setLinkage(llvm::GlobalVariable::ExternalLinkage); 1202ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1203ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetCommonAttributes(D, GV); 1204ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1205ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Emit global variable debug information. 1206ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (CGDebugInfo *DI = getDebugInfo()) { 1207ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DI->setLocation(D->getLocation()); 1208ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DI->EmitGlobalVariable(GV, D); 1209ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1210ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1211ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1212ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1213ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// implement a function with no prototype, e.g. "int foo() {}". If there are 1214ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// existing call uses of the old function in the module, this adjusts them to 1215ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// call the new function directly. 1216ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 1217ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// This is not just a cleanup: the always_inline pass requires direct calls to 1218ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// functions to be able to inline them. If there is a bitcast in the way, it 1219ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// won't inline them. Instcombine normally deletes these calls, but it isn't 1220ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// run at -O0. 1221ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1222ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *NewFn) { 1223ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If we're redefining a global as a function, don't transform it. 1224ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 1225ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (OldFn == 0) return; 1226ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1227ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *NewRetTy = NewFn->getReturnType(); 1228ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::SmallVector<llvm::Value*, 4> ArgList; 1229ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1230ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 1231ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UI != E; ) { 1232ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // TODO: Do invokes ever occur in C code? If so, we should handle them too. 1233ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Value::use_iterator I = UI++; // Increment before the CI is erased. 1234ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I); 1235ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::CallSite CS(CI); 1236ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!CI || !CS.isCallee(I)) continue; 1237ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1238ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If the return types don't match exactly, and if the call isn't dead, then 1239ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // we can't transform this call. 1240ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (CI->getType() != NewRetTy && !CI->use_empty()) 1241ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown continue; 1242ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1243ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If the function was passed too few arguments, don't transform. If extra 1244ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // arguments were passed, we silently drop them. If any of the types 1245ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // mismatch, we don't transform. 1246ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned ArgNo = 0; 1247ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool DontTransform = false; 1248ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 1249ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 1250ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (CS.arg_size() == ArgNo || 1251ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CS.getArgument(ArgNo)->getType() != AI->getType()) { 1252ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DontTransform = true; 1253ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1254ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1255ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1256ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (DontTransform) 1257ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown continue; 1258ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1259ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Okay, we can transform this. Create the new call instruction and copy 1260ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // over the required information. 1261ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo); 1262ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(), 1263ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ArgList.end(), "", CI); 1264ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ArgList.clear(); 1265ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!NewCall->getType()->isVoidTy()) 1266ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NewCall->takeName(CI); 1267ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NewCall->setAttributes(CI->getAttributes()); 1268ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NewCall->setCallingConv(CI->getCallingConv()); 1269ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1270ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Finally, remove the old call, replacing any uses with the new one. 1271ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!CI->use_empty()) 1272ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CI->replaceAllUsesWith(NewCall); 1273ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1274ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Copy debug location attached to CI. 1275ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!CI->getDebugLoc().isUnknown()) 1276ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NewCall->setDebugLoc(CI->getDebugLoc()); 1277ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CI->eraseFromParent(); 1278ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1279ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1280ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1281ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1282ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 1283ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 1284ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::FunctionType *Ty = getTypes().GetFunctionType(GD); 1285ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangleContext().mangleInitDiscriminator(); 1286ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Get or create the prototype for the function. 1287ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 1288ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1289ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Strip off a bitcast if we got one back. 1290ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1291ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(CE->getOpcode() == llvm::Instruction::BitCast); 1292ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry = CE->getOperand(0); 1293ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1294ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1295ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1296ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 1297ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 1298ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1299ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If the types mismatch then we have to rewrite the definition. 1300ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(OldFn->isDeclaration() && 1301ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "Shouldn't replace non-declaration"); 1302ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1303ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // F is the Function* for the one with the wrong type, we must make a new 1304ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Function* and update everything that used F (a declaration) with the new 1305ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Function* (which will be a definition). 1306ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // 1307ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This happens if there is a prototype for a function 1308ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // (e.g. "int f()") and then a definition of a different type 1309ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // (e.g. "int f(int x)"). Move the old function aside so that it 1310ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // doesn't interfere with GetAddrOfFunction. 1311ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OldFn->setName(llvm::StringRef()); 1312ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 1313ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1314ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this is an implementation of a function without a prototype, try to 1315ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // replace any existing uses of the function (which may be calls) with uses 1316ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // of the new function 1317ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->getType()->isFunctionNoProtoType()) { 1318ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 1319ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OldFn->removeDeadConstantUsers(); 1320ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1321ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1322ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Replace uses of F with the Function we will endow with a body. 1323ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Entry->use_empty()) { 1324ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *NewPtrForOldDecl = 1325ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 1326ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->replaceAllUsesWith(NewPtrForOldDecl); 1327ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1328ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1329ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Ok, delete the old function now, which is dead. 1330ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OldFn->eraseFromParent(); 1331ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1332ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry = NewFn; 1333ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1334ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1335ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function *Fn = cast<llvm::Function>(Entry); 1336ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1337ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenFunction(*this).GenerateCode(D, Fn); 1338ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1339ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetFunctionDefinitionAttributes(D, Fn); 1340ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetLLVMFunctionAttributesForDefinition(D, Fn); 1341ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1342ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 1343ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AddGlobalCtor(Fn, CA->getPriority()); 1344ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 1345ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AddGlobalDtor(Fn, DA->getPriority()); 1346ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1347ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1348ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 1349ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1350ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const AliasAttr *AA = D->getAttr<AliasAttr>(); 1351ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(AA && "Not an alias?"); 1352ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1353ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MangleBuffer MangledName; 1354ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getMangledName(MangledName, GD); 1355ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1356ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If there is a definition in the module, then it wins over the alias. 1357ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // This is dubious, but allow it to be safe. Just ignore the alias. 1358ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1359ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry && !Entry->isDeclaration()) 1360ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1361ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1362ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 1363ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1364ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create a reference to the named value. This ensures that it is emitted 1365ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // if a deferred decl. 1366ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Aliasee; 1367ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isa<llvm::FunctionType>(DeclTy)) 1368ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl()); 1369ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 1370ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 1371ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::PointerType::getUnqual(DeclTy), 0); 1372ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1373ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create the new alias itself, but don't set a name yet. 1374ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue *GA = 1375ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalAlias(Aliasee->getType(), 1376ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Function::ExternalLinkage, 1377ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "", Aliasee, &getModule()); 1378ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1379ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry) { 1380ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(Entry->isDeclaration()); 1381ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1382ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If there is a declaration in the module, then we had an extern followed 1383ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // by the alias, as in: 1384ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // extern int test6(); 1385ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // ... 1386ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // int test6() __attribute__((alias("test7"))); 1387ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // 1388ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Remove it and replace uses of it with the alias. 1389ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GA->takeName(Entry); 1390ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1391ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 1392ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->getType())); 1393ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry->eraseFromParent(); 1394ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1395ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GA->setName(MangledName.getString()); 1396ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1397ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1398ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Set attributes which are particular to an alias; this is a 1399ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // specialization of the attributes which may be set on a global 1400ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // variable/function. 1401ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->hasAttr<DLLExportAttr>()) { 1402ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1403ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // The dllexport attribute is ignored for undefined symbols. 1404ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (FD->getBody()) 1405ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GA->setLinkage(llvm::Function::DLLExportLinkage); 1406ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1407ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GA->setLinkage(llvm::Function::DLLExportLinkage); 1408ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1409ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else if (D->hasAttr<WeakAttr>() || 1410ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->hasAttr<WeakRefAttr>() || 1411ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->hasAttr<WeakImportAttr>()) { 1412ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GA->setLinkage(llvm::Function::WeakAnyLinkage); 1413ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1414ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1415ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SetCommonAttributes(D, GA); 1416ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1417ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1418ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// getBuiltinLibFunction - Given a builtin id for a function like 1419ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// "__builtin_fabsf", return a Function* for "fabsf". 1420ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD, 1421ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned BuiltinID) { 1422ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert((Context.BuiltinInfo.isLibFunction(BuiltinID) || 1423ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) && 1424ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "isn't a lib fn"); 1425ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1426ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Get the name, skip over the __builtin_ prefix (if necessary). 1427ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const char *Name = Context.BuiltinInfo.GetName(BuiltinID); 1428ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Context.BuiltinInfo.isLibFunction(BuiltinID)) 1429ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Name += 10; 1430ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1431ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::FunctionType *Ty = 1432ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType())); 1433ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1434ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD)); 1435ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1436ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1437ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 1438ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned NumTys) { 1439ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return llvm::Intrinsic::getDeclaration(&getModule(), 1440ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (llvm::Intrinsic::ID)IID, Tys, NumTys); 1441ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1442ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1443ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1444ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Function *CodeGenModule::getMemCpyFn(const llvm::Type *DestType, 1445ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *SrcType, 1446ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *SizeType) { 1447ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *ArgTypes[3] = {DestType, SrcType, SizeType }; 1448ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getIntrinsic(llvm::Intrinsic::memcpy, ArgTypes, 3); 1449ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1450ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1451ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Function *CodeGenModule::getMemMoveFn(const llvm::Type *DestType, 1452ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *SrcType, 1453ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *SizeType) { 1454ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *ArgTypes[3] = {DestType, SrcType, SizeType }; 1455ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getIntrinsic(llvm::Intrinsic::memmove, ArgTypes, 3); 1456ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1457ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1458ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Function *CodeGenModule::getMemSetFn(const llvm::Type *DestType, 1459ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *SizeType) { 1460ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *ArgTypes[2] = { DestType, SizeType }; 1461ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return getIntrinsic(llvm::Intrinsic::memset, ArgTypes, 2); 1462ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1463ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1464ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic llvm::StringMapEntry<llvm::Constant*> & 1465ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownGetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 1466ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const StringLiteral *Literal, 1467ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool TargetIsLSB, 1468ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool &IsUTF16, 1469ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned &StringLength) { 1470ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned NumBytes = Literal->getByteLength(); 1471ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1472ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Check for simple case. 1473ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Literal->containsNonAsciiOrNull()) { 1474ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown StringLength = NumBytes; 1475ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(), 1476ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown StringLength)); 1477ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1478ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1479ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Otherwise, convert the UTF8 literals into a byte string. 1480ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::SmallVector<UTF16, 128> ToBuf(NumBytes); 1481ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const UTF8 *FromPtr = (UTF8 *)Literal->getStrData(); 1482ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UTF16 *ToPtr = &ToBuf[0]; 1483ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1484ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 1485ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown &ToPtr, ToPtr + NumBytes, 1486ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown strictConversion); 1487ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1488ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Check for conversion failure. 1489ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Result != conversionOK) { 1490ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: Have Sema::CheckObjCString() validate the UTF-8 string and remove 1491ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // this duplicate code. 1492ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(Result == sourceIllegal && "UTF-8 to UTF-16 conversion failed"); 1493ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown StringLength = NumBytes; 1494ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(), 1495ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown StringLength)); 1496ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1497ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1498ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // ConvertUTF8toUTF16 returns the length in ToPtr. 1499ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown StringLength = ToPtr - &ToBuf[0]; 1500ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1501ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Render the UTF-16 string into a byte array and convert to the target byte 1502ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // order. 1503ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // 1504ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: This isn't something we should need to do here. 1505ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::SmallString<128> AsBytes; 1506ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AsBytes.reserve(StringLength * 2); 1507ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (unsigned i = 0; i != StringLength; ++i) { 1508ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned short Val = ToBuf[i]; 1509ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (TargetIsLSB) { 1510ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AsBytes.push_back(Val & 0xFF); 1511ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AsBytes.push_back(Val >> 8); 1512ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1513ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AsBytes.push_back(Val >> 8); 1514ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AsBytes.push_back(Val & 0xFF); 1515ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1516ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1517ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Append one extra null character, the second is automatically added by our 1518ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // caller. 1519ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown AsBytes.push_back(0); 1520ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1521ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown IsUTF16 = true; 1522ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size())); 1523ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1524ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1525ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 1526ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 1527ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned StringLength = 0; 1528ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool isUTF16 = false; 1529ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringMapEntry<llvm::Constant*> &Entry = 1530ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GetConstantCFStringEntry(CFConstantStringMap, Literal, 1531ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getTargetData().isLittleEndian(), 1532ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown isUTF16, StringLength); 1533ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1534ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (llvm::Constant *C = Entry.getValue()) 1535ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return C; 1536ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1537ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Zero = 1538ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 1539ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Zeros[] = { Zero, Zero }; 1540ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1541ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If we don't already have it, get __CFConstantStringClassReference. 1542ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!CFConstantStringClassRef) { 1543ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 1544ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ty = llvm::ArrayType::get(Ty, 0); 1545ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *GV = CreateRuntimeVariable(Ty, 1546ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "__CFConstantStringClassReference"); 1547ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Decay array -> ptr 1548ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CFConstantStringClassRef = 1549ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1550ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1551ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1552ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown QualType CFTy = getContext().getCFConstantStringType(); 1553ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1554ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::StructType *STy = 1555ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 1556ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1557ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<llvm::Constant*> Fields(4); 1558ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1559ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Class pointer. 1560ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[0] = CFConstantStringClassRef; 1561ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1562ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Flags. 1563ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 1564ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 1565ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantInt::get(Ty, 0x07C8); 1566ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1567ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // String pointer. 1568ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 1569ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1570ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::LinkageTypes Linkage; 1571ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool isConstant; 1572ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isUTF16) { 1573ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: why do utf strings get "_" labels instead of "L" labels? 1574ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage = llvm::GlobalValue::InternalLinkage; 1575ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Note: -fwritable-strings doesn't make unicode CFStrings writable, but 1576ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // does make plain ascii ones writable. 1577ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown isConstant = true; 1578ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1579ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage = llvm::GlobalValue::PrivateLinkage; 1580ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown isConstant = !Features.WritableStrings; 1581ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1582ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1583ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable *GV = 1584ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 1585ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ".str"); 1586ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isUTF16) { 1587ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 1588ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setAlignment(Align.getQuantity()); 1589ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1590ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1591ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1592ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // String length. 1593ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ty = getTypes().ConvertType(getContext().LongTy); 1594ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 1595ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1596ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // The struct. 1597ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown C = llvm::ConstantStruct::get(STy, Fields); 1598ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 1599ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable::PrivateLinkage, C, 1600ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "_unnamed_cfstring_"); 1601ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const char *Sect = getContext().Target.getCFStringSection()) 1602ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setSection(Sect); 1603ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry.setValue(GV); 1604ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1605ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GV; 1606ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1607ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1608ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 1609ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::GetAddrOfConstantNSString(const StringLiteral *Literal) { 1610ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned StringLength = 0; 1611ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool isUTF16 = false; 1612ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringMapEntry<llvm::Constant*> &Entry = 1613ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GetConstantCFStringEntry(CFConstantStringMap, Literal, 1614ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getTargetData().isLittleEndian(), 1615ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown isUTF16, StringLength); 1616ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1617ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (llvm::Constant *C = Entry.getValue()) 1618ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return C; 1619ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1620ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Zero = 1621ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 1622ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *Zeros[] = { Zero, Zero }; 1623ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1624ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If we don't already have it, get _NSConstantStringClassReference. 1625ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!NSConstantStringClassRef) { 1626ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 1627ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ty = llvm::ArrayType::get(Ty, 0); 1628ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *GV = CreateRuntimeVariable(Ty, 1629ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Features.ObjCNonFragileABI ? 1630ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "OBJC_CLASS_$_NSConstantString" : 1631ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "_NSConstantStringClassReference"); 1632ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Decay array -> ptr 1633ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NSConstantStringClassRef = 1634ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1635ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1636ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1637ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown QualType NSTy = getContext().getNSConstantStringType(); 1638ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1639ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::StructType *STy = 1640ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 1641ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1642ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::vector<llvm::Constant*> Fields(3); 1643ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1644ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Class pointer. 1645ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[0] = NSConstantStringClassRef; 1646ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1647ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // String pointer. 1648ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 1649ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1650ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::LinkageTypes Linkage; 1651ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool isConstant; 1652ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isUTF16) { 1653ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: why do utf strings get "_" labels instead of "L" labels? 1654ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage = llvm::GlobalValue::InternalLinkage; 1655ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Note: -fwritable-strings doesn't make unicode NSStrings writable, but 1656ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // does make plain ascii ones writable. 1657ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown isConstant = true; 1658ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1659ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Linkage = llvm::GlobalValue::PrivateLinkage; 1660ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown isConstant = !Features.WritableStrings; 1661ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1662ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1663ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable *GV = 1664ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 1665ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ".str"); 1666ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isUTF16) { 1667ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 1668ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setAlignment(Align.getQuantity()); 1669ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1670ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1671ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1672ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // String length. 1673ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 1674ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 1675ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1676ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // The struct. 1677ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown C = llvm::ConstantStruct::get(STy, Fields); 1678ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 1679ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalVariable::PrivateLinkage, C, 1680ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "_unnamed_nsstring_"); 1681ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME. Fix section. 1682ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (const char *Sect = 1683ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Features.ObjCNonFragileABI 1684ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ? getContext().Target.getNSStringNonFragileABISection() 1685ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown : getContext().Target.getNSStringSection()) 1686ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GV->setSection(Sect); 1687ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry.setValue(GV); 1688ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1689ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GV; 1690ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1691ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1692ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetStringForStringLiteral - Return the appropriate bytes for a 1693ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// string literal, properly padded to match the literal type. 1694ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstd::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) { 1695ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const char *StrData = E->getStrData(); 1696ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned Len = E->getByteLength(); 1697ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1698ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const ConstantArrayType *CAT = 1699ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getContext().getAsConstantArrayType(E->getType()); 1700ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(CAT && "String isn't pointer or array!"); 1701ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1702ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Resize the string to the right size. 1703ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::string Str(StrData, StrData+Len); 1704ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown uint64_t RealLen = CAT->getSize().getZExtValue(); 1705ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1706ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (E->isWide()) 1707ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown RealLen *= getContext().Target.getWCharWidth()/8; 1708ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1709ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Str.resize(RealLen, '\0'); 1710ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1711ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Str; 1712ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1713ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1714ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 1715ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// constant array for the given string literal. 1716ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 1717ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 1718ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: This can be more efficient. 1719ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // FIXME: We shouldn't need to bitcast the constant in the wide string case. 1720ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S)); 1721ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (S->isWide()) { 1722ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Type *DestTy = 1723ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType())); 1724ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown C = llvm::ConstantExpr::getBitCast(C, DestTy); 1725ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1726ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return C; 1727ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1728ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1729ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 1730ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// array for the given ObjCEncodeExpr node. 1731ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant * 1732ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownCodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 1733ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown std::string Str; 1734ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getContext().getObjCEncodingForType(E->getEncodedType(), Str); 1735ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1736ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetAddrOfConstantCString(Str); 1737ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1738ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1739ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1740ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GenerateWritableString -- Creates storage for a string literal. 1741ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic llvm::Constant *GenerateStringLiteral(const std::string &str, 1742ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool constant, 1743ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenModule &CGM, 1744ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const char *GlobalName) { 1745ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create Constant for this string literal. Don't add a '\0'. 1746ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *C = 1747ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::ConstantArray::get(CGM.getLLVMContext(), str, false); 1748ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1749ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create a global variable for this string 1750ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 1751ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::GlobalValue::PrivateLinkage, 1752ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown C, GlobalName); 1753ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1754ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1755ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetAddrOfConstantString - Returns a pointer to a character array 1756ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// containing the literal. This contents are exactly that of the 1757ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// given string, i.e. it will not be null terminated automatically; 1758ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// see GetAddrOfConstantCString. Note that whether the result is 1759ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// actually a pointer to an LLVM constant depends on 1760ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// Feature.WriteableStrings. 1761ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// 1762ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// The result has pointer to array type. 1763ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str, 1764ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const char *GlobalName) { 1765ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown bool IsConstant = !Features.WritableStrings; 1766ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1767ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Get the default prefix if a name wasn't specified. 1768ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!GlobalName) 1769ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GlobalName = ".str"; 1770ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1771ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Don't share any string literals if strings aren't constant. 1772ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!IsConstant) 1773ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GenerateStringLiteral(str, false, *this, GlobalName); 1774ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1775ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringMapEntry<llvm::Constant *> &Entry = 1776ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 1777ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1778ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Entry.getValue()) 1779ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return Entry.getValue(); 1780ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1781ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Create a global variable for this. 1782ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName); 1783ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Entry.setValue(C); 1784ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return C; 1785ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1786ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1787ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// GetAddrOfConstantCString - Returns a pointer to a character 1788ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// array containing the literal and a terminating '\-' 1789ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// character. The result has pointer to array type. 1790ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownllvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str, 1791ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const char *GlobalName){ 1792ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return GetAddrOfConstantString(str + '\0', GlobalName); 1793ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1794ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1795ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// EmitObjCPropertyImplementations - Emit information for synthesized 1796ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// properties for an implementation. 1797ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitObjCPropertyImplementations(const 1798ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCImplementationDecl *D) { 1799ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (ObjCImplementationDecl::propimpl_iterator 1800ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 1801ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCPropertyImplDecl *PID = *i; 1802ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1803ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Dynamic is just for type-checking. 1804ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 1805ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCPropertyDecl *PD = PID->getPropertyDecl(); 1806ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1807ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Determine which methods need to be implemented, some may have 1808ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // been overridden. Note that ::isSynthesized is not the method 1809ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // we want, that just indicates if the decl came from a 1810ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // property. What we want to know is if the method is defined in 1811ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // this implementation. 1812ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!D->getInstanceMethod(PD->getGetterName())) 1813ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenFunction(*this).GenerateObjCGetter( 1814ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const_cast<ObjCImplementationDecl *>(D), PID); 1815ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!PD->isReadOnly() && 1816ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown !D->getInstanceMethod(PD->getSetterName())) 1817ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenFunction(*this).GenerateObjCSetter( 1818ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const_cast<ObjCImplementationDecl *>(D), PID); 1819ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1820ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1821ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1822ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1823ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// EmitObjCIvarInitializations - Emit information for ivar initialization 1824ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// for an implementation. 1825ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 1826ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!Features.NeXTRuntime || D->getNumIvarInitializers() == 0) 1827ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1828ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DeclContext* DC = const_cast<DeclContext*>(dyn_cast<DeclContext>(D)); 1829ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(DC && "EmitObjCIvarInitializations - null DeclContext"); 1830ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 1831ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 1832ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCMethodDecl *DTORMethod = ObjCMethodDecl::Create(getContext(), 1833ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->getLocation(), 1834ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->getLocation(), cxxSelector, 1835ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getContext().VoidTy, 0, 1836ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DC, true, false, true, 1837ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCMethodDecl::Required); 1838ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->addInstanceMethod(DTORMethod); 1839ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 1840ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1841ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown II = &getContext().Idents.get(".cxx_construct"); 1842ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown cxxSelector = getContext().Selectors.getSelector(0, &II); 1843ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // The constructor returns 'self'. 1844ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 1845ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->getLocation(), 1846ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->getLocation(), cxxSelector, 1847ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getContext().getObjCIdType(), 0, 1848ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DC, true, false, true, 1849ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCMethodDecl::Required); 1850ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown D->addInstanceMethod(CTORMethod); 1851ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 1852ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1853ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1854ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1855ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1856ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// EmitNamespace - Emit all declarations in a namespace. 1857ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 1858ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 1859ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown I != E; ++I) 1860ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitTopLevelDecl(*I); 1861ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1862ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1863ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown// EmitLinkageSpec - Emit all declarations in a linkage spec. 1864ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 1865ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 1866ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 1867ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ErrorUnsupported(LSD, "linkage spec"); 1868ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1869ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1870ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1871ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 1872ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown I != E; ++I) 1873ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitTopLevelDecl(*I); 1874ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1875ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1876ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/// EmitTopLevelDecl - Emit code for a single top level declaration. 1877ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid CodeGenModule::EmitTopLevelDecl(Decl *D) { 1878ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If an error has occurred, stop code generation, but continue 1879ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // parsing and semantic analysis (to ensure all warnings and errors 1880ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // are emitted). 1881ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (Diags.hasErrorOccurred()) 1882ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1883ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1884ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Ignore dependent declarations. 1885ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 1886ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1887ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1888ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (D->getKind()) { 1889ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::CXXConversion: 1890ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::CXXMethod: 1891ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::Function: 1892ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Skip function templates 1893ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate()) 1894ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1895ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1896ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitGlobal(cast<FunctionDecl>(D)); 1897ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1898ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1899ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::Var: 1900ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitGlobal(cast<VarDecl>(D)); 1901ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1902ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1903ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // C++ Decls 1904ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::Namespace: 1905ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitNamespace(cast<NamespaceDecl>(D)); 1906ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1907ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // No code generation needed. 1908ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::UsingShadow: 1909ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::Using: 1910ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::UsingDirective: 1911ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ClassTemplate: 1912ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::FunctionTemplate: 1913ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::NamespaceAlias: 1914ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1915ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::CXXConstructor: 1916ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Skip function templates 1917ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate()) 1918ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 1919ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1920ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 1921ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1922ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::CXXDestructor: 1923ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 1924ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1925ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1926ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::StaticAssert: 1927ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Nothing to do. 1928ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1929ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1930ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Objective-C Decls 1931ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1932ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Forward declarations, no (immediate) code generation. 1933ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCClass: 1934ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCForwardProtocol: 1935ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCCategory: 1936ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCInterface: 1937ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1938ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1939ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCProtocol: 1940ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D)); 1941ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1942ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1943ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCCategoryImpl: 1944ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Categories have properties but don't support synthesize so we 1945ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // can ignore them here. 1946ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 1947ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1948ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1949ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCImplementation: { 1950ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 1951ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitObjCPropertyImplementations(OMD); 1952ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitObjCIvarInitializations(OMD); 1953ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Runtime->GenerateClass(OMD); 1954ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1955ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1956ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCMethod: { 1957ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 1958ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // If this is not a prototype, emit the body. 1959ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (OMD->getBody()) 1960ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CodeGenFunction(*this).GenerateObjCMethod(OMD); 1961ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1962ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1963ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::ObjCCompatibleAlias: 1964ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // compatibility-alias is a directive and has no code gen. 1965ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1966ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1967ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::LinkageSpec: 1968ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 1969ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1970ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1971ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case Decl::FileScopeAsm: { 1972ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 1973ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown llvm::StringRef AsmString = AD->getAsmString()->getString(); 1974ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1975ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown const std::string &S = getModule().getModuleInlineAsm(); 1976ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (S.empty()) 1977ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getModule().setModuleInlineAsm(AsmString); 1978ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 1979ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 1980ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1981ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1982ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1983ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown default: 1984ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // Make sure we handled everything we should, every other kind is a 1985ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 1986ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown // function. Need to recode Decl::Kind to do that easily. 1987ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 1988ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1989ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1990ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown