CodeGenModule.cpp revision 34771b594ca8cdf8cd2e40b27170efa4ed2833c5
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
145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenModule.h"
15bd3606426d389370616126af969904ec493cb105Chris Lattner#include "CGDebugInfo.h"
165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenFunction.h"
170dbe227feccf6a8dbadfff8ca3f80416b7bf2f28Daniel Dunbar#include "CGCall.h"
18af2f62ce32e462f256855cd24b06dec4755d2827Daniel Dunbar#include "CGObjCRuntime.h"
195f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor#include "Mangle.h"
20bd3606426d389370616126af969904ec493cb105Chris Lattner#include "clang/Frontend/CompileOptions.h"
215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/ASTContext.h"
22c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h"
2321ef7ae45c8b91f23cf5eab2263421bb398a644bChris Lattner#include "clang/AST/DeclCXX.h"
241b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner#include "clang/Basic/Builtins.h"
252c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner#include "clang/Basic/Diagnostic.h"
268bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman#include "clang/Basic/SourceManager.h"
275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h"
28e9b7d8ace8674585818990cff585daae7745bd88Steve Naroff#include "clang/Basic/ConvertUTF.h"
29ec9426ca6039279bcc99bc2c625bb2abe4f0353dNate Begeman#include "llvm/CallingConv.h"
30bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner#include "llvm/Module.h"
315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/Intrinsics.h"
3220ff3108fcd2c3bd734dc79efc22ebaa090abd41Anton Korobeynikov#include "llvm/Target/TargetData.h"
335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang;
345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen;
355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
37bd3606426d389370616126af969904ec493cb105Chris LattnerCodeGenModule::CodeGenModule(ASTContext &C, const CompileOptions &compileOpts,
38fb97b03e42d397405f617be0252be83e77a66f6eChris Lattner                             llvm::Module &M, const llvm::TargetData &TD,
39bd3606426d389370616126af969904ec493cb105Chris Lattner                             Diagnostic &diags)
40bd3606426d389370616126af969904ec493cb105Chris Lattner  : BlockModule(C, M, TD, Types, *this), Context(C),
41bd3606426d389370616126af969904ec493cb105Chris Lattner    Features(C.getLangOptions()), CompileOpts(compileOpts), TheModule(M),
422a998148a6823c44d67da347c95eb2ea21f6b986Mike Stump    TheTargetData(TD), Diags(diags), Types(C, M, TD), Runtime(0),
43a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson    MemCpyFn(0), MemMoveFn(0), MemSetFn(0), CFConstantStringClassRef(0),
44a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson    VMContext(M.getContext()) {
45208ff5e8a073de2a5d15cbe03cab8a4c0d935e28Daniel Dunbar
463c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner  if (!Features.ObjC1)
473c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner    Runtime = 0;
483c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner  else if (!Features.NeXTRuntime)
493c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner    Runtime = CreateGNUObjCRuntime(*this);
503c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner  else if (Features.ObjCNonFragileABI)
513c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner    Runtime = CreateMacNonFragileABIObjCRuntime(*this);
523c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner  else
533c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner    Runtime = CreateMacObjCRuntime(*this);
54e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta
55e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta  // If debug info generation is enabled, create the CGDebugInfo object.
566dba432c7b862c2219e5d6e52b0cd188fbf84b01Devang Patel  DebugInfo = CompileOpts.DebugInfo ? new CGDebugInfo(this) : 0;
572b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner}
582b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner
592b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris LattnerCodeGenModule::~CodeGenModule() {
60815c78fd9ab8bd5dfe8e8a91b8c6a413e2b8c889Ted Kremenek  delete Runtime;
61815c78fd9ab8bd5dfe8e8a91b8c6a413e2b8c889Ted Kremenek  delete DebugInfo;
62815c78fd9ab8bd5dfe8e8a91b8c6a413e2b8c889Ted Kremenek}
63815c78fd9ab8bd5dfe8e8a91b8c6a413e2b8c889Ted Kremenek
64815c78fd9ab8bd5dfe8e8a91b8c6a413e2b8c889Ted Kremenekvoid CodeGenModule::Release() {
6589ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson  // We need to call this first because it can add deferred declarations.
6689ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson  EmitCXXGlobalInitFunc();
6789ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson
6882227ff4eb665bbf41720ebdc0dc9215a86ba838Chris Lattner  EmitDeferred();
69208ff5e8a073de2a5d15cbe03cab8a4c0d935e28Daniel Dunbar  if (Runtime)
70208ff5e8a073de2a5d15cbe03cab8a4c0d935e28Daniel Dunbar    if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
71208ff5e8a073de2a5d15cbe03cab8a4c0d935e28Daniel Dunbar      AddGlobalCtor(ObjCInitFunction);
726bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  EmitCtorList(GlobalCtors, "llvm.global_ctors");
736bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  EmitCtorList(GlobalDtors, "llvm.global_dtors");
74532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman  EmitAnnotations();
750269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar  EmitLLVMUsed();
76f1968f28869f4e0675450ae39c478a37c5b9abd6Daniel Dunbar}
77f1968f28869f4e0675450ae39c478a37c5b9abd6Daniel Dunbar
78488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the
792c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner/// specified stmt yet.
8090df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
8190df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar                                     bool OmitOnError) {
8290df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar  if (OmitOnError && getDiags().hasErrorOccurred())
8390df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar    return;
841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
8556b8001b42bd603ef593e3cb278d8b9b9ba26ca9Daniel Dunbar                                               "cannot compile this %0 yet");
862c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner  std::string Msg = Type;
870a14eee528a901c16f0e288fbc10a3abc1660d87Chris Lattner  getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
880a14eee528a901c16f0e288fbc10a3abc1660d87Chris Lattner    << Msg << S->getSourceRange();
892c8569d5f43f7de1fb993e84c95ea571dd9ac55eChris Lattner}
9058c3f9ec11cbe852a518bf2f83af46f938b7b852Chris Lattner
91488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the
92c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner/// specified decl yet.
9390df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
9490df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar                                     bool OmitOnError) {
9590df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar  if (OmitOnError && getDiags().hasErrorOccurred())
9690df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar    return;
971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
9856b8001b42bd603ef593e3cb278d8b9b9ba26ca9Daniel Dunbar                                               "cannot compile this %0 yet");
99c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner  std::string Msg = Type;
1000a14eee528a901c16f0e288fbc10a3abc1660d87Chris Lattner  getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
101c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner}
102c6fdc34ac0183bfa03d65f317c78b7bdac52897eChris Lattner
1031eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpLangOptions::VisibilityMode
10404d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel DunbarCodeGenModule::getDeclVisibilityMode(const Decl *D) const {
10504d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
10604d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    if (VD->getStorageClass() == VarDecl::PrivateExtern)
10704d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar      return LangOptions::Hidden;
10804d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar
10940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) {
11004d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    switch (attr->getVisibility()) {
11104d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    default: assert(0 && "Unknown visibility!");
1121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    case VisibilityAttr::DefaultVisibility:
11304d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar      return LangOptions::Default;
11404d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    case VisibilityAttr::HiddenVisibility:
11504d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar      return LangOptions::Hidden;
11604d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    case VisibilityAttr::ProtectedVisibility:
11704d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar      return LangOptions::Protected;
11804d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    }
1197e714cd931fa3a90bfd728318a92485aa3e95748Daniel Dunbar  }
1206ab187a49a42de6d351248d8a6e0206e39743a0cDaniel Dunbar
12104d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  return getLangOptions().getVisibilityMode();
1224f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman}
1234f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman
1241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
12504d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar                                        const Decl *D) const {
12604d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  // Internal definitions always have default visibility.
127df102fcb978588d5edbc661fb5da0b6922f9ab1cChris Lattner  if (GV->hasLocalLinkage()) {
1287e714cd931fa3a90bfd728318a92485aa3e95748Daniel Dunbar    GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1296ab187a49a42de6d351248d8a6e0206e39743a0cDaniel Dunbar    return;
1307e714cd931fa3a90bfd728318a92485aa3e95748Daniel Dunbar  }
1316ab187a49a42de6d351248d8a6e0206e39743a0cDaniel Dunbar
13204d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  switch (getDeclVisibilityMode(D)) {
1337cd2e93125e2f3b6ca01b24ed0c3fd7e94683fd9Fariborz Jahanian  default: assert(0 && "Unknown visibility!");
13404d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  case LangOptions::Default:
13504d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    return GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
13604d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  case LangOptions::Hidden:
13704d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    return GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
13804d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar  case LangOptions::Protected:
13904d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    return GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1407cd2e93125e2f3b6ca01b24ed0c3fd7e94683fd9Fariborz Jahanian  }
1417cd2e93125e2f3b6ca01b24ed0c3fd7e94683fd9Fariborz Jahanian}
1427cd2e93125e2f3b6ca01b24ed0c3fd7e94683fd9Fariborz Jahanian
1432a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlssonconst char *CodeGenModule::getMangledName(const GlobalDecl &GD) {
1444a6835e650ff24e19ce08a3bd347c0ad186777fdAnders Carlsson  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
1451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1462a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
1472a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson    return getMangledCXXCtorName(D, GD.getCtorType());
1482a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
1492a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson    return getMangledCXXDtorName(D, GD.getDtorType());
1501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1512a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  return getMangledName(ND);
1522a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson}
1532a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson
1545f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor/// \brief Retrieves the mangled name for the given declaration.
1555f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor///
1565f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor/// If the given declaration requires a mangled name, returns an
157c50689bd1e8788a7fc8f19070b7505ff95034979Chris Lattner/// const char* containing the mangled name.  Otherwise, returns
158c50689bd1e8788a7fc8f19070b7505ff95034979Chris Lattner/// the unmangled name.
1595f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor///
1606ec3668a2608b63473207319f5ceff9bbd22ea51Douglas Gregorconst char *CodeGenModule::getMangledName(const NamedDecl *ND) {
161c50689bd1e8788a7fc8f19070b7505ff95034979Chris Lattner  // In C, functions with no attributes never need to be mangled. Fastpath them.
162c50689bd1e8788a7fc8f19070b7505ff95034979Chris Lattner  if (!getLangOptions().CPlusPlus && !ND->hasAttrs()) {
163c50689bd1e8788a7fc8f19070b7505ff95034979Chris Lattner    assert(ND->getIdentifier() && "Attempt to mangle unnamed decl.");
1643c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner    return ND->getNameAsCString();
165c50689bd1e8788a7fc8f19070b7505ff95034979Chris Lattner  }
1661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1676ec3668a2608b63473207319f5ceff9bbd22ea51Douglas Gregor  llvm::SmallString<256> Name;
1686ec3668a2608b63473207319f5ceff9bbd22ea51Douglas Gregor  llvm::raw_svector_ostream Out(Name);
169fe345572459b69a6b680322fef504b4f8bd98dd7Daniel Dunbar  if (!mangleName(ND, Context, Out)) {
170fe345572459b69a6b680322fef504b4f8bd98dd7Daniel Dunbar    assert(ND->getIdentifier() && "Attempt to mangle unnamed decl.");
1713c8f153ae767fa55b2da74438c7f8ec370a06d6fChris Lattner    return ND->getNameAsCString();
172fe345572459b69a6b680322fef504b4f8bd98dd7Daniel Dunbar  }
1735f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor
1746ec3668a2608b63473207319f5ceff9bbd22ea51Douglas Gregor  Name += '\0';
17595d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson  return UniqueMangledName(Name.begin(), Name.end());
17695d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson}
17795d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson
17895d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlssonconst char *CodeGenModule::UniqueMangledName(const char *NameStart,
17995d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson                                             const char *NameEnd) {
18095d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson  assert(*(NameEnd - 1) == '\0' && "Mangled name must be null terminated!");
1811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
18295d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson  return MangledNames.GetOrCreateValue(NameStart, NameEnd).getKeyData();
1835f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor}
1845f2bfd4811996abb783aa6c7254c56baa6930e8cDouglas Gregor
1856d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner/// AddGlobalCtor - Add a function to the list that will be called before
1866d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner/// main() runs.
1876bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbarvoid CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
18849988884c1da4b2200bfe2298a1e41b3f044e8d4Daniel Dunbar  // FIXME: Type coercion of void()* types.
1896bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  GlobalCtors.push_back(std::make_pair(Ctor, Priority));
1906d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner}
1916d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner
1926bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar/// AddGlobalDtor - Add a function to the list that will be called
1936bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar/// when the module is unloaded.
1946bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbarvoid CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
19549988884c1da4b2200bfe2298a1e41b3f044e8d4Daniel Dunbar  // FIXME: Type coercion of void()* types.
1966bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  GlobalDtors.push_back(std::make_pair(Dtor, Priority));
1976bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar}
1986bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar
1996bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbarvoid CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
2006bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  // Ctor function type is void()*.
2016bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  llvm::FunctionType* CtorFTy =
2021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
2036bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar                            std::vector<const llvm::Type*>(),
2046bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar                            false);
20596e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson  llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
2066bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar
2076bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  // Get the type of a ctor entry, { i32, void ()* }.
2081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::StructType* CtorStructTy =
2091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext),
21096e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson                          llvm::PointerType::getUnqual(CtorFTy), NULL);
2116bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar
2126bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  // Construct the constructor and destructor arrays.
2136bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  std::vector<llvm::Constant*> Ctors;
2146bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
2156bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar    std::vector<llvm::Constant*> S;
2161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
2170032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson                I->second, false));
2183c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
21908e252425ca2cbdc44ba65d9a657ed5398014e36Owen Anderson    Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
2206bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  }
2216bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar
2226bfed7e411adc46eaf616371f85f68305c6e6257Daniel Dunbar  if (!Ctors.empty()) {
22396e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson    llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
2241c431b323d776362490bbf7cc796b74fedaf19f2Owen Anderson    new llvm::GlobalVariable(TheModule, AT, false,
225572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner                             llvm::GlobalValue::AppendingLinkage,
2267db6d838aad4083fe86d7bf703a75fe6e8a17856Owen Anderson                             llvm::ConstantArray::get(AT, Ctors),
2271c431b323d776362490bbf7cc796b74fedaf19f2Owen Anderson                             GlobalName);
2286d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner  }
2296d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner}
2306d39760673df2e92d9293f46ff8c66dad6ab5e0aChris Lattner
231532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begemanvoid CodeGenModule::EmitAnnotations() {
232532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman  if (Annotations.empty())
233532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman    return;
234532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman
235532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman  // Create a new global variable for the ConstantStruct in the Module.
236532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman  llvm::Constant *Array =
23796e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson  llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
238532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman                                                Annotations.size()),
239532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman                           Annotations);
2401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::GlobalValue *gv =
2411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  new llvm::GlobalVariable(TheModule, Array->getType(), false,
2421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump                           llvm::GlobalValue::AppendingLinkage, Array,
2431c431b323d776362490bbf7cc796b74fedaf19f2Owen Anderson                           "llvm.global.annotations");
244532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman  gv->setSection("llvm.metadata");
245532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman}
246532485cc6c078d9e51b517c6bbd8984deb17f0feNate Begeman
24786daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattnerstatic CodeGenModule::GVALinkage
2481eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpGetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD,
24968584ed35ad819a1668e3f527ba7f5dd4ae6a333Douglas Gregor                      const LangOptions &Features) {
2501fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor  // The kind of external linkage this function will have, if it is not
2511fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor  // inline or static.
2521fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor  CodeGenModule::GVALinkage External = CodeGenModule::GVA_StrongExternal;
2531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  if (Context.getLangOptions().CPlusPlus &&
254d0e3daf2b980b505e535d35b432c938c6d0208efDouglas Gregor      FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
2551fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor    External = CodeGenModule::GVA_TemplateInstantiation;
2561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
257167b824ce1947bf71ec8a71296daa2c54ebe58dfAnders Carlsson  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
258167b824ce1947bf71ec8a71296daa2c54ebe58dfAnders Carlsson    // C++ member functions defined inside the class are always inline.
259f5cecfbdcd20be224861f9e67c5973a9a2b61512Argyrios Kyrtzidis    if (MD->isInline() || !MD->isOutOfLine())
260167b824ce1947bf71ec8a71296daa2c54ebe58dfAnders Carlsson      return CodeGenModule::GVA_CXXInline;
2611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2621fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor    return External;
263167b824ce1947bf71ec8a71296daa2c54ebe58dfAnders Carlsson  }
2641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
26543907e87c776391d7d96da04b48e7bf06d8baafcEli Friedman  // "static" functions get internal linkage.
2665e222139610a9f8b2b5f4ddd112f10dec9ec1e97Eli Friedman  if (FD->getStorageClass() == FunctionDecl::Static)
2677c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    return CodeGenModule::GVA_Internal;
2687c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
269005eedce54da6580de37bb115bf581008637e4b1Chris Lattner  if (!FD->isInline())
2701fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor    return External;
2711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2721fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor  if (!Features.CPlusPlus || FD->hasAttr<GNUInlineAttr>()) {
2731fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor    // GNU or C99 inline semantics. Determine whether this symbol should be
2741fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor    // externally visible.
2751fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor    if (FD->isInlineDefinitionExternallyVisible())
2761fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor      return External;
277cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner
2781fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor    // C99 inline semantics, where the symbol is not externally visible.
279b3efa98e320590e8be9d62818e89e599303e65b4Douglas Gregor    return CodeGenModule::GVA_C99Inline;
2801fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor  }
281b3efa98e320590e8be9d62818e89e599303e65b4Douglas Gregor
2821fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor  // C++ inline semantics
2831fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor  assert(Features.CPlusPlus && "Must be in C++ mode");
2841fc09a92d0bffda20e06fa882388c01e192e2069Douglas Gregor  return CodeGenModule::GVA_CXXInline;
2857c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar}
2867c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
2877c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar/// SetFunctionDefinitionAttributes - Set attributes for a global.
288b97b69244a4e7916c7b8fca28fa21b36ce5b30b2Daniel Dunbar///
289f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump/// FIXME: This is currently only done for aliases and functions, but not for
290f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump/// variables (these details are set in EmitGlobalVarDefinition for variables).
2917c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbarvoid CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
2927c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar                                                    llvm::GlobalValue *GV) {
29368584ed35ad819a1668e3f527ba7f5dd4ae6a333Douglas Gregor  GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features);
2947c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
29555d6f50b23a1fd0a04b568787a25beb7537e6c9bDaniel Dunbar  if (Linkage == GVA_Internal) {
2969f9427999cf69b3b89cd0ed3be16ed27a1c282c7Chris Lattner    GV->setLinkage(llvm::Function::InternalLinkage);
29740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  } else if (D->hasAttr<DLLExportAttr>()) {
2987c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    GV->setLinkage(llvm::Function::DLLExportLinkage);
29940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  } else if (D->hasAttr<WeakAttr>()) {
30044b0bc008ee11cdee69ad12210ca7550e4fa426aChris Lattner    GV->setLinkage(llvm::Function::WeakAnyLinkage);
301cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner  } else if (Linkage == GVA_C99Inline) {
302cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner    // In C99 mode, 'inline' functions are guaranteed to have a strong
303cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner    // definition somewhere else, so we can use available_externally linkage.
304d9d049a93c55624908e81cf3927b7905efeba05fChris Lattner    GV->setLinkage(llvm::Function::AvailableExternallyLinkage);
3051fd2dd145d9bcdf0b8d60a88e1795b6ae83656f5Douglas Gregor  } else if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) {
30686daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // In C++, the compiler has to emit a definition in every translation unit
30786daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // that references the function.  We should use linkonce_odr because
30886daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // a) if all references in this translation unit are optimized away, we
30986daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // don't need to codegen it.  b) if the function persists, it needs to be
31086daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // merged with other definitions. c) C++ has the ODR, so we know the
31186daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // definition is dependable.
31286daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    GV->setLinkage(llvm::Function::LinkOnceODRLinkage);
3137c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  } else {
314cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner    assert(Linkage == GVA_StrongExternal);
315cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner    // Otherwise, we have strong external linkage.
3167c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    GV->setLinkage(llvm::Function::ExternalLinkage);
3170dbe227feccf6a8dbadfff8ca3f80416b7bf2f28Daniel Dunbar  }
318d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes
3197c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  SetCommonAttributes(D, GV);
320d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes}
321d4cbda6292b321c2e7dce7f039d92918fee99b3aNuno Lopes
3227dbd8197040313d796282d4af06eccdf8a17319cDaniel Dunbarvoid CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
3231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump                                              const CGFunctionInfo &Info,
3247dbd8197040313d796282d4af06eccdf8a17319cDaniel Dunbar                                              llvm::Function *F) {
325ca6408c3176783f0b29da4679a08512aa05f0c73Daniel Dunbar  unsigned CallingConv;
326761d7f78e2dac7ea5f35828c2271e60d91e106ceDevang Patel  AttributeListType AttributeList;
327ca6408c3176783f0b29da4679a08512aa05f0c73Daniel Dunbar  ConstructAttributeList(Info, D, AttributeList, CallingConv);
328761d7f78e2dac7ea5f35828c2271e60d91e106ceDevang Patel  F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
329ca6408c3176783f0b29da4679a08512aa05f0c73Daniel Dunbar                                          AttributeList.size()));
330ca6408c3176783f0b29da4679a08512aa05f0c73Daniel Dunbar  F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
331f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbar}
332f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbar
3337c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbarvoid CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
3347c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar                                                           llvm::Function *F) {
33574ac74ae244c501027924c99f2a33559a1e23b53Daniel Dunbar  if (!Features.Exceptions && !Features.ObjCNonFragileABI)
3361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    F->addFnAttr(llvm::Attribute::NoUnwind);
337af668b0e7d3581dea3b4f29a9262686e83887e5bDaniel Dunbar
33840b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (D->hasAttr<AlwaysInlineAttr>())
339af668b0e7d3581dea3b4f29a9262686e83887e5bDaniel Dunbar    F->addFnAttr(llvm::Attribute::AlwaysInline);
3401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
3411feade8e520be483293dbf55eb57a51720899589Mike Stump  if (D->hasAttr<NoInlineAttr>())
34281ebbde0fb30a40df0f5e913d8a1f71c383d271aAnders Carlsson    F->addFnAttr(llvm::Attribute::NoInline);
343f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbar}
344f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbar
3451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid CodeGenModule::SetCommonAttributes(const Decl *D,
3467c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar                                        llvm::GlobalValue *GV) {
3477c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  setGlobalVisibility(GV, D);
3487c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
34940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (D->hasAttr<UsedAttr>())
3507c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    AddUsedGlobal(GV);
3517c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
35240b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (const SectionAttr *SA = D->getAttr<SectionAttr>())
3537c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    GV->setSection(SA->getName());
3547c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar}
3557c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
3560e4f40e1bbc4dce16bbb9870300a435419f1b3d5Daniel Dunbarvoid CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
3570e4f40e1bbc4dce16bbb9870300a435419f1b3d5Daniel Dunbar                                                  llvm::Function *F,
3580e4f40e1bbc4dce16bbb9870300a435419f1b3d5Daniel Dunbar                                                  const CGFunctionInfo &FI) {
3590e4f40e1bbc4dce16bbb9870300a435419f1b3d5Daniel Dunbar  SetLLVMFunctionAttributes(D, FI, F);
3600e4f40e1bbc4dce16bbb9870300a435419f1b3d5Daniel Dunbar  SetLLVMFunctionAttributesForDefinition(D, F);
3617c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
3627c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  F->setLinkage(llvm::Function::InternalLinkage);
3637c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
3640e4f40e1bbc4dce16bbb9870300a435419f1b3d5Daniel Dunbar  SetCommonAttributes(D, F);
365f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbar}
366f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbar
367f80519b919a348db004fba18530706314d1ebfb5Daniel Dunbarvoid CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD,
368c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman                                          llvm::Function *F,
369c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman                                          bool IsIncompleteFunction) {
370c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman  if (!IsIncompleteFunction)
371c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman    SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(FD), F);
3721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
3737c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  // Only a few attributes are set on declarations; these may later be
3747c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  // overridden by a definition.
3751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
37640b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (FD->hasAttr<DLLImportAttr>()) {
3777c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    F->setLinkage(llvm::Function::DLLImportLinkage);
3781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  } else if (FD->hasAttr<WeakAttr>() ||
37940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis             FD->hasAttr<WeakImportAttr>()) {
3807c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    // "extern_weak" is overloaded in LLVM; we probably should have
3811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    // separate linkage types for this.
3827c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    F->setLinkage(llvm::Function::ExternalWeakLinkage);
3837c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  } else {
3841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    F->setLinkage(llvm::Function::ExternalLinkage);
3857c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  }
3867c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
38740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
3887c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    F->setSection(SA->getName());
389219df6644e2338ff067471ab0d85f27b88544ac2Daniel Dunbar}
390219df6644e2338ff067471ab0d85f27b88544ac2Daniel Dunbar
3910269871c9cba493f76237175ab60313406f3bafaDaniel Dunbarvoid CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
3921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  assert(!GV->isDeclaration() &&
3930269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar         "Only globals with definition can force usage.");
39435f38a2c22d68c22e2dbe8e9ee84c120c8f327bbChris Lattner  LLVMUsed.push_back(GV);
3950269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar}
3960269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar
3970269871c9cba493f76237175ab60313406f3bafaDaniel Dunbarvoid CodeGenModule::EmitLLVMUsed() {
3980269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar  // Don't create llvm.used if there is no need.
399ad64e024bd18cf25dcfa44e049004371838decd8Chris Lattner  if (LLVMUsed.empty())
4000269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar    return;
4010269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar
4020032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  llvm::Type *i8PTy =
4030032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson      llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
4041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
40535f38a2c22d68c22e2dbe8e9ee84c120c8f327bbChris Lattner  // Convert LLVMUsed to what ConstantArray needs.
40635f38a2c22d68c22e2dbe8e9ee84c120c8f327bbChris Lattner  std::vector<llvm::Constant*> UsedArray;
40735f38a2c22d68c22e2dbe8e9ee84c120c8f327bbChris Lattner  UsedArray.resize(LLVMUsed.size());
40835f38a2c22d68c22e2dbe8e9ee84c120c8f327bbChris Lattner  for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
4091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    UsedArray[i] =
4101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump     llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
411a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson                                      i8PTy);
41235f38a2c22d68c22e2dbe8e9ee84c120c8f327bbChris Lattner  }
4131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
414c38e9affd4519ea199af22419c8c794973cc4b23Fariborz Jahanian  if (UsedArray.empty())
415c38e9affd4519ea199af22419c8c794973cc4b23Fariborz Jahanian    return;
41696e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson  llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size());
4171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::GlobalVariable *GV =
4191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    new llvm::GlobalVariable(getModule(), ATy, false,
4200269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar                             llvm::GlobalValue::AppendingLinkage,
4217db6d838aad4083fe86d7bf703a75fe6e8a17856Owen Anderson                             llvm::ConstantArray::get(ATy, UsedArray),
4221c431b323d776362490bbf7cc796b74fedaf19f2Owen Anderson                             "llvm.used");
4230269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar
4240269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar  GV->setSection("llvm.metadata");
4250269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar}
4260269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar
4270269871c9cba493f76237175ab60313406f3bafaDaniel Dunbarvoid CodeGenModule::EmitDeferred() {
42867b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // Emit code for any potentially referenced deferred decls.  Since a
42967b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // previously unused static decl may become used during the generation of code
43067b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // for a static function, iterate until no  changes are made.
43167b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  while (!DeferredDeclsToEmit.empty()) {
4322a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson    GlobalDecl D = DeferredDeclsToEmit.back();
43367b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    DeferredDeclsToEmit.pop_back();
43467b00520c8f5b48fad722b790d87fea6be764efeChris Lattner
43567b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // The mangled name for the decl must have been emitted in GlobalDeclMap.
43667b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // Look it up to see if it was defined with a stronger definition (e.g. an
43767b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // extern inline function with a strong function redefinition).  If so,
43867b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // just ignore the deferred decl.
43967b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    llvm::GlobalValue *CGRef = GlobalDeclMap[getMangledName(D)];
44067b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    assert(CGRef && "Deferred decl wasn't referenced?");
4411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
44267b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    if (!CGRef->isDeclaration())
44367b00520c8f5b48fad722b790d87fea6be764efeChris Lattner      continue;
4441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
44567b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // Otherwise, emit the definition and move on to the next one.
44667b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    EmitGlobalDefinition(D);
44767b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  }
4485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
4495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
4501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
4518bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// annotation information for a given GlobalValue.  The annotation struct is
4521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// {i8 *, i8 *, i8 *, i32}.  The first field is a constant expression, the
4531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// GlobalValue being annotated.  The second field is the constant string
4541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// created from the AnnotateAttr's annotation.  The third field is a constant
4558bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// string containing the name of the translation unit.  The fourth field is
4568bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// the line number in the file of the annotated value declaration.
4578bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman///
4588bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman/// FIXME: this does not unique the annotation string constants, as llvm-gcc
4598bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman///        appears to.
4608bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman///
4611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpllvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
4628bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman                                                const AnnotateAttr *AA,
4638bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman                                                unsigned LineNo) {
4648bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  llvm::Module *M = &getModule();
4658bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman
4668bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  // get [N x i8] constants for the annotation string, and the filename string
4678bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  // which are the 2nd and 3rd elements of the global annotation structure.
4680032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  const llvm::Type *SBP =
4690032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson      llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
4701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::Constant *anno = llvm::ConstantArray::get(VMContext,
4710032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson                                                  AA->getAnnotation(), true);
4720032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  llvm::Constant *unit = llvm::ConstantArray::get(VMContext,
4730032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson                                                  M->getModuleIdentifier(),
4748bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman                                                  true);
4758bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman
4768bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  // Get the two global values corresponding to the ConstantArrays we just
4778bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  // created to hold the bytes of the strings.
4781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::GlobalValue *annoGV =
47995b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    new llvm::GlobalVariable(*M, anno->getType(), false,
48095b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner                             llvm::GlobalValue::PrivateLinkage, anno,
48195b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner                             GV->getName());
4828bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  // translation unit name string, emitted into the llvm.metadata section.
4838bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  llvm::GlobalValue *unitGV =
48495b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    new llvm::GlobalVariable(*M, unit->getType(), false,
4851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump                             llvm::GlobalValue::PrivateLinkage, unit,
48695b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner                             ".str");
4878bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman
48857d5cee133495bc21d1abdbce45ab05a79274a23Daniel Dunbar  // Create the ConstantStruct for the global annotation.
4898bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  llvm::Constant *Fields[4] = {
4903c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    llvm::ConstantExpr::getBitCast(GV, SBP),
4913c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    llvm::ConstantExpr::getBitCast(annoGV, SBP),
4923c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    llvm::ConstantExpr::getBitCast(unitGV, SBP),
4930032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson    llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo)
4948bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  };
49547a434ff3d49e7906eda88e8e8242e4297725b32Owen Anderson  return llvm::ConstantStruct::get(VMContext, Fields, 4, false);
4968bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman}
4978bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman
49873241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbarbool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
4995c61d97ad442b2c0bbecb617c8f21857ce1fff6dDaniel Dunbar  // Never defer when EmitAllDecls is specified or the decl has
5005c61d97ad442b2c0bbecb617c8f21857ce1fff6dDaniel Dunbar  // attribute used.
50140b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (Features.EmitAllDecls || Global->hasAttr<UsedAttr>())
50273241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar    return false;
503bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
504bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
50573241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar    // Constructors and destructors should never be deferred.
5061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    if (FD->hasAttr<ConstructorAttr>() ||
50740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis        FD->hasAttr<DestructorAttr>())
50873241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar      return false;
50973241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar
51068584ed35ad819a1668e3f527ba7f5dd4ae6a333Douglas Gregor    GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features);
5111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
512dbb5a376c8b9272813a30c5519031e9ea2fb071fChris Lattner    // static, static inline, always_inline, and extern inline functions can
51386daeee2d4aa6523679f07f27a826bf4c42ca95dChris Lattner    // always be deferred.  Normal inline functions can be deferred in C99/C++.
514cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner    if (Linkage == GVA_Internal || Linkage == GVA_C99Inline ||
515cbb8fc18d86a886856f5b852a6a3ead71fec17f9Chris Lattner        Linkage == GVA_CXXInline)
516dbb5a376c8b9272813a30c5519031e9ea2fb071fChris Lattner      return true;
517dbb5a376c8b9272813a30c5519031e9ea2fb071fChris Lattner    return false;
51873241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar  }
5191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
520dbb5a376c8b9272813a30c5519031e9ea2fb071fChris Lattner  const VarDecl *VD = cast<VarDecl>(Global);
521dbb5a376c8b9272813a30c5519031e9ea2fb071fChris Lattner  assert(VD->isFileVarDecl() && "Invalid decl");
522b6c8c8bd8d362c8a6cdb767415b0d21e62b77eb2Douglas Gregor
523dbb5a376c8b9272813a30c5519031e9ea2fb071fChris Lattner  return VD->getStorageClass() == VarDecl::Static;
52473241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar}
52573241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar
526b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattnervoid CodeGenModule::EmitGlobal(GlobalDecl GD) {
5274a6835e650ff24e19ce08a3bd347c0ad186777fdAnders Carlsson  const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
5281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
529bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // If this is an alias definition (which otherwise looks like a declaration)
530bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // emit it now.
53140b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (Global->hasAttr<AliasAttr>())
532bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    return EmitAliasDefinition(Global);
533219df6644e2338ff067471ab0d85f27b88544ac2Daniel Dunbar
53467b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // Ignore declarations, they will be emitted on their first use.
5355e1e1f95c98b1add70c238093bbd5dc8d4f9c4e9Daniel Dunbar  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
53673241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar    // Forward declarations are emitted lazily on first use.
53773241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar    if (!FD->isThisDeclarationADefinition())
53873241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar      return;
5390269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar  } else {
5400269871c9cba493f76237175ab60313406f3bafaDaniel Dunbar    const VarDecl *VD = cast<VarDecl>(Global);
541bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar    assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
542bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
543b6c8c8bd8d362c8a6cdb767415b0d21e62b77eb2Douglas Gregor    // In C++, if this is marked "extern", defer code generation.
5442928c2107f2e0007f35fe1c224aab63535f1403dAnders Carlsson    if (getLangOptions().CPlusPlus && !VD->getInit() &&
5451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump        (VD->getStorageClass() == VarDecl::Extern ||
54648a83b5e7ae4051c7c11680ac00c1fa02d610a62Douglas Gregor         VD->isExternC()))
547b6c8c8bd8d362c8a6cdb767415b0d21e62b77eb2Douglas Gregor      return;
548b6c8c8bd8d362c8a6cdb767415b0d21e62b77eb2Douglas Gregor
549b6c8c8bd8d362c8a6cdb767415b0d21e62b77eb2Douglas Gregor    // In C, if this isn't a definition, defer code generation.
550b6c8c8bd8d362c8a6cdb767415b0d21e62b77eb2Douglas Gregor    if (!getLangOptions().CPlusPlus && !VD->getInit())
55173241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar      return;
5524c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman  }
5534c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman
55467b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // Defer code generation when possible if this is a static definition, inline
55567b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // function etc.  These we only want to emit if they are used.
55673241dfeb5c498255b662984cca369fd28ec3147Daniel Dunbar  if (MayDeferGeneration(Global)) {
55767b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // If the value has already been used, add it directly to the
55867b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // DeferredDeclsToEmit list.
5592a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson    const char *MangledName = getMangledName(GD);
56067b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    if (GlobalDeclMap.count(MangledName))
5612a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson      DeferredDeclsToEmit.push_back(GD);
56267b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    else {
56367b00520c8f5b48fad722b790d87fea6be764efeChris Lattner      // Otherwise, remember that we saw a deferred decl with this name.  The
56467b00520c8f5b48fad722b790d87fea6be764efeChris Lattner      // first use of the mangled name will cause it to move into
56567b00520c8f5b48fad722b790d87fea6be764efeChris Lattner      // DeferredDeclsToEmit.
5662a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson      DeferredDecls[MangledName] = GD;
56767b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    }
568bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar    return;
569bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar  }
570bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
571bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar  // Otherwise emit the definition.
5722a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  EmitGlobalDefinition(GD);
5734c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman}
5744c13b7a3973d2d263d9682d7b68fbfeb76334af5Nate Begeman
575b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattnervoid CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
5764a6835e650ff24e19ce08a3bd347c0ad186777fdAnders Carlsson  const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
5771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
5782a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
5792a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson    EmitCXXConstructor(CD, GD.getCtorType());
5807267c1693abe7875b0c57268be05005ae013c6c9Anders Carlsson  else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
5817267c1693abe7875b0c57268be05005ae013c6c9Anders Carlsson    EmitCXXDestructor(DD, GD.getDtorType());
582b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner  else if (isa<FunctionDecl>(D))
583b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner    EmitGlobalFunctionDefinition(GD);
5842a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
585bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar    EmitGlobalVarDefinition(VD);
5862a131fbca2a51085dc083b8c56a2d4ced3cf1413Anders Carlsson  else {
587bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar    assert(0 && "Invalid argument to EmitGlobalDefinition()");
588bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar  }
589bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar}
590bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
59174391b48b4791cded373683a3baf67314f358d50Chris Lattner/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
59274391b48b4791cded373683a3baf67314f358d50Chris Lattner/// module, create and return an llvm Function with the specified type. If there
59374391b48b4791cded373683a3baf67314f358d50Chris Lattner/// is something in the module with the specified name, return it potentially
59474391b48b4791cded373683a3baf67314f358d50Chris Lattner/// bitcasted to the right type.
59574391b48b4791cded373683a3baf67314f358d50Chris Lattner///
59674391b48b4791cded373683a3baf67314f358d50Chris Lattner/// If D is non-null, it specifies a decl that correspond to this.  This is used
59774391b48b4791cded373683a3baf67314f358d50Chris Lattner/// to set the attributes on the function when it is first created.
59874391b48b4791cded373683a3baf67314f358d50Chris Lattnerllvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(const char *MangledName,
59974391b48b4791cded373683a3baf67314f358d50Chris Lattner                                                       const llvm::Type *Ty,
600b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner                                                       GlobalDecl D) {
6010558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  // Lookup the entry, lazily creating it if necessary.
6020558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
6030558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  if (Entry) {
6040558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner    if (Entry->getType()->getElementType() == Ty)
6050558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner      return Entry;
6061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
6070558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner    // Make sure the result is of the correct type.
60896e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson    const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
6093c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    return llvm::ConstantExpr::getBitCast(Entry, PTy);
6100558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  }
6111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
61267b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // This is the first use or definition of a mangled name.  If there is a
61367b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // deferred decl with this name, remember that we need to emit it at the end
61467b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // of the file.
6151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::DenseMap<const char*, GlobalDecl>::iterator DDI =
6169fa959d5bfbbb17d7c6ba71252219201fc8dc971Chris Lattner    DeferredDecls.find(MangledName);
61767b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  if (DDI != DeferredDecls.end()) {
61867b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
61967b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // list, and remove it from DeferredDecls (since we don't need it anymore).
62067b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    DeferredDeclsToEmit.push_back(DDI->second);
62167b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    DeferredDecls.erase(DDI);
622b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner  } else if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl())) {
6230c337ed63ff0f04fd8315afabb2d7a51969fdc97Chris Lattner    // If this the first reference to a C++ inline function in a class, queue up
6240c337ed63ff0f04fd8315afabb2d7a51969fdc97Chris Lattner    // the deferred function body for emission.  These are not seen as
6250c337ed63ff0f04fd8315afabb2d7a51969fdc97Chris Lattner    // top-level declarations.
626b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner    if (FD->isThisDeclarationADefinition() && MayDeferGeneration(FD))
627b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner      DeferredDeclsToEmit.push_back(D);
628c7ff8e19081c2e974f05f66c4fa9b40750fc655fFariborz Jahanian    // A called constructor which has no definition or declaration need be
629c7ff8e19081c2e974f05f66c4fa9b40750fc655fFariborz Jahanian    // synthesized.
630c7ff8e19081c2e974f05f66c4fa9b40750fc655fFariborz Jahanian    else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
6311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      const CXXRecordDecl *ClassDecl =
632c7ff8e19081c2e974f05f66c4fa9b40750fc655fFariborz Jahanian        cast<CXXRecordDecl>(CD->getDeclContext());
63397a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian      if (CD->isCopyConstructor(getContext()))
63497a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian        DeferredCopyConstructorToEmit(D);
6359889652dbc10060cd604861ed2e5bc6719f845b0Fariborz Jahanian      else if (!ClassDecl->hasUserDeclaredConstructor())
636c7ff8e19081c2e974f05f66c4fa9b40750fc655fFariborz Jahanian        DeferredDeclsToEmit.push_back(D);
637c7ff8e19081c2e974f05f66c4fa9b40750fc655fFariborz Jahanian    }
6381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    else if (isa<CXXDestructorDecl>(FD))
639b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian       DeferredDestructorToEmit(D);
640ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
641ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian           if (MD->isCopyAssignment())
642ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian             DeferredCopyAssignmentToEmit(D);
64367b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  }
6441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
6450558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  // This function doesn't have a complete type (for example, the return
6460558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  // type is an incomplete struct). Use a fake type instead, and make
6470558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  // sure not to try to set attributes.
648c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman  bool IsIncompleteFunction = false;
6490558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  if (!isa<llvm::FunctionType>(Ty)) {
6500032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson    Ty = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
6510558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner                                 std::vector<const llvm::Type*>(), false);
652c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman    IsIncompleteFunction = true;
6530558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  }
6541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::Function *F = llvm::Function::Create(cast<llvm::FunctionType>(Ty),
6550558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner                                             llvm::Function::ExternalLinkage,
656d972678a053d4785772b75cf6c8d4ab74ac2c7f6Chris Lattner                                             "", &getModule());
657d972678a053d4785772b75cf6c8d4ab74ac2c7f6Chris Lattner  F->setName(MangledName);
658c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman  if (D.getDecl())
659c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman    SetFunctionAttributes(cast<FunctionDecl>(D.getDecl()), F,
660c6c14d1cd68afcd90d097715296377f15be45210Eli Friedman                          IsIncompleteFunction);
6610558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  Entry = F;
6620558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  return F;
6630558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner}
6640558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner
66597a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian/// Defer definition of copy constructor(s) which need be implicitly defined.
66697a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanianvoid CodeGenModule::DeferredCopyConstructorToEmit(GlobalDecl CopyCtorDecl) {
6671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  const CXXConstructorDecl *CD =
66897a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    cast<CXXConstructorDecl>(CopyCtorDecl.getDecl());
66997a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
67097a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  if (ClassDecl->hasTrivialCopyConstructor() ||
67197a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian      ClassDecl->hasUserDeclaredCopyConstructor())
67297a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    return;
6731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
67497a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  // First make sure all direct base classes and virtual bases and non-static
67597a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  // data mebers which need to have their copy constructors implicitly defined
67697a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  // are defined. 12.8.p7
67797a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
67897a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian       Base != ClassDecl->bases_end(); ++Base) {
67997a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    CXXRecordDecl *BaseClassDecl
68097a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
6811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    if (CXXConstructorDecl *BaseCopyCtor =
68280e4b9e0e87064a824d72b6ff89074206ecced58Fariborz Jahanian        BaseClassDecl->getCopyConstructor(Context, 0))
68397a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian      GetAddrOfCXXConstructor(BaseCopyCtor, Ctor_Complete);
68497a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  }
6851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
68697a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
68797a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian       FieldEnd = ClassDecl->field_end();
68897a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian       Field != FieldEnd; ++Field) {
68997a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    QualType FieldType = Context.getCanonicalType((*Field)->getType());
69097a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    if (const ArrayType *Array = Context.getAsArrayType(FieldType))
69197a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian      FieldType = Array->getElementType();
69297a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
693e64941280877d065a27e8cefd2a9038256d0e3acFariborz Jahanian      if ((*Field)->isAnonymousStructOrUnion())
694e64941280877d065a27e8cefd2a9038256d0e3acFariborz Jahanian        continue;
69597a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian      CXXRecordDecl *FieldClassDecl
696e64941280877d065a27e8cefd2a9038256d0e3acFariborz Jahanian        = cast<CXXRecordDecl>(FieldClassType->getDecl());
6971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      if (CXXConstructorDecl *FieldCopyCtor =
69880e4b9e0e87064a824d72b6ff89074206ecced58Fariborz Jahanian          FieldClassDecl->getCopyConstructor(Context, 0))
69997a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian        GetAddrOfCXXConstructor(FieldCopyCtor, Ctor_Complete);
70097a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian    }
70197a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  }
70297a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian  DeferredDeclsToEmit.push_back(CopyCtorDecl);
703ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian}
704ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian
705ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian/// Defer definition of copy assignments which need be implicitly defined.
706ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanianvoid CodeGenModule::DeferredCopyAssignmentToEmit(GlobalDecl CopyAssignDecl) {
707ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  const CXXMethodDecl *CD = cast<CXXMethodDecl>(CopyAssignDecl.getDecl());
708ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
7091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
710ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  if (ClassDecl->hasTrivialCopyAssignment() ||
711ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian      ClassDecl->hasUserDeclaredCopyAssignment())
712ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    return;
7131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
714ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  // First make sure all direct base classes and virtual bases and non-static
715ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  // data mebers which need to have their copy assignments implicitly defined
716ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  // are defined. 12.8.p12
717ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
718ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian       Base != ClassDecl->bases_end(); ++Base) {
719ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    CXXRecordDecl *BaseClassDecl
720ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
721ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    const CXXMethodDecl *MD = 0;
722183d7181fd59842ac969cbc6fe0376f85dc63ae4Fariborz Jahanian    if (!BaseClassDecl->hasTrivialCopyAssignment() &&
723183d7181fd59842ac969cbc6fe0376f85dc63ae4Fariborz Jahanian        !BaseClassDecl->hasUserDeclaredCopyAssignment() &&
724183d7181fd59842ac969cbc6fe0376f85dc63ae4Fariborz Jahanian        BaseClassDecl->hasConstCopyAssignment(getContext(), MD))
725555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson      GetAddrOfFunction(MD, 0);
726ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  }
7271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
728ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
729ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian       FieldEnd = ClassDecl->field_end();
730ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian       Field != FieldEnd; ++Field) {
731ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    QualType FieldType = Context.getCanonicalType((*Field)->getType());
732ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    if (const ArrayType *Array = Context.getAsArrayType(FieldType))
733ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian      FieldType = Array->getElementType();
734ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
735ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian      if ((*Field)->isAnonymousStructOrUnion())
736ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian        continue;
737ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian      CXXRecordDecl *FieldClassDecl
738ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian        = cast<CXXRecordDecl>(FieldClassType->getDecl());
739ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian      const CXXMethodDecl *MD = 0;
740183d7181fd59842ac969cbc6fe0376f85dc63ae4Fariborz Jahanian      if (!FieldClassDecl->hasTrivialCopyAssignment() &&
741183d7181fd59842ac969cbc6fe0376f85dc63ae4Fariborz Jahanian          !FieldClassDecl->hasUserDeclaredCopyAssignment() &&
742183d7181fd59842ac969cbc6fe0376f85dc63ae4Fariborz Jahanian          FieldClassDecl->hasConstCopyAssignment(getContext(), MD))
743555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson          GetAddrOfFunction(MD, 0);
744ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian    }
745ad25883a644dd6b52c7923dd128a7d05fb26213cFariborz Jahanian  }
7461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  DeferredDeclsToEmit.push_back(CopyAssignDecl);
74797a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian}
74897a937532c24a8ea44317d4fdee26d9701a1e83cFariborz Jahanian
749b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanianvoid CodeGenModule::DeferredDestructorToEmit(GlobalDecl DtorDecl) {
750b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  const CXXDestructorDecl *DD = cast<CXXDestructorDecl>(DtorDecl.getDecl());
751b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext());
752b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  if (ClassDecl->hasTrivialDestructor() ||
753b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian      ClassDecl->hasUserDeclaredDestructor())
754b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian    return;
755b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian
756b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
757b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian       Base != ClassDecl->bases_end(); ++Base) {
758b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian    CXXRecordDecl *BaseClassDecl
759b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
7601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    if (const CXXDestructorDecl *BaseDtor =
761b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian          BaseClassDecl->getDestructor(Context))
762b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian      GetAddrOfCXXDestructor(BaseDtor, Dtor_Complete);
763b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  }
7641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
765b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
766b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian       FieldEnd = ClassDecl->field_end();
767b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian       Field != FieldEnd; ++Field) {
768b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian    QualType FieldType = Context.getCanonicalType((*Field)->getType());
769b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian    if (const ArrayType *Array = Context.getAsArrayType(FieldType))
770b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian      FieldType = Array->getElementType();
771b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
772b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian      if ((*Field)->isAnonymousStructOrUnion())
773b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian        continue;
774b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian      CXXRecordDecl *FieldClassDecl
775b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian        = cast<CXXRecordDecl>(FieldClassType->getDecl());
7761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      if (const CXXDestructorDecl *FieldDtor =
777b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian            FieldClassDecl->getDestructor(Context))
778b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian        GetAddrOfCXXDestructor(FieldDtor, Dtor_Complete);
779b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian    }
780b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  }
781b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian  DeferredDeclsToEmit.push_back(DtorDecl);
782b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian}
783b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian
784b193a414f13d7cfa2524a8149eff8d4871f8cbf6Fariborz Jahanian
78574391b48b4791cded373683a3baf67314f358d50Chris Lattner/// GetAddrOfFunction - Return the address of the given function.  If Ty is
78674391b48b4791cded373683a3baf67314f358d50Chris Lattner/// non-null, then this function will use the specified type if it has to
78774391b48b4791cded373683a3baf67314f358d50Chris Lattner/// create it (this occurs when we see a definition of the function).
788b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
78974391b48b4791cded373683a3baf67314f358d50Chris Lattner                                                 const llvm::Type *Ty) {
79074391b48b4791cded373683a3baf67314f358d50Chris Lattner  // If there was no specific requested type, just convert it now.
79174391b48b4791cded373683a3baf67314f358d50Chris Lattner  if (!Ty)
7924a6835e650ff24e19ce08a3bd347c0ad186777fdAnders Carlsson    Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
7934fe95f99a2693f1145785ea5835ba6937e49c730Douglas Gregor  return GetOrCreateLLVMFunction(getMangledName(GD), Ty, GD);
79474391b48b4791cded373683a3baf67314f358d50Chris Lattner}
79577ba708819285931932ecd33691a672bb59d221aEli Friedman
79674391b48b4791cded373683a3baf67314f358d50Chris Lattner/// CreateRuntimeFunction - Create a new runtime function with the specified
79774391b48b4791cded373683a3baf67314f358d50Chris Lattner/// type and name.
79874391b48b4791cded373683a3baf67314f358d50Chris Lattnerllvm::Constant *
79974391b48b4791cded373683a3baf67314f358d50Chris LattnerCodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
80074391b48b4791cded373683a3baf67314f358d50Chris Lattner                                     const char *Name) {
80174391b48b4791cded373683a3baf67314f358d50Chris Lattner  // Convert Name to be a uniqued string from the IdentifierInfo table.
80274391b48b4791cded373683a3baf67314f358d50Chris Lattner  Name = getContext().Idents.get(Name).getName();
803b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner  return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl());
80474391b48b4791cded373683a3baf67314f358d50Chris Lattner}
805bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
80674391b48b4791cded373683a3baf67314f358d50Chris Lattner/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
80774391b48b4791cded373683a3baf67314f358d50Chris Lattner/// create and return an llvm GlobalVariable with the specified type.  If there
80874391b48b4791cded373683a3baf67314f358d50Chris Lattner/// is something in the module with the specified name, return it potentially
80974391b48b4791cded373683a3baf67314f358d50Chris Lattner/// bitcasted to the right type.
81074391b48b4791cded373683a3baf67314f358d50Chris Lattner///
81174391b48b4791cded373683a3baf67314f358d50Chris Lattner/// If D is non-null, it specifies a decl that correspond to this.  This is used
81274391b48b4791cded373683a3baf67314f358d50Chris Lattner/// to set the attributes on the global when it is first created.
81374391b48b4791cded373683a3baf67314f358d50Chris Lattnerllvm::Constant *CodeGenModule::GetOrCreateLLVMGlobal(const char *MangledName,
81474391b48b4791cded373683a3baf67314f358d50Chris Lattner                                                     const llvm::PointerType*Ty,
81574391b48b4791cded373683a3baf67314f358d50Chris Lattner                                                     const VarDecl *D) {
8163c827a79cb7d04c255db8080e682ee2c6912373dDaniel Dunbar  // Lookup the entry, lazily creating it if necessary.
8175d4f5c724533b994de05df49ae259120482ec366Chris Lattner  llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
81899b53613ebe2c59d41030e987962c1ed101b2efeChris Lattner  if (Entry) {
81974391b48b4791cded373683a3baf67314f358d50Chris Lattner    if (Entry->getType() == Ty)
820570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner      return Entry;
8211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
82299b53613ebe2c59d41030e987962c1ed101b2efeChris Lattner    // Make sure the result is of the correct type.
8233c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    return llvm::ConstantExpr::getBitCast(Entry, Ty);
82499b53613ebe2c59d41030e987962c1ed101b2efeChris Lattner  }
8251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
82667b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // This is the first use or definition of a mangled name.  If there is a
82767b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // deferred decl with this name, remember that we need to emit it at the end
82867b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  // of the file.
8291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::DenseMap<const char*, GlobalDecl>::iterator DDI =
83067b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    DeferredDecls.find(MangledName);
83167b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  if (DDI != DeferredDecls.end()) {
83267b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
83367b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    // list, and remove it from DeferredDecls (since we don't need it anymore).
83467b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    DeferredDeclsToEmit.push_back(DDI->second);
83567b00520c8f5b48fad722b790d87fea6be764efeChris Lattner    DeferredDecls.erase(DDI);
83667b00520c8f5b48fad722b790d87fea6be764efeChris Lattner  }
8371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
8381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::GlobalVariable *GV =
8391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
84099b53613ebe2c59d41030e987962c1ed101b2efeChris Lattner                             llvm::GlobalValue::ExternalLinkage,
8411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump                             0, "", 0,
84256ebe5082da7411fb37479e230b52735f77cff35Eli Friedman                             false, Ty->getAddressSpace());
843d972678a053d4785772b75cf6c8d4ab74ac2c7f6Chris Lattner  GV->setName(MangledName);
84449988884c1da4b2200bfe2298a1e41b3f044e8d4Daniel Dunbar
84599b53613ebe2c59d41030e987962c1ed101b2efeChris Lattner  // Handle things which are present even on external declarations.
84674391b48b4791cded373683a3baf67314f358d50Chris Lattner  if (D) {
847f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump    // FIXME: This code is overly simple and should be merged with other global
848f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump    // handling.
84974391b48b4791cded373683a3baf67314f358d50Chris Lattner    GV->setConstant(D->getType().isConstant(Context));
85049988884c1da4b2200bfe2298a1e41b3f044e8d4Daniel Dunbar
85174391b48b4791cded373683a3baf67314f358d50Chris Lattner    // FIXME: Merge with other attribute handling code.
85274391b48b4791cded373683a3baf67314f358d50Chris Lattner    if (D->getStorageClass() == VarDecl::PrivateExtern)
85304d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar      GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
85449988884c1da4b2200bfe2298a1e41b3f044e8d4Daniel Dunbar
8551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    if (D->hasAttr<WeakAttr>() ||
85640b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis        D->hasAttr<WeakImportAttr>())
85774391b48b4791cded373683a3baf67314f358d50Chris Lattner      GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
85856ebe5082da7411fb37479e230b52735f77cff35Eli Friedman
85956ebe5082da7411fb37479e230b52735f77cff35Eli Friedman    GV->setThreadLocal(D->isThreadSpecified());
86074391b48b4791cded373683a3baf67314f358d50Chris Lattner  }
8611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
86274391b48b4791cded373683a3baf67314f358d50Chris Lattner  return Entry = GV;
86374391b48b4791cded373683a3baf67314f358d50Chris Lattner}
864eda9a5ec380f172f4e0063744eb796144a125480Daniel Dunbar
865eda9a5ec380f172f4e0063744eb796144a125480Daniel Dunbar
86674391b48b4791cded373683a3baf67314f358d50Chris Lattner/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
86774391b48b4791cded373683a3baf67314f358d50Chris Lattner/// given global variable.  If Ty is non-null and if the global doesn't exist,
86874391b48b4791cded373683a3baf67314f358d50Chris Lattner/// then it will be greated with the specified type instead of whatever the
86974391b48b4791cded373683a3baf67314f358d50Chris Lattner/// normal requested type would be.
87074391b48b4791cded373683a3baf67314f358d50Chris Lattnerllvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
87174391b48b4791cded373683a3baf67314f358d50Chris Lattner                                                  const llvm::Type *Ty) {
87274391b48b4791cded373683a3baf67314f358d50Chris Lattner  assert(D->hasGlobalStorage() && "Not a global variable");
87374391b48b4791cded373683a3baf67314f358d50Chris Lattner  QualType ASTTy = D->getType();
87474391b48b4791cded373683a3baf67314f358d50Chris Lattner  if (Ty == 0)
87574391b48b4791cded373683a3baf67314f358d50Chris Lattner    Ty = getTypes().ConvertTypeForMem(ASTTy);
8761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
8771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  const llvm::PointerType *PTy =
87896e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson    llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
87974391b48b4791cded373683a3baf67314f358d50Chris Lattner  return GetOrCreateLLVMGlobal(getMangledName(D), PTy, D);
88074391b48b4791cded373683a3baf67314f358d50Chris Lattner}
8813f75c43bd77e063342bc888ac276daf64ba0ce07Daniel Dunbar
88274391b48b4791cded373683a3baf67314f358d50Chris Lattner/// CreateRuntimeVariable - Create a new runtime global variable with the
88374391b48b4791cded373683a3baf67314f358d50Chris Lattner/// specified type and name.
88474391b48b4791cded373683a3baf67314f358d50Chris Lattnerllvm::Constant *
88574391b48b4791cded373683a3baf67314f358d50Chris LattnerCodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty,
88674391b48b4791cded373683a3baf67314f358d50Chris Lattner                                     const char *Name) {
88774391b48b4791cded373683a3baf67314f358d50Chris Lattner  // Convert Name to be a uniqued string from the IdentifierInfo table.
88874391b48b4791cded373683a3baf67314f358d50Chris Lattner  Name = getContext().Idents.get(Name).getName();
88996e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson  return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0);
890bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar}
891bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
89203f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbarvoid CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
89303f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar  assert(!D->getInit() && "Cannot emit definite definitions here!");
89403f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar
8957520bd1de12af10ea08c662440565adbdf589317Douglas Gregor  if (MayDeferGeneration(D)) {
8967520bd1de12af10ea08c662440565adbdf589317Douglas Gregor    // If we have not seen a reference to this variable yet, place it
8977520bd1de12af10ea08c662440565adbdf589317Douglas Gregor    // into the deferred declarations table to be emitted if needed
8987520bd1de12af10ea08c662440565adbdf589317Douglas Gregor    // later.
8997520bd1de12af10ea08c662440565adbdf589317Douglas Gregor    const char *MangledName = getMangledName(D);
9007520bd1de12af10ea08c662440565adbdf589317Douglas Gregor    if (GlobalDeclMap.count(MangledName) == 0) {
901555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson      DeferredDecls[MangledName] = D;
90203f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar      return;
9037520bd1de12af10ea08c662440565adbdf589317Douglas Gregor    }
9047520bd1de12af10ea08c662440565adbdf589317Douglas Gregor  }
9057520bd1de12af10ea08c662440565adbdf589317Douglas Gregor
9067520bd1de12af10ea08c662440565adbdf589317Douglas Gregor  // The tentative definition is the only definition.
90703f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar  EmitGlobalVarDefinition(D);
90803f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar}
90903f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar
910bd012ff1fa088181646a784f385b28867372d434Daniel Dunbarvoid CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
9118f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner  llvm::Constant *Init = 0;
91277ba708819285931932ecd33691a672bb59d221aEli Friedman  QualType ASTTy = D->getType();
9131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
9148f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner  if (D->getInit() == 0) {
915cd5f4aaf0c219189878126d556f35e38fdb8afa1Eli Friedman    // This is a tentative definition; tentative definitions are
91603f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // implicitly initialized with { 0 }.
91703f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    //
91803f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // Note that tentative definitions are only emitted at the end of
91903f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // a translation unit, so they should never have incomplete
92003f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // type. In addition, EmitTentativeDefinition makes sure that we
92103f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // never attempt to emit a tentative definition if a real one
92203f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // exists. A use may still exists, however, so we still may need
92303f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    // to do a RAUW.
92403f5ad9a7707e098f601921fcec17ed65eb355a7Daniel Dunbar    assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
925b0d0ea042116c1f451d3db8ceff9f1dd92bc36d2Anders Carlsson    Init = EmitNullConstant(D->getType());
92677ba708819285931932ecd33691a672bb59d221aEli Friedman  } else {
927e9352cc9818ba59e7cf88500ef048991c90f3821Anders Carlsson    Init = EmitConstantExpr(D->getInit(), D->getType());
9281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
9296e656f45ae04b415ba7a4c0c25e55633e2d0ecd0Eli Friedman    if (!Init) {
9306e656f45ae04b415ba7a4c0c25e55633e2d0ecd0Eli Friedman      QualType T = D->getInit()->getType();
93189ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson      if (getLangOptions().CPlusPlus) {
93289ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson        CXXGlobalInits.push_back(D);
93389ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson        Init = EmitNullConstant(T);
93489ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson      } else {
93589ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson        ErrorUnsupported(D, "static initializer");
93689ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson        Init = llvm::UndefValue::get(getTypes().ConvertType(T));
93789ed31d3f9eeb8ec77c284a5cf404a74bf5e7acfAnders Carlsson      }
9386e656f45ae04b415ba7a4c0c25e55633e2d0ecd0Eli Friedman    }
9398f32f7189b12f67aa4a19bc7c3855b599980eca0Chris Lattner  }
9408e53e720b3d7c962e91138a130dbd5d6c2def0e5Devang Patel
9412d58406872e5af0c924623d9f7c194c4f09936d3Chris Lattner  const llvm::Type* InitType = Init->getType();
942570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
9431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
944570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // Strip off a bitcast if we got one back.
945570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
9469d4a15fd3b85434c43ea27562793de63a793321aChris Lattner    assert(CE->getOpcode() == llvm::Instruction::BitCast ||
9479d4a15fd3b85434c43ea27562793de63a793321aChris Lattner           // all zero index gep.
9489d4a15fd3b85434c43ea27562793de63a793321aChris Lattner           CE->getOpcode() == llvm::Instruction::GetElementPtr);
949570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    Entry = CE->getOperand(0);
950570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  }
9511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
952570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // Entry is now either a Function or GlobalVariable.
953570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
9541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
955570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // We have a definition after a declaration with the wrong type.
956570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // We must make a new GlobalVariable* and update everything that used OldGV
957570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // (a declaration or tentative definition) with the new GlobalVariable*
958570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // (which will be a definition).
959570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  //
960570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // This happens if there is a prototype for a global (e.g.
961570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // "extern int x[];") and then a definition of a different type (e.g.
962570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // "int x[10];"). This also happens when an initializer has a different type
963570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  // from the type of the global (this happens with unions).
964570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner  if (GV == 0 ||
965570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner      GV->getType()->getElementType() != InitType ||
966570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner      GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) {
9671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
968570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    // Remove the old entry from GlobalDeclMap so that we'll create a new one.
969570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    GlobalDeclMap.erase(getMangledName(D));
970232350d4faf46ec38d5ff60e11505f9c4fa9535bDaniel Dunbar
971570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    // Make a new global with the correct type, this is now guaranteed to work.
972570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
9730558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner    GV->takeName(cast<llvm::GlobalValue>(Entry));
9740558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner
97577ba708819285931932ecd33691a672bb59d221aEli Friedman    // Replace all uses of the old global with the new global
9761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    llvm::Constant *NewPtrForOldDecl =
9773c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson        llvm::ConstantExpr::getBitCast(GV, Entry->getType());
978570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    Entry->replaceAllUsesWith(NewPtrForOldDecl);
97977ba708819285931932ecd33691a672bb59d221aEli Friedman
98077ba708819285931932ecd33691a672bb59d221aEli Friedman    // Erase the old global, since it is no longer used.
981570585c91dee98d7ba8ccf1198c03208ba17966bChris Lattner    cast<llvm::GlobalValue>(Entry)->eraseFromParent();
98277ba708819285931932ecd33691a672bb59d221aEli Friedman  }
98377ba708819285931932ecd33691a672bb59d221aEli Friedman
98440b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
9858bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman    SourceManager &SM = Context.getSourceManager();
9868bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman    AddAnnotation(EmitAnnotateAttr(GV, AA,
987f7cf85b330bedd2877e1371fb0a83e99751ae162Chris Lattner                              SM.getInstantiationLineNumber(D->getLocation())));
9888bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman  }
9898bd4afeb876fd0015bb808eb2f3de1fe709658a7Nate Begeman
99088a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner  GV->setInitializer(Init);
991e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner
992e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  // If it is safe to mark the global 'constant', do so now.
993e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  GV->setConstant(false);
994e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  if (D->getType().isConstant(Context)) {
995e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    // FIXME: In C++, if the variable has a non-trivial ctor/dtor or any mutable
996e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    // members, it cannot be declared "LLVM const".
997e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    GV->setConstant(true);
998e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  }
9991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
10000de40af3a3aa14e3854c0eafeabd08f6762801f9Eli Friedman  GV->setAlignment(getContext().getDeclAlignInBytes(D));
100108d7802a406ee4a7cc18e8fce0c137b8c410ea7cEli Friedman
100288a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner  // Set the llvm linkage type as appropriate.
10038fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner  if (D->getStorageClass() == VarDecl::Static)
10048fabd78f1976243cb223fb3e969c6f317d1ae44dChris Lattner    GV->setLinkage(llvm::Function::InternalLinkage);
100540b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  else if (D->hasAttr<DLLImportAttr>())
1006ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner    GV->setLinkage(llvm::Function::DLLImportLinkage);
100740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  else if (D->hasAttr<DLLExportAttr>())
1008ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner    GV->setLinkage(llvm::Function::DLLExportLinkage);
1009e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  else if (D->hasAttr<WeakAttr>()) {
1010e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    if (GV->isConstant())
1011e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner      GV->setLinkage(llvm::GlobalVariable::WeakODRLinkage);
1012e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    else
1013e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner      GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
1014e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  } else if (!CompileOpts.NoCommon &&
1015309457d0f1b416c1b379c9f3e172848adffedb23Chris Lattner           !D->hasExternalStorage() && !D->getInit() &&
1016e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner           !D->getAttr<SectionAttr>()) {
101704d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    GV->setLinkage(llvm::GlobalVariable::CommonLinkage);
1018e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    // common vars aren't constant even if declared const.
1019e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner    GV->setConstant(false);
1020e78b86f3201ae5f09e2cf85bd6558f1d9b34de26Chris Lattner  } else
102104d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar    GV->setLinkage(llvm::GlobalVariable::ExternalLinkage);
10227e714cd931fa3a90bfd728318a92485aa3e95748Daniel Dunbar
10237c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  SetCommonAttributes(D, GV);
102404d4078425614bf9fd58d606335c1f5f74ee7fa4Daniel Dunbar
1025686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta  // Emit global variable debug information.
10262d58406872e5af0c924623d9f7c194c4f09936d3Chris Lattner  if (CGDebugInfo *DI = getDebugInfo()) {
102766031a5594bc9a7dc0dc5137c3e7955f835e4639Daniel Dunbar    DI->setLocation(D->getLocation());
1028686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta    DI->EmitGlobalVariable(GV, D);
1029686226b538e72c5059ab7c9a8f87eb883193b645Sanjiv Gupta  }
103088a69ad80e1550e9932666e6efa050a5b1223889Chris Lattner}
10315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
1032bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1033bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// implement a function with no prototype, e.g. "int foo() {}".  If there are
1034bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// existing call uses of the old function in the module, this adjusts them to
1035bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// call the new function directly.
1036bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner///
1037bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// This is not just a cleanup: the always_inline pass requires direct calls to
1038bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// functions to be able to inline them.  If there is a bitcast in the way, it
1039bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// won't inline them.  Instcombine normally deletes these calls, but it isn't
1040bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner/// run at -O0.
1041bdb0132722082886558f31eccdba06ae1852c0eeChris Lattnerstatic void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1042bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner                                                      llvm::Function *NewFn) {
1043bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  // If we're redefining a global as a function, don't transform it.
1044bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1045bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  if (OldFn == 0) return;
10461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1047bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  const llvm::Type *NewRetTy = NewFn->getReturnType();
1048bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  llvm::SmallVector<llvm::Value*, 4> ArgList;
1049bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner
1050bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
1051bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner       UI != E; ) {
1052bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // TODO: Do invokes ever occur in C code?  If so, we should handle them too.
105308c93a7f2210b464e5abe298a5474b99414615f6Chris Lattner    unsigned OpNo = UI.getOperandNo();
1054bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*UI++);
105508c93a7f2210b464e5abe298a5474b99414615f6Chris Lattner    if (!CI || OpNo != 0) continue;
10561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1057bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // If the return types don't match exactly, and if the call isn't dead, then
1058bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // we can't transform this call.
1059bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    if (CI->getType() != NewRetTy && !CI->use_empty())
1060bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      continue;
1061bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner
1062bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // If the function was passed too few arguments, don't transform.  If extra
1063bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // arguments were passed, we silently drop them.  If any of the types
1064bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // mismatch, we don't transform.
1065bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    unsigned ArgNo = 0;
1066bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    bool DontTransform = false;
1067bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1068bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner         E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
1069bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      if (CI->getNumOperands()-1 == ArgNo ||
1070bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner          CI->getOperand(ArgNo+1)->getType() != AI->getType()) {
1071bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner        DontTransform = true;
1072bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner        break;
1073bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      }
1074bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    }
1075bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    if (DontTransform)
1076bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      continue;
10771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1078bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // Okay, we can transform this.  Create the new call instruction and copy
1079bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // over the required information.
1080bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    ArgList.append(CI->op_begin()+1, CI->op_begin()+1+ArgNo);
1081bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(),
1082bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner                                                     ArgList.end(), "", CI);
1083bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    ArgList.clear();
10840032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson    if (NewCall->getType() != llvm::Type::getVoidTy(Old->getContext()))
1085bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      NewCall->takeName(CI);
1086bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    NewCall->setAttributes(CI->getAttributes());
1087ca6408c3176783f0b29da4679a08512aa05f0c73Daniel Dunbar    NewCall->setCallingConv(CI->getCallingConv());
1088bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner
1089bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // Finally, remove the old call, replacing any uses with the new one.
1090bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    if (!CI->use_empty())
1091bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      CI->replaceAllUsesWith(NewCall);
1092bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    CI->eraseFromParent();
1093bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner  }
1094bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner}
1095bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner
1096bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
1097b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattnervoid CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
10982b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson  const llvm::FunctionType *Ty;
1099b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner  const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
11001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11012b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
11022b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    bool isVariadic = D->getType()->getAsFunctionProtoType()->isVariadic();
11031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11042b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    Ty = getTypes().GetFunctionType(getTypes().getFunctionInfo(MD), isVariadic);
11052b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson  } else {
11062b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    Ty = cast<llvm::FunctionType>(getTypes().ConvertType(D->getType()));
11071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11082b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    // As a special case, make sure that definitions of K&R function
11092b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    // "type foo()" aren't declared as varargs (which forces the backend
11102b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    // to do unnecessary work).
11112b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    if (D->getType()->isFunctionNoProtoType()) {
11122b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson      assert(Ty->isVarArg() && "Didn't lower type as expected");
11131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      // Due to stret, the lowered function could have arguments.
11141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      // Just create the same type as was lowered by ConvertType
11152b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson      // but strip off the varargs bit.
11162b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson      std::vector<const llvm::Type*> Args(Ty->param_begin(), Ty->param_end());
111796e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson      Ty = llvm::FunctionType::get(Ty->getReturnType(), Args, false);
11182b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson    }
1119ff75e1db95a53c7606e0bb114cf9adc59ab3d7f6Chris Lattner  }
1120d5d31801fc87239436fa349c89dce7797cf13537Daniel Dunbar
11219fa959d5bfbbb17d7c6ba71252219201fc8dc971Chris Lattner  // Get or create the prototype for the function.
1122b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner  llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
11231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11240558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  // Strip off a bitcast if we got one back.
11250558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
11260558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner    assert(CE->getOpcode() == llvm::Instruction::BitCast);
11270558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner    Entry = CE->getOperand(0);
11280558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  }
11291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11310558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
1132bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
11331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
113442745815fa4e90bfb07e581d2e5152b2c2db08ffDaniel Dunbar    // If the types mismatch then we have to rewrite the definition.
1135bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    assert(OldFn->isDeclaration() &&
11360558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner           "Shouldn't replace non-declaration");
113734809507232bc4c3c4840c7d092c7440219fddafChris Lattner
113862b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // F is the Function* for the one with the wrong type, we must make a new
113962b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // Function* and update everything that used F (a declaration) with the new
114062b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // Function* (which will be a definition).
114162b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    //
114262b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // This happens if there is a prototype for a function
114362b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // (e.g. "int f()") and then a definition of a different type
114462b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // (e.g. "int f(int x)").  Start by making a new function of the
114562b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // correct type, RAUW, then steal the name.
114634809507232bc4c3c4840c7d092c7440219fddafChris Lattner    GlobalDeclMap.erase(getMangledName(D));
1147b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner    llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
1148bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    NewFn->takeName(OldFn);
11491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1150bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // If this is an implementation of a function without a prototype, try to
1151bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // replace any existing uses of the function (which may be calls) with uses
1152bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    // of the new function
11539fa959d5bfbbb17d7c6ba71252219201fc8dc971Chris Lattner    if (D->getType()->isFunctionNoProtoType()) {
1154bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
11559fa959d5bfbbb17d7c6ba71252219201fc8dc971Chris Lattner      OldFn->removeDeadConstantUsers();
11569fa959d5bfbbb17d7c6ba71252219201fc8dc971Chris Lattner    }
11571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
115862b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // Replace uses of F with the Function we will endow with a body.
1159bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    if (!Entry->use_empty()) {
11601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      llvm::Constant *NewPtrForOldDecl =
11613c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson        llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
1162bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner      Entry->replaceAllUsesWith(NewPtrForOldDecl);
1163bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    }
11641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
116562b33ea51adbd0e7f2f05983e9e4a3a2b2ed26deChris Lattner    // Ok, delete the old function now, which is dead.
1166bdb0132722082886558f31eccdba06ae1852c0eeChris Lattner    OldFn->eraseFromParent();
11671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11680558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner    Entry = NewFn;
1169bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar  }
11701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
11710558e79840bfdbbd38c6e2b4f6765bf0158e85f4Chris Lattner  llvm::Function *Fn = cast<llvm::Function>(Entry);
1172bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
1173219df6644e2338ff067471ab0d85f27b88544ac2Daniel Dunbar  CodeGenFunction(*this).GenerateCode(D, Fn);
11746379a7a15335e0af543a942efe9cfd514a83dab8Daniel Dunbar
11757c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  SetFunctionDefinitionAttributes(D, Fn);
11767c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  SetLLVMFunctionAttributesForDefinition(D, Fn);
11771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
117840b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
1179219df6644e2338ff067471ab0d85f27b88544ac2Daniel Dunbar    AddGlobalCtor(Fn, CA->getPriority());
118040b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
1181219df6644e2338ff067471ab0d85f27b88544ac2Daniel Dunbar    AddGlobalDtor(Fn, DA->getPriority());
1182bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar}
1183bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar
1184bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattnervoid CodeGenModule::EmitAliasDefinition(const ValueDecl *D) {
118540b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  const AliasAttr *AA = D->getAttr<AliasAttr>();
1186bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  assert(AA && "Not an alias?");
1187bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner
1188bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
11891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1190bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // Unique the name through the identifier table.
1191bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  const char *AliaseeName = AA->getAliasee().c_str();
1192bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  AliaseeName = getContext().Idents.get(AliaseeName).getName();
1193bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner
1194bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // Create a reference to the named value.  This ensures that it is emitted
1195bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // if a deferred decl.
1196bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  llvm::Constant *Aliasee;
1197bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  if (isa<llvm::FunctionType>(DeclTy))
1198b4880bab7fc1b61267cfd9a0ad52188e7a828cb3Chris Lattner    Aliasee = GetOrCreateLLVMFunction(AliaseeName, DeclTy, GlobalDecl());
1199bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  else
1200bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    Aliasee = GetOrCreateLLVMGlobal(AliaseeName,
120196e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson                                    llvm::PointerType::getUnqual(DeclTy), 0);
1202bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner
1203bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // Create the new alias itself, but don't set a name yet.
12041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::GlobalValue *GA =
1205bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    new llvm::GlobalAlias(Aliasee->getType(),
1206bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner                          llvm::Function::ExternalLinkage,
1207bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner                          "", Aliasee, &getModule());
12081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1209bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // See if there is already something with the alias' name in the module.
1210bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  const char *MangledName = getMangledName(D);
1211bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
12121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1213bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  if (Entry && !Entry->isDeclaration()) {
1214bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    // If there is a definition in the module, then it wins over the alias.
1215bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    // This is dubious, but allow it to be safe.  Just ignore the alias.
1216bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    GA->eraseFromParent();
1217bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    return;
1218bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  }
12191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1220bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  if (Entry) {
1221bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    // If there is a declaration in the module, then we had an extern followed
1222bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    // by the alias, as in:
1223bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    //   extern int test6();
1224bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    //   ...
1225bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    //   int test6() __attribute__((alias("test7")));
1226bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    //
1227bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    // Remove it and replace uses of it with the alias.
12281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
12293c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson    Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
1230bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner                                                          Entry->getType()));
1231bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner    Entry->eraseFromParent();
1232bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  }
12331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1234bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  // Now we know that there is no conflict, set the name.
1235bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  Entry = GA;
1236bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner  GA->setName(MangledName);
1237bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner
12387c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  // Set attributes which are particular to an alias; this is a
12397c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  // specialization of the attributes which may be set on a global
12407c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  // variable/function.
124140b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis  if (D->hasAttr<DLLExportAttr>()) {
12427c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
12437c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar      // The dllexport attribute is ignored for undefined symbols.
12446fb0aee4f9dc261bbec72e1283ad8dc0557a6d96Argyrios Kyrtzidis      if (FD->getBody())
12457c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar        GA->setLinkage(llvm::Function::DLLExportLinkage);
12467c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    } else {
12477c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar      GA->setLinkage(llvm::Function::DLLExportLinkage);
12487c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    }
12491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  } else if (D->hasAttr<WeakAttr>() ||
125040b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis             D->hasAttr<WeakImportAttr>()) {
12517c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar    GA->setLinkage(llvm::Function::WeakAnyLinkage);
12527c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  }
12537c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar
12547c65e990e9f0dafaf9adbc59b766dcc23eaee845Daniel Dunbar  SetCommonAttributes(D, GA);
1255bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner}
1256bd53271dc7570b54f7b7cab7b09bcf04c6e927f6Chris Lattner
1257b808c952bbff821dce727dd801a1098d64394f98Chris Lattner/// getBuiltinLibFunction - Given a builtin id for a function like
1258b808c952bbff821dce727dd801a1098d64394f98Chris Lattner/// "__builtin_fabsf", return a Function* for "fabsf".
125934771b594ca8cdf8cd2e40b27170efa4ed2833c5Daniel Dunbarllvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
126034771b594ca8cdf8cd2e40b27170efa4ed2833c5Daniel Dunbar                                                  unsigned BuiltinID) {
12613e41d60eb627dc227c770f1c1c87d06909cf05fdDouglas Gregor  assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
12621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump          Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
12633e41d60eb627dc227c770f1c1c87d06909cf05fdDouglas Gregor         "isn't a lib fn");
12641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
12653e41d60eb627dc227c770f1c1c87d06909cf05fdDouglas Gregor  // Get the name, skip over the __builtin_ prefix (if necessary).
12663e41d60eb627dc227c770f1c1c87d06909cf05fdDouglas Gregor  const char *Name = Context.BuiltinInfo.GetName(BuiltinID);
12673e41d60eb627dc227c770f1c1c87d06909cf05fdDouglas Gregor  if (Context.BuiltinInfo.isLibFunction(BuiltinID))
12683e41d60eb627dc227c770f1c1c87d06909cf05fdDouglas Gregor    Name += 10;
12691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1270bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner  // Get the type for the builtin.
127186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner  ASTContext::GetBuiltinTypeError Error;
127286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner  QualType Type = Context.GetBuiltinType(BuiltinID, Error);
127386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner  assert(Error == ASTContext::GE_None && "Can't get builtin type");
1274370ab3f1373841d70582feac9e35c3c6b3489f63Douglas Gregor
12751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  const llvm::FunctionType *Ty =
1276bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner    cast<llvm::FunctionType>(getTypes().ConvertType(Type));
1277bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner
1278b808c952bbff821dce727dd801a1098d64394f98Chris Lattner  // Unique the name through the identifier table.
1279b808c952bbff821dce727dd801a1098d64394f98Chris Lattner  Name = getContext().Idents.get(Name).getName();
128034771b594ca8cdf8cd2e40b27170efa4ed2833c5Daniel Dunbar  return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD));
1281bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner}
1282bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner
12837acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattnerllvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
12847acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner                                            unsigned NumTys) {
12857acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner  return llvm::Intrinsic::getDeclaration(&getModule(),
12867acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner                                         (llvm::Intrinsic::ID)IID, Tys, NumTys);
12877acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner}
1288bef20ac367a09555b30d6eb3847a81ec164caf88Chris Lattner
12895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerllvm::Function *CodeGenModule::getMemCpyFn() {
12905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  if (MemCpyFn) return MemCpyFn;
12910032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext);
12924e8a9e8640a6717120394ee2ee5f27989757754dChris Lattner  return MemCpyFn = getIntrinsic(llvm::Intrinsic::memcpy, &IntPtr, 1);
12935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
1294c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson
12950c99509927a0c7a48490486b9fec287b63e5c09cEli Friedmanllvm::Function *CodeGenModule::getMemMoveFn() {
12960c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman  if (MemMoveFn) return MemMoveFn;
12970032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext);
12984e8a9e8640a6717120394ee2ee5f27989757754dChris Lattner  return MemMoveFn = getIntrinsic(llvm::Intrinsic::memmove, &IntPtr, 1);
12990c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman}
13000c99509927a0c7a48490486b9fec287b63e5c09cEli Friedman
130141ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venanciollvm::Function *CodeGenModule::getMemSetFn() {
130241ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio  if (MemSetFn) return MemSetFn;
13030032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext);
13044e8a9e8640a6717120394ee2ee5f27989757754dChris Lattner  return MemSetFn = getIntrinsic(llvm::Intrinsic::memset, &IntPtr, 1);
130541ef30e869d3f4940437503eb6a2cf70819fdb08Lauro Ramos Venancio}
13067acda7c4a0e4aec6c003b3169ca45a5f3bc7e033Chris Lattner
13071d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbarstatic llvm::StringMapEntry<llvm::Constant*> &
13081d5529132e4620562cab931c1f84c24e42f02741Daniel DunbarGetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
13091d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                         const StringLiteral *Literal,
131070ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar                         bool TargetIsLSB,
13111d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                         bool &IsUTF16,
13121d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                         unsigned &StringLength) {
13131d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  unsigned NumBytes = Literal->getByteLength();
13141d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar
13151d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  // Check for simple case.
13161d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  if (!Literal->containsNonAsciiOrNull()) {
13171d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar    StringLength = NumBytes;
13181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(),
13191d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                                                StringLength));
13201d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  }
13211d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar
13221d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  // Otherwise, convert the UTF8 literals into a byte string.
13231d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  llvm::SmallVector<UTF16, 128> ToBuf(NumBytes);
13241d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  const UTF8 *FromPtr = (UTF8 *)Literal->getStrData();
13251d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  UTF16 *ToPtr = &ToBuf[0];
13261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
13271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
13281d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                                               &ToPtr, ToPtr + NumBytes,
13291d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                                               strictConversion);
13301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
13311d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  // Check for conversion failure.
13321d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  if (Result != conversionOK) {
13331d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar    // FIXME: Have Sema::CheckObjCString() validate the UTF-8 string and remove
13341d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar    // this duplicate code.
13351d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar    assert(Result == sourceIllegal && "UTF-8 to UTF-16 conversion failed");
13361d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar    StringLength = NumBytes;
13371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(),
13381d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar                                                StringLength));
1339e9b7d8ace8674585818990cff585daae7745bd88Steve Naroff  }
13401d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar
134170ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  // ConvertUTF8toUTF16 returns the length in ToPtr.
13421d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  StringLength = ToPtr - &ToBuf[0];
134370ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar
134470ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  // Render the UTF-16 string into a byte array and convert to the target byte
134570ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  // order.
134670ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  //
134770ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  // FIXME: This isn't something we should need to do here.
134870ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  llvm::SmallString<128> AsBytes;
134970ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  AsBytes.reserve(StringLength * 2);
135070ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  for (unsigned i = 0; i != StringLength; ++i) {
135170ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar    unsigned short Val = ToBuf[i];
135270ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar    if (TargetIsLSB) {
135370ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar      AsBytes.push_back(Val & 0xFF);
135470ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar      AsBytes.push_back(Val >> 8);
135570ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar    } else {
135670ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar      AsBytes.push_back(Val >> 8);
135770ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar      AsBytes.push_back(Val & 0xFF);
135870ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar    }
135970ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  }
1360434da48d0e35764f18b3fc96c75504746050b046Daniel Dunbar  // Append one extra null character, the second is automatically added by our
1361434da48d0e35764f18b3fc96c75504746050b046Daniel Dunbar  // caller.
1362434da48d0e35764f18b3fc96c75504746050b046Daniel Dunbar  AsBytes.push_back(0);
136370ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar
13641d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  IsUTF16 = true;
136570ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar  return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size()));
13661d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar}
13671d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar
13681d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbarllvm::Constant *
13691d5529132e4620562cab931c1f84c24e42f02741Daniel DunbarCodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
13701d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  unsigned StringLength = 0;
13711d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  bool isUTF16 = false;
13721d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  llvm::StringMapEntry<llvm::Constant*> &Entry =
13731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    GetConstantCFStringEntry(CFConstantStringMap, Literal,
137470ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar                             getTargetData().isLittleEndian(),
137570ee975fad4653fa09f8e77f9a46a7b1f592ef59Daniel Dunbar                             isUTF16, StringLength);
13761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
13771d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  if (llvm::Constant *C = Entry.getValue())
13781d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar    return C;
13791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
13800032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  llvm::Constant *Zero =
13810032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson      llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
13823e9df9920db8de8ec93a424b0c1784f9bff301eaDaniel Dunbar  llvm::Constant *Zeros[] = { Zero, Zero };
13831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
13849d4a15fd3b85434c43ea27562793de63a793321aChris Lattner  // If we don't already have it, get __CFConstantStringClassReference.
1385c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  if (!CFConstantStringClassRef) {
1386c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson    const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
138796e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson    Ty = llvm::ArrayType::get(Ty, 0);
13881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    llvm::Constant *GV = CreateRuntimeVariable(Ty,
13899d4a15fd3b85434c43ea27562793de63a793321aChris Lattner                                           "__CFConstantStringClassReference");
13903e9df9920db8de8ec93a424b0c1784f9bff301eaDaniel Dunbar    // Decay array -> ptr
13913e9df9920db8de8ec93a424b0c1784f9bff301eaDaniel Dunbar    CFConstantStringClassRef =
13923c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson      llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1393c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  }
13941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1395e3daa761061982f2267f7c8fb847ea02abad0aa9Anders Carlsson  QualType CFTy = getContext().getCFConstantStringType();
13963e9df9920db8de8ec93a424b0c1784f9bff301eaDaniel Dunbar
13971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  const llvm::StructType *STy =
1398e3daa761061982f2267f7c8fb847ea02abad0aa9Anders Carlsson    cast<llvm::StructType>(getTypes().ConvertType(CFTy));
1399e3daa761061982f2267f7c8fb847ea02abad0aa9Anders Carlsson
14005add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson  std::vector<llvm::Constant*> Fields(4);
140144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor
1402c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  // Class pointer.
14035add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson  Fields[0] = CFConstantStringClassRef;
14041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1405c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  // Flags.
14063e9df9920db8de8ec93a424b0c1784f9bff301eaDaniel Dunbar  const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
14071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
14085add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson    llvm::ConstantInt::get(Ty, 0x07C8);
14095add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson
1410c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  // String pointer.
14110032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1412a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar
1413a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  const char *Sect, *Prefix;
1414a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  bool isConstant;
141595b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner  llvm::GlobalValue::LinkageTypes Linkage;
1416a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  if (isUTF16) {
1417a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    Prefix = getContext().Target.getUnicodeStringSymbolPrefix();
1418a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    Sect = getContext().Target.getUnicodeStringSection();
141995b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    // FIXME: why do utf strings get "l" labels instead of "L" labels?
142095b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    Linkage = llvm::GlobalValue::InternalLinkage;
1421a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    // FIXME: Why does GCC not set constant here?
1422a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    isConstant = false;
1423a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  } else {
142495b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    Prefix = ".str";
1425a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    Sect = getContext().Target.getCFStringDataSection();
142695b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    Linkage = llvm::GlobalValue::PrivateLinkage;
1427a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    // FIXME: -fwritable-strings should probably affect this, but we
1428a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    // are following gcc here.
1429a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    isConstant = true;
1430a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  }
14311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::GlobalVariable *GV =
14321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    new llvm::GlobalVariable(getModule(), C->getType(), isConstant,
143395b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner                             Linkage, C, Prefix);
1434a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  if (Sect)
14358e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar    GV->setSection(Sect);
1436a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  if (isUTF16) {
1437a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar    unsigned Align = getContext().getTypeAlign(getContext().ShortTy)/8;
14381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump    GV->setAlignment(Align);
1439a9668e0b4c451a1021fe650c451b54dc98c2d18dDaniel Dunbar  }
14405add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson  Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
14415add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson
1442c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  // String length.
1443c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  Ty = getTypes().ConvertType(getContext().LongTy);
14445add6835b0c6b0f67e19fd5366825d3e41eb0dcfAnders Carlsson  Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
14451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1446c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson  // The struct.
144708e252425ca2cbdc44ba65d9a657ed5398014e36Owen Anderson  C = llvm::ConstantStruct::get(STy, Fields);
14481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
14491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump                                llvm::GlobalVariable::PrivateLinkage, C,
145095b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner                                "_unnamed_cfstring_");
14518e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar  if (const char *Sect = getContext().Target.getCFStringSection())
14528e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar    GV->setSection(Sect);
14531d5529132e4620562cab931c1f84c24e42f02741Daniel Dunbar  Entry.setValue(GV);
14541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
14550c67829763b98bc670062b553897a851fab17401Anders Carlsson  return GV;
1456c9e2091efcb535110474434dd12015afdc3b1637Anders Carlsson}
145745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner
14586143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// GetStringForStringLiteral - Return the appropriate bytes for a
14591e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar/// string literal, properly padded to match the literal type.
14606143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbarstd::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
14611e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  const char *StrData = E->getStrData();
14621e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  unsigned Len = E->getByteLength();
14631e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar
14641e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  const ConstantArrayType *CAT =
14651e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar    getContext().getAsConstantArrayType(E->getType());
14661e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  assert(CAT && "String isn't pointer or array!");
14671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1468dbb1ecc32ca122b07b7c98fd0a8f6f53985adaccChris Lattner  // Resize the string to the right size.
14691e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  std::string Str(StrData, StrData+Len);
14701e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  uint64_t RealLen = CAT->getSize().getZExtValue();
14711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1472dbb1ecc32ca122b07b7c98fd0a8f6f53985adaccChris Lattner  if (E->isWide())
1473dbb1ecc32ca122b07b7c98fd0a8f6f53985adaccChris Lattner    RealLen *= getContext().Target.getWCharWidth()/8;
14741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
14751e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  Str.resize(RealLen, '\0');
14761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
14771e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar  return Str;
14781e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar}
14791e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar
14806143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
14816143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// constant array for the given string literal.
14826143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbarllvm::Constant *
14836143293fa4366ee95d7e47e61bd030a34bf68b55Daniel DunbarCodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
14846143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar  // FIXME: This can be more efficient.
14856143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar  return GetAddrOfConstantString(GetStringForStringLiteral(S));
14866143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar}
14876143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar
1488eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
1489eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner/// array for the given ObjCEncodeExpr node.
1490eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattnerllvm::Constant *
1491eaf2bb89eb2aad3b80673de30febe52df43c10ecChris LattnerCodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
1492eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner  std::string Str;
1493eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner  getContext().getObjCEncodingForType(E->getEncodedType(), Str);
1494a210f350fa78c263caa26e0f999cce85bb235309Eli Friedman
1495a210f350fa78c263caa26e0f999cce85bb235309Eli Friedman  return GetAddrOfConstantCString(Str);
1496eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner}
1497eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner
1498eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner
1499a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner/// GenerateWritableString -- Creates storage for a string literal.
15001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic llvm::Constant *GenerateStringLiteral(const std::string &str,
150145e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner                                             bool constant,
15025fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbar                                             CodeGenModule &CGM,
15035fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbar                                             const char *GlobalName) {
15046143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar  // Create Constant for this string literal. Don't add a '\0'.
15050032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson  llvm::Constant *C =
15060032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson      llvm::ConstantArray::get(CGM.getLLVMContext(), str, false);
15071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
150845e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner  // Create a global variable for this string
15091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
151095b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner                                  llvm::GlobalValue::PrivateLinkage,
15111c431b323d776362490bbf7cc796b74fedaf19f2Owen Anderson                                  C, GlobalName);
151245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner}
151345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner
15146143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// GetAddrOfConstantString - Returns a pointer to a character array
15156143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// containing the literal. This contents are exactly that of the
15166143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// given string, i.e. it will not be null terminated automatically;
15176143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// see GetAddrOfConstantCString. Note that whether the result is
15186143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// actually a pointer to an LLVM constant depends on
15196143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// Feature.WriteableStrings.
15206143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar///
15216143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// The result has pointer to array type.
15225fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbarllvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str,
15235fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbar                                                       const char *GlobalName) {
15248e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar  bool IsConstant = !Features.WritableStrings;
15258e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar
15268e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar  // Get the default prefix if a name wasn't specified.
15278e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar  if (!GlobalName)
152895b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    GlobalName = ".str";
15298e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar
15308e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar  // Don't share any string literals if strings aren't constant.
15318e5c2b8072f4409c7c0004331d1db9652d5209c0Daniel Dunbar  if (!IsConstant)
15325fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbar    return GenerateStringLiteral(str, false, *this, GlobalName);
15331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
15341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  llvm::StringMapEntry<llvm::Constant *> &Entry =
153595b851e55c328af4b69da7bfc1124bf258c0ffe5Chris Lattner    ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
153645e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner
153745e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner  if (Entry.getValue())
1538eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner    return Entry.getValue();
153945e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner
154045e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner  // Create a global variable for this.
15415fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbar  llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName);
154245e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner  Entry.setValue(C);
154345e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner  return C;
154445e8cbdce25c2e16c7aac2036a591f6190097ae6Chris Lattner}
15456143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar
15466143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// GetAddrOfConstantCString - Returns a pointer to a character
15476143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// array containing the literal and a terminating '\-'
15486143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar/// character. The result has pointer to array type.
15495fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbarllvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str,
15505fabf9dbee29464bcd06cd09f8e569d1b850f948Daniel Dunbar                                                        const char *GlobalName){
1551c9f29c61856ffb5f643cedbe87ac076f21a1381aChris Lattner  return GetAddrOfConstantString(str + '\0', GlobalName);
15526143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar}
155341071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
1554af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar/// EmitObjCPropertyImplementations - Emit information for synthesized
1555af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar/// properties for an implementation.
15561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid CodeGenModule::EmitObjCPropertyImplementations(const
1557af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar                                                    ObjCImplementationDecl *D) {
15581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  for (ObjCImplementationDecl::propimpl_iterator
155917945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis         i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
1560af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    ObjCPropertyImplDecl *PID = *i;
15611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1562af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    // Dynamic is just for type-checking.
1563af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
1564af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      ObjCPropertyDecl *PD = PID->getPropertyDecl();
1565af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar
1566af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      // Determine which methods need to be implemented, some may have
1567af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      // been overridden. Note that ::isSynthesized is not the method
1568af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      // we want, that just indicates if the decl came from a
1569af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      // property. What we want to know is if the method is defined in
1570af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      // this implementation.
157117945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis      if (!D->getInstanceMethod(PD->getGetterName()))
1572fef30b55230064d334a669a065a1c9acdb87cdfeFariborz Jahanian        CodeGenFunction(*this).GenerateObjCGetter(
1573fef30b55230064d334a669a065a1c9acdb87cdfeFariborz Jahanian                                 const_cast<ObjCImplementationDecl *>(D), PID);
1574af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar      if (!PD->isReadOnly() &&
157517945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis          !D->getInstanceMethod(PD->getSetterName()))
1576fef30b55230064d334a669a065a1c9acdb87cdfeFariborz Jahanian        CodeGenFunction(*this).GenerateObjCSetter(
1577fef30b55230064d334a669a065a1c9acdb87cdfeFariborz Jahanian                                 const_cast<ObjCImplementationDecl *>(D), PID);
1578af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    }
1579af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar  }
1580af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar}
1581af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar
158291e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson/// EmitNamespace - Emit all declarations in a namespace.
1583984e06874685396ca2cb51f0008cfff7c9b3d9c6Anders Carlssonvoid CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
158417945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis  for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
1585984e06874685396ca2cb51f0008cfff7c9b3d9c6Anders Carlsson       I != E; ++I)
1586984e06874685396ca2cb51f0008cfff7c9b3d9c6Anders Carlsson    EmitTopLevelDecl(*I);
1587984e06874685396ca2cb51f0008cfff7c9b3d9c6Anders Carlsson}
1588984e06874685396ca2cb51f0008cfff7c9b3d9c6Anders Carlsson
158991e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson// EmitLinkageSpec - Emit all declarations in a linkage spec.
159091e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlssonvoid CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
1591f976be8a63f9e0d3bd50e33dadef02c3c9921747Eli Friedman  if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
1592f976be8a63f9e0d3bd50e33dadef02c3c9921747Eli Friedman      LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
159391e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson    ErrorUnsupported(LSD, "linkage spec");
159491e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson    return;
159591e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson  }
159691e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson
159717945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis  for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
159891e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson       I != E; ++I)
159991e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson    EmitTopLevelDecl(*I);
160091e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson}
160191e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson
160241071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar/// EmitTopLevelDecl - Emit code for a single top level declaration.
160341071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbarvoid CodeGenModule::EmitTopLevelDecl(Decl *D) {
160441071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  // If an error has occurred, stop code generation, but continue
160541071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  // parsing and semantic analysis (to ensure all warnings and errors
160641071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  // are emitted).
160741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  if (Diags.hasErrorOccurred())
160841071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    return;
160941071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
161016e8be2ac532358d4e413fdfa2643b1876edda78Douglas Gregor  // Ignore dependent declarations.
161116e8be2ac532358d4e413fdfa2643b1876edda78Douglas Gregor  if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
161216e8be2ac532358d4e413fdfa2643b1876edda78Douglas Gregor    return;
16131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
161441071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  switch (D->getKind()) {
1615293361afd4199c92aabff9267fddea890943c586Anders Carlsson  case Decl::CXXConversion:
16162b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson  case Decl::CXXMethod:
161741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::Function:
161816e8be2ac532358d4e413fdfa2643b1876edda78Douglas Gregor    // Skip function templates
161916e8be2ac532358d4e413fdfa2643b1876edda78Douglas Gregor    if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
162016e8be2ac532358d4e413fdfa2643b1876edda78Douglas Gregor      return;
16211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1622555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson    EmitGlobal(cast<FunctionDecl>(D));
1623555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson    break;
1624555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson
162541071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::Var:
1626555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson    EmitGlobal(cast<VarDecl>(D));
162741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
162841071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
162995d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson  // C++ Decls
163041071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::Namespace:
1631984e06874685396ca2cb51f0008cfff7c9b3d9c6Anders Carlsson    EmitNamespace(cast<NamespaceDecl>(D));
163241071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
16339cfbe48a7a20a217fdb2920b29b67ae7941cb116Douglas Gregor    // No code generation needed.
16349cfbe48a7a20a217fdb2920b29b67ae7941cb116Douglas Gregor  case Decl::Using:
1635dd9967a6374c9a44be4af02aaeee340ffb82848fDouglas Gregor  case Decl::UsingDirective:
1636127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor  case Decl::ClassTemplate:
1637127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor  case Decl::FunctionTemplate:
16389cfbe48a7a20a217fdb2920b29b67ae7941cb116Douglas Gregor    break;
163995d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson  case Decl::CXXConstructor:
164095d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson    EmitCXXConstructors(cast<CXXConstructorDecl>(D));
164195d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson    break;
164227ae53665f8b00fe4ba21da0fa79a4ce6e0b6cd5Anders Carlsson  case Decl::CXXDestructor:
164327ae53665f8b00fe4ba21da0fa79a4ce6e0b6cd5Anders Carlsson    EmitCXXDestructors(cast<CXXDestructorDecl>(D));
164427ae53665f8b00fe4ba21da0fa79a4ce6e0b6cd5Anders Carlsson    break;
164536674d2978eb53962218ac67bb4d352cc287ea05Anders Carlsson
164636674d2978eb53962218ac67bb4d352cc287ea05Anders Carlsson  case Decl::StaticAssert:
164736674d2978eb53962218ac67bb4d352cc287ea05Anders Carlsson    // Nothing to do.
164836674d2978eb53962218ac67bb4d352cc287ea05Anders Carlsson    break;
164936674d2978eb53962218ac67bb4d352cc287ea05Anders Carlsson
165095d4e5d2f87a0f07fb143ccb824dfc4c5c595c78Anders Carlsson  // Objective-C Decls
16511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
165238e24c782c17b6058bf61d635747bbde19fb1bc7Fariborz Jahanian  // Forward declarations, no (immediate) code generation.
165341071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::ObjCClass:
165441071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::ObjCForwardProtocol:
1655b31cb7f1752ea011fd06ac9574ce24667d11cbdbFariborz Jahanian  case Decl::ObjCCategory:
1656b31cb7f1752ea011fd06ac9574ce24667d11cbdbFariborz Jahanian  case Decl::ObjCInterface:
165741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
1658285d0dba947b7c9960eaa88e8c4fced0398d4319Chris Lattner
165941071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::ObjCProtocol:
1660b31cb7f1752ea011fd06ac9574ce24667d11cbdbFariborz Jahanian    Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
166141071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
166241071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
166341071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::ObjCCategoryImpl:
1664af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    // Categories have properties but don't support synthesize so we
1665af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    // can ignore them here.
166641071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
166741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
166841071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
1669af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar  case Decl::ObjCImplementation: {
1670af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
1671af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    EmitObjCPropertyImplementations(OMD);
1672af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar    Runtime->GenerateClass(OMD);
167341071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
16741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  }
167541071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::ObjCMethod: {
167641071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
167741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    // If this is not a prototype, emit the body.
16786fb0aee4f9dc261bbec72e1283ad8dc0557a6d96Argyrios Kyrtzidis    if (OMD->getBody())
167941071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar      CodeGenFunction(*this).GenerateObjCMethod(OMD);
168041071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
168141071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  }
16821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  case Decl::ObjCCompatibleAlias:
1683305c658ebce84bb9833fc0e7675554656453b8e8Fariborz Jahanian    // compatibility-alias is a directive and has no code gen.
168441071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
168541071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
168691e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson  case Decl::LinkageSpec:
168791e20dd8bf1bc8980ee93839383d2bd170bce050Anders Carlsson    EmitLinkageSpec(cast<LinkageSpecDecl>(D));
168841071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
168941071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar
169041071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  case Decl::FileScopeAsm: {
169141071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
169241071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    std::string AsmString(AD->getAsmString()->getStrData(),
169341071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar                          AD->getAsmString()->getByteLength());
16941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
169541071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    const std::string &S = getModule().getModuleInlineAsm();
169641071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    if (S.empty())
169741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar      getModule().setModuleInlineAsm(AsmString);
169841071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    else
169941071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar      getModule().setModuleInlineAsm(S + '\n' + AsmString);
170041071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    break;
170141071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  }
17021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
17031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  default:
1704f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump    // Make sure we handled everything we should, every other kind is a
1705f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump    // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
1706f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump    // function. Need to recode Decl::Kind to do that easily.
170741071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar    assert(isa<TypeDecl>(D) && "Unsupported decl kind");
170841071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar  }
170941071debe9b8887449c3f2ee0dd7124ed47bdda8Daniel Dunbar}
1710