CodeGenModule.cpp revision 0c99509927a0c7a48490486b9fec287b63e5c09c
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" 28a1945fa74d04098d7e22d7c31585342555eca928Chris Lattner#include "llvm/Analysis/Verifier.h" 29ce39faa836d0fe2f3be9ff11865c6433f734b2c6Christopher Lamb#include <algorithm> 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris LattnerCodeGenModule::CodeGenModule(ASTContext &C, const LangOptions &LO, 35fb97b03e42d397405f617be0252be83e77a66f6eChris Lattner llvm::Module &M, const llvm::TargetData &TD, 36e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta Diagnostic &diags, bool GenerateDebugInfo) 37fb97b03e42d397405f617be0252be83e77a66f6eChris Lattner : Context(C), Features(LO), TheModule(M), TheTargetData(TD), Diags(diags), 380c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman Types(C, M, TD), MemCpyFn(0), MemMoveFn(0), MemSetFn(0), 390c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman CFConstantStringClassRef(0) { 402b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner //TODO: Make this selectable at runtime 41391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner Runtime = CreateObjCRuntime(M, 42391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner getTypes().ConvertType(getContext().IntTy), 43391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner getTypes().ConvertType(getContext().LongTy)); 44e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta 45e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta // If debug info generation is enabled, create the CGDebugInfo object. 46e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta if (GenerateDebugInfo) 47e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta DebugInfo = new CGDebugInfo(this); 48e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta else 49e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta DebugInfo = NULL; 502b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner} 512b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner 522b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris LattnerCodeGenModule::~CodeGenModule() { 53391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction(); 54ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner if (ObjCInitFunction) 55391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AddGlobalCtor(ObjCInitFunction); 564c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman EmitStatics(); 576d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner EmitGlobalCtors(); 58532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman EmitAnnotations(); 592b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner delete Runtime; 60e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta delete DebugInfo; 61a1945fa74d04098d7e22d7c31585342555eca928Chris Lattner // Run the verifier to check that the generated code is consistent. 62a1945fa74d04098d7e22d7c31585342555eca928Chris Lattner assert(!verifyModule(TheModule)); 632b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner} 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 652c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner/// WarnUnsupported - Print out a warning that codegen doesn't support the 662c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner/// specified stmt yet. 672c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattnervoid CodeGenModule::WarnUnsupported(const Stmt *S, const char *Type) { 682c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Warning, 692c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner "cannot codegen this %0 yet"); 702c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner SourceRange Range = S->getSourceRange(); 712c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner std::string Msg = Type; 729c728dc4d8da89c73fcae74c9e72d7a83ffd7b6dTed Kremenek getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID, 737a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek &Msg, 1, &Range, 1); 742c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner} 7558c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner 76c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner/// WarnUnsupported - Print out a warning that codegen doesn't support the 77c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner/// specified decl yet. 78c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattnervoid CodeGenModule::WarnUnsupported(const Decl *D, const char *Type) { 79c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Warning, 80c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner "cannot codegen this %0 yet"); 81c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner std::string Msg = Type; 82c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID, 83c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner &Msg, 1); 84c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner} 85c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner 864f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman/// setVisibility - Set the visibility for the given LLVM GlobalValue 874f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman/// according to the given clang AST visibility value. 884f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohmanvoid CodeGenModule::setVisibility(llvm::GlobalValue *GV, 894f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman VisibilityAttr::VisibilityTypes Vis) { 904f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman switch (Vis) { 914f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman default: assert(0 && "Unknown visibility!"); 924f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman case VisibilityAttr::DefaultVisibility: 934f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 944f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman break; 954f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman case VisibilityAttr::HiddenVisibility: 964f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 974f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman break; 984f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman case VisibilityAttr::ProtectedVisibility: 994f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman GV->setVisibility(llvm::GlobalValue::ProtectedVisibility); 1004f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman break; 1014f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman } 1024f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman} 1034f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman 1046d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner/// AddGlobalCtor - Add a function to the list that will be called before 1056d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner/// main() runs. 1066d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattnervoid CodeGenModule::AddGlobalCtor(llvm::Function * Ctor) { 1076d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // TODO: Type coercion of void()* types. 1086d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner GlobalCtors.push_back(Ctor); 1096d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner} 1106d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 111391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// EmitGlobalCtors - Generates the array of contsturctor functions to be 112391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// called on module load, if any have been registered with AddGlobalCtor. 1136d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattnervoid CodeGenModule::EmitGlobalCtors() { 114391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner if (GlobalCtors.empty()) return; 115ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner 1166d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Get the type of @llvm.global_ctors 1176d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner std::vector<const llvm::Type*> CtorFields; 1186d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner CtorFields.push_back(llvm::IntegerType::get(32)); 1196d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Constructor function type 1206d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner std::vector<const llvm::Type*> VoidArgs; 121ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::FunctionType* CtorFuncTy = 122ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::FunctionType::get(llvm::Type::VoidTy, VoidArgs, false); 123ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner 1246d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // i32, function type pair 125572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner const llvm::Type *FPType = llvm::PointerType::getUnqual(CtorFuncTy); 126572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::StructType* CtorStructTy = 127572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::StructType::get(llvm::Type::Int32Ty, FPType, NULL); 1286d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Array of fields 129572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::ArrayType* GlobalCtorsTy = 130572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::ArrayType::get(CtorStructTy, GlobalCtors.size()); 1316d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 1326d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Define the global variable 133572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::GlobalVariable *GlobalCtorsVal = 134572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner new llvm::GlobalVariable(GlobalCtorsTy, false, 135572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::GlobalValue::AppendingLinkage, 136572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner (llvm::Constant*)0, "llvm.global_ctors", 137572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner &TheModule); 1386d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 1396d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner // Populate the array 1406d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner std::vector<llvm::Constant*> CtorValues; 141572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::Constant *MagicNumber = 142572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner llvm::ConstantInt::get(llvm::Type::Int32Ty, 65535, false); 143572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner std::vector<llvm::Constant*> StructValues; 1446d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner for (std::vector<llvm::Constant*>::iterator I = GlobalCtors.begin(), 145572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner E = GlobalCtors.end(); I != E; ++I) { 146572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner StructValues.clear(); 1476d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner StructValues.push_back(MagicNumber); 1486d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner StructValues.push_back(*I); 1496d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 150572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner CtorValues.push_back(llvm::ConstantStruct::get(CtorStructTy, StructValues)); 1516d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner } 152572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner 153572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner GlobalCtorsVal->setInitializer(llvm::ConstantArray::get(GlobalCtorsTy, 154572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner CtorValues)); 1556d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner} 1566d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner 157391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 158391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 159532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begemanvoid CodeGenModule::EmitAnnotations() { 160532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman if (Annotations.empty()) 161532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman return; 162532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman 163532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman // Create a new global variable for the ConstantStruct in the Module. 164532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::Constant *Array = 165532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(), 166532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman Annotations.size()), 167532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman Annotations); 168532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::GlobalValue *gv = 169532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman new llvm::GlobalVariable(Array->getType(), false, 170532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman llvm::GlobalValue::AppendingLinkage, Array, 171532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman "llvm.global.annotations", &TheModule); 172532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman gv->setSection("llvm.metadata"); 173532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman} 174532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman 17558c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner/// ReplaceMapValuesWith - This is a really slow and bad function that 17658c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner/// searches for any entries in GlobalDeclMap that point to OldVal, changing 17758c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner/// them to point to NewVal. This is badbadbad, FIXME! 17858c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattnervoid CodeGenModule::ReplaceMapValuesWith(llvm::Constant *OldVal, 17958c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner llvm::Constant *NewVal) { 18058c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner for (llvm::DenseMap<const Decl*, llvm::Constant*>::iterator 18158c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner I = GlobalDeclMap.begin(), E = GlobalDeclMap.end(); I != E; ++I) 18258c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner if (I->second == OldVal) I->second = NewVal; 18358c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner} 18458c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner 18558c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner 1869cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattnerllvm::Constant *CodeGenModule::GetAddrOfFunctionDecl(const FunctionDecl *D, 1879cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner bool isDefinition) { 1889cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // See if it is already in the map. If so, just return it. 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Constant *&Entry = GlobalDeclMap[D]; 190be14c5c6e29af948f6f809c499f83d844e755af9Eli Friedman#if 0 191be14c5c6e29af948f6f809c499f83d844e755af9Eli Friedman // FIXME: The cache is currently broken! 1925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Entry) return Entry; 193be14c5c6e29af948f6f809c499f83d844e755af9Eli Friedman#endif 194be14c5c6e29af948f6f809c499f83d844e755af9Eli Friedman 1959cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner const llvm::Type *Ty = getTypes().ConvertType(D->getType()); 1969cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 1979cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Check to see if the function already exists. 1989cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Function *F = getModule().getFunction(D->getName()); 1999cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner const llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty); 2009cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2019cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If it doesn't already exist, just create and return an entry. 2029cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (F == 0) { 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: param attributes for sext/zext etc. 2044c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman F = llvm::Function::Create(FTy, llvm::Function::ExternalLinkage, 2054c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman D->getName(), &getModule()); 206ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman 207ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman // Set the appropriate calling convention for the Function. 208ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman if (D->getAttr<FastCallAttr>()) 209ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman F->setCallingConv(llvm::CallingConv::Fast); 210ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman return Entry = F; 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2139cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If the pointer type matches, just return it. 214ddc23f3e6fdc4f83dd46ef7e20394cfbd6063ff9Christopher Lamb llvm::Type *PFTy = llvm::PointerType::getUnqual(Ty); 2159cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (PFTy == F->getType()) return Entry = F; 216fafad83da6eff6bf090f6eb2dc1019ace7473f38Chris Lattner 2179cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If this isn't a definition, just return it casted to the right type. 2189cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (!isDefinition) 2199cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = llvm::ConstantExpr::getBitCast(F, PFTy); 2209cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2219cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Otherwise, we have a definition after a prototype with the wrong type. 2229cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // F is the Function* for the one with the wrong type, we must make a new 2239cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Function* and update everything that used F (a declaration) with the new 2249cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Function* (which will be a definition). 2259cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // 2269cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // This happens if there is a prototype for a function (e.g. "int f()") and 2279cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // then a definition of a different type (e.g. "int f(int x)"). Start by 2289cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // making a new function of the correct type, RAUW, then steal the name. 229984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::Function *NewFn = llvm::Function::Create(FTy, 2309cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Function::ExternalLinkage, 2319cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner "", &getModule()); 2329cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner NewFn->takeName(F); 2339cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2349cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Replace uses of F with the Function we will endow with a body. 2359cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Constant *NewPtrForOldDecl = 2369cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::ConstantExpr::getBitCast(NewFn, F->getType()); 2379cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner F->replaceAllUsesWith(NewPtrForOldDecl); 2389cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2399cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // FIXME: Update the globaldeclmap for the previous decl of this name. We 2409cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // really want a way to walk all of these, but we don't have it yet. This 2419cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // is incredibly slow! 2429cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner ReplaceMapValuesWith(F, NewPtrForOldDecl); 2439cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2449cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Ok, delete the old function now, which is dead. 2459cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner assert(F->isDeclaration() && "Shouldn't replace non-declaration"); 2469cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner F->eraseFromParent(); 2479cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2489cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Return the new function which has the right type. 2499cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = NewFn; 2509cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner} 2519cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 252c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattnerstatic bool IsZeroElementArray(const llvm::Type *Ty) { 253c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner if (const llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(Ty)) 254c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner return ATy->getNumElements() == 0; 255c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner return false; 256c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner} 257c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner 2582b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 2592b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattner bool isDefinition) { 2602b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattner assert(D->hasGlobalStorage() && "Not a global variable"); 2612b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattner 2629cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // See if it is already in the map. 2639cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Constant *&Entry = GlobalDeclMap[D]; 2649cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (Entry) return Entry; 2659cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 266ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb QualType ASTTy = D->getType(); 267ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb const llvm::Type *Ty = getTypes().ConvertTypeForMem(ASTTy); 2689cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2699cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Check to see if the global already exists. 270495737830441e3e01ed2699eb9e38c8f15116cb5Chris Lattner llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName(), true); 2719cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2729cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If it doesn't already exist, just create and return an entry. 2739cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (GV == 0) { 2749cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = new llvm::GlobalVariable(Ty, false, 2759cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::GlobalValue::ExternalLinkage, 276ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 0, D->getName(), &getModule(), 0, 277ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb ASTTy.getAddressSpace()); 278fafad83da6eff6bf090f6eb2dc1019ace7473f38Chris Lattner } 279fafad83da6eff6bf090f6eb2dc1019ace7473f38Chris Lattner 2809cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If the pointer type matches, just return it. 281ddc23f3e6fdc4f83dd46ef7e20394cfbd6063ff9Christopher Lamb llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 2829cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (PTy == GV->getType()) return Entry = GV; 2839cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2849cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If this isn't a definition, just return it casted to the right type. 2859cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner if (!isDefinition) 2869cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = llvm::ConstantExpr::getBitCast(GV, PTy); 2879cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2889cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 2899cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Otherwise, we have a definition after a prototype with the wrong type. 2909cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // GV is the GlobalVariable* for the one with the wrong type, we must make a 2919cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner /// new GlobalVariable* and update everything that used GV (a declaration) 2929cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // with the new GlobalVariable* (which will be a definition). 2939cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // 2949cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // This happens if there is a prototype for a global (e.g. "extern int x[];") 2959cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // and then a definition of a different type (e.g. "int x[10];"). Start by 2969cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // making a new global of the correct type, RAUW, then steal the name. 2979cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::GlobalVariable *NewGV = 2989cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner new llvm::GlobalVariable(Ty, false, llvm::GlobalValue::ExternalLinkage, 299ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 0, D->getName(), &getModule(), 0, 300ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb ASTTy.getAddressSpace()); 3019cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner NewGV->takeName(GV); 3029cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3039cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Replace uses of GV with the globalvalue we will endow with a body. 3049cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::Constant *NewPtrForOldDecl = 3059cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::ConstantExpr::getBitCast(NewGV, GV->getType()); 3069cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner GV->replaceAllUsesWith(NewPtrForOldDecl); 3079cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3089cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // FIXME: Update the globaldeclmap for the previous decl of this name. We 3099cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // really want a way to walk all of these, but we don't have it yet. This 3109cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // is incredibly slow! 3119cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner ReplaceMapValuesWith(GV, NewPtrForOldDecl); 3129cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 313c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner // Verify that GV was a declaration or something like x[] which turns into 314c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner // [0 x type]. 315c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner assert((GV->isDeclaration() || 316c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner IsZeroElementArray(GV->getType()->getElementType())) && 317c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner "Shouldn't replace non-declaration"); 318c4b23a530b04ee77b56772a70191d32119eadc3eChris Lattner 3199cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Ok, delete the old global now, which is dead. 3209cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner GV->eraseFromParent(); 3219cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 3229cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Return the new global which has the right type. 3239cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner return Entry = NewGV; 3245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3269cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 327391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattnervoid CodeGenModule::EmitObjCMethod(const ObjCMethodDecl *OMD) { 328391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // If this is not a prototype, emit the body. 329391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner if (OMD->getBody()) 330391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner CodeGenFunction(*this).GenerateObjCMethod(OMD); 331391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 332391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 33388a69ad80e1550e9932666e6efa050a5b1223889Chris Lattnervoid CodeGenModule::EmitFunction(const FunctionDecl *FD) { 3345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is not a prototype, emit the body. 335a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner if (!FD->isThisDeclarationADefinition()) 336a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner return; 337a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 338a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // If the function is a static, defer code generation until later so we can 339a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // easily omit unused statics. 340a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner if (FD->getStorageClass() != FunctionDecl::Static) { 3415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CodeGenFunction(*this).GenerateCode(FD); 342a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner return; 3434c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 344a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 345a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // We need to check the Module here to see if GetAddrOfFunctionDecl() has 346a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // already added this function to the Module because the address of the 347a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // function's prototype was taken. If this is the case, call 348a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // GetAddrOfFunctionDecl to insert the static FunctionDecl into the used 349a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // GlobalDeclsMap, so that EmitStatics will generate code for it later. 350a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // 351a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // Example: 352a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // static int foo(); 353a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // int bar() { return foo(); } 354a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner // static int foo() { return 5; } 355a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner if (getModule().getFunction(FD->getName())) 356a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner GetAddrOfFunctionDecl(FD, true); 357a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner 358a212c56e9b7533bcc2d6be90efd52ad241bf894eChris Lattner StaticDecls.push_back(FD); 3594c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman} 3604c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 3614c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begemanvoid CodeGenModule::EmitStatics() { 3624c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Emit code for each used static decl encountered. Since a previously unused 3634c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // static decl may become used during the generation of code for a static 3644c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // function, iterate until no changes are made. 3654c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman bool Changed; 3664c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman do { 3674c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman Changed = false; 3684c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman for (unsigned i = 0, e = StaticDecls.size(); i != e; ++i) { 3694c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Check the map of used decls for our static. If not found, continue. 3704c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman const Decl *D = StaticDecls[i]; 3711a1d92ac5e1354634af08c62a1d72e263d13be0cNate Begeman if (!GlobalDeclMap.count(D)) 3724c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman continue; 3734c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 3744c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // If this is a function decl, generate code for the static function if it 3754c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // has a body. Otherwise, we must have a var decl for a static global 3764c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // variable. 3774c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 3784c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (FD->getBody()) 3794c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman CodeGenFunction(*this).GenerateCode(FD); 3804c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } else { 3811a1d92ac5e1354634af08c62a1d72e263d13be0cNate Begeman EmitGlobalVarInit(cast<VarDecl>(D)); 3824c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 3834c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Erase the used decl from the list. 3844c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls[i] = StaticDecls.back(); 3854c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls.pop_back(); 3864c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman --i; 3874c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman --e; 3884c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 3894c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // Remember that we made a change. 3904c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman Changed = true; 3914c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 3924c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } while (Changed); 3935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3953b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonllvm::Constant *CodeGenModule::EmitGlobalInit(const Expr *Expr) { 3963b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitConstantExpr(Expr); 3979e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel} 3989e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel 3998bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 4008bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// annotation information for a given GlobalValue. The annotation struct is 4018bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 4028bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// GlobalValue being annotated. The second filed is thee constant string 4038bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// created from the AnnotateAttr's annotation. The third field is a constant 4048bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// string containing the name of the translation unit. The fourth field is 4058bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// the line number in the file of the annotated value declaration. 4068bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// 4078bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// FIXME: this does not unique the annotation string constants, as llvm-gcc 4088bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// appears to. 4098bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// 4108bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begemanllvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 4118bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman const AnnotateAttr *AA, 4128bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman unsigned LineNo) { 4138bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Module *M = &getModule(); 4148bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 4158bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // get [N x i8] constants for the annotation string, and the filename string 4168bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // which are the 2nd and 3rd elements of the global annotation structure. 4178bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman const llvm::Type *SBP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 4188bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *anno = llvm::ConstantArray::get(AA->getAnnotation(), true); 4198bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *unit = llvm::ConstantArray::get(M->getModuleIdentifier(), 4208bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman true); 4218bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 4228bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // Get the two global values corresponding to the ConstantArrays we just 4238bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // created to hold the bytes of the strings. 4248bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue *annoGV = 4258bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman new llvm::GlobalVariable(anno->getType(), false, 4268bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue::InternalLinkage, anno, 4278bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman GV->getName() + ".str", M); 4288bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // translation unit name string, emitted into the llvm.metadata section. 4298bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue *unitGV = 4308bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman new llvm::GlobalVariable(unit->getType(), false, 4318bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::GlobalValue::InternalLinkage, unit, ".str", M); 4328bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 4338bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman // Create the ConstantStruct that is the global annotion. 4348bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::Constant *Fields[4] = { 4358bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(GV, SBP), 4368bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(annoGV, SBP), 4378bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantExpr::getBitCast(unitGV, SBP), 4388bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman llvm::ConstantInt::get(llvm::Type::Int32Ty, LineNo) 4398bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman }; 4408bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman return llvm::ConstantStruct::get(Fields, 4, false); 4418bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman} 4428bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 443248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroffvoid CodeGenModule::EmitGlobalVar(const VarDecl *D) { 4444c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // If the VarDecl is a static, defer code generation until later so we can 4454c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman // easily omit unused statics. 4464c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman if (D->getStorageClass() == VarDecl::Static) { 4474c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman StaticDecls.push_back(D); 4484c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman return; 4494c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman } 4504c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 4519cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // If this is just a forward declaration of the variable, don't emit it now, 4529cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // allow it to be emitted lazily on its first use. 45388a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner if (D->getStorageClass() == VarDecl::Extern && D->getInit() == 0) 45488a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner return; 4559cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 4564c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman EmitGlobalVarInit(D); 4574c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman} 4584c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman 4594c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begemanvoid CodeGenModule::EmitGlobalVarInit(const VarDecl *D) { 4609cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Get the global, forcing it to be a direct reference. 4619cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner llvm::GlobalVariable *GV = 4622b9d2ca4ce53fffbe8a77c7db2fe4df5ccfb9fd4Chris Lattner cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, true)); 4639cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner 4649cd4fe4af6d3e8b6dcfce9c2cdefcaafca7eed7cChris Lattner // Convert the initializer, or use zero if appropriate. 4658f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner llvm::Constant *Init = 0; 4668f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner if (D->getInit() == 0) { 46788a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner Init = llvm::Constant::getNullValue(GV->getType()->getElementType()); 4688f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner } else if (D->getType()->isIntegerType()) { 4697b66000bdfc2684351fb03208e672f23012ed569Hartmut Kaiser llvm::APSInt Value(static_cast<uint32_t>( 47098be4943e8dc4f3905629a7102668960873cf863Chris Lattner getContext().getTypeSize(D->getInit()->getType()))); 471590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (D->getInit()->isIntegerConstantExpr(Value, Context)) 4728f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner Init = llvm::ConstantInt::get(Value); 4738f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner } 4748e53e720b3d7c962e91138a130dbd5d6c2def0e5Devang Patel 4759e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel if (!Init) 4762824723d6d181d2dfa56e62caabd68b0b18f0b9dOliver Hunt Init = EmitGlobalInit(D->getInit()); 4779e32d4b4a7270a9701b7cb454381eeaa4cc42a77Devang Patel 4788bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) { 4798bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman SourceManager &SM = Context.getSourceManager(); 4808bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman AddAnnotation(EmitAnnotateAttr(GV, AA, 4818bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman SM.getLogicalLineNumber(D->getLocation()))); 4828bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman } 4838bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman 484f89dfb292478b0921c68ef7177ceb738bee1e11bChris Lattner assert(GV->getType()->getElementType() == Init->getType() && 485f89dfb292478b0921c68ef7177ceb738bee1e11bChris Lattner "Initializer codegen type mismatch!"); 48688a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner GV->setInitializer(Init); 487ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 488ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) 4894f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman setVisibility(GV, attr->getVisibility()); 490ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // FIXME: else handle -fvisibility 49188a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner 49288a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner // Set the llvm linkage type as appropriate. 4938fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner if (D->getStorageClass() == VarDecl::Static) 4948fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner GV->setLinkage(llvm::Function::InternalLinkage); 4958fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else if (D->getAttr<DLLImportAttr>()) 496ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::Function::DLLImportLinkage); 497ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner else if (D->getAttr<DLLExportAttr>()) 498ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::Function::DLLExportLinkage); 4998fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else if (D->getAttr<WeakAttr>()) 500ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::GlobalVariable::WeakLinkage); 5018fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner else { 502ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // FIXME: This isn't right. This should handle common linkage and other 503ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // stuff. 504ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner switch (D->getStorageClass()) { 5058fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner case VarDecl::Static: assert(0 && "This case handled above"); 506ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Auto: 507ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Register: 508ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner assert(0 && "Can't have auto or register globals"); 509ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::None: 510ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner if (!D->getInit()) 511ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner GV->setLinkage(llvm::GlobalVariable::WeakLinkage); 512ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner break; 513ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::Extern: 514ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner case VarDecl::PrivateExtern: 515ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner // todo: common 516ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner break; 517ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner } 51888a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner } 51988a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner} 5205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 52132b266cff60737fedff00e8e721f3474533835efChris Lattner/// EmitGlobalVarDeclarator - Emit all the global vars attached to the specified 52232b266cff60737fedff00e8e721f3474533835efChris Lattner/// declarator chain. 523248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroffvoid CodeGenModule::EmitGlobalVarDeclarator(const VarDecl *D) { 524248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff for (; D; D = cast_or_null<VarDecl>(D->getNextDeclarator())) 525248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (D->isFileVarDecl()) 526248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff EmitGlobalVar(D); 52732b266cff60737fedff00e8e721f3474533835efChris Lattner} 5285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 529c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 530c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner // Make sure that this type is translated. 531c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner Types.UpdateCompletedType(TD); 532d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 533d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 534d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 535bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner/// getBuiltinLibFunction 536bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattnerllvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) { 5371426fecdf90dd1986751b9940422e675880ff671Chris Lattner if (BuiltinID > BuiltinFunctions.size()) 5381426fecdf90dd1986751b9940422e675880ff671Chris Lattner BuiltinFunctions.resize(BuiltinID); 539bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 5401426fecdf90dd1986751b9940422e675880ff671Chris Lattner // Cache looked up functions. Since builtin id #0 is invalid we don't reserve 5411426fecdf90dd1986751b9940422e675880ff671Chris Lattner // a slot for it. 5421426fecdf90dd1986751b9940422e675880ff671Chris Lattner assert(BuiltinID && "Invalid Builtin ID"); 5431426fecdf90dd1986751b9940422e675880ff671Chris Lattner llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID-1]; 544bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner if (FunctionSlot) 545bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner return FunctionSlot; 546bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 547bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner assert(Context.BuiltinInfo.isLibFunction(BuiltinID) && "isn't a lib fn"); 548bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 549bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // Get the name, skip over the __builtin_ prefix. 550bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner const char *Name = Context.BuiltinInfo.GetName(BuiltinID)+10; 551bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 552bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // Get the type for the builtin. 553bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context); 554bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner const llvm::FunctionType *Ty = 555bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner cast<llvm::FunctionType>(getTypes().ConvertType(Type)); 556bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 557bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // FIXME: This has a serious problem with code like this: 558bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // void abs() {} 559bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // ... __builtin_abs(x); 560bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // The two versions of abs will collide. The fix is for the builtin to win, 561bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // and for the existing one to be turned into a constantexpr cast of the 562bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // builtin. In the case where the existing one is a static function, it 563bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // should just be renamed. 564c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner if (llvm::Function *Existing = getModule().getFunction(Name)) { 565c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage()) 566c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner return FunctionSlot = Existing; 567c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner assert(Existing == 0 && "FIXME: Name collision"); 568c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner } 569bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 570bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner // FIXME: param attributes for sext/zext etc. 5714c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman return FunctionSlot = 5724c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman llvm::Function::Create(Ty, llvm::Function::ExternalLinkage, Name, 5734c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman &getModule()); 574bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner} 575bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 5767acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattnerllvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 5777acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner unsigned NumTys) { 5787acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner return llvm::Intrinsic::getDeclaration(&getModule(), 5797acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner (llvm::Intrinsic::ID)IID, Tys, NumTys); 5807acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner} 581bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner 5825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerllvm::Function *CodeGenModule::getMemCpyFn() { 5835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (MemCpyFn) return MemCpyFn; 5845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Intrinsic::ID IID; 585f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner switch (Context.Target.getPointerWidth(0)) { 5865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown ptr width"); 5875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case 32: IID = llvm::Intrinsic::memcpy_i32; break; 5885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case 64: IID = llvm::Intrinsic::memcpy_i64; break; 5895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 5907acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner return MemCpyFn = getIntrinsic(IID); 5915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 592c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 5930c99509927a0c7a48490486b9fec287b63e5c09cEli Friedmanllvm::Function *CodeGenModule::getMemMoveFn() { 5940c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman if (MemMoveFn) return MemMoveFn; 5950c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman llvm::Intrinsic::ID IID; 5960c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman switch (Context.Target.getPointerWidth(0)) { 5970c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman default: assert(0 && "Unknown ptr width"); 5980c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman case 32: IID = llvm::Intrinsic::memmove_i32; break; 5990c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman case 64: IID = llvm::Intrinsic::memmove_i64; break; 6000c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman } 6010c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman return MemMoveFn = getIntrinsic(IID); 6020c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman} 6030c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman 60441ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venanciollvm::Function *CodeGenModule::getMemSetFn() { 60541ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio if (MemSetFn) return MemSetFn; 60641ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio llvm::Intrinsic::ID IID; 607f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner switch (Context.Target.getPointerWidth(0)) { 60841ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio default: assert(0 && "Unknown ptr width"); 60941ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio case 32: IID = llvm::Intrinsic::memset_i32; break; 61041ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio case 64: IID = llvm::Intrinsic::memset_i64; break; 61141ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio } 61241ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio return MemSetFn = getIntrinsic(IID); 61341ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio} 6147acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner 615bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattnerllvm::Constant *CodeGenModule:: 616bef20ac367a09555b30d6eb3847a81ec164caf88Chris LattnerGetAddrOfConstantCFString(const std::string &str) { 617c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::StringMapEntry<llvm::Constant *> &Entry = 618c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 619c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 620c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson if (Entry.getValue()) 621c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson return Entry.getValue(); 622c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 623c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson std::vector<llvm::Constant*> Fields; 624c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 625c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson if (!CFConstantStringClassRef) { 626c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 627c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = llvm::ArrayType::get(Ty, 0); 628c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 629c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson CFConstantStringClassRef = 630c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson new llvm::GlobalVariable(Ty, false, 631c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::GlobalVariable::ExternalLinkage, 0, 632c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson "__CFConstantStringClassReference", 633c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson &getModule()); 634c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson } 635c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 636c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // Class pointer. 637c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty); 638c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *Zeros[] = { Zero, Zero }; 639c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::Constant *C = 640c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::ConstantExpr::getGetElementPtr(CFConstantStringClassRef, Zeros, 2); 641c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(C); 642c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 643c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // Flags. 644c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 645c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(llvm::ConstantInt::get(Ty, 1992)); 646c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 647c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // String pointer. 648c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantArray::get(str); 649c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = new llvm::GlobalVariable(C->getType(), true, 650c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson llvm::GlobalValue::InternalLinkage, 651c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C, ".str", &getModule()); 652c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 653c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2); 654c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(C); 655c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 656c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // String length. 657c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = getTypes().ConvertType(getContext().LongTy); 658c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Fields.push_back(llvm::ConstantInt::get(Ty, str.length())); 659c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson 660c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson // The struct. 661c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson Ty = getTypes().ConvertType(getContext().getCFConstantStringType()); 662c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson C = llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Fields); 6630c67829763b98bc670062b553897a851fab17401Anders Carlsson llvm::GlobalVariable *GV = 6640c67829763b98bc670062b553897a851fab17401Anders Carlsson new llvm::GlobalVariable(C->getType(), true, 6650c67829763b98bc670062b553897a851fab17401Anders Carlsson llvm::GlobalVariable::InternalLinkage, 6660c67829763b98bc670062b553897a851fab17401Anders Carlsson C, "", &getModule()); 6670c67829763b98bc670062b553897a851fab17401Anders Carlsson GV->setSection("__DATA,__cfstring"); 6680c67829763b98bc670062b553897a851fab17401Anders Carlsson Entry.setValue(GV); 6690c67829763b98bc670062b553897a851fab17401Anders Carlsson return GV; 670c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson} 67145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 672a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// GenerateWritableString -- Creates storage for a string literal. 67345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattnerstatic llvm::Constant *GenerateStringLiteral(const std::string &str, 67445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner bool constant, 6752c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner CodeGenModule &CGM) { 67645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create Constant for this string literal 67745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::Constant *C=llvm::ConstantArray::get(str); 67845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 67945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create a global variable for this string 68045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner C = new llvm::GlobalVariable(C->getType(), constant, 68145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::GlobalValue::InternalLinkage, 6822c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner C, ".str", &CGM.getModule()); 68345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return C; 68445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner} 68545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 686a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// CodeGenModule::GetAddrOfConstantString -- returns a pointer to the character 687a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// array containing the literal. The result is pointer to array type. 68845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str) { 68945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Don't share any string literals if writable-strings is turned on. 69045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner if (Features.WritableStrings) 69145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return GenerateStringLiteral(str, false, *this); 69245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 69345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::StringMapEntry<llvm::Constant *> &Entry = 69445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 69545e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 69645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner if (Entry.getValue()) 69745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return Entry.getValue(); 69845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner 69945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner // Create a global variable for this. 70045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner llvm::Constant *C = GenerateStringLiteral(str, true, *this); 70145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner Entry.setValue(C); 70245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner return C; 70345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner} 704