CodeGenModule.cpp revision 3db6cae19c236fe2cef343c90105ce7cca7de965
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This coordinates the per-module state used while generating code. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta#include "CGDebugInfo.h" 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenModule.h" 165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenFunction.h" 175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/ASTContext.h" 185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/Decl.h" 192c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner#include "clang/Basic/Diagnostic.h" 2045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner#include "clang/Basic/LangOptions.h" 218bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman#include "clang/Basic/SourceManager.h" 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 23ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman#include "llvm/CallingConv.h" 248f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner#include "llvm/Constants.h" 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/DerivedTypes.h" 26bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner#include "llvm/Module.h" 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/Intrinsics.h" 2820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov#include "llvm/Target/TargetData.h" 29a1945fa74d04098d7e22d7c31585342555eca928Chris Lattner#include "llvm/Analysis/Verifier.h" 30ce39faa836d0fe2f3be9ff11865c6433f734b2c6Christopher Lamb#include <algorithm> 315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris LattnerCodeGenModule::CodeGenModule(ASTContext &C, const LangOptions &LO, 36fb97b03e42d397405f617be0252be83e77a66f6eChris Lattner llvm::Module &M, const llvm::TargetData &TD, 37e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta Diagnostic &diags, bool GenerateDebugInfo) 38fb97b03e42d397405f617be0252be83e77a66f6eChris Lattner : Context(C), Features(LO), TheModule(M), TheTargetData(TD), Diags(diags), 390c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman Types(C, M, TD), MemCpyFn(0), MemMoveFn(0), MemSetFn(0), 400c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman CFConstantStringClassRef(0) { 412b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner //TODO: Make this selectable at runtime 42dce1406f1c1f572cfd61c494546572d63461c741Chris Lattner Runtime = CreateObjCRuntime(*this); 43e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta 44e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta // If debug info generation is enabled, create the CGDebugInfo object. 45e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta if (GenerateDebugInfo) 46e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta DebugInfo = new CGDebugInfo(this); 47e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta else 48e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta DebugInfo = NULL; 492b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner} 502b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner 512b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris LattnerCodeGenModule::~CodeGenModule() { 5220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov EmitStatics(); 53391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction(); 54ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner if (ObjCInitFunction) 55391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AddGlobalCtor(ObjCInitFunction); 566d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner EmitGlobalCtors(); 57532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman EmitAnnotations(); 582b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner delete Runtime; 59e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta delete DebugInfo; 60a1945fa74d04098d7e22d7c31585342555eca928Chris Lattner // Run the verifier to check that the generated code is consistent. 61a1945fa74d04098d7e22d7c31585342555eca928Chris Lattner assert(!verifyModule(TheModule)); 622b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner} 635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 642c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner/// WarnUnsupported - Print out a warning that codegen doesn't support the 652c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner/// specified stmt yet. 662c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattnervoid CodeGenModule::WarnUnsupported(const Stmt *S, const char *Type) { 672c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Warning, 682c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner "cannot codegen this %0 yet"); 692c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner SourceRange Range = S->getSourceRange(); 702c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner std::string Msg = Type; 719c728dc4d8da89c73fcae74c9e72d7a83ffd7b6dTed Kremenek getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID, 727a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek &Msg, 1, &Range, 1); 732c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner} 7458c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner 75c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner/// WarnUnsupported - Print out a warning that codegen doesn't support the 76c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner/// specified decl yet. 77c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattnervoid CodeGenModule::WarnUnsupported(const Decl *D, const char *Type) { 78c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Warning, 79c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner "cannot codegen this %0 yet"); 80c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner std::string Msg = Type; 81c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID, 82c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner &Msg, 1); 83c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner} 84c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner 854f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman/// setVisibility - Set the visibility for the given LLVM GlobalValue 864f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman/// according to the given clang AST visibility value. 874f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohmanvoid CodeGenModule::setVisibility(llvm::GlobalValue *GV, 884f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman VisibilityAttr::VisibilityTypes Vis) { 894f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman switch (Vis) { 904f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman default: assert(0 && "Unknown visibility!"); 914f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman case VisibilityAttr::DefaultVisibility: 924f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 934f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman break; 944f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman case VisibilityAttr::HiddenVisibility: 954f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 964f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman break; 974f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman case VisibilityAttr::ProtectedVisibility: 984f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman GV->setVisibility(llvm::GlobalValue::ProtectedVisibility); 994f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman break; 1004f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman } 1014f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman} 1024f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman 1036d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner/// AddGlobalCtor - Add a function to the list that will be called before 1046d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner/// main() runs. 1056d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattnervoid CodeGenModule::AddGlobalCtor(llvm::Function * Ctor) { 1066d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // TODO: Type coercion of void()* types. 1076d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner GlobalCtors.push_back(Ctor); 1086d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner} 1096d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 110391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// EmitGlobalCtors - Generates the array of contsturctor functions to be 111391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// called on module load, if any have been registered with AddGlobalCtor. 1126d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattnervoid CodeGenModule::EmitGlobalCtors() { 113391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner if (GlobalCtors.empty()) return; 114ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner 1156d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Get the type of @llvm.global_ctors 1166d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner std::vector<const llvm::Type*> CtorFields; 1176d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner CtorFields.push_back(llvm::IntegerType::get(32)); 1186d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Constructor function type 1196d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner std::vector<const llvm::Type*> VoidArgs; 120ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::FunctionType* CtorFuncTy = 121ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::FunctionType::get(llvm::Type::VoidTy, VoidArgs, false); 122ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner 1236d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // i32, function type pair 124572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner const llvm::Type *FPType = llvm::PointerType::getUnqual(CtorFuncTy); 125572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::StructType* CtorStructTy = 126572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::StructType::get(llvm::Type::Int32Ty, FPType, NULL); 1276d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Array of fields 128572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::ArrayType* GlobalCtorsTy = 129572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::ArrayType::get(CtorStructTy, GlobalCtors.size()); 1306d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 1316d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Define the global variable 132572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::GlobalVariable *GlobalCtorsVal = 133572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner new llvm::GlobalVariable(GlobalCtorsTy, false, 134572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::GlobalValue::AppendingLinkage, 135572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner (llvm::Constant*)0, "llvm.global_ctors", 136572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner &TheModule); 1376d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 1386d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Populate the array 1396d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner std::vector<llvm::Constant*> CtorValues; 140572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::Constant *MagicNumber = 141572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::ConstantInt::get(llvm::Type::Int32Ty, 65535, false); 142572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner std::vector<llvm::Constant*> StructValues; 1436d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner for (std::vector<llvm::Constant*>::iterator I = GlobalCtors.begin(), 144572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner E = GlobalCtors.end(); I != E; ++I) { 145572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner StructValues.clear(); 1466d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner StructValues.push_back(MagicNumber); 1476d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner StructValues.push_back(*I); 1486d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 149572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner CtorValues.push_back(llvm::ConstantStruct::get(CtorStructTy, StructValues)); 1506d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner } 151572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner 152572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner GlobalCtorsVal->setInitializer(llvm::ConstantArray::get(GlobalCtorsTy, 153572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner CtorValues)); 1546d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner} 1556d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 156391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 157391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 158532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begemanvoid CodeGenModule::EmitAnnotations() { 159532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman if (Annotations.empty()) 160532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman return; 161532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman 162532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman // Create a new global variable for the ConstantStruct in the Module. 163532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::Constant *Array = 164532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(), 165532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman Annotations.size()), 166532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman Annotations); 167532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::GlobalValue *gv = 168532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman new llvm::GlobalVariable(Array->getType(), false, 169532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::GlobalValue::AppendingLinkage, Array, 170532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman "llvm.global.annotations", &TheModule); 171532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman gv->setSection("llvm.metadata"); 172532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman} 173532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman 17458c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner/// ReplaceMapValuesWith - This is a really slow and bad function that 17558c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner/// searches for any entries in GlobalDeclMap that point to OldVal, changing 17658c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner/// them to point to NewVal. This is badbadbad, FIXME! 17758c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattnervoid CodeGenModule::ReplaceMapValuesWith(llvm::Constant *OldVal, 17858c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner llvm::Constant *NewVal) { 17958c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner for (llvm::DenseMap<const Decl*, llvm::Constant*>::iterator 18058c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner I = GlobalDeclMap.begin(), E = GlobalDeclMap.end(); I != E; ++I) 18158c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner if (I->second == OldVal) I->second = NewVal; 18258c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner} 18358c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner 184ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedmanbool hasAggregateLLVMType(QualType T) { 185ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman return !T->isRealType() && !T->isPointerLikeType() && 186ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman !T->isVoidType() && !T->isVectorType() && !T->isFunctionType(); 187ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman} 188ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman 189d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopesvoid CodeGenModule::SetGlobalValueAttributes(const FunctionDecl *FD, 190d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes llvm::GlobalValue *GV) { 191d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes // TODO: Set up linkage and many other things. Note, this is a simple 192d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes // approximation of what we really want. 193d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (FD->getStorageClass() == FunctionDecl::Static) 194d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GV->setLinkage(llvm::Function::InternalLinkage); 195d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes else if (FD->getAttr<DLLImportAttr>()) 196d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GV->setLinkage(llvm::Function::DLLImportLinkage); 197d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes else if (FD->getAttr<DLLExportAttr>()) 198d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GV->setLinkage(llvm::Function::DLLExportLinkage); 199d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes else if (FD->getAttr<WeakAttr>() || FD->isInline()) 200d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GV->setLinkage(llvm::Function::WeakLinkage); 201d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes 202d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (const VisibilityAttr *attr = FD->getAttr<VisibilityAttr>()) 203d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes CodeGenModule::setVisibility(GV, attr->getVisibility()); 204d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes // FIXME: else handle -fvisibility 205d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes} 206d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes 207ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedmanvoid CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD, 208ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman llvm::Function *F, 209ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman const llvm::FunctionType *FTy) { 210ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman unsigned FuncAttrs = 0; 211ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman if (FD->getAttr<NoThrowAttr>()) 212ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman FuncAttrs |= llvm::ParamAttr::NoUnwind; 213ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman if (FD->getAttr<NoReturnAttr>()) 214ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman FuncAttrs |= llvm::ParamAttr::NoReturn; 215ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman 216ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman llvm::SmallVector<llvm::ParamAttrsWithIndex, 8> ParamAttrList; 217ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman if (FuncAttrs) 218ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman ParamAttrList.push_back(llvm::ParamAttrsWithIndex::get(0, FuncAttrs)); 219ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman // Note that there is parallel code in CodeGenFunction::EmitCallExpr 220ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman bool AggregateReturn = hasAggregateLLVMType(FD->getResultType()); 221ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman if (AggregateReturn) 222ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman ParamAttrList.push_back( 223ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman llvm::ParamAttrsWithIndex::get(1, llvm::ParamAttr::StructRet)); 224ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman unsigned increment = AggregateReturn ? 2 : 1; 225c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman const FunctionTypeProto* FTP = dyn_cast<FunctionTypeProto>(FD->getType()); 226c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman if (FTP) { 227c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman for (unsigned i = 0; i < FTP->getNumArgs(); i++) { 228c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman QualType ParamType = FTP->getArgType(i); 229c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman unsigned ParamAttrs = 0; 230c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman if (ParamType->isRecordType()) 231c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman ParamAttrs |= llvm::ParamAttr::ByVal; 232a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner if (ParamType->isSignedIntegerType() && 233a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ParamType->isPromotableIntegerType()) 234c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman ParamAttrs |= llvm::ParamAttr::SExt; 235a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner if (ParamType->isUnsignedIntegerType() && 236a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ParamType->isPromotableIntegerType()) 237c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman ParamAttrs |= llvm::ParamAttr::ZExt; 238c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman if (ParamAttrs) 239c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman ParamAttrList.push_back(llvm::ParamAttrsWithIndex::get(i + increment, 240c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman ParamAttrs)); 241c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman } 242ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman } 243c134fcb0d7989fe6937e47e6216637647e074aefEli Friedman 244ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman F->setParamAttrs(llvm::PAListPtr::get(ParamAttrList.begin(), 245ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman ParamAttrList.size())); 246ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman 247ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman // Set the appropriate calling convention for the Function. 248ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman if (FD->getAttr<FastCallAttr>()) 249ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman F->setCallingConv(llvm::CallingConv::Fast); 250ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman 251d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes SetGlobalValueAttributes(FD, F); 252ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman} 253ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman 254ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman 25558c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner 2569cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattnerllvm::Constant *CodeGenModule::GetAddrOfFunctionDecl(const FunctionDecl *D, 2579cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner bool isDefinition) { 2589cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // See if it is already in the map. If so, just return it. 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Constant *&Entry = GlobalDeclMap[D]; 260109603de14dfe69f3eb9b264a273b38e5684c8deEli Friedman if (!isDefinition && Entry) return Entry; 261be14c5c6e29af948f6f809c499f83d844e755af9Eli Friedman 2629cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner const llvm::Type *Ty = getTypes().ConvertType(D->getType()); 2639cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2649cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Check to see if the function already exists. 2659cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Function *F = getModule().getFunction(D->getName()); 2669cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner const llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty); 2679cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2689cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If it doesn't already exist, just create and return an entry. 2699cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (F == 0) { 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: param attributes for sext/zext etc. 271d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (D->getBody() || !D->getAttr<AliasAttr>()) 272d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes F = llvm::Function::Create(FTy, llvm::Function::ExternalLinkage, 273d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes D->getName(), &getModule()); 274d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes else { 275d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes const std::string& aliaseeName = D->getAttr<AliasAttr>()->getAliasee(); 276d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes llvm::Function *aliasee = getModule().getFunction(aliaseeName); 277d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes llvm::GlobalValue *alias = new llvm::GlobalAlias(aliasee->getType(), 278a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::Function::ExternalLinkage, 279d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes D->getName(), 280d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes aliasee, 281d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes &getModule()); 282d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes SetGlobalValueAttributes(D, alias); 283d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes return Entry = alias; 284d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes } 285ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman 286ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman SetFunctionAttributes(D, F, FTy); 287ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman return Entry = F; 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2909cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If the pointer type matches, just return it. 291ddc23f3e6fdc4f83dd46ef7e20394cfbd6063ff9Christopher Lamb llvm::Type *PFTy = llvm::PointerType::getUnqual(Ty); 2929cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (PFTy == F->getType()) return Entry = F; 293fafad83da6eff6bf090f6eb2dc1019ace7473f38Chris Lattner 2949cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If this isn't a definition, just return it casted to the right type. 2959cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (!isDefinition) 2969cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = llvm::ConstantExpr::getBitCast(F, PFTy); 2979cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2989cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Otherwise, we have a definition after a prototype with the wrong type. 2999cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // F is the Function* for the one with the wrong type, we must make a new 3009cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Function* and update everything that used F (a declaration) with the new 3019cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Function* (which will be a definition). 3029cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // 3039cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // This happens if there is a prototype for a function (e.g. "int f()") and 3049cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // then a definition of a different type (e.g. "int f(int x)"). Start by 3059cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // making a new function of the correct type, RAUW, then steal the name. 306984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::Function *NewFn = llvm::Function::Create(FTy, 3079cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Function::ExternalLinkage, 3089cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner "", &getModule()); 3099cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner NewFn->takeName(F); 3109cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3119cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Replace uses of F with the Function we will endow with a body. 3129cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Constant *NewPtrForOldDecl = 3139cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::ConstantExpr::getBitCast(NewFn, F->getType()); 3149cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner F->replaceAllUsesWith(NewPtrForOldDecl); 3159cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3169cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // FIXME: Update the globaldeclmap for the previous decl of this name. We 3179cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // really want a way to walk all of these, but we don't have it yet. This 3189cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // is incredibly slow! 3199cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner ReplaceMapValuesWith(F, NewPtrForOldDecl); 3209cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3219cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Ok, delete the old function now, which is dead. 3229cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner assert(F->isDeclaration() && "Shouldn't replace non-declaration"); 3239cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner F->eraseFromParent(); 3249cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 325ff4a2d9e2c1ddbf87e00e2a36ae341faf03eafb3Eli Friedman SetFunctionAttributes(D, NewFn, FTy); 3269cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Return the new function which has the right type. 3279cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = NewFn; 3289cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner} 3299cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3302b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 3312b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattner bool isDefinition) { 3322b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattner assert(D->hasGlobalStorage() && "Not a global variable"); 33377ba708819285931932ecd33691a672bb59d221aEli Friedman assert(!isDefinition && "This shouldn't be called for definitions!"); 33477ba708819285931932ecd33691a672bb59d221aEli Friedman 3359cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // See if it is already in the map. 3369cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Constant *&Entry = GlobalDeclMap[D]; 3379cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (Entry) return Entry; 33877ba708819285931932ecd33691a672bb59d221aEli Friedman 339ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb QualType ASTTy = D->getType(); 340ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb const llvm::Type *Ty = getTypes().ConvertTypeForMem(ASTTy); 3419cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3429cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Check to see if the global already exists. 343495737830441e3e01ed2699eb9e38c8f15116cb5Chris Lattner llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName(), true); 3449cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3459cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If it doesn't already exist, just create and return an entry. 3469cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (GV == 0) { 3479cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = new llvm::GlobalVariable(Ty, false, 3489cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::GlobalValue::ExternalLinkage, 349ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 0, D->getName(), &getModule(), 0, 350ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb ASTTy.getAddressSpace()); 351fafad83da6eff6bf090f6eb2dc1019ace7473f38Chris Lattner } 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35377ba708819285931932ecd33691a672bb59d221aEli Friedman // Otherwise, it already exists; return the existing version 35477ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::PointerType *PTy = llvm::PointerType::get(Ty, ASTTy.getAddressSpace()); 35577ba708819285931932ecd33691a672bb59d221aEli Friedman return Entry = llvm::ConstantExpr::getBitCast(GV, PTy); 35677ba708819285931932ecd33691a672bb59d221aEli Friedman} 3579cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 358391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattnervoid CodeGenModule::EmitObjCMethod(const ObjCMethodDecl *OMD) { 359391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // If this is not a prototype, emit the body. 360391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner if (OMD->getBody()) 361391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner CodeGenFunction(*this).GenerateObjCMethod(OMD); 362391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 36320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikovvoid CodeGenModule::EmitObjCProtocolImplementation(const ObjCProtocolDecl *PD){ 36420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<std::string, 16> Protocols; 36520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (unsigned i = 0, e = PD->getNumReferencedProtocols() ; i < e ; i++) 36620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Protocols.push_back(PD->getReferencedProtocols()[i]->getName()); 36720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames; 36820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes; 36920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCProtocolDecl::instmeth_iterator iter = PD->instmeth_begin(), 37020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = PD->instmeth_end() ; iter != endIter ; iter++) { 37120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 37220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForMethodDecl((*iter),TypeStr); 37320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov InstanceMethodNames.push_back( 37420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov GetAddrOfConstantString((*iter)->getSelector().getName())); 37520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 37620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 37720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about class methods: 37820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames; 37920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes; 38020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCProtocolDecl::classmeth_iterator iter = PD->classmeth_begin(), 38120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = PD->classmeth_end() ; iter != endIter ; iter++) { 38220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 38320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForMethodDecl((*iter),TypeStr); 38420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ClassMethodNames.push_back( 38520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov GetAddrOfConstantString((*iter)->getSelector().getName())); 38620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 38720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 38820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Runtime->GenerateProtocol(PD->getName(), Protocols, InstanceMethodNames, 38920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov InstanceMethodTypes, ClassMethodNames, ClassMethodTypes); 39020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov} 39120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 39220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikovvoid CodeGenModule::EmitObjCCategoryImpl(const ObjCCategoryImplDecl *OCD) { 39320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 39420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about instance methods 395a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::SmallVector<Selector, 16> InstanceMethodSels; 39620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes; 39720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCCategoryDecl::instmeth_iterator iter = OCD->instmeth_begin(), 39820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = OCD->instmeth_end() ; iter != endIter ; iter++) { 399a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner InstanceMethodSels.push_back((*iter)->getSelector()); 40020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 401fba676396703e87a5034e5f308aa30a633468f66Chris Lattner Context.getObjCEncodingForMethodDecl(*iter,TypeStr); 40220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 40320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 40420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 40520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about class methods 406a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::SmallVector<Selector, 16> ClassMethodSels; 40720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes; 40820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCCategoryDecl::classmeth_iterator iter = OCD->classmeth_begin(), 40920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = OCD->classmeth_end() ; iter != endIter ; iter++) { 410a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels.push_back((*iter)->getSelector()); 41120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 412fba676396703e87a5034e5f308aa30a633468f66Chris Lattner Context.getObjCEncodingForMethodDecl(*iter,TypeStr); 41320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 41420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 41520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 41620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect the names of referenced protocols 41720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<std::string, 16> Protocols; 4183db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner const ObjCInterfaceDecl *ClassDecl = OCD->getClassInterface(); 4193db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner const ObjCList<ObjCProtocolDecl> &Protos =ClassDecl->getReferencedProtocols(); 4203db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(), 4213db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner E = Protos.end(); I != E; ++I) 4223db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner Protocols.push_back((*I)->getName()); 42320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 42420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Generate the category 42520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Runtime->GenerateCategory(OCD->getClassInterface()->getName(), 426a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner OCD->getName(), InstanceMethodSels, InstanceMethodTypes, 427a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels, ClassMethodTypes, Protocols); 42820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov} 42920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 43020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikovvoid CodeGenModule::EmitObjCClassImplementation( 43120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const ObjCImplementationDecl *OID) { 43220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the superclass name. 43320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const ObjCInterfaceDecl * SCDecl = OID->getClassInterface()->getSuperClass(); 43420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const char * SCName = NULL; 43520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov if (SCDecl) { 43620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov SCName = SCDecl->getName(); 43720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 43820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 43920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the class name 44020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjCInterfaceDecl * ClassDecl = (ObjCInterfaceDecl*)OID->getClassInterface(); 44120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const char * ClassName = ClassDecl->getName(); 44220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 44320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the size of instances. For runtimes that support late-bound instances 44420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // this should probably be something different (size just of instance 44520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // varaibles in this class, not superclasses?). 44620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov int instanceSize = 0; 44720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const llvm::Type *ObjTy; 44820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov if (!Runtime->LateBoundIVars()) { 44920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjTy = getTypes().ConvertType(Context.getObjCInterfaceType(ClassDecl)); 45020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov instanceSize = TheTargetData.getABITypeSize(ObjTy); 45120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 45220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 45320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about instance variables. 45420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> IvarNames; 45520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> IvarTypes; 45620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> IvarOffsets; 45720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const llvm::StructLayout *Layout = 45820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov TheTargetData.getStructLayout(cast<llvm::StructType>(ObjTy)); 45920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjTy = llvm::PointerType::getUnqual(ObjTy); 46020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCInterfaceDecl::ivar_iterator iter = ClassDecl->ivar_begin(), 46120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = ClassDecl->ivar_end() ; iter != endIter ; iter++) { 46220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Store the name 46320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov IvarNames.push_back(GetAddrOfConstantString((*iter)->getName())); 46420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the type encoding for this ivar 46520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 46620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<const RecordType *, 8> EncodingRecordTypes; 46720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForType((*iter)->getType(), TypeStr, 46820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov EncodingRecordTypes); 46920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov IvarTypes.push_back(GetAddrOfConstantString(TypeStr)); 47020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the offset 47120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov int offset = 47220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov (int)Layout->getElementOffset(getTypes().getLLVMFieldNo(*iter)); 47320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov IvarOffsets.push_back( 47420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::ConstantInt::get(llvm::Type::Int32Ty, offset)); 47520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 47620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 47720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about instance methods 478a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::SmallVector<Selector, 16> InstanceMethodSels; 47920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes; 48020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCImplementationDecl::instmeth_iterator iter = OID->instmeth_begin(), 48120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = OID->instmeth_end() ; iter != endIter ; iter++) { 482a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner InstanceMethodSels.push_back((*iter)->getSelector()); 48320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 48420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForMethodDecl((*iter),TypeStr); 48520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 48620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 48720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 48820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about class methods 489a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::SmallVector<Selector, 16> ClassMethodSels; 49020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes; 49120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCImplementationDecl::classmeth_iterator iter = OID->classmeth_begin(), 49220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = OID->classmeth_end() ; iter != endIter ; iter++) { 493a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels.push_back((*iter)->getSelector()); 49420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 49520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForMethodDecl((*iter),TypeStr); 49620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 49720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 49820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect the names of referenced protocols 49920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<std::string, 16> Protocols; 5003db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner const ObjCList<ObjCProtocolDecl> &Protos =ClassDecl->getReferencedProtocols(); 5013db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(), 5023db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner E = Protos.end(); I != E; ++I) 5033db6cae19c236fe2cef343c90105ce7cca7de965Chris Lattner Protocols.push_back((*I)->getName()); 50420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 50520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Generate the category 50620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Runtime->GenerateClass(ClassName, SCName, instanceSize, IvarNames, IvarTypes, 507a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner IvarOffsets, InstanceMethodSels, InstanceMethodTypes, 508a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels, ClassMethodTypes, Protocols); 50920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov} 51020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 511391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 51288a69ad80e1550e9932666e6efa050a5b1223889Chris Lattnervoid CodeGenModule::EmitFunction(const FunctionDecl *FD) { 5135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is not a prototype, emit the body. 514d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (!FD->isThisDeclarationADefinition()) { 515d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (FD->getAttr<AliasAttr>()) 516d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GetAddrOfFunctionDecl(FD, true); 517a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner return; 518d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes } 519a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 520a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // If the function is a static, defer code generation until later so we can 521a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // easily omit unused statics. 522a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner if (FD->getStorageClass() != FunctionDecl::Static) { 5235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CodeGenFunction(*this).GenerateCode(FD); 524a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner return; 5254c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 526a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 527a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner StaticDecls.push_back(FD); 5284c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman} 5294c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 5304c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begemanvoid CodeGenModule::EmitStatics() { 5314c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Emit code for each used static decl encountered. Since a previously unused 5324c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // static decl may become used during the generation of code for a static 5334c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // function, iterate until no changes are made. 5344c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman bool Changed; 5354c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman do { 5364c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman Changed = false; 5374c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman for (unsigned i = 0, e = StaticDecls.size(); i != e; ++i) { 5384c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman const Decl *D = StaticDecls[i]; 5396f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman 5406f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman // Check if we have used a decl with the same name 5416f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman // FIXME: The AST should have some sort of aggregate decls or 5426f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman // global symbol map. 5436f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5446f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman if (!getModule().getFunction(FD->getName())) 5456f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman continue; 5466f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman } else { 5476f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman if (!getModule().getNamedGlobal(cast<VarDecl>(D)->getName())) 5486f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman continue; 5496f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman } 5506f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman 5514c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // If this is a function decl, generate code for the static function if it 5524c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // has a body. Otherwise, we must have a var decl for a static global 5534c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // variable. 5544c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5554c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (FD->getBody()) 5564c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman CodeGenFunction(*this).GenerateCode(FD); 557d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes else if (FD->getAttr<AliasAttr>()) 558d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GetAddrOfFunctionDecl(FD, true); 5594c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } else { 5601a1d92ac5e1354634af08c62a1d72e263d13be0cNate Begeman EmitGlobalVarInit(cast<VarDecl>(D)); 5614c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 5624c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Erase the used decl from the list. 5634c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls[i] = StaticDecls.back(); 5644c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls.pop_back(); 5654c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman --i; 5664c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman --e; 5674c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 5684c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Remember that we made a change. 5694c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman Changed = true; 5704c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 5714c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } while (Changed); 5725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5743b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonllvm::Constant *CodeGenModule::EmitGlobalInit(const Expr *Expr) { 5753b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitConstantExpr(Expr); 5769e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel} 5779e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel 5788bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 5798bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// annotation information for a given GlobalValue. The annotation struct is 5808bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 5818bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// GlobalValue being annotated. The second filed is thee constant string 5828bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// created from the AnnotateAttr's annotation. The third field is a constant 5838bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// string containing the name of the translation unit. The fourth field is 5848bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// the line number in the file of the annotated value declaration. 5858bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// 5868bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// FIXME: this does not unique the annotation string constants, as llvm-gcc 5878bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// appears to. 5888bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// 5898bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begemanllvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 5908bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman const AnnotateAttr *AA, 5918bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman unsigned LineNo) { 5928bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Module *M = &getModule(); 5938bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 5948bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // get [N x i8] constants for the annotation string, and the filename string 5958bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // which are the 2nd and 3rd elements of the global annotation structure. 5968bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman const llvm::Type *SBP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 5978bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *anno = llvm::ConstantArray::get(AA->getAnnotation(), true); 5988bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *unit = llvm::ConstantArray::get(M->getModuleIdentifier(), 5998bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman true); 6008bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 6018bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // Get the two global values corresponding to the ConstantArrays we just 6028bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // created to hold the bytes of the strings. 6038bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue *annoGV = 6048bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman new llvm::GlobalVariable(anno->getType(), false, 6058bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue::InternalLinkage, anno, 6068bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman GV->getName() + ".str", M); 6078bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // translation unit name string, emitted into the llvm.metadata section. 6088bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue *unitGV = 6098bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman new llvm::GlobalVariable(unit->getType(), false, 6108bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue::InternalLinkage, unit, ".str", M); 6118bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 6128bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // Create the ConstantStruct that is the global annotion. 6138bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *Fields[4] = { 6148bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(GV, SBP), 6158bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(annoGV, SBP), 6168bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(unitGV, SBP), 6178bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantInt::get(llvm::Type::Int32Ty, LineNo) 6188bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman }; 6198bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman return llvm::ConstantStruct::get(Fields, 4, false); 6208bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman} 6218bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 622248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroffvoid CodeGenModule::EmitGlobalVar(const VarDecl *D) { 6234c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // If the VarDecl is a static, defer code generation until later so we can 6244c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // easily omit unused statics. 6254c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (D->getStorageClass() == VarDecl::Static) { 6264c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls.push_back(D); 6274c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman return; 6284c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 6294c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 6309cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If this is just a forward declaration of the variable, don't emit it now, 6319cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // allow it to be emitted lazily on its first use. 63288a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner if (D->getStorageClass() == VarDecl::Extern && D->getInit() == 0) 63388a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner return; 6349cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 6354c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman EmitGlobalVarInit(D); 6364c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman} 6374c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 6384c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begemanvoid CodeGenModule::EmitGlobalVarInit(const VarDecl *D) { 63977ba708819285931932ecd33691a672bb59d221aEli Friedman assert(D->hasGlobalStorage() && "Not a global variable"); 64077ba708819285931932ecd33691a672bb59d221aEli Friedman 6418f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner llvm::Constant *Init = 0; 64277ba708819285931932ecd33691a672bb59d221aEli Friedman QualType ASTTy = D->getType(); 64377ba708819285931932ecd33691a672bb59d221aEli Friedman const llvm::Type *VarTy = getTypes().ConvertTypeForMem(ASTTy); 64477ba708819285931932ecd33691a672bb59d221aEli Friedman const llvm::Type *VarPtrTy = 64577ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::PointerType::get(VarTy, ASTTy.getAddressSpace()); 64677ba708819285931932ecd33691a672bb59d221aEli Friedman 6478f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner if (D->getInit() == 0) { 648cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // This is a tentative definition; tentative definitions are 649cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // implicitly initialized with { 0 } 650cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman const llvm::Type* InitTy; 651cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman if (ASTTy->isIncompleteArrayType()) { 652cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // An incomplete array is normally [ TYPE x 0 ], but we need 653cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // to fix it to [ TYPE x 1 ]. 654cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman const llvm::ArrayType* ATy = cast<llvm::ArrayType>(VarTy); 655cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman InitTy = llvm::ArrayType::get(ATy->getElementType(), 1); 656cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman } else { 657cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman InitTy = VarTy; 658cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman } 659cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman Init = llvm::Constant::getNullValue(InitTy); 66077ba708819285931932ecd33691a672bb59d221aEli Friedman } else { 66177ba708819285931932ecd33691a672bb59d221aEli Friedman Init = EmitGlobalInit(D->getInit()); 6628f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner } 66377ba708819285931932ecd33691a672bb59d221aEli Friedman const llvm::Type* InitType = Init->getType(); 6648e53e720b3d7c962e91138a130dbd5d6c2def0e5Devang Patel 66577ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName(), true); 66677ba708819285931932ecd33691a672bb59d221aEli Friedman 66777ba708819285931932ecd33691a672bb59d221aEli Friedman if (!GV) { 66877ba708819285931932ecd33691a672bb59d221aEli Friedman GV = new llvm::GlobalVariable(InitType, false, 66977ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalValue::ExternalLinkage, 67077ba708819285931932ecd33691a672bb59d221aEli Friedman 0, D->getName(), &getModule(), 0, 67177ba708819285931932ecd33691a672bb59d221aEli Friedman ASTTy.getAddressSpace()); 67277ba708819285931932ecd33691a672bb59d221aEli Friedman } else if (GV->getType()->getElementType() != InitType || 67377ba708819285931932ecd33691a672bb59d221aEli Friedman GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) { 67477ba708819285931932ecd33691a672bb59d221aEli Friedman // We have a definition after a prototype with the wrong type. 67577ba708819285931932ecd33691a672bb59d221aEli Friedman // We must make a new GlobalVariable* and update everything that used OldGV 67677ba708819285931932ecd33691a672bb59d221aEli Friedman // (a declaration or tentative definition) with the new GlobalVariable* 67777ba708819285931932ecd33691a672bb59d221aEli Friedman // (which will be a definition). 67877ba708819285931932ecd33691a672bb59d221aEli Friedman // 67977ba708819285931932ecd33691a672bb59d221aEli Friedman // This happens if there is a prototype for a global (e.g. "extern int x[];") 68077ba708819285931932ecd33691a672bb59d221aEli Friedman // and then a definition of a different type (e.g. "int x[10];"). This also 68177ba708819285931932ecd33691a672bb59d221aEli Friedman // happens when an initializer has a different type from the type of the 68277ba708819285931932ecd33691a672bb59d221aEli Friedman // global (this happens with unions). 683cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // 684cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // FIXME: This also ends up happening if there's a definition followed by 685cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // a tentative definition! (Although Sema rejects that construct 686cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // at the moment.) 68777ba708819285931932ecd33691a672bb59d221aEli Friedman 68877ba708819285931932ecd33691a672bb59d221aEli Friedman // Save the old global 68977ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalVariable *OldGV = GV; 69077ba708819285931932ecd33691a672bb59d221aEli Friedman 69177ba708819285931932ecd33691a672bb59d221aEli Friedman // Make a new global with the correct type 69277ba708819285931932ecd33691a672bb59d221aEli Friedman GV = new llvm::GlobalVariable(InitType, false, 69377ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalValue::ExternalLinkage, 69477ba708819285931932ecd33691a672bb59d221aEli Friedman 0, D->getName(), &getModule(), 0, 69577ba708819285931932ecd33691a672bb59d221aEli Friedman ASTTy.getAddressSpace()); 69677ba708819285931932ecd33691a672bb59d221aEli Friedman // Steal the name of the old global 69777ba708819285931932ecd33691a672bb59d221aEli Friedman GV->takeName(OldGV); 69877ba708819285931932ecd33691a672bb59d221aEli Friedman 69977ba708819285931932ecd33691a672bb59d221aEli Friedman // Replace all uses of the old global with the new global 70077ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::Constant *NewPtrForOldDecl = 70177ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 70277ba708819285931932ecd33691a672bb59d221aEli Friedman OldGV->replaceAllUsesWith(NewPtrForOldDecl); 70377ba708819285931932ecd33691a672bb59d221aEli Friedman // Make sure we don't keep around any stale references to globals 70477ba708819285931932ecd33691a672bb59d221aEli Friedman // FIXME: This is really slow; we need a better way to walk all 70577ba708819285931932ecd33691a672bb59d221aEli Friedman // the decls with the same name 70677ba708819285931932ecd33691a672bb59d221aEli Friedman ReplaceMapValuesWith(OldGV, NewPtrForOldDecl); 70777ba708819285931932ecd33691a672bb59d221aEli Friedman 70877ba708819285931932ecd33691a672bb59d221aEli Friedman // Erase the old global, since it is no longer used. 70977ba708819285931932ecd33691a672bb59d221aEli Friedman OldGV->eraseFromParent(); 71077ba708819285931932ecd33691a672bb59d221aEli Friedman } 71177ba708819285931932ecd33691a672bb59d221aEli Friedman 71277ba708819285931932ecd33691a672bb59d221aEli Friedman GlobalDeclMap[D] = llvm::ConstantExpr::getBitCast(GV, VarPtrTy); 7139e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel 7148bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) { 7158bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman SourceManager &SM = Context.getSourceManager(); 7168bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman AddAnnotation(EmitAnnotateAttr(GV, AA, 7178bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman SM.getLogicalLineNumber(D->getLocation()))); 7188bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman } 7198bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 72088a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner GV->setInitializer(Init); 721ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 722cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // FIXME: This is silly; getTypeAlign should just work for incomplete arrays 723cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman unsigned Align; 724cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman if (const IncompleteArrayType* IAT = D->getType()->getAsIncompleteArrayType()) 725cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman Align = Context.getTypeAlign(IAT->getElementType()); 726cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman else 727cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman Align = Context.getTypeAlign(D->getType()); 72808d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman if (const AlignedAttr* AA = D->getAttr<AlignedAttr>()) { 72908d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman Align = std::max(Align, AA->getAlignment()); 73008d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman } 73108d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman GV->setAlignment(Align / 8); 73208d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman 733ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) 7344f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman setVisibility(GV, attr->getVisibility()); 735ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // FIXME: else handle -fvisibility 73688a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner 73788a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner // Set the llvm linkage type as appropriate. 7388fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner if (D->getStorageClass() == VarDecl::Static) 7398fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner GV->setLinkage(llvm::Function::InternalLinkage); 7408fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else if (D->getAttr<DLLImportAttr>()) 741ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::Function::DLLImportLinkage); 742ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner else if (D->getAttr<DLLExportAttr>()) 743ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::Function::DLLExportLinkage); 7448fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else if (D->getAttr<WeakAttr>()) 745ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::GlobalVariable::WeakLinkage); 7468fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else { 747ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // FIXME: This isn't right. This should handle common linkage and other 748ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // stuff. 749ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner switch (D->getStorageClass()) { 7508fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner case VarDecl::Static: assert(0 && "This case handled above"); 751ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Auto: 752ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Register: 753ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner assert(0 && "Can't have auto or register globals"); 754ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::None: 755ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner if (!D->getInit()) 756a07b76419a03f126c22949dce2e546ba4df0e415Eli Friedman GV->setLinkage(llvm::GlobalVariable::CommonLinkage); 757ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner break; 758ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Extern: 759ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::PrivateExtern: 760ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // todo: common 761ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner break; 762ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner } 76388a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner } 764686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta 765686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta // Emit global variable debug information. 766686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta CGDebugInfo *DI = getDebugInfo(); 767686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta if(DI) { 768686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta if(D->getLocation().isValid()) 769686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta DI->setLocation(D->getLocation()); 770686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta DI->EmitGlobalVariable(GV, D); 771686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta } 77288a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner} 7735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 77432b266cff60737fedff00e8e721f3474533835efChris Lattner/// EmitGlobalVarDeclarator - Emit all the global vars attached to the specified 77532b266cff60737fedff00e8e721f3474533835efChris Lattner/// declarator chain. 776248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroffvoid CodeGenModule::EmitGlobalVarDeclarator(const VarDecl *D) { 777248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff for (; D; D = cast_or_null<VarDecl>(D->getNextDeclarator())) 778248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (D->isFileVarDecl()) 779248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff EmitGlobalVar(D); 78032b266cff60737fedff00e8e721f3474533835efChris Lattner} 7815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 782c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 783c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner // Make sure that this type is translated. 784c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner Types.UpdateCompletedType(TD); 785d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 786d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 787d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 788bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner/// getBuiltinLibFunction 789bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattnerllvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) { 7901426fecdf90dd1986751b9940422e675880ff671Chris Lattner if (BuiltinID > BuiltinFunctions.size()) 7911426fecdf90dd1986751b9940422e675880ff671Chris Lattner BuiltinFunctions.resize(BuiltinID); 792bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 7931426fecdf90dd1986751b9940422e675880ff671Chris Lattner // Cache looked up functions. Since builtin id #0 is invalid we don't reserve 7941426fecdf90dd1986751b9940422e675880ff671Chris Lattner // a slot for it. 7951426fecdf90dd1986751b9940422e675880ff671Chris Lattner assert(BuiltinID && "Invalid Builtin ID"); 7961426fecdf90dd1986751b9940422e675880ff671Chris Lattner llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID-1]; 797bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner if (FunctionSlot) 798bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner return FunctionSlot; 799bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 800bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner assert(Context.BuiltinInfo.isLibFunction(BuiltinID) && "isn't a lib fn"); 801bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 802bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // Get the name, skip over the __builtin_ prefix. 803bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner const char *Name = Context.BuiltinInfo.GetName(BuiltinID)+10; 804bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 805bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // Get the type for the builtin. 806bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context); 807bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner const llvm::FunctionType *Ty = 808bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner cast<llvm::FunctionType>(getTypes().ConvertType(Type)); 809bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 810bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // FIXME: This has a serious problem with code like this: 811bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // void abs() {} 812bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // ... __builtin_abs(x); 813bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // The two versions of abs will collide. The fix is for the builtin to win, 814bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // and for the existing one to be turned into a constantexpr cast of the 815bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // builtin. In the case where the existing one is a static function, it 816bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // should just be renamed. 817c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner if (llvm::Function *Existing = getModule().getFunction(Name)) { 818c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage()) 819c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner return FunctionSlot = Existing; 820c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner assert(Existing == 0 && "FIXME: Name collision"); 821c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner } 822bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 823bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // FIXME: param attributes for sext/zext etc. 8244c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman return FunctionSlot = 8254c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman llvm::Function::Create(Ty, llvm::Function::ExternalLinkage, Name, 8264c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman &getModule()); 827bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner} 828bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 8297acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattnerllvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 8307acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner unsigned NumTys) { 8317acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner return llvm::Intrinsic::getDeclaration(&getModule(), 8327acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner (llvm::Intrinsic::ID)IID, Tys, NumTys); 8337acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner} 834bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 8355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerllvm::Function *CodeGenModule::getMemCpyFn() { 8365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (MemCpyFn) return MemCpyFn; 8375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Intrinsic::ID IID; 838f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner switch (Context.Target.getPointerWidth(0)) { 8395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown ptr width"); 8405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case 32: IID = llvm::Intrinsic::memcpy_i32; break; 8415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case 64: IID = llvm::Intrinsic::memcpy_i64; break; 8425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8437acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner return MemCpyFn = getIntrinsic(IID); 8445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 845c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 8460c99509927a0c7a48490486b9fec287b63e5c09cEli Friedmanllvm::Function *CodeGenModule::getMemMoveFn() { 8470c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman if (MemMoveFn) return MemMoveFn; 8480c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman llvm::Intrinsic::ID IID; 8490c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman switch (Context.Target.getPointerWidth(0)) { 8500c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman default: assert(0 && "Unknown ptr width"); 8510c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman case 32: IID = llvm::Intrinsic::memmove_i32; break; 8520c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman case 64: IID = llvm::Intrinsic::memmove_i64; break; 8530c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman } 8540c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman return MemMoveFn = getIntrinsic(IID); 8550c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman} 8560c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman 85741ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venanciollvm::Function *CodeGenModule::getMemSetFn() { 85841ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio if (MemSetFn) return MemSetFn; 85941ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio llvm::Intrinsic::ID IID; 860f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner switch (Context.Target.getPointerWidth(0)) { 86141ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio default: assert(0 && "Unknown ptr width"); 86241ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio case 32: IID = llvm::Intrinsic::memset_i32; break; 86341ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio case 64: IID = llvm::Intrinsic::memset_i64; break; 86441ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio } 86541ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio return MemSetFn = getIntrinsic(IID); 86641ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio} 8677acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner 86820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov// FIXME: This needs moving into an Apple Objective-C runtime class 869bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattnerllvm::Constant *CodeGenModule:: 870bef20ac367a09555b30d6eb3847a81ec164caf88Chris LattnerGetAddrOfConstantCFString(const std::string &str) { 871c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::StringMapEntry<llvm::Constant *> &Entry = 872c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 873c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 874c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson if (Entry.getValue()) 875c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson return Entry.getValue(); 876c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 877c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson std::vector<llvm::Constant*> Fields; 878c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 879c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson if (!CFConstantStringClassRef) { 880c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 881c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = llvm::ArrayType::get(Ty, 0); 882c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 883c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson CFConstantStringClassRef = 884c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson new llvm::GlobalVariable(Ty, false, 885c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::GlobalVariable::ExternalLinkage, 0, 886c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson "__CFConstantStringClassReference", 887c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson &getModule()); 888c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson } 889c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 890c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // Class pointer. 891c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty); 892c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *Zeros[] = { Zero, Zero }; 893c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *C = 894c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::ConstantExpr::getGetElementPtr(CFConstantStringClassRef, Zeros, 2); 895c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(C); 896c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 897c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // Flags. 898c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 899c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(llvm::ConstantInt::get(Ty, 1992)); 900c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 901c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // String pointer. 902c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantArray::get(str); 903c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = new llvm::GlobalVariable(C->getType(), true, 904c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::GlobalValue::InternalLinkage, 905c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C, ".str", &getModule()); 906c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 907c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2); 908c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(C); 909c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 910c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // String length. 911c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = getTypes().ConvertType(getContext().LongTy); 912c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(llvm::ConstantInt::get(Ty, str.length())); 913c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 914c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // The struct. 915c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = getTypes().ConvertType(getContext().getCFConstantStringType()); 916c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Fields); 9170c67829763b98bc670062b553897a851fab17401Anders Carlsson llvm::GlobalVariable *GV = 9180c67829763b98bc670062b553897a851fab17401Anders Carlsson new llvm::GlobalVariable(C->getType(), true, 9190c67829763b98bc670062b553897a851fab17401Anders Carlsson llvm::GlobalVariable::InternalLinkage, 9200c67829763b98bc670062b553897a851fab17401Anders Carlsson C, "", &getModule()); 9210c67829763b98bc670062b553897a851fab17401Anders Carlsson GV->setSection("__DATA,__cfstring"); 9220c67829763b98bc670062b553897a851fab17401Anders Carlsson Entry.setValue(GV); 9230c67829763b98bc670062b553897a851fab17401Anders Carlsson return GV; 924c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson} 92545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 926a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// GenerateWritableString -- Creates storage for a string literal. 92745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattnerstatic llvm::Constant *GenerateStringLiteral(const std::string &str, 92845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner bool constant, 9292c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner CodeGenModule &CGM) { 93045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create Constant for this string literal 93145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::Constant *C=llvm::ConstantArray::get(str); 93245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 93345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create a global variable for this string 93445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner C = new llvm::GlobalVariable(C->getType(), constant, 93545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::GlobalValue::InternalLinkage, 9362c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner C, ".str", &CGM.getModule()); 93745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return C; 93845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner} 93945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 940a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// CodeGenModule::GetAddrOfConstantString -- returns a pointer to the character 941a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// array containing the literal. The result is pointer to array type. 94245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str) { 94345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Don't share any string literals if writable-strings is turned on. 94445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner if (Features.WritableStrings) 94545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return GenerateStringLiteral(str, false, *this); 94645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 94745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::StringMapEntry<llvm::Constant *> &Entry = 94845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 94945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 95045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner if (Entry.getValue()) 95145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return Entry.getValue(); 95245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 95345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create a global variable for this. 95445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::Constant *C = GenerateStringLiteral(str, true, *this); 95545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner Entry.setValue(C); 95645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return C; 95745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner} 958