CodeGenModule.cpp revision a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69
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; 41820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjCInterfaceDecl * ClassDecl = (ObjCInterfaceDecl*)OCD->getClassInterface(); 41920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (unsigned i=0 ; i<ClassDecl->getNumIntfRefProtocols() ; i++) 42020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Protocols.push_back(ClassDecl->getReferencedProtocols()[i]->getName()); 42120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 42220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Generate the category 42320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Runtime->GenerateCategory(OCD->getClassInterface()->getName(), 424a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner OCD->getName(), InstanceMethodSels, InstanceMethodTypes, 425a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels, ClassMethodTypes, Protocols); 42620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov} 42720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 42820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikovvoid CodeGenModule::EmitObjCClassImplementation( 42920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const ObjCImplementationDecl *OID) { 43020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the superclass name. 43120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const ObjCInterfaceDecl * SCDecl = OID->getClassInterface()->getSuperClass(); 43220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const char * SCName = NULL; 43320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov if (SCDecl) { 43420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov SCName = SCDecl->getName(); 43520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 43620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 43720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the class name 43820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjCInterfaceDecl * ClassDecl = (ObjCInterfaceDecl*)OID->getClassInterface(); 43920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const char * ClassName = ClassDecl->getName(); 44020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 44120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the size of instances. For runtimes that support late-bound instances 44220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // this should probably be something different (size just of instance 44320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // varaibles in this class, not superclasses?). 44420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov int instanceSize = 0; 44520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const llvm::Type *ObjTy; 44620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov if (!Runtime->LateBoundIVars()) { 44720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjTy = getTypes().ConvertType(Context.getObjCInterfaceType(ClassDecl)); 44820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov instanceSize = TheTargetData.getABITypeSize(ObjTy); 44920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 45020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 45120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about instance variables. 45220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> IvarNames; 45320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> IvarTypes; 45420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> IvarOffsets; 45520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov const llvm::StructLayout *Layout = 45620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov TheTargetData.getStructLayout(cast<llvm::StructType>(ObjTy)); 45720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ObjTy = llvm::PointerType::getUnqual(ObjTy); 45820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCInterfaceDecl::ivar_iterator iter = ClassDecl->ivar_begin(), 45920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = ClassDecl->ivar_end() ; iter != endIter ; iter++) { 46020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Store the name 46120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov IvarNames.push_back(GetAddrOfConstantString((*iter)->getName())); 46220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the type encoding for this ivar 46320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 46420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<const RecordType *, 8> EncodingRecordTypes; 46520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForType((*iter)->getType(), TypeStr, 46620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov EncodingRecordTypes); 46720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov IvarTypes.push_back(GetAddrOfConstantString(TypeStr)); 46820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Get the offset 46920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov int offset = 47020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov (int)Layout->getElementOffset(getTypes().getLLVMFieldNo(*iter)); 47120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov IvarOffsets.push_back( 47220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::ConstantInt::get(llvm::Type::Int32Ty, offset)); 47320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 47420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 47520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about instance methods 476a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::SmallVector<Selector, 16> InstanceMethodSels; 47720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes; 47820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCImplementationDecl::instmeth_iterator iter = OID->instmeth_begin(), 47920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = OID->instmeth_end() ; iter != endIter ; iter++) { 480a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner InstanceMethodSels.push_back((*iter)->getSelector()); 48120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 48220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForMethodDecl((*iter),TypeStr); 48320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 48420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 48520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 48620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect information about class methods 487a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner llvm::SmallVector<Selector, 16> ClassMethodSels; 48820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes; 48920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (ObjCImplementationDecl::classmeth_iterator iter = OID->classmeth_begin(), 49020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov endIter = OID->classmeth_end() ; iter != endIter ; iter++) { 491a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels.push_back((*iter)->getSelector()); 49220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov std::string TypeStr; 49320ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Context.getObjCEncodingForMethodDecl((*iter),TypeStr); 49420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr)); 49520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov } 49620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Collect the names of referenced protocols 49720ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov llvm::SmallVector<std::string, 16> Protocols; 49820ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov for (unsigned i = 0, e = ClassDecl->getNumIntfRefProtocols() ; i < e ; i++) 49920ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Protocols.push_back(ClassDecl->getReferencedProtocols()[i]->getName()); 50020ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 50120ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov // Generate the category 50220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov Runtime->GenerateClass(ClassName, SCName, instanceSize, IvarNames, IvarTypes, 503a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner IvarOffsets, InstanceMethodSels, InstanceMethodTypes, 504a4210076fc1d7ac0a20b8b4a79e18a8ae33b9c69Chris Lattner ClassMethodSels, ClassMethodTypes, Protocols); 50520ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov} 50620ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov 507391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 50888a69ad80e1550e9932666e6efa050a5b1223889Chris Lattnervoid CodeGenModule::EmitFunction(const FunctionDecl *FD) { 5095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is not a prototype, emit the body. 510d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (!FD->isThisDeclarationADefinition()) { 511d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes if (FD->getAttr<AliasAttr>()) 512d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GetAddrOfFunctionDecl(FD, true); 513a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner return; 514d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes } 515a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 516a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // If the function is a static, defer code generation until later so we can 517a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // easily omit unused statics. 518a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner if (FD->getStorageClass() != FunctionDecl::Static) { 5195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CodeGenFunction(*this).GenerateCode(FD); 520a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner return; 5214c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 522a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 523a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner StaticDecls.push_back(FD); 5244c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman} 5254c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 5264c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begemanvoid CodeGenModule::EmitStatics() { 5274c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Emit code for each used static decl encountered. Since a previously unused 5284c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // static decl may become used during the generation of code for a static 5294c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // function, iterate until no changes are made. 5304c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman bool Changed; 5314c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman do { 5324c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman Changed = false; 5334c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman for (unsigned i = 0, e = StaticDecls.size(); i != e; ++i) { 5344c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman const Decl *D = StaticDecls[i]; 5356f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman 5366f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman // Check if we have used a decl with the same name 5376f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman // FIXME: The AST should have some sort of aggregate decls or 5386f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman // global symbol map. 5396f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5406f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman if (!getModule().getFunction(FD->getName())) 5416f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman continue; 5426f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman } else { 5436f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman if (!getModule().getNamedGlobal(cast<VarDecl>(D)->getName())) 5446f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman continue; 5456f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman } 5466f7e2eee917a136ffc36834f020782b3f15d8fa6Eli Friedman 5474c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // If this is a function decl, generate code for the static function if it 5484c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // has a body. Otherwise, we must have a var decl for a static global 5494c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // variable. 5504c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5514c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (FD->getBody()) 5524c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman CodeGenFunction(*this).GenerateCode(FD); 553d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes else if (FD->getAttr<AliasAttr>()) 554d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes GetAddrOfFunctionDecl(FD, true); 5554c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } else { 5561a1d92ac5e1354634af08c62a1d72e263d13be0cNate Begeman EmitGlobalVarInit(cast<VarDecl>(D)); 5574c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 5584c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Erase the used decl from the list. 5594c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls[i] = StaticDecls.back(); 5604c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls.pop_back(); 5614c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman --i; 5624c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman --e; 5634c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 5644c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Remember that we made a change. 5654c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman Changed = true; 5664c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 5674c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } while (Changed); 5685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5703b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonllvm::Constant *CodeGenModule::EmitGlobalInit(const Expr *Expr) { 5713b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitConstantExpr(Expr); 5729e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel} 5739e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel 5748bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 5758bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// annotation information for a given GlobalValue. The annotation struct is 5768bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 5778bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// GlobalValue being annotated. The second filed is thee constant string 5788bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// created from the AnnotateAttr's annotation. The third field is a constant 5798bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// string containing the name of the translation unit. The fourth field is 5808bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// the line number in the file of the annotated value declaration. 5818bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// 5828bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// FIXME: this does not unique the annotation string constants, as llvm-gcc 5838bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// appears to. 5848bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// 5858bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begemanllvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 5868bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman const AnnotateAttr *AA, 5878bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman unsigned LineNo) { 5888bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Module *M = &getModule(); 5898bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 5908bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // get [N x i8] constants for the annotation string, and the filename string 5918bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // which are the 2nd and 3rd elements of the global annotation structure. 5928bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman const llvm::Type *SBP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 5938bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *anno = llvm::ConstantArray::get(AA->getAnnotation(), true); 5948bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *unit = llvm::ConstantArray::get(M->getModuleIdentifier(), 5958bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman true); 5968bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 5978bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // Get the two global values corresponding to the ConstantArrays we just 5988bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // created to hold the bytes of the strings. 5998bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue *annoGV = 6008bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman new llvm::GlobalVariable(anno->getType(), false, 6018bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue::InternalLinkage, anno, 6028bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman GV->getName() + ".str", M); 6038bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // translation unit name string, emitted into the llvm.metadata section. 6048bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue *unitGV = 6058bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman new llvm::GlobalVariable(unit->getType(), false, 6068bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue::InternalLinkage, unit, ".str", M); 6078bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 6088bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // Create the ConstantStruct that is the global annotion. 6098bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *Fields[4] = { 6108bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(GV, SBP), 6118bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(annoGV, SBP), 6128bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(unitGV, SBP), 6138bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantInt::get(llvm::Type::Int32Ty, LineNo) 6148bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman }; 6158bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman return llvm::ConstantStruct::get(Fields, 4, false); 6168bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman} 6178bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 618248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroffvoid CodeGenModule::EmitGlobalVar(const VarDecl *D) { 6194c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // If the VarDecl is a static, defer code generation until later so we can 6204c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // easily omit unused statics. 6214c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (D->getStorageClass() == VarDecl::Static) { 6224c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls.push_back(D); 6234c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman return; 6244c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 6254c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 6269cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If this is just a forward declaration of the variable, don't emit it now, 6279cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // allow it to be emitted lazily on its first use. 62888a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner if (D->getStorageClass() == VarDecl::Extern && D->getInit() == 0) 62988a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner return; 6309cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 6314c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman EmitGlobalVarInit(D); 6324c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman} 6334c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 6344c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begemanvoid CodeGenModule::EmitGlobalVarInit(const VarDecl *D) { 63577ba708819285931932ecd33691a672bb59d221aEli Friedman assert(D->hasGlobalStorage() && "Not a global variable"); 63677ba708819285931932ecd33691a672bb59d221aEli Friedman 6378f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner llvm::Constant *Init = 0; 63877ba708819285931932ecd33691a672bb59d221aEli Friedman QualType ASTTy = D->getType(); 63977ba708819285931932ecd33691a672bb59d221aEli Friedman const llvm::Type *VarTy = getTypes().ConvertTypeForMem(ASTTy); 64077ba708819285931932ecd33691a672bb59d221aEli Friedman const llvm::Type *VarPtrTy = 64177ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::PointerType::get(VarTy, ASTTy.getAddressSpace()); 64277ba708819285931932ecd33691a672bb59d221aEli Friedman 6438f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner if (D->getInit() == 0) { 644cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // This is a tentative definition; tentative definitions are 645cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // implicitly initialized with { 0 } 646cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman const llvm::Type* InitTy; 647cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman if (ASTTy->isIncompleteArrayType()) { 648cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // An incomplete array is normally [ TYPE x 0 ], but we need 649cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // to fix it to [ TYPE x 1 ]. 650cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman const llvm::ArrayType* ATy = cast<llvm::ArrayType>(VarTy); 651cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman InitTy = llvm::ArrayType::get(ATy->getElementType(), 1); 652cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman } else { 653cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman InitTy = VarTy; 654cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman } 655cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman Init = llvm::Constant::getNullValue(InitTy); 65677ba708819285931932ecd33691a672bb59d221aEli Friedman } else { 65777ba708819285931932ecd33691a672bb59d221aEli Friedman Init = EmitGlobalInit(D->getInit()); 6588f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner } 65977ba708819285931932ecd33691a672bb59d221aEli Friedman const llvm::Type* InitType = Init->getType(); 6608e53e720b3d7c962e91138a130dbd5d6c2def0e5Devang Patel 66177ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName(), true); 66277ba708819285931932ecd33691a672bb59d221aEli Friedman 66377ba708819285931932ecd33691a672bb59d221aEli Friedman if (!GV) { 66477ba708819285931932ecd33691a672bb59d221aEli Friedman GV = new llvm::GlobalVariable(InitType, false, 66577ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalValue::ExternalLinkage, 66677ba708819285931932ecd33691a672bb59d221aEli Friedman 0, D->getName(), &getModule(), 0, 66777ba708819285931932ecd33691a672bb59d221aEli Friedman ASTTy.getAddressSpace()); 66877ba708819285931932ecd33691a672bb59d221aEli Friedman } else if (GV->getType()->getElementType() != InitType || 66977ba708819285931932ecd33691a672bb59d221aEli Friedman GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) { 67077ba708819285931932ecd33691a672bb59d221aEli Friedman // We have a definition after a prototype with the wrong type. 67177ba708819285931932ecd33691a672bb59d221aEli Friedman // We must make a new GlobalVariable* and update everything that used OldGV 67277ba708819285931932ecd33691a672bb59d221aEli Friedman // (a declaration or tentative definition) with the new GlobalVariable* 67377ba708819285931932ecd33691a672bb59d221aEli Friedman // (which will be a definition). 67477ba708819285931932ecd33691a672bb59d221aEli Friedman // 67577ba708819285931932ecd33691a672bb59d221aEli Friedman // This happens if there is a prototype for a global (e.g. "extern int x[];") 67677ba708819285931932ecd33691a672bb59d221aEli Friedman // and then a definition of a different type (e.g. "int x[10];"). This also 67777ba708819285931932ecd33691a672bb59d221aEli Friedman // happens when an initializer has a different type from the type of the 67877ba708819285931932ecd33691a672bb59d221aEli Friedman // global (this happens with unions). 679cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // 680cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // FIXME: This also ends up happening if there's a definition followed by 681cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // a tentative definition! (Although Sema rejects that construct 682cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // at the moment.) 68377ba708819285931932ecd33691a672bb59d221aEli Friedman 68477ba708819285931932ecd33691a672bb59d221aEli Friedman // Save the old global 68577ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalVariable *OldGV = GV; 68677ba708819285931932ecd33691a672bb59d221aEli Friedman 68777ba708819285931932ecd33691a672bb59d221aEli Friedman // Make a new global with the correct type 68877ba708819285931932ecd33691a672bb59d221aEli Friedman GV = new llvm::GlobalVariable(InitType, false, 68977ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::GlobalValue::ExternalLinkage, 69077ba708819285931932ecd33691a672bb59d221aEli Friedman 0, D->getName(), &getModule(), 0, 69177ba708819285931932ecd33691a672bb59d221aEli Friedman ASTTy.getAddressSpace()); 69277ba708819285931932ecd33691a672bb59d221aEli Friedman // Steal the name of the old global 69377ba708819285931932ecd33691a672bb59d221aEli Friedman GV->takeName(OldGV); 69477ba708819285931932ecd33691a672bb59d221aEli Friedman 69577ba708819285931932ecd33691a672bb59d221aEli Friedman // Replace all uses of the old global with the new global 69677ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::Constant *NewPtrForOldDecl = 69777ba708819285931932ecd33691a672bb59d221aEli Friedman llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 69877ba708819285931932ecd33691a672bb59d221aEli Friedman OldGV->replaceAllUsesWith(NewPtrForOldDecl); 69977ba708819285931932ecd33691a672bb59d221aEli Friedman // Make sure we don't keep around any stale references to globals 70077ba708819285931932ecd33691a672bb59d221aEli Friedman // FIXME: This is really slow; we need a better way to walk all 70177ba708819285931932ecd33691a672bb59d221aEli Friedman // the decls with the same name 70277ba708819285931932ecd33691a672bb59d221aEli Friedman ReplaceMapValuesWith(OldGV, NewPtrForOldDecl); 70377ba708819285931932ecd33691a672bb59d221aEli Friedman 70477ba708819285931932ecd33691a672bb59d221aEli Friedman // Erase the old global, since it is no longer used. 70577ba708819285931932ecd33691a672bb59d221aEli Friedman OldGV->eraseFromParent(); 70677ba708819285931932ecd33691a672bb59d221aEli Friedman } 70777ba708819285931932ecd33691a672bb59d221aEli Friedman 70877ba708819285931932ecd33691a672bb59d221aEli Friedman GlobalDeclMap[D] = llvm::ConstantExpr::getBitCast(GV, VarPtrTy); 7099e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel 7108bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) { 7118bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman SourceManager &SM = Context.getSourceManager(); 7128bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman AddAnnotation(EmitAnnotateAttr(GV, AA, 7138bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman SM.getLogicalLineNumber(D->getLocation()))); 7148bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman } 7158bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 71688a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner GV->setInitializer(Init); 717ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 718cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman // FIXME: This is silly; getTypeAlign should just work for incomplete arrays 719cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman unsigned Align; 720cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman if (const IncompleteArrayType* IAT = D->getType()->getAsIncompleteArrayType()) 721cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman Align = Context.getTypeAlign(IAT->getElementType()); 722cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman else 723cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman Align = Context.getTypeAlign(D->getType()); 72408d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman if (const AlignedAttr* AA = D->getAttr<AlignedAttr>()) { 72508d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman Align = std::max(Align, AA->getAlignment()); 72608d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman } 72708d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman GV->setAlignment(Align / 8); 72808d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman 729ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) 7304f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman setVisibility(GV, attr->getVisibility()); 731ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // FIXME: else handle -fvisibility 73288a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner 73388a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner // Set the llvm linkage type as appropriate. 7348fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner if (D->getStorageClass() == VarDecl::Static) 7358fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner GV->setLinkage(llvm::Function::InternalLinkage); 7368fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else if (D->getAttr<DLLImportAttr>()) 737ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::Function::DLLImportLinkage); 738ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner else if (D->getAttr<DLLExportAttr>()) 739ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::Function::DLLExportLinkage); 7408fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else if (D->getAttr<WeakAttr>()) 741ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::GlobalVariable::WeakLinkage); 7428fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else { 743ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // FIXME: This isn't right. This should handle common linkage and other 744ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // stuff. 745ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner switch (D->getStorageClass()) { 7468fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner case VarDecl::Static: assert(0 && "This case handled above"); 747ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Auto: 748ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Register: 749ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner assert(0 && "Can't have auto or register globals"); 750ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::None: 751ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner if (!D->getInit()) 752a07b76419a03f126c22949dce2e546ba4df0e415Eli Friedman GV->setLinkage(llvm::GlobalVariable::CommonLinkage); 753ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner break; 754ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Extern: 755ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::PrivateExtern: 756ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // todo: common 757ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner break; 758ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner } 75988a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner } 760686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta 761686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta // Emit global variable debug information. 762686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta CGDebugInfo *DI = getDebugInfo(); 763686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta if(DI) { 764686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta if(D->getLocation().isValid()) 765686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta DI->setLocation(D->getLocation()); 766686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta DI->EmitGlobalVariable(GV, D); 767686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta } 76888a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner} 7695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 77032b266cff60737fedff00e8e721f3474533835efChris Lattner/// EmitGlobalVarDeclarator - Emit all the global vars attached to the specified 77132b266cff60737fedff00e8e721f3474533835efChris Lattner/// declarator chain. 772248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroffvoid CodeGenModule::EmitGlobalVarDeclarator(const VarDecl *D) { 773248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff for (; D; D = cast_or_null<VarDecl>(D->getNextDeclarator())) 774248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (D->isFileVarDecl()) 775248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff EmitGlobalVar(D); 77632b266cff60737fedff00e8e721f3474533835efChris Lattner} 7775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 778c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 779c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner // Make sure that this type is translated. 780c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner Types.UpdateCompletedType(TD); 781d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 782d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 783d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 784bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner/// getBuiltinLibFunction 785bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattnerllvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) { 7861426fecdf90dd1986751b9940422e675880ff671Chris Lattner if (BuiltinID > BuiltinFunctions.size()) 7871426fecdf90dd1986751b9940422e675880ff671Chris Lattner BuiltinFunctions.resize(BuiltinID); 788bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 7891426fecdf90dd1986751b9940422e675880ff671Chris Lattner // Cache looked up functions. Since builtin id #0 is invalid we don't reserve 7901426fecdf90dd1986751b9940422e675880ff671Chris Lattner // a slot for it. 7911426fecdf90dd1986751b9940422e675880ff671Chris Lattner assert(BuiltinID && "Invalid Builtin ID"); 7921426fecdf90dd1986751b9940422e675880ff671Chris Lattner llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID-1]; 793bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner if (FunctionSlot) 794bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner return FunctionSlot; 795bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 796bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner assert(Context.BuiltinInfo.isLibFunction(BuiltinID) && "isn't a lib fn"); 797bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 798bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // Get the name, skip over the __builtin_ prefix. 799bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner const char *Name = Context.BuiltinInfo.GetName(BuiltinID)+10; 800bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 801bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // Get the type for the builtin. 802bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context); 803bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner const llvm::FunctionType *Ty = 804bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner cast<llvm::FunctionType>(getTypes().ConvertType(Type)); 805bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 806bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // FIXME: This has a serious problem with code like this: 807bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // void abs() {} 808bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // ... __builtin_abs(x); 809bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // The two versions of abs will collide. The fix is for the builtin to win, 810bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // and for the existing one to be turned into a constantexpr cast of the 811bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // builtin. In the case where the existing one is a static function, it 812bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // should just be renamed. 813c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner if (llvm::Function *Existing = getModule().getFunction(Name)) { 814c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage()) 815c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner return FunctionSlot = Existing; 816c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner assert(Existing == 0 && "FIXME: Name collision"); 817c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner } 818bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 819bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // FIXME: param attributes for sext/zext etc. 8204c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman return FunctionSlot = 8214c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman llvm::Function::Create(Ty, llvm::Function::ExternalLinkage, Name, 8224c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman &getModule()); 823bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner} 824bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 8257acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattnerllvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 8267acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner unsigned NumTys) { 8277acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner return llvm::Intrinsic::getDeclaration(&getModule(), 8287acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner (llvm::Intrinsic::ID)IID, Tys, NumTys); 8297acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner} 830bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 8315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerllvm::Function *CodeGenModule::getMemCpyFn() { 8325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (MemCpyFn) return MemCpyFn; 8335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Intrinsic::ID IID; 834f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner switch (Context.Target.getPointerWidth(0)) { 8355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown ptr width"); 8365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case 32: IID = llvm::Intrinsic::memcpy_i32; break; 8375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case 64: IID = llvm::Intrinsic::memcpy_i64; break; 8385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8397acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner return MemCpyFn = getIntrinsic(IID); 8405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 841c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 8420c99509927a0c7a48490486b9fec287b63e5c09cEli Friedmanllvm::Function *CodeGenModule::getMemMoveFn() { 8430c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman if (MemMoveFn) return MemMoveFn; 8440c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman llvm::Intrinsic::ID IID; 8450c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman switch (Context.Target.getPointerWidth(0)) { 8460c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman default: assert(0 && "Unknown ptr width"); 8470c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman case 32: IID = llvm::Intrinsic::memmove_i32; break; 8480c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman case 64: IID = llvm::Intrinsic::memmove_i64; break; 8490c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman } 8500c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman return MemMoveFn = getIntrinsic(IID); 8510c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman} 8520c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman 85341ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venanciollvm::Function *CodeGenModule::getMemSetFn() { 85441ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio if (MemSetFn) return MemSetFn; 85541ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio llvm::Intrinsic::ID IID; 856f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner switch (Context.Target.getPointerWidth(0)) { 85741ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio default: assert(0 && "Unknown ptr width"); 85841ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio case 32: IID = llvm::Intrinsic::memset_i32; break; 85941ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio case 64: IID = llvm::Intrinsic::memset_i64; break; 86041ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio } 86141ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio return MemSetFn = getIntrinsic(IID); 86241ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio} 8637acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner 86420ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov// FIXME: This needs moving into an Apple Objective-C runtime class 865bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattnerllvm::Constant *CodeGenModule:: 866bef20ac367a09555b30d6eb3847a81ec164caf88Chris LattnerGetAddrOfConstantCFString(const std::string &str) { 867c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::StringMapEntry<llvm::Constant *> &Entry = 868c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 869c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 870c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson if (Entry.getValue()) 871c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson return Entry.getValue(); 872c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 873c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson std::vector<llvm::Constant*> Fields; 874c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 875c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson if (!CFConstantStringClassRef) { 876c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 877c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = llvm::ArrayType::get(Ty, 0); 878c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 879c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson CFConstantStringClassRef = 880c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson new llvm::GlobalVariable(Ty, false, 881c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::GlobalVariable::ExternalLinkage, 0, 882c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson "__CFConstantStringClassReference", 883c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson &getModule()); 884c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson } 885c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 886c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // Class pointer. 887c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty); 888c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *Zeros[] = { Zero, Zero }; 889c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *C = 890c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::ConstantExpr::getGetElementPtr(CFConstantStringClassRef, Zeros, 2); 891c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(C); 892c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 893c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // Flags. 894c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 895c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(llvm::ConstantInt::get(Ty, 1992)); 896c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 897c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // String pointer. 898c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantArray::get(str); 899c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = new llvm::GlobalVariable(C->getType(), true, 900c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::GlobalValue::InternalLinkage, 901c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C, ".str", &getModule()); 902c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 903c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2); 904c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(C); 905c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 906c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // String length. 907c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = getTypes().ConvertType(getContext().LongTy); 908c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(llvm::ConstantInt::get(Ty, str.length())); 909c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 910c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // The struct. 911c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = getTypes().ConvertType(getContext().getCFConstantStringType()); 912c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Fields); 9130c67829763b98bc670062b553897a851fab17401Anders Carlsson llvm::GlobalVariable *GV = 9140c67829763b98bc670062b553897a851fab17401Anders Carlsson new llvm::GlobalVariable(C->getType(), true, 9150c67829763b98bc670062b553897a851fab17401Anders Carlsson llvm::GlobalVariable::InternalLinkage, 9160c67829763b98bc670062b553897a851fab17401Anders Carlsson C, "", &getModule()); 9170c67829763b98bc670062b553897a851fab17401Anders Carlsson GV->setSection("__DATA,__cfstring"); 9180c67829763b98bc670062b553897a851fab17401Anders Carlsson Entry.setValue(GV); 9190c67829763b98bc670062b553897a851fab17401Anders Carlsson return GV; 920c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson} 92145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 922a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// GenerateWritableString -- Creates storage for a string literal. 92345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattnerstatic llvm::Constant *GenerateStringLiteral(const std::string &str, 92445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner bool constant, 9252c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner CodeGenModule &CGM) { 92645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create Constant for this string literal 92745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::Constant *C=llvm::ConstantArray::get(str); 92845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 92945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create a global variable for this string 93045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner C = new llvm::GlobalVariable(C->getType(), constant, 93145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::GlobalValue::InternalLinkage, 9322c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner C, ".str", &CGM.getModule()); 93345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return C; 93445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner} 93545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 936a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// CodeGenModule::GetAddrOfConstantString -- returns a pointer to the character 937a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// array containing the literal. The result is pointer to array type. 93845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str) { 93945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Don't share any string literals if writable-strings is turned on. 94045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner if (Features.WritableStrings) 94145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return GenerateStringLiteral(str, false, *this); 94245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 94345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::StringMapEntry<llvm::Constant *> &Entry = 94445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 94545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 94645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner if (Entry.getValue()) 94745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return Entry.getValue(); 94845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 94945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create a global variable for this. 95045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::Constant *C = GenerateStringLiteral(str, true, *this); 95145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner Entry.setValue(C); 95245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return C; 95345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner} 954